package service import ( "errors" "testing" "github.com/kazier/backend/repository" ) func newExtractStore(t *testing.T) (*Resources, *Extract) { t.Helper() s := newServiceStore(t) return s, NewExtract(s.Repository) } const extractCorpus = `EDF - SERVICE CLIENTS Facture n° FA-2026-0031 du 12/03/2026 Montant total TTC : 84,20 € À payer avant le 12/04/2026 ` func TestProcessTextPersistsAutoFacts(t *testing.T) { s, ex := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-auto") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil { t.Fatalf("process: %v", err) } facts, err := s.GetFacts(userID, fileID) if err != nil { t.Fatalf("get facts: %v", err) } byType := map[string][]FactDTO{} for _, f := range facts { byType[f.FactType] = append(byType[f.FactType], f) if f.Origin != "auto" { t.Errorf("origine = %q, attendu auto", f.Origin) } } if len(byType["reference"]) == 0 || len(byType["amount"]) == 0 || len(byType["date"]) == 0 || len(byType["due_date"]) == 0 || len(byType["doc_type"]) == 0 { t.Fatalf("faits manquants: %+v", byType) } var amount float64 for _, f := range byType["amount"] { if f.ValueNum != nil { amount = *f.ValueNum } } if amount != 84.20 { t.Errorf("montant = %v, attendu 84.20", amount) } } func TestProcessTextPreservesUserCorrections(t *testing.T) { s, ex := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-user") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } // Correction manuelle (S3, simulée en SQL) : l'auto ne doit jamais l'écraser. if _, err := s.Repository.Resources.DB.Exec( `INSERT INTO resource_facts (id, resource_id, fact_type, value_text, confidence, origin) VALUES ($1, $2, 'issuer', 'Vrai Fournisseur', 1.0, 'user')`, repository.NewID(), fileID, ); err != nil { t.Fatalf("seed user fact: %v", err) } if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil { t.Fatalf("process: %v", err) } // Re-passe (idempotence du remplacement auto). if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil { t.Fatalf("re-process: %v", err) } facts, err := s.GetFacts(userID, fileID) if err != nil { t.Fatalf("get facts: %v", err) } issuers := map[string]string{} autoCount := 0 for _, f := range facts { if f.FactType == "issuer" { issuers[f.Origin] = f.ValueText } if f.Origin == "auto" { autoCount++ } } if issuers["user"] != "Vrai Fournisseur" { t.Errorf("correction user écrasée: %+v", issuers) } if autoCount == 0 { t.Error("aucun fait auto après re-passe") } // Pas de doublons auto après deux passes. seen := map[string]int{} for _, f := range facts { if f.Origin == "auto" { seen[f.FactType+"\x00"+f.ValueText]++ } } for k, n := range seen { if n > 1 { t.Errorf("doublon auto %q x%d", k, n) } } } func TestProcessTextEmptyClearsStaleAuto(t *testing.T) { s, ex := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-clear") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil { t.Fatalf("process: %v", err) } if err := ex.ProcessText(userID, fileID, ""); err != nil { t.Fatalf("clear: %v", err) } facts, err := s.GetFacts(userID, fileID) if err != nil { t.Fatalf("get facts: %v", err) } if len(facts) != 0 { t.Fatalf("auto périmés non purgés: %+v", facts) } } func TestGetFactsScope(t *testing.T) { s, ex := newExtractStore(t) owner := mustCreateUser(t, s.Repository, "extract-scope-o") other := mustCreateUser(t, s.Repository, "extract-scope-x") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(owner, fileID, "doc.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } if err := ex.ProcessText(owner, fileID, extractCorpus); err != nil { t.Fatalf("process: %v", err) } if _, err := s.GetFacts(other, fileID); err != repository.ErrNotFound { t.Fatalf("étranger : attendu NOT_FOUND, got %v", err) } if _, err := s.GetFacts(owner, repository.NewID()); err != repository.ErrNotFound { t.Fatalf("inconnu : attendu NOT_FOUND, got %v", err) } if _, err := s.Trash(owner, fileID); err != nil { t.Fatalf("trash: %v", err) } if _, err := s.GetFacts(owner, fileID); err != repository.ErrNotFound { t.Fatalf("trashé : attendu NOT_FOUND, got %v", err) } } func TestBackfill(t *testing.T) { s, ex := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-backfill") oldID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, oldID, "vieux.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } // OCR d'avant la V3 : texte présent, aucun fait auto. if err := s.Repository.Resources.UpdateOcrText(userID, oldID, extractCorpus); err != nil { t.Fatalf("ocr text: %v", err) } n, err := ex.Backfill(200) if err != nil { t.Fatalf("backfill: %v", err) } if n != 1 { t.Fatalf("backfill = %d, attendu 1", n) } facts, err := s.GetFacts(userID, oldID) if err != nil || len(facts) == 0 { t.Fatalf("faits après backfill: %+v %v", facts, err) } // Deuxième passe : rien à faire (idempotent). n, err = ex.Backfill(200) if err != nil { t.Fatalf("backfill 2: %v", err) } if n != 0 { t.Fatalf("backfill 2 = %d, attendu 0", n) } } func correctDTO(factType, valueText string) FactDTO { return FactDTO{FactType: factType, ValueText: valueText, Confidence: 1.0} } func TestCorrectFactsReplacesUserSet(t *testing.T) { s, ex := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-correct") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil { t.Fatalf("process: %v", err) } // Correction : l'émetteur auto est faux, l'utilisateur le fixe. if err := s.CorrectFacts(userID, fileID, []FactDTO{correctDTO("issuer", "Vrai Fournisseur")}); err != nil { t.Fatalf("correct: %v", err) } facts, err := s.GetFacts(userID, fileID) if err != nil { t.Fatalf("get facts: %v", err) } var userIssuer, autoIssuer int for _, f := range facts { if f.FactType == "issuer" && f.Origin == "user" && f.ValueText == "Vrai Fournisseur" { userIssuer++ } if f.FactType == "issuer" && f.Origin == "auto" { autoIssuer++ } } if userIssuer != 1 { t.Fatalf("correction user manquante: %+v", facts) } if autoIssuer == 0 { t.Error("l'auto doit survivre à côté du user (les deux sont lus, user d'abord)") } // Deuxième correction (jeu vide) : efface les corrections, garde l'auto. if err := s.CorrectFacts(userID, fileID, nil); err != nil { t.Fatalf("clear corrections: %v", err) } facts, _ = s.GetFacts(userID, fileID) for _, f := range facts { if f.Origin == "user" { t.Fatalf("corrections restantes: %+v", facts) } } if len(facts) == 0 { t.Fatal("l'auto doit survivre à l'effacement des corrections") } } func TestCorrectFactsValidation(t *testing.T) { s, _ := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-correct-val") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } num := 12.5 cases := []struct { name string facts []FactDTO }{ {"type inconnu", []FactDTO{{FactType: "couleur", ValueText: "bleu"}}}, {"confiance hors bornes", []FactDTO{{FactType: "issuer", ValueText: "X", Confidence: 2}}}, {"date non ISO", []FactDTO{{FactType: "date", ValueDate: "12/03/2026"}}}, {"sans valeur", []FactDTO{{FactType: "issuer"}}}, } for _, tc := range cases { if err := s.CorrectFacts(userID, fileID, tc.facts); err == nil { t.Errorf("%s : erreur attendue", tc.name) } else if !errors.Is(err, ErrInvalidFact) { t.Errorf("%s : attendu ErrInvalidFact, got %v", tc.name, err) } } // Valides : date ISO + montant numérique. if err := s.CorrectFacts(userID, fileID, []FactDTO{ {FactType: "due_date", ValueDate: "2026-04-12"}, {FactType: "amount", ValueNum: &num}, }); err != nil { t.Fatalf("faits valides rejetés: %v", err) } } func TestCorrectFactsScope(t *testing.T) { s, _ := newExtractStore(t) owner := mustCreateUser(t, s.Repository, "extract-corr-o") viewer := mustCreateUser(t, s.Repository, "extract-corr-v") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(owner, fileID, "doc.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } // Étranger (même viewer via partage simulé plus bas) → NOT_FOUND. if err := s.CorrectFacts(viewer, fileID, nil); err != repository.ErrNotFound { t.Fatalf("étranger : attendu NOT_FOUND, got %v", err) } // Absent → NOT_FOUND (EffectiveAccess sur ressource inconnue). if err := s.CorrectFacts(owner, repository.NewID(), []FactDTO{correctDTO("issuer", "X")}); err != repository.ErrNotFound { t.Fatalf("absent : attendu NOT_FOUND, got %v", err) } } func TestSyncOpCorrectFacts(t *testing.T) { s, ex := newExtractStore(t) userID := mustCreateUser(t, s.Repository, "extract-op") other := mustCreateUser(t, s.Repository, "extract-op-x") device := mustRegisterDevice(t, s.Repository, "c0000000000000000000000000000001") fileID := repository.NewID() if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert: %v", err) } if err := ex.ProcessText(userID, fileID, extractCorpus); err != nil { t.Fatalf("process: %v", err) } foreignID := repository.NewID() if err := s.Repository.Resources.InsertFile(other, foreignID, "autre.pdf", "", 0, nil, nil); err != nil { t.Fatalf("insert foreign: %v", err) } apply := func(resID string, facts []FactDTO) SyncResult { t.Helper() raw := map[string]any{"facts": facts} res, err := s.ApplyBatch(userID, device, []SyncOperation{ syncOp(repository.NewID(), resID, OpCorrectFacts, "file", raw), }) if err != nil { t.Fatalf("apply: %v", err) } return res } if res := apply(fileID, []FactDTO{correctDTO("issuer", "Corrigé")}); res.Applied != 1 || res.Failed != nil { t.Fatalf("correct op: %+v", res) } facts, _ := s.GetFacts(userID, fileID) found := false for _, f := range facts { if f.FactType == "issuer" && f.Origin == "user" && f.ValueText == "Corrigé" { found = true } } if !found { t.Fatalf("correction via op manquante: %+v", facts) } // Op étrangère → halt NOT_FOUND. if res := apply(foreignID, []FactDTO{correctDTO("issuer", "X")}); res.Failed == nil || res.Failed.Code != "NOT_FOUND" { t.Fatalf("correct autrui doit halter NOT_FOUND: %+v", res) } // Payload invalide → halt INVALID_REQUEST. res, err := s.ApplyBatch(userID, device, []SyncOperation{ syncOp(repository.NewID(), fileID, OpCorrectFacts, "file", map[string]any{ "facts": []any{map[string]any{"factType": "couleur", "valueText": "bleu"}}, }), }) if err != nil { t.Fatalf("apply: %v", err) } if res.Failed == nil || res.Failed.Code != "INVALID_REQUEST" { t.Fatalf("payload invalide doit halter INVALID_REQUEST: %+v", res) } }