Janady13/missionmatch / internal/platform/benchimport/benchimport_test.go

1package benchimport 2 3import ( 4 "context" 5 "os" 6 "path/filepath" 7 "reflect" 8 "strings" 9 "testing" 10 11 "github.com/missionworkforce/missionmatch/internal/platform/extraction" 12 "github.com/missionworkforce/missionmatch/internal/platform/sourcing" 13) 14 15// sampleResume carries a person name and an email (the PII that must never be embedded) alongside the 16// structured workforce tokens the mapping is allowed to keep. 17const sampleResume = `Jane Q Operator 18jane.operator@example.com 19(505) 555-0142 20Albuquerque, NM 21 22SIGINT Analyst with active TS/SCI clearance and 8 years experience. 23Skills: Python, Splunk, SIEM, Incident Response, RMF, ATO. 24Certifications: CISSP, CompTIA Security+. 25Supported the Air Force and NSA.` 26 27// composeEmbedProfile mirrors the name free embed profile the embed-backfill composer builds (the headline 28// is JobTitle or Role plus the first six skills, no name, no email), so the invariant 5 test asserts on the 29// exact string the inference plane would see. It is a deliberate mirror of sourcing.buildHeadline plus the 30// embed-backfill SQL composition, kept here because the source side composers are unexported. 31func composeEmbedProfile(sp sourcing.SourcedPerson) string { 32 skills := sp.Skills 33 if len(skills) > 6 { 34 skills = skills[:6] 35 } 36 headline := sp.JobTitle 37 if headline == "" { 38 headline = sp.Role 39 } 40 if len(skills) > 0 { 41 if headline != "" { 42 headline += " | " 43 } 44 headline += strings.Join(skills, ", ") 45 } 46 headline = strings.TrimSpace(headline) 47 // The embed profile is the headline plus the skills line only, name free and email free by construction 48 // (the resume mapping never routes a name or an email into the job title, the role, or any skill). 49 return strings.Join([]string{ 50 headline, 51 "skills: " + strings.Join(sp.Skills, ", "), 52 }, " | ") 53} 54 55// TestResumeMappingKeepsPIIOutOfEmbedProfile is the invariant 5 test. It feeds a resume containing a name 56// and an email, maps it through the resume source, composes the same name free embed profile the embed 57// backfill builds, and asserts the composed string contains NEITHER the name NOR the email. It also 58// confirms the name is carried on the candidate name field (so it lands in candidates.full_name) and that 59// the clearance code is captured for triage but never placed on a scored field. 60func TestResumeMappingKeepsPIIOutOfEmbedProfile(t *testing.T) { 61 s := resumeSource{ext: extraction.NewDeterministic()} 62 rec, ok := s.mapResume(context.Background(), sampleResume) 63 if !ok { 64 t.Fatal("expected the sample resume to yield a record with signal") 65 } 66 67 const name = "Jane Q Operator" 68 const email = "jane.operator@example.com" 69 70 // The name lands only on the candidate name field. 71 if rec.FullName != name { 72 t.Fatalf("expected FullName %q on the candidate name field, got %q", name, rec.FullName) 73 } 74 // The name and email never reach the title or any embeddable field on the record. 75 if strings.Contains(rec.JobTitle, "Jane") || strings.Contains(rec.JobTitle, "@") { 76 t.Fatalf("a name or email leaked into JobTitle: %q", rec.JobTitle) 77 } 78 if rec.Email != email { 79 t.Fatalf("expected the email captured for dedup only, got %q", rec.Email) 80 } 81 82 sp := rec.ToSourcedPerson() 83 // SourcedPerson must route the name only to FullName, never to JobTitle or Role. 84 if sp.FullName != name { 85 t.Fatalf("expected SourcedPerson.FullName %q, got %q", name, sp.FullName) 86 } 87 if strings.Contains(sp.JobTitle, "Jane") || strings.Contains(sp.Role, "Jane") { 88 t.Fatalf("a name leaked into JobTitle or Role: title=%q role=%q", sp.JobTitle, sp.Role) 89 } 90 91 profile := composeEmbedProfile(sp) 92 if strings.Contains(profile, name) || strings.Contains(profile, "Jane") { 93 t.Fatalf("the embed profile contains the person name: %q", profile) 94 } 95 if strings.Contains(profile, email) || strings.Contains(profile, "@") { 96 t.Fatalf("the embed profile contains the email: %q", profile) 97 } 98 99 // Sanity: the structured tokens that SHOULD be embedded are present. 100 if !strings.Contains(profile, "Python") { 101 t.Fatalf("expected a structured skill in the embed profile: %q", profile) 102 } 103 104 // Clearance is captured for triage only, never on a scored field. ToSourcedPerson has no clearance 105 // field, so the code can never reach a clearance column. 106 if rec.ClearanceCode == "" { 107 t.Fatalf("expected the clearance code captured for triage, got empty") 108 } 109 if hasClearanceField(sp) { 110 t.Fatal("SourcedPerson must not carry a clearance field") 111 } 112} 113 114// hasClearanceField reflectively asserts SourcedPerson exposes no clearance field, so the triage clearance 115// code can never ride into a candidate clearance column through the mapping. 116func hasClearanceField(sp sourcing.SourcedPerson) bool { 117 tp := reflect.TypeOf(sp) 118 for i := 0; i < tp.NumField(); i++ { 119 if strings.Contains(strings.ToLower(tp.Field(i).Name), "clearance") { 120 return true 121 } 122 } 123 return false 124} 125 126// TestResumeSourceOverDocextractFixtures runs the resume source over the docextract testdata fixtures so 127// the end to end path (read file, extract text, run the extractor, map) is exercised on real files of each 128// format. Each fixture carries a title token, so each yields a record with a sanitized JobTitle and no PII. 129func TestResumeSourceOverDocextractFixtures(t *testing.T) { 130 dir := filepath.Join("..", "docextract", "testdata") 131 if _, err := os.Stat(dir); err != nil { 132 t.Skipf("docextract testdata not present: %v", err) 133 } 134 s := NewResumeSource(extraction.NewDeterministic()) 135 var got []BenchRecord 136 res, err := s.Resumes(context.Background(), dir, func(rec BenchRecord, file string) error { 137 got = append(got, rec) 138 // No fixture file path or content may carry a person name into a title. 139 if strings.Contains(rec.JobTitle, "@") { 140 t.Fatalf("an email shaped token reached JobTitle from %s: %q", file, rec.JobTitle) 141 } 142 return nil 143 }) 144 if err != nil { 145 t.Fatalf("Resumes over fixtures: %v", err) 146 } 147 if res.Read == 0 { 148 t.Fatal("expected to read at least one fixture") 149 } 150 // The PDF fixture says SIGINT Analyst and the DOCX says ISSO, both title gazetteer hits, so at least 151 // one record must carry a sanitized title. 152 var titled int 153 for _, r := range got { 154 if r.JobTitle != "" { 155 titled++ 156 } 157 } 158 if titled == 0 { 159 t.Fatalf("expected at least one fixture to resolve a sanitized title, mapped %d records", len(got)) 160 } 161} 162 163// TestResumeWithSampleFile writes a small sample resume to a temp directory and proves the directory walk 164// reads it, extracts it, and maps it to a record with the expected structured tokens and no PII in any 165// embeddable field. 166func TestResumeWithSampleFile(t *testing.T) { 167 dir := t.TempDir() 168 if err := os.WriteFile(filepath.Join(dir, "operator.txt"), []byte(sampleResume), 0o644); err != nil { 169 t.Fatalf("write sample: %v", err) 170 } 171 s := NewResumeSource(extraction.NewDeterministic()) 172 var got BenchRecord 173 res, err := s.Resumes(context.Background(), dir, func(rec BenchRecord, file string) error { 174 got = rec 175 return nil 176 }) 177 if err != nil { 178 t.Fatalf("Resumes: %v", err) 179 } 180 if res.Mapped != 1 { 181 t.Fatalf("expected 1 mapped record, got %d (read %d skipped %d)", res.Mapped, res.Read, res.Skipped) 182 } 183 if got.JobTitle != "Intelligence Analyst" { 184 t.Fatalf("expected sanitized title Intelligence Analyst, got %q", got.JobTitle) 185 } 186 wantSkills := map[string]bool{"Python": true, "Splunk": true, "SIEM": true} 187 for s := range wantSkills { 188 if !containsStr(got.Skills, s) { 189 t.Fatalf("expected skill %q in %v", s, got.Skills) 190 } 191 } 192 if got.ClearanceCode != "ts_sci" { 193 t.Fatalf("expected triage clearance code ts_sci, got %q", got.ClearanceCode) 194 } 195} 196 197// splitFieldName splits a CamelCase Go field name into lowercased word segments, so "FullName" becomes 198// {"full","name"} and a demographic marker is matched as a whole segment, never as a substring of an 199// unrelated workforce word. 200func splitFieldName(name string) []string { 201 var segs []string 202 var cur []rune 203 for _, r := range name { 204 if r >= 'A' && r <= 'Z' && len(cur) > 0 { 205 segs = append(segs, strings.ToLower(string(cur))) 206 cur = cur[:0] 207 } 208 cur = append(cur, r) 209 } 210 if len(cur) > 0 { 211 segs = append(segs, strings.ToLower(string(cur))) 212 } 213 return segs 214} 215 216func containsStr(xs []string, s string) bool { 217 for _, x := range xs { 218 if x == s { 219 return true 220 } 221 } 222 return false 223} 224 225// TestBenchRecordCarriesNoDemographicField is the structural invariant: BenchRecord must carry no protected 226// attribute or close proxy. It asserts field by field that none of the field names matches a demographic 227// marker, so a future edit that adds a demographic field fails this test by construction. 228func TestBenchRecordCarriesNoDemographicField(t *testing.T) { 229 // Markers match a field name as a whole, lowercased, underscore split segment, so a workforce field 230 // like "Agencies" is not flagged by the "age" demographic marker on a substring overlap. 231 markers := map[string]bool{ 232 "race": true, "ethnicity": true, "gender": true, "sex": true, "age": true, "birth": true, 233 "dob": true, "veteran": true, "disability": true, "nationalorigin": true, "nationality": true, 234 "religion": true, "marital": true, "pregnancy": true, "demographic": true, "protected": true, 235 } 236 tp := reflect.TypeOf(BenchRecord{}) 237 for i := 0; i < tp.NumField(); i++ { 238 for _, seg := range splitFieldName(tp.Field(i).Name) { 239 if markers[seg] { 240 t.Fatalf("BenchRecord field %q has demographic segment %q", tp.Field(i).Name, seg) 241 } 242 } 243 } 244 // Document the exact allowed field set so an added field is a deliberate, reviewed change. 245 want := []string{ 246 "FullName", "Location", "JobTitle", "Skills", "Certs", "Agencies", 247 "Years", "ClearanceCode", "ExternalID", "Email", "Phone", 248 } 249 if tp.NumField() != len(want) { 250 t.Fatalf("BenchRecord field count changed: got %d want %d, review the no demographic field invariant", tp.NumField(), len(want)) 251 } 252 for i, w := range want { 253 if tp.Field(i).Name != w { 254 t.Fatalf("BenchRecord field %d is %q, expected %q", i, tp.Field(i).Name, w) 255 } 256 } 257} 258