Backend : resource_links + scan_session_id (000021), réconciliation déterministe (same_scan outbox, doublons SHA-256 à l'upload + backfill, same_issuer/référence via faits effectifs, verdicts préservés, élagage auto), GET /files/:id/relations + verdict (owner-only), GET /duplicates (groupes + gain récupérable). Tests service + handlers + migrations. Mobile (Room v22) : links + collections, scanSessionId dans les creates de scan, LinksRepository (sync + verdicts REST), « Voir aussi » dans la fiche (verdict infirmer/re-confirmer), écran Doublons (garder le plus récent), collections locales (sauver/rejouer/supprimer). FR/EN. Contrat docs/api-v1.md (/relations, pas /links — pris par le partage), V3.md (S5 livré, version_of non matérialisé).
364 lines
11 KiB
Go
364 lines
11 KiB
Go
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)
|
|
}
|
|
}
|