Janady13/missionmatch / internal/modules/recruiting/service_test.go

1package recruiting 2 3import ( 4 "errors" 5 "strings" 6 "testing" 7 "time" 8 9 "github.com/google/uuid" 10 "github.com/jackc/pgx/v5/pgconn" 11) 12 13// TestParseTokenRequiresAValue. An update without a concurrency token must be refused rather than 14// silently treated as last write wins, which is the failure mode the token exists to prevent. 15func TestParseTokenRequiresAValue(t *testing.T) { 16 for _, v := range []string{"", " ", "\t"} { 17 if _, err := parseToken(v); !errors.Is(err, ErrInvalid) { 18 t.Errorf("parseToken(%q) error = %v, want a validation error", v, err) 19 } 20 } 21} 22 23func TestParseTokenRejectsNonRFC3339(t *testing.T) { 24 for _, v := range []string{"yesterday", "2026-07-20", "1721520000"} { 25 if _, err := parseToken(v); err == nil { 26 t.Errorf("parseToken(%q) accepted a value that is not RFC3339", v) 27 } 28 } 29} 30 31// TestTokenRoundTripPreservesMicroseconds is the property the whole optimistic concurrency scheme rests 32// on. Postgres stores timestamptz at microsecond precision; if the wire format truncated it, every 33// update would compare unequal and every write would 409 forever. 34func TestTokenRoundTripPreservesMicroseconds(t *testing.T) { 35 original := time.Date(2026, 7, 21, 1, 49, 23, 90678000, time.UTC) 36 parsed, err := parseToken(ts(original)) 37 if err != nil { 38 t.Fatalf("round trip failed: %v", err) 39 } 40 if !parsed.Equal(original) { 41 t.Errorf("round trip lost precision: %s became %s", 42 original.Format(time.RFC3339Nano), parsed.Format(time.RFC3339Nano)) 43 } 44} 45 46// TestCleanTrimsAndBounds. 47func TestCleanTrimsAndBounds(t *testing.T) { 48 got, err := clean("name", " Acme Defense ", 200) 49 if err != nil || got != "Acme Defense" { 50 t.Errorf("clean trimmed to %q err=%v, want \"Acme Defense\"", got, err) 51 } 52 if _, err := clean("name", strings.Repeat("x", 201), 200); err == nil { 53 t.Error("an over length value was accepted") 54 } 55 if got, err := clean("name", strings.Repeat("x", 200), 200); err != nil || len(got) != 200 { 56 t.Errorf("a value exactly at the bound was rejected: %v", err) 57 } 58} 59 60// TestTranslatePGMapsConstraintsToTypedErrors is the reason a duplicate client name is a 409 that names 61// the field instead of a 500. The constraint names are declared in migration 0047 and this test is what 62// stops a rename there silently turning a clean conflict back into an internal error. 63func TestTranslatePGMapsConstraintsToTypedErrors(t *testing.T) { 64 cases := []struct { 65 name string 66 code string 67 constraint string 68 column string 69 wantField string 70 wantDup bool 71 wantVal bool 72 }{ 73 {"duplicate client name", "23505", "uq_clients_org_name", "", "name", true, false}, 74 {"duplicate client uei", "23505", "uq_clients_org_uei", "", "uei", true, false}, 75 {"two primary contacts", "23505", "uq_client_contacts_primary", "", "is_primary", true, false}, 76 {"unknown unique", "23505", "some_other_uq", "", "some_other_uq", true, false}, 77 {"status check", "23514", "clients_status_check", "", "status", false, true}, 78 {"not null", "23502", "", "name", "name", false, true}, 79 } 80 for _, c := range cases { 81 t.Run(c.name, func(t *testing.T) { 82 err := translatePG(&pgconn.PgError{Code: c.code, ConstraintName: c.constraint, ColumnName: c.column}) 83 var dup *DuplicateError 84 var val *ValidationError 85 switch { 86 case c.wantDup: 87 if !errors.As(err, &dup) { 88 t.Fatalf("want a DuplicateError, got %T: %v", err, err) 89 } 90 if dup.Field != c.wantField { 91 t.Errorf("field = %q, want %q", dup.Field, c.wantField) 92 } 93 case c.wantVal: 94 if !errors.As(err, &val) { 95 t.Fatalf("want a ValidationError, got %T: %v", err, err) 96 } 97 if val.Field != c.wantField { 98 t.Errorf("field = %q, want %q", val.Field, c.wantField) 99 } 100 if !errors.Is(err, ErrInvalid) { 101 t.Error("a ValidationError must unwrap to ErrInvalid so the handler can classify it") 102 } 103 } 104 }) 105 } 106} 107 108// TestTranslatePGMapsForeignKeyToNotFound. A write naming a client that does not exist is a 404 for the 109// caller, not a 500. 110func TestTranslatePGMapsForeignKeyToNotFound(t *testing.T) { 111 if err := translatePG(&pgconn.PgError{Code: "23503"}); !errors.Is(err, ErrNotFound) { 112 t.Errorf("foreign key violation mapped to %v, want ErrNotFound", err) 113 } 114} 115 116// TestTranslatePGPassesThroughNonPGErrors. A context cancellation must not be reported as a constraint 117// problem. 118func TestTranslatePGPassesThroughNonPGErrors(t *testing.T) { 119 sentinel := errors.New("context canceled") 120 if got := translatePG(sentinel); !errors.Is(got, sentinel) { 121 t.Errorf("a non Postgres error was rewritten: %v", got) 122 } 123 if translatePG(nil) != nil { 124 t.Error("translatePG(nil) must stay nil") 125 } 126} 127 128// TestStatusVocabulariesMatchTheMigrations pins the Go allowlists against the CHECK constraints in 0047. 129// If they drift, the database rejects a value the service accepted and the caller gets a 500. 130func TestStatusVocabulariesMatchTheMigrations(t *testing.T) { 131 for _, s := range []string{"prospect", "active", "inactive"} { 132 if !clientStatuses[s] { 133 t.Errorf("client status %q is in migration 0047 but missing from the service allowlist", s) 134 } 135 } 136 if len(clientStatuses) != 3 { 137 t.Errorf("client status allowlist has %d entries, migration 0047 permits 3", len(clientStatuses)) 138 } 139 for _, s := range []string{"active", "inactive"} { 140 if !contactStatuses[s] { 141 t.Errorf("contact status %q is in migration 0047 but missing from the service allowlist", s) 142 } 143 } 144 if len(contactStatuses) != 2 { 145 t.Errorf("contact status allowlist has %d entries, migration 0047 permits 2", len(contactStatuses)) 146 } 147} 148 149func TestItoa(t *testing.T) { 150 for _, c := range []struct { 151 in int 152 want string 153 }{{0, "0"}, {7, "7"}, {200, "200"}, {4000, "4000"}} { 154 if got := itoa(c.in); got != c.want { 155 t.Errorf("itoa(%d) = %q, want %q", c.in, got, c.want) 156 } 157 } 158} 159 160// TestOwnershipDecision is the full access matrix. Ownership is the lock, so this is the rule that 161// decides whether two recruiters can ever be in the same client at once. 162func TestOwnershipDecision(t *testing.T) { 163 alice := uuid.MustParse("11111111-1111-1111-1111-111111111111") 164 bob := uuid.MustParse("22222222-2222-2222-2222-222222222222") 165 166 cases := []struct { 167 name string 168 holder *uuid.UUID 169 actor uuid.UUID 170 isAdmin bool 171 wantClaim bool 172 wantErr bool 173 }{ 174 {"unowned account is claimed by the editor", nil, alice, false, true, false}, 175 {"unowned account is claimed by an admin too", nil, alice, true, true, false}, 176 {"the holder may edit", &alice, alice, false, false, false}, 177 {"another recruiter is refused", &alice, bob, false, false, true}, 178 {"an admin may edit an account they do not hold", &alice, bob, true, false, false}, 179 {"the holder who is also admin may edit", &alice, alice, true, false, false}, 180 } 181 for _, c := range cases { 182 t.Run(c.name, func(t *testing.T) { 183 o := owner{userID: c.holder, name: "Alice"} 184 actor := c.actor 185 claim, err := ownershipDecision(o, &actor, c.isAdmin) 186 if c.wantErr { 187 var notOwner *ErrNotOwner 188 if !errors.As(err, &notOwner) { 189 t.Fatalf("want ErrNotOwner, got %v", err) 190 } 191 if notOwner.OwnerName != "Alice" { 192 t.Errorf("the refusal must name the holder, got %q", notOwner.OwnerName) 193 } 194 return 195 } 196 if err != nil { 197 t.Fatalf("unexpected error: %v", err) 198 } 199 if claim != c.wantClaim { 200 t.Errorf("claim = %v, want %v", claim, c.wantClaim) 201 } 202 }) 203 } 204} 205 206// TestOwnershipRefusalNamesTheHolder. The answer to a collision is a conversation, so the error must 207// carry who to talk to rather than a bare denial. 208func TestOwnershipRefusalNamesTheHolder(t *testing.T) { 209 alice := uuid.MustParse("11111111-1111-1111-1111-111111111111") 210 bob := uuid.MustParse("22222222-2222-2222-2222-222222222222") 211 _, err := ownershipDecision(owner{userID: &alice, name: "Alice Chen"}, &bob, false) 212 if err == nil || !strings.Contains(err.Error(), "Alice Chen") { 213 t.Fatalf("error %v does not name the holder", err) 214 } 215} 216