262 lines
10 KiB
Go
262 lines
10 KiB
Go
package agent
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/example/glpi-ai-agent/internal/config"
|
|
"github.com/example/glpi-ai-agent/internal/knowledge"
|
|
"github.com/example/glpi-ai-agent/internal/metrics"
|
|
"github.com/example/glpi-ai-agent/internal/model"
|
|
"github.com/example/glpi-ai-agent/internal/queue"
|
|
"github.com/example/glpi-ai-agent/internal/state"
|
|
)
|
|
|
|
type fakeGLPI struct {
|
|
ticket model.Ticket
|
|
followups []model.Followup
|
|
cats []model.Category
|
|
setCategory int
|
|
addReply int
|
|
ticketReads int
|
|
followupReads int
|
|
injectFollowupOnSecondCheck bool
|
|
}
|
|
|
|
func (f *fakeGLPI) Ping(context.Context) error { return nil }
|
|
func (f *fakeGLPI) ValidateContract(context.Context) error { return nil }
|
|
func (f *fakeGLPI) ListRecentTickets(context.Context, int, string) ([]model.Ticket, error) {
|
|
return nil, nil
|
|
}
|
|
func (f *fakeGLPI) GetTicket(context.Context, int64) (model.Ticket, error) {
|
|
f.ticketReads++
|
|
return f.ticket, nil
|
|
}
|
|
func (f *fakeGLPI) GetFollowups(context.Context, int64) ([]model.Followup, error) {
|
|
f.followupReads++
|
|
if f.injectFollowupOnSecondCheck && f.followupReads >= 2 {
|
|
return []model.Followup{{ID: 99}}, nil
|
|
}
|
|
return f.followups, nil
|
|
}
|
|
func (f *fakeGLPI) SetCategory(_ context.Context, _ int64, id int64) error {
|
|
f.setCategory++
|
|
f.ticket.CategoryID = id
|
|
f.ticket.DateMod = "v2"
|
|
return nil
|
|
}
|
|
func (f *fakeGLPI) AddFollowup(context.Context, int64, string, bool) error {
|
|
f.addReply++
|
|
f.ticket.DateMod = "v3"
|
|
return nil
|
|
}
|
|
func (f *fakeGLPI) GetCategories(context.Context) ([]model.Category, error) { return f.cats, nil }
|
|
|
|
type fakeAI struct {
|
|
d model.Decision
|
|
replyHitCount *int
|
|
}
|
|
|
|
func (f fakeAI) Ping(context.Context) error { return nil }
|
|
func (f fakeAI) Analyse(_ context.Context, _ model.Ticket, _ []model.Category, _ []model.KnowledgeHit, replyHits []model.KnowledgeHit, _ model.ContextSnapshot) (model.Decision, error) {
|
|
if f.replyHitCount != nil {
|
|
*f.replyHitCount = len(replyHits)
|
|
}
|
|
return f.d, nil
|
|
}
|
|
|
|
func newTestService(t *testing.T, g *fakeGLPI, d model.Decision, autoReply bool) *Service {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
kDir := dir + "/k"
|
|
if err := os.MkdirAll(kDir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
doc := `{"id":"KB1","title":"Known","text":"vpn gateway","answer":"Bitte starten Sie den VPN-Client neu.","auto_reply":true,"min_score":0,"categories":[2],"keywords":["vpn","gateway"],"source":"internal-kb","language":"de-DE","communication_style":"formal"}`
|
|
if err := os.WriteFile(kDir+"/kb.json", []byte(doc), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
k, err := knowledge.Load(context.Background(), kDir, dir, nil, false, []string{"internal-kb"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st, err := state.Open(dir, 100)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg := config.Config{DryRun: false, AutoCategory: true, AutoReply: autoReply, CategoryConfidence: .9, ReplyConfidence: .9, KnowledgeMinScore: 0, KnowledgeTopK: 1, CategoryPromptLimit: 20, Workers: 1, GLPIAllowedStatusIDs: []int64{1}, KnowledgeAllowedSources: []string{"internal-kb"}, KnowledgeCategorySources: []string{"internal-kb"}, KnowledgeAutoReplySources: []string{"internal-kb"}, CommunicationLanguage: "de-DE", CommunicationStyle: "formal", CommunicationSalutation: "Guten Tag,", CommunicationClosing: "Mit freundlichen Grüßen", CommunicationSignature: "IT-Service", AIContentLabelEnabled: true}
|
|
return New(cfg, g, fakeAI{d: d}, k, nil, st, queue.New(8), metrics.New(), nil)
|
|
}
|
|
|
|
func TestExistingFollowupBlocksReplyButNotCategory(t *testing.T) {
|
|
g := &fakeGLPI{ticket: model.Ticket{ID: 1, Name: "vpn", Content: "gateway", DateMod: "v1", StatusID: 1, CategoryID: 1}, followups: []model.Followup{{ID: 5}}, cats: []model.Category{{ID: 1}, {ID: 2}}}
|
|
var d model.Decision
|
|
d.Category.ID, d.Category.Confidence = 2, 1
|
|
d.Reply.Allowed, d.Reply.Confidence, d.Reply.KnowledgeID = true, 1, "KB1"
|
|
svc := newTestService(t, g, d, true)
|
|
replyHitCount := -1
|
|
svc.ai = fakeAI{d: d, replyHitCount: &replyHitCount}
|
|
if err := svc.Process(context.Background(), 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if g.setCategory != 1 {
|
|
t.Fatalf("category writes=%d", g.setCategory)
|
|
}
|
|
if g.addReply != 0 {
|
|
t.Fatalf("reply writes=%d", g.addReply)
|
|
}
|
|
if replyHitCount != 0 {
|
|
t.Fatalf("reply candidates sent to AI=%d, want 0", replyHitCount)
|
|
}
|
|
runs := svc.state.Recent(1)
|
|
if len(runs) != 1 || runs[0].ReplyDecision != "reply_existing_followup" || runs[0].Outcome != "processed" {
|
|
t.Fatalf("unexpected run audit: %+v", runs)
|
|
}
|
|
}
|
|
|
|
func TestRaceFollowupBlocksReply(t *testing.T) {
|
|
g := &fakeGLPI{ticket: model.Ticket{ID: 1, Name: "vpn", Content: "gateway", DateMod: "v1", StatusID: 1, CategoryID: 2}, cats: []model.Category{{ID: 2}}, injectFollowupOnSecondCheck: true}
|
|
var d model.Decision
|
|
d.Reply.Allowed, d.Reply.Confidence, d.Reply.KnowledgeID = true, 1, "KB1"
|
|
svc := newTestService(t, g, d, true)
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
if err := svc.Process(ctx, 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if g.addReply != 0 {
|
|
t.Fatalf("reply writes=%d", g.addReply)
|
|
}
|
|
}
|
|
|
|
func TestDisallowedStatusSkipsWithoutWrites(t *testing.T) {
|
|
g := &fakeGLPI{ticket: model.Ticket{ID: 1, Name: "vpn", Content: "gateway", DateMod: "v1", StatusID: 6, CategoryID: 1}, cats: []model.Category{{ID: 1}, {ID: 2}}}
|
|
var d model.Decision
|
|
d.Category.ID, d.Category.Confidence = 2, 1
|
|
svc := newTestService(t, g, d, true)
|
|
if err := svc.Process(context.Background(), 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if g.setCategory != 0 || g.addReply != 0 {
|
|
t.Fatalf("unexpected writes: category=%d reply=%d", g.setCategory, g.addReply)
|
|
}
|
|
}
|
|
|
|
func TestRunAuditExplainsCategoryBelowThreshold(t *testing.T) {
|
|
g := &fakeGLPI{ticket: model.Ticket{ID: 1, Name: "konto", Content: "anmeldung", DateMod: "v1", StatusID: 1, CategoryID: 1}, cats: []model.Category{{ID: 1, Name: "Allgemein"}, {ID: 2, Name: "Active Directory"}}}
|
|
var d model.Decision
|
|
d.Category.ID, d.Category.Confidence = 2, .82
|
|
d.Reason = "Das Problem deutet auf Active Directory hin."
|
|
svc := newTestService(t, g, d, false)
|
|
if err := svc.Process(context.Background(), 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if g.setCategory != 0 {
|
|
t.Fatalf("unexpected category write: %d", g.setCategory)
|
|
}
|
|
runs := svc.state.Recent(1)
|
|
if len(runs) != 1 {
|
|
t.Fatalf("runs=%d", len(runs))
|
|
}
|
|
r := runs[0]
|
|
if r.AIRecommendedCategoryID != 2 || r.AIRecommendedCategoryName != "Active Directory" || r.AICategoryConfidence != .82 || r.CategoryThreshold != .9 {
|
|
t.Fatalf("missing AI category audit: %+v", r)
|
|
}
|
|
if r.CategoryDecision != "category_confidence_below_threshold" || r.CategoryWouldChange || r.CategoryChanged {
|
|
t.Fatalf("unexpected category decision audit: %+v", r)
|
|
}
|
|
if r.AIReason == "" || r.PolicyReason == "" {
|
|
t.Fatalf("missing reason audit: %+v", r)
|
|
}
|
|
}
|
|
|
|
func TestSemanticHintsImproveActiveDirectoryCategory(t *testing.T) {
|
|
h := strings.Join(semanticCategoryHints(model.Category{ID: 2, Name: "Active Directory"}), " ")
|
|
if !strings.Contains(strings.ToLower(h), "konto gesperrt") || !strings.Contains(strings.ToLower(h), "anmeldung") {
|
|
t.Fatalf("expected identity hints, got %q", h)
|
|
}
|
|
}
|
|
|
|
func TestRunStoresStructuredPolicyChecks(t *testing.T) {
|
|
g := &fakeGLPI{ticket: model.Ticket{ID: 1, Name: "konto", Content: "anmeldung", DateMod: "v1", StatusID: 1, CategoryID: 1}, cats: []model.Category{{ID: 1, Name: "Allgemein"}, {ID: 2, Name: "Active Directory"}}}
|
|
var d model.Decision
|
|
d.Category.ID, d.Category.Confidence = 2, .82
|
|
d.Reply.Allowed = false
|
|
svc := newTestService(t, g, d, false)
|
|
if err := svc.Process(context.Background(), 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r := svc.state.Recent(1)[0]
|
|
if len(r.CategoryChecks) < 4 {
|
|
t.Fatalf("category checks=%d", len(r.CategoryChecks))
|
|
}
|
|
if len(r.ReplyChecks) < 8 {
|
|
t.Fatalf("reply checks=%d", len(r.ReplyChecks))
|
|
}
|
|
found := false
|
|
for _, c := range r.CategoryChecks {
|
|
if c.Code == "category_confidence" && c.Status == "fail" && c.Blocking {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatalf("missing blocking confidence rule: %+v", r.CategoryChecks)
|
|
}
|
|
}
|
|
|
|
func TestDiagnoseKnowledgeExplainsCandidate(t *testing.T) {
|
|
g := &fakeGLPI{ticket: model.Ticket{ID: 1, Name: "VPN gateway", Content: "gateway nicht erreichbar", DateMod: "v1", StatusID: 1, CategoryID: 2}, cats: []model.Category{{ID: 2, Name: "VPN"}}}
|
|
var d model.Decision
|
|
d.Category.ID, d.Category.Confidence = 2, 1
|
|
d.Reply.Allowed, d.Reply.Confidence, d.Reply.KnowledgeID = true, 1, "KB1"
|
|
svc := newTestService(t, g, d, true)
|
|
if err := svc.Process(context.Background(), 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r := svc.state.Recent(1)[0]
|
|
diag, err := svc.DiagnoseKnowledge(context.Background(), r.RunID, "KB1")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if diag.KnowledgeID != "KB1" || diag.RetrievalRank != 1 {
|
|
t.Fatalf("unexpected diagnostic: %+v", diag)
|
|
}
|
|
if len(diag.Checks) == 0 {
|
|
t.Fatal("expected diagnostic checks")
|
|
}
|
|
if diag.CurrentTicketChanged {
|
|
t.Fatal("ticket should not be marked changed")
|
|
}
|
|
}
|
|
|
|
func TestCategoryHintsUseOnlyConfiguredCategorySources(t *testing.T) {
|
|
dir := t.TempDir()
|
|
kDir := dir + "/knowledge"
|
|
if err := os.MkdirAll(kDir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
categoryDoc := `{"id":"CAT","title":"Category selector","text":"category evidence","categories":[2],"keywords":["category-only-hint"],"source":"internal-category","language":"de-DE","communication_style":"formal"}`
|
|
replyDoc := `{"id":"REPLY","title":"Reply article","text":"reply evidence","answer":"answer","categories":[1],"keywords":["reply-only-hint"],"source":"internal-kb","language":"de-DE","communication_style":"formal"}`
|
|
if err := os.WriteFile(kDir+"/cat.json", []byte(categoryDoc), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(kDir+"/reply.json", []byte(replyDoc), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
k, err := knowledge.Load(context.Background(), kDir, dir, nil, false, []string{"internal-category", "internal-kb"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
svc := &Service{cfg: config.Config{KnowledgeCategorySources: []string{"internal-category"}}, knowledge: k}
|
|
cats := svc.enrichCategories([]model.Category{{ID: 1, Name: "One"}, {ID: 2, Name: "Two"}})
|
|
if strings.Contains(strings.Join(cats[0].Hints, " "), "reply-only-hint") {
|
|
t.Fatalf("normal reply source influenced category hints: %+v", cats[0].Hints)
|
|
}
|
|
if !strings.Contains(strings.Join(cats[1].Hints, " "), "category-only-hint") {
|
|
t.Fatalf("category source hint missing: %+v", cats[1].Hints)
|
|
}
|
|
}
|