Source identity
| Field | Recorded value |
|---|---|
| Source type | GitHub source |
| Original record | Janady13/missionmatch / internal/modules/recruitmatch/derive_test.go |
| Date | Not specified in source |
| Repository | Janady13/missionmatch |
| Revision | 720d47fae476b0d38477ae4401697d372b1ea2bc |
| Branch | feature/opportunity-to-outcome |
| Path or archive member | internal/modules/recruitmatch/derive_test.go |
| Original SHA-256 | b42b0c641dbc656f1c387e3a7be6f78722659966c0e96ec92e0a792be2354322 |
| Git blob SHA | 11b30f84a18fb1af0bf4f7996d2dfdd7205db2f7 |
| Reading-copy SHA-256 | b42b0c641dbc656f1c387e3a7be6f78722659966c0e96ec92e0a792be2354322 |
Every recorded occurrence
These 2 records contain identical original source bytes. Their paths and revisions remain part of the archive.
| Original record | Branch or archive | Revision / identifier | Original location |
|---|---|---|---|
| Janady13/missionmatch / internal/modules/recruitmatch/derive_test.go | feature/opportunity-to-outcome | 720d47fae476b0d38477ae4401697d372b1ea2bc | Open original |
| Janady13/missionmatch / internal/modules/recruitmatch/derive_test.go | feature/aioe-upgrade | 2178e7298d0e5d9af83afa12402fd587f0ba6ed8 | Open original |
Recovered source transcript
Download complete source text ↓198 lines · 6.4 KB
package recruitmatch
import (
"testing"
"github.com/shopspring/decimal"
)
// TestPctZeroDenominatorIsZero covers the zero data organization, which is the state of every client on
// the day they are onboarded. It must be a plain zero, never a panic and never NaN.
func TestPctZeroDenominatorIsZero(t *testing.T) {
for _, den := range []int64{0, -1, -1000} {
if got := pct(5, den); !got.Equal(decimal.Zero) {
t.Errorf("pct(5, %d) = %s, want 0", den, got)
}
}
}
// TestPctKnownValues pins the arithmetic against hand computed results including a repeating decimal and
// a half way rounding boundary.
func TestPctKnownValues(t *testing.T) {
cases := []struct {
num, den int64
want string
}{
{0, 100, "0"},
{100, 100, "100"},
{1, 3, "33.33"},
{2, 3, "66.67"},
{1, 8, "12.5"},
{1, 16, "6.25"},
{667, 2000, "33.35"}, // 33.35 exactly, guards the half away from zero boundary
{1, 1000000, "0"},
}
for _, c := range cases {
if got := pct(c.num, c.den).String(); got != c.want {
t.Errorf("pct(%d, %d) = %s, want %s", c.num, c.den, got, c.want)
}
}
}
// TestPctNeverExceedsHundredWhenNumLeDen is the property the funnel width depends on. If this can fail,
// a stage can render wider than the chart.
func TestPctNeverExceedsHundredWhenNumLeDen(t *testing.T) {
for den := int64(1); den <= 500; den++ {
for num := int64(0); num <= den; num++ {
p := pct(num, den)
if p.GreaterThan(hundred) {
t.Fatalf("pct(%d, %d) = %s exceeds 100", num, den, p)
}
if p.IsNegative() {
t.Fatalf("pct(%d, %d) = %s is negative", num, den, p)
}
}
}
}
// TestPctIsOrderIndependentAtThisPrecision proves the claim asserted in the pct doc comment: dividing
// first is equivalent to multiplying first after Round(2). If a future decimal upgrade changes
// DivisionPrecision this test fails and the comment stops being a lie.
func TestPctIsOrderIndependentAtThisPrecision(t *testing.T) {
for den := int64(1); den <= 400; den++ {
for num := int64(0); num <= den; num++ {
divFirst := decimal.NewFromInt(num).Div(decimal.NewFromInt(den)).Mul(hundred).Round(2)
mulFirst := decimal.NewFromInt(num).Mul(hundred).Div(decimal.NewFromInt(den)).Round(2)
if !divFirst.Equal(mulFirst) {
t.Fatalf("order dependence at num=%d den=%d: divFirst=%s mulFirst=%s", num, den, divFirst, mulFirst)
}
}
}
}
// TestBuildFunnelEmptyOrg is the day one case: four stages, all zero, no division by zero.
func TestBuildFunnelEmptyOrg(t *testing.T) {
got := buildFunnel(0, 0, 0, 0)
if len(got) != 4 {
t.Fatalf("want 4 stages, got %d", len(got))
}
for _, s := range got {
if s.Count != 0 {
t.Errorf("stage %q count = %d, want 0", s.Key, s.Count)
}
if s.Pct != "0.00" {
t.Errorf("stage %q pct = %q, want 0.00", s.Key, s.Pct)
}
if s.Label == "" {
t.Errorf("stage %q has an empty label", s.Key)
}
}
}
// TestBuildFunnelPercentagesAreShareOfIdentified pins the semantics: every stage is a share of the whole
// bench, not of the previous stage.
func TestBuildFunnelPercentagesAreShareOfIdentified(t *testing.T) {
got := buildFunnel(200, 100, 50, 20)
want := map[string]string{
"identified": "100.00",
"screened": "50.00",
"submitted": "25.00",
"approved": "10.00",
}
for _, s := range got {
if want[s.Key] != s.Pct {
t.Errorf("stage %q pct = %q, want %q", s.Key, s.Pct, want[s.Key])
}
}
}
// TestBuildFunnelIsNonIncreasingForMonotonicInput is the core invariant. service_queries derives every
// stage from the same live candidate set as a DISTINCT count, so the input is always non increasing.
// This sweeps a large space of such inputs and proves the rendered percentages never rise.
func TestBuildFunnelIsNonIncreasingForMonotonicInput(t *testing.T) {
for identified := int64(0); identified <= 60; identified++ {
for screened := int64(0); screened <= identified; screened++ {
for submitted := int64(0); submitted <= screened; submitted++ {
for approved := int64(0); approved <= submitted; approved++ {
st := buildFunnel(identified, screened, submitted, approved)
prev := decimal.NewFromInt(101)
for _, s := range st {
cur, err := decimal.NewFromString(s.Pct)
if err != nil {
t.Fatalf("stage %q pct %q does not parse: %v", s.Key, s.Pct, err)
}
if cur.GreaterThan(prev) {
t.Fatalf("funnel rose at %q: %s after %s (in=%d,%d,%d,%d)",
s.Key, cur, prev, identified, screened, submitted, approved)
}
if cur.GreaterThan(hundred) {
t.Fatalf("stage %q = %s exceeds 100", s.Key, cur)
}
prev = cur
}
}
}
}
}
}
// TestBuildFunnelStageOrderIsStable guards the contract the frontend renders against.
func TestBuildFunnelStageOrderIsStable(t *testing.T) {
want := []string{"identified", "screened", "submitted", "approved"}
got := buildFunnel(10, 5, 3, 1)
if len(got) != len(want) {
t.Fatalf("want %d stages, got %d", len(want), len(got))
}
for i, w := range want {
if got[i].Key != w {
t.Errorf("stage %d = %q, want %q", i, got[i].Key, w)
}
}
}
// TestBuildDecisionsExcludesPendingFromTheRate proves an undecided member cannot drag the approve rate.
// A backlog of pending reviews is a throughput signal, not evidence of rejection.
func TestBuildDecisionsExcludesPendingFromTheRate(t *testing.T) {
a := buildDecisions(3, 1, 0)
b := buildDecisions(3, 1, 96)
if a.ApproveRate != b.ApproveRate {
t.Errorf("pending changed the approve rate: %s then %s", a.ApproveRate, b.ApproveRate)
}
if a.ApproveRate != "75.00" {
t.Errorf("approve rate = %q, want 75.00", a.ApproveRate)
}
if b.Total != 100 {
t.Errorf("total = %d, want 100", b.Total)
}
}
// TestBuildDecisionsAllPendingIsZeroNotNaN is the state of a slate that has been generated but never
// reviewed, which is common and must not divide by zero.
func TestBuildDecisionsAllPendingIsZeroNotNaN(t *testing.T) {
d := buildDecisions(0, 0, 12)
if d.ApproveRate != "0.00" {
t.Errorf("approve rate = %q, want 0.00", d.ApproveRate)
}
if d.Total != 12 {
t.Errorf("total = %d, want 12", d.Total)
}
}
// TestNotTrackedPanelsAreFullyPopulated. A blank reason would render an empty box that looks broken.
func TestNotTrackedPanelsAreFullyPopulated(t *testing.T) {
panels := notTracked()
if len(panels) == 0 {
t.Fatal("notTracked returned nothing")
}
seen := map[string]bool{}
for _, p := range panels {
if p.Key == "" || p.Title == "" || p.Reason == "" {
t.Errorf("panel %+v has an empty field", p)
}
if seen[p.Key] {
t.Errorf("duplicate panel key %q", p.Key)
}
seen[p.Key] = true
}
}