Janady13/missionmatch / internal/modules/federalsignal/tenant_tag_test.go

1package federalsignal 2 3// Offline unit test for the Phase 5a tenant mission tagging service. It injects an in memory fake repo 4// with fixture candidates and requirements and a fixed AliasIndex, runs the service with NO database, and 5// asserts the exact candidate_mission_tags and requirement_mission_tags produced (codes, mechanisms, and 6// evidence), plus idempotency: a second run never grows the tag set. The classifier is the same pure 7// deterministic missionclass the global pass uses, so the SIGINT analyst gets a SIGINT tag and the COMSEC 8// skill gets a COMSEC tag. 9 10import ( 11 "context" 12 "sort" 13 "testing" 14 15 "github.com/google/uuid" 16 17 "github.com/missionworkforce/missionmatch/internal/platform/database/dbgen" 18 "github.com/missionworkforce/missionmatch/internal/platform/missionclass" 19 "github.com/missionworkforce/missionmatch/internal/platform/tenant" 20) 21 22// fakeTenantTagRepo serves fixture rows and records every upserted tag so the test can assert the exact 23// output. It honors idempotency the way the real ON CONFLICT DO UPDATE does, keying candidate tags on 24// (candidate_id, mission_code) and requirement tags on (requirement_id, mission_code), so a second run 25// never grows the row set. 26type fakeTenantTagRepo struct { 27 candidates []dbgen.ListCandidatesForMissionTaggingRow 28 requirements []dbgen.ListRequirementsForMissionTaggingRow 29 30 candTags map[string]dbgen.UpsertCandidateMissionTagParams 31 reqTags map[string]dbgen.UpsertRequirementMissionTagParams 32} 33 34func newFakeTenantTagRepo() *fakeTenantTagRepo { 35 return &fakeTenantTagRepo{ 36 candTags: map[string]dbgen.UpsertCandidateMissionTagParams{}, 37 reqTags: map[string]dbgen.UpsertRequirementMissionTagParams{}, 38 } 39} 40 41func (r *fakeTenantTagRepo) ListCandidatesForTagging(_ context.Context) ([]dbgen.ListCandidatesForMissionTaggingRow, error) { 42 return r.candidates, nil 43} 44 45func (r *fakeTenantTagRepo) ListRequirementsForTagging(_ context.Context) ([]dbgen.ListRequirementsForMissionTaggingRow, error) { 46 return r.requirements, nil 47} 48 49func (r *fakeTenantTagRepo) UpsertCandidateMissionTags(_ context.Context, tags []dbgen.UpsertCandidateMissionTagParams) error { 50 for _, t := range tags { 51 r.candTags[t.CandidateID.String()+"|"+t.MissionCode] = t 52 } 53 return nil 54} 55 56func (r *fakeTenantTagRepo) UpsertRequirementMissionTags(_ context.Context, tags []dbgen.UpsertRequirementMissionTagParams) error { 57 for _, t := range tags { 58 r.reqTags[t.RequirementID.String()+"|"+t.MissionCode] = t 59 } 60 return nil 61} 62 63// missionTag is the comparable shape the assertions use. 64type missionTag struct { 65 code, mechanism, evidence string 66} 67 68func TestTenantTagCandidatesAndRequirements(t *testing.T) { 69 org := uuid.New() 70 candID := uuid.New() 71 reqID := uuid.New() 72 73 repo := newFakeTenantTagRepo() 74 // One candidate: headline mentions SIGINT, with a COMSEC skill. The classifier should produce a SIGINT 75 // tag (keyword in headline) and a COMSEC tag (keyword in the joined skill text). 76 repo.candidates = []dbgen.ListCandidatesForMissionTaggingRow{ 77 {CandidateID: candID, Headline: "SIGINT analyst", SkillText: "COMSEC"}, 78 } 79 // One requirement: title and labor category plus a required skill. The title carries Electronic Warfare 80 // (EW) and the labor category carries GEOINT, proving title and labor category and skill text all feed 81 // the classifier. 82 repo.requirements = []dbgen.ListRequirementsForMissionTaggingRow{ 83 {RequirementID: reqID, Title: "Electronic Warfare Engineer", LaborCategory: "GEOINT Analyst", SkillText: "COMSEC"}, 84 } 85 86 // A deliberately empty AliasIndex: the fixture relies on the literal keyword gazetteer only, so the 87 // assertions are about the deterministic keyword mechanism, not a curated alias. 88 idx := missionclass.NewAliasIndex(map[string]string{}) 89 svc := NewTenantTagService(repo, idx) 90 ctx := tenant.WithOrg(context.Background(), org.String()) 91 92 cRes, err := svc.TagCandidatesForOrg(ctx) 93 if err != nil { 94 t.Fatalf("TagCandidatesForOrg: %v", err) 95 } 96 rRes, err := svc.TagRequirementsForOrg(ctx) 97 if err != nil { 98 t.Fatalf("TagRequirementsForOrg: %v", err) 99 } 100 101 // Candidate: exactly SIGINT and COMSEC, both by keyword, with the canonical evidence phrases. 102 wantCand := []missionTag{ 103 {"SIGINT", missionclass.MechKeyword, "sigint"}, 104 {"COMSEC", missionclass.MechKeyword, "comsec"}, 105 } 106 gotCand := collectCandTags(repo, candID) 107 assertTags(t, "candidate", wantCand, gotCand) 108 if cRes.CandidatesScanned != 1 || cRes.CandidateTags != 2 { 109 t.Fatalf("candidate result counts = scanned %d tags %d, want scanned 1 tags 2", cRes.CandidatesScanned, cRes.CandidateTags) 110 } 111 // Every candidate tag must carry the org from the context, never a blank or foreign org. 112 for k, v := range repo.candTags { 113 if v.OrganizationID != org { 114 t.Fatalf("candidate tag %s has org %s, want %s", k, v.OrganizationID, org) 115 } 116 } 117 118 // Requirement: EW from the title, GEOINT from the labor category, COMSEC from the required skill text, 119 // all by keyword. This proves the title, the labor category, AND the required skill names each feed the 120 // requirement classifier. 121 wantReq := []missionTag{ 122 {"GEOINT", missionclass.MechKeyword, "geoint"}, 123 {"COMSEC", missionclass.MechKeyword, "comsec"}, 124 {"EW", missionclass.MechKeyword, "electronic warfare"}, 125 } 126 gotReq := collectReqTags(repo, reqID) 127 assertTags(t, "requirement", wantReq, gotReq) 128 if rRes.RequirementsScanned != 1 || rRes.RequirementTags != 3 { 129 t.Fatalf("requirement result counts = scanned %d tags %d, want scanned 1 tags 3", rRes.RequirementsScanned, rRes.RequirementTags) 130 } 131 for k, v := range repo.reqTags { 132 if v.OrganizationID != org { 133 t.Fatalf("requirement tag %s has org %s, want %s", k, v.OrganizationID, org) 134 } 135 } 136 137 // Idempotency: a second identical run must not grow either tag set (ON CONFLICT refreshes in place). 138 if _, err := svc.TagCandidatesForOrg(ctx); err != nil { 139 t.Fatalf("second TagCandidatesForOrg: %v", err) 140 } 141 if _, err := svc.TagRequirementsForOrg(ctx); err != nil { 142 t.Fatalf("second TagRequirementsForOrg: %v", err) 143 } 144 if len(repo.candTags) != 2 { 145 t.Fatalf("idempotency broken: candidate tag set grew to %d after a second run (want 2)", len(repo.candTags)) 146 } 147 if len(repo.reqTags) != 3 { 148 t.Fatalf("idempotency broken: requirement tag set grew to %d after a second run (want 3)", len(repo.reqTags)) 149 } 150} 151 152// TestTenantTagRefusesUnscopedContext proves the service fails closed when no org is in the context, 153// mirroring RunInTenantTx: no validated org means no tagging. 154func TestTenantTagRefusesUnscopedContext(t *testing.T) { 155 repo := newFakeTenantTagRepo() 156 repo.candidates = []dbgen.ListCandidatesForMissionTaggingRow{ 157 {CandidateID: uuid.New(), Headline: "SIGINT analyst"}, 158 } 159 svc := NewTenantTagService(repo, missionclass.NewAliasIndex(map[string]string{})) 160 161 if _, err := svc.TagCandidatesForOrg(context.Background()); err == nil { 162 t.Fatal("TagCandidatesForOrg with no org in context must error (fail closed)") 163 } 164 if _, err := svc.TagRequirementsForOrg(context.Background()); err == nil { 165 t.Fatal("TagRequirementsForOrg with no org in context must error (fail closed)") 166 } 167 if len(repo.candTags) != 0 || len(repo.reqTags) != 0 { 168 t.Fatal("an unscoped run must write nothing") 169 } 170} 171 172// TestTenantTagAliasLayer proves the curated alias layer adds a mission beyond the literal keyword: an 173// alias phrase that is not a gazetteer keyword still produces the right code, with the alias mechanism. 174func TestTenantTagAliasLayer(t *testing.T) { 175 org := uuid.New() 176 candID := uuid.New() 177 repo := newFakeTenantTagRepo() 178 repo.candidates = []dbgen.ListCandidatesForMissionTaggingRow{ 179 {CandidateID: candID, Headline: "intercept operator", SkillText: ""}, 180 } 181 // "intercept operator" is not a SIGINT gazetteer keyword; the curated alias maps it to SIGINT. 182 idx := missionclass.NewAliasIndex(map[string]string{"intercept operator": "SIGINT"}) 183 svc := NewTenantTagService(repo, idx) 184 ctx := tenant.WithOrg(context.Background(), org.String()) 185 186 if _, err := svc.TagCandidatesForOrg(ctx); err != nil { 187 t.Fatalf("TagCandidatesForOrg: %v", err) 188 } 189 got := collectCandTags(repo, candID) 190 assertTags(t, "alias candidate", []missionTag{{"SIGINT", missionclass.MechAlias, "intercept operator"}}, got) 191} 192 193func collectCandTags(r *fakeTenantTagRepo, candID uuid.UUID) []missionTag { 194 var out []missionTag 195 for _, v := range r.candTags { 196 if v.CandidateID == candID { 197 out = append(out, missionTag{v.MissionCode, v.Mechanism, v.Evidence}) 198 } 199 } 200 return out 201} 202 203func collectReqTags(r *fakeTenantTagRepo, reqID uuid.UUID) []missionTag { 204 var out []missionTag 205 for _, v := range r.reqTags { 206 if v.RequirementID == reqID { 207 out = append(out, missionTag{v.MissionCode, v.Mechanism, v.Evidence}) 208 } 209 } 210 return out 211} 212 213// assertTags compares two tag sets order independently: the upsert map iteration order is not stable, so 214// the test sorts both sides by code before comparing. 215func assertTags(t *testing.T, label string, want, got []missionTag) { 216 t.Helper() 217 byCode := func(s []missionTag) { sort.Slice(s, func(i, j int) bool { return s[i].code < s[j].code }) } 218 byCode(want) 219 byCode(got) 220 if len(want) != len(got) { 221 t.Fatalf("%s tags: got %d %+v, want %d %+v", label, len(got), got, len(want), want) 222 } 223 for i := range want { 224 if want[i] != got[i] { 225 t.Fatalf("%s tag %d: got %+v, want %+v", label, i, got[i], want[i]) 226 } 227 } 228} 229