Source identity
| Field | Recorded value |
|---|---|
| Source type | GitHub source |
| Original record | Janady13/missionmatch / internal/modules/alerts/dto_test.go |
| Date | Not specified in source |
| Repository | Janady13/missionmatch |
| Revision | 720d47fae476b0d38477ae4401697d372b1ea2bc |
| Branch | feature/opportunity-to-outcome |
| Path or archive member | internal/modules/alerts/dto_test.go |
| Original SHA-256 | d30f8b871e99cf437ec4d8590faaddcad2aa5b2fe2f1889c054857f0e674a63b |
| Git blob SHA | 55eb02f34068204c45de245d7d409bddaa70fb6d |
| Reading-copy SHA-256 | d30f8b871e99cf437ec4d8590faaddcad2aa5b2fe2f1889c054857f0e674a63b |
Recovered source transcript
Download complete source text ↓191 lines · 8.1 KB
package alerts
import (
"reflect"
"strings"
"testing"
)
// TestDedupeKey pins the stable dedupe key construction. The key is the type prefix joined to the subject id,
// and the org scoping comes from the UNIQUE (organization_id, dedupe_key) constraint, so the same event
// always yields the same key (the basis for the idempotent UPSERT) and two different subjects never collide.
func TestDedupeKey(t *testing.T) {
cases := []struct {
alertType string
subjectID string
want string
}{
{TypeClearanceExpiring, "11111111-1111-1111-1111-111111111111", "clearance_expiring:11111111-1111-1111-1111-111111111111"},
{TypeRecompeteWinnable, "22222222-2222-2222-2222-222222222222", "recompete_winnable:22222222-2222-2222-2222-222222222222"},
{TypeGapFillable, "33333333-3333-3333-3333-333333333333", "gap_fillable:33333333-3333-3333-3333-333333333333"},
{TypeCollision, "44444444-4444-4444-4444-444444444444", "collision:44444444-4444-4444-4444-444444444444"},
}
for _, c := range cases {
if got := dedupeKey(c.alertType, c.subjectID); got != c.want {
t.Errorf("dedupeKey(%q, %q) = %q, want %q", c.alertType, c.subjectID, got, c.want)
}
}
// The same event is byte stable: a re sweep recomputes the identical key, which is what makes the UPSERT
// idempotent.
a := dedupeKey(TypeClearanceExpiring, "abc")
b := dedupeKey(TypeClearanceExpiring, "abc")
if a != b {
t.Errorf("dedupeKey must be stable for the same event, got %q then %q", a, b)
}
// Two different subjects never collide, so two candidates each get their own alert row.
if dedupeKey(TypeClearanceExpiring, "abc") == dedupeKey(TypeClearanceExpiring, "def") {
t.Error("different subjects must yield different dedupe keys")
}
// Two different types over the same subject never collide either.
if dedupeKey(TypeGapFillable, "abc") == dedupeKey(TypeClearanceExpiring, "abc") {
t.Error("different alert types must yield different dedupe keys for the same subject")
}
}
// TestIsValidType pins the closed set of alert types the DB CHECK enforces.
func TestIsValidType(t *testing.T) {
for _, ty := range []string{TypeRecompeteWinnable, TypeClearanceExpiring, TypeGapFillable, TypeCollision} {
if !IsValidType(ty) {
t.Errorf("%q must be a valid alert type", ty)
}
}
for _, ty := range []string{"", "recompete", "RECOMPETE_WINNABLE", "gap", "clearance_expiring "} {
if IsValidType(ty) {
t.Errorf("%q must NOT be a valid alert type", ty)
}
}
}
// TestIsValidSeverity pins the closed set of severities the DB CHECK enforces.
func TestIsValidSeverity(t *testing.T) {
for _, s := range []string{SeverityInfo, SeverityWatch, SeverityUrgent} {
if !IsValidSeverity(s) {
t.Errorf("%q must be a valid severity", s)
}
}
for _, s := range []string{"", "low", "URGENT", "critical"} {
if IsValidSeverity(s) {
t.Errorf("%q must NOT be a valid severity", s)
}
}
}
// TestIsValidStatus pins the closed set of statuses the DB CHECK enforces and the UI PATCH validates against.
func TestIsValidStatus(t *testing.T) {
for _, s := range []string{StatusUnread, StatusRead, StatusDismissed} {
if !IsValidStatus(s) {
t.Errorf("%q must be a valid status", s)
}
}
for _, s := range []string{"", "open", "archived", "READ", "dismissed "} {
if IsValidStatus(s) {
t.Errorf("%q must NOT be a valid status", s)
}
}
}
// TestSweepSummaryTotal pins the total as the sum of the per type counts.
func TestSweepSummaryTotal(t *testing.T) {
s := SweepSummary{ClearanceExpiring: 2, RecompeteWinnable: 3, GapFillable: 4, Collision: 5}
if s.Total() != 14 {
t.Errorf("Total() = %d, want 14", s.Total())
}
if (SweepSummary{}).Total() != 0 {
t.Errorf("an empty summary must total 0")
}
}
// TestCollisionToAlert pins the collision severity logic and the advisory shape: a scarce cleared person OR a
// true double commitment (approved on two or more) is urgent, an ordinary proposed collision is watch, and the
// finding always names the deterministic suggested primary and discloses clearance is self reported, not
// verified. It is advisory (a candidate subject, never an auto rejection).
func TestCollisionToAlert(t *testing.T) {
// A scarce cleared candidate proposed on two bids: urgent.
scarce := collision{candidateID: "c1", fullName: "Ada", scarceCleared: true, oppCount: 2, approvedCount: 0, suggestedPrimary: "Bid A", opportunityNames: "Bid A, Bid B"}
a := scarce.toAlert()
if a.severity != SeverityUrgent {
t.Errorf("a scarce cleared collision must be urgent, got %q", a.severity)
}
if a.alertType != TypeCollision || a.subjectType != SubjectCandidate || a.subjectID != "c1" {
t.Errorf("collision alert shape wrong: %+v", a)
}
if a.dedupeKey != "collision:c1" {
t.Errorf("dedupe key must be one per candidate, got %q", a.dedupeKey)
}
// A non scarce candidate merely proposed (approved on zero or one): watch.
proposed := collision{candidateID: "c2", fullName: "Grace", scarceCleared: false, oppCount: 2, approvedCount: 1, suggestedPrimary: "Bid X", opportunityNames: "Bid X, Bid Y"}
if p := proposed.toAlert(); p.severity != SeverityWatch {
t.Errorf("an ordinary proposed collision must be watch, got %q", p.severity)
}
// A true double commitment (approved on two) is urgent even without a scarce clearance.
doubled := collision{candidateID: "c3", fullName: "Kay", scarceCleared: false, oppCount: 2, approvedCount: 2, suggestedPrimary: "Bid M", opportunityNames: "Bid M, Bid N"}
d := doubled.toAlert()
if d.severity != SeverityUrgent {
t.Errorf("a double commitment must be urgent, got %q", d.severity)
}
// The disclosure and the suggested primary must always be present in the detail.
for _, want := range []string{"Suggested primary", "not verified"} {
if !strings.Contains(d.detail, want) {
t.Errorf("collision detail must contain %q, got %q", want, d.detail)
}
}
}
// THE COUNTS ONLY AUDIT EVENT AND THE TOTAL MUST BOTH KNOW ABOUT EVERY TYPE.
//
// This is the failure the sweep would otherwise hide: a fifth trigger fires, upserts alerts, and the audit
// row and the total report a smaller number than actually happened. Nobody would notice, because the alerts
// themselves appear on screen and only the accounting of them is wrong. Reflection over the summary struct
// means a sixth type cannot be added without either being counted or being deliberately excluded here.
func TestSweepSummaryTotalCountsEveryType(t *testing.T) {
var s SweepSummary
v := reflect.ValueOf(&s).Elem()
want := 0
for i := 0; i < v.NumField(); i++ {
if v.Field(i).Kind() != reflect.Int {
continue
}
v.Field(i).SetInt(int64(i + 1))
want += i + 1
}
if got := s.Total(); got != want {
t.Fatalf("Total() = %d, want %d. A type was added to SweepSummary and left out of Total, so the "+
"sweep under reports what it actually did.", got, want)
}
}
// Every type in the closed vocabulary must be accepted by the validator, or the sweep writes an alert the
// read path refuses to serve.
func TestRedeploymentDueIsAValidType(t *testing.T) {
if !validTypes[TypeRedeploymentDue] {
t.Fatal("redeployment_due is not in the accepted set, the sweep would write alerts nothing can read")
}
}
// THE VOCABULARY MUST MATCH THE DATABASE CHECK, and this is the drift that proved it can silently stop
// matching. Migration 0075 widened the CHECK by two members and this map was not updated for a year of
// commits, which nothing caught because IsValidType has no caller. A list that claims to mirror a constraint
// and does not is worse than no list, because the next person to use it trusts it.
//
// The seven members here are the seven in the CHECK after migration 0099. If a migration widens the CHECK
// again, this fails, which is the point.
func TestVocabularyMatchesTheDatabaseCheck(t *testing.T) {
inCheck := []string{
"recompete_winnable", "clearance_expiring", "gap_fillable", "collision",
"opportunity_amendment", "opportunity_deadline", "redeployment_due",
}
for _, want := range inCheck {
if !validTypes[want] {
t.Errorf("%q is accepted by the database CHECK and missing from validTypes", want)
}
}
if len(validTypes) != len(inCheck) {
t.Errorf("validTypes has %d members and the CHECK has %d. A value the database refuses would be "+
"accepted here and fail as a raw constraint violation.", len(validTypes), len(inCheck))
}
}