Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go
Date	Not specified in source
Repository	Janady13/missionmatch
Revision	720d47fae476b0d38477ae4401697d372b1ea2bc
Branch	feature/opportunity-to-outcome
Path or archive member	internal/modules/matching/chainedresolver_test.go
Original SHA-256	53d558971b0124ed2484023ec32b24f11eec629b96e878b78ae2efa56294af5b
Git blob SHA	b74ff65f05303771f96d2275be62fcf4449514c1
Reading-copy SHA-256	53d558971b0124ed2484023ec32b24f11eec629b96e878b78ae2efa56294af5b

Original source ↗

Every recorded occurrence

These 19 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/matching/chainedresolver_test.go	feature/opportunity-to-outcome	720d47fae476b0d38477ae4401697d372b1ea2bc	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	collision-deconfliction	4ee5a09972608ed89f8377c6665542d5f450f0a6	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	ws6-retrieval	6c56e29231ec05735927fa265c97d517499dfeaf	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	m5-price-to-win	41000ad30fff4129fdaf5ec84e15ba14c27d4890	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	master	1e9249840a4302ec82e123b9c9cb6f75badea3e4	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	ws8-teaching-loop	c823f0fb6bb2aba0f39001eb6de96f4000d9321f	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	mag-substrate	b82c7100a492dec67dfd1eda6b3f53def859be35	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	ws3-clearance	4b8e7ce594c068621867f9c9deed0ec64ae6c553	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	phase2-eval-fairness	d361af254701975fe239927656ababb56374655e	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	time-to-fill-survival	b66e1e505863d4f17741a4b9ede73509e45bd6c6	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	graphrag-foundation	b0ddeb9f633fd138d09309d1a17b7d13bc3a67f7	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	ws9-bench-ingestion	f585a9ef32fa554663ce1fba9a414a54b6e49cf0	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	ws2-alias-relationship	e4dada4601c6eb101830f9d223a9655dfa120616	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	presentation-readiness	eb574acaa29d71ce4d0f852572e87c275c79fdb7	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	vendor-intelligence	fe9796a19c261951d3f2565206c0c1b5ac294465	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	ws7-federal-signal	6a9f6ce9cfb13345ffb47770d4960e7c2d9c17c2	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	phase2-connectors	e038d4c687aec16f8bd9bc4d907eea14d91f8704	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	feature/aioe-upgrade	2178e7298d0e5d9af83afa12402fd587f0ba6ed8	Open original
Janady13/missionmatch / internal/modules/matching/chainedresolver_test.go	capture-readiness	bae6af7cb2997e819174a9e9cfff5e16067a1975	Open original

Recovered source transcript

Download complete source text ↓135 lines · 5.0 KB

package matching

import (
	"context"
	"testing"

	"github.com/shopspring/decimal"

	"github.com/missionworkforce/missionmatch/internal/modules/matching/engine"
)

// fakeAliasResolver is a test double for DeterministicAliasResolver that returns a fixed result.
type fakeAliasResolver struct {
	match engine.SkillMatch
	ok    bool
}

func (f *fakeAliasResolver) ResolveAlias(_ context.Context, _ engine.RequiredSkill, _ []engine.CandidateSkill) (engine.SkillMatch, bool) {
	return f.match, f.ok
}

// fakeSemanticMatcher is a test double for engine.SkillMatcher that counts calls and returns a
// fixed result.
type fakeSemanticMatcher struct {
	match engine.SkillMatch
	ok    bool
	calls int
}

func (f *fakeSemanticMatcher) Match(_ context.Context, _ engine.RequiredSkill, _ []engine.CandidateSkill, _ decimal.Decimal) (engine.SkillMatch, bool) {
	f.calls++
	return f.match, f.ok
}

// resolverBridge adapts fakeAliasResolver to the interface ChainedResolver expects. ChainedResolver
// holds a *DeterministicAliasResolver directly, so for tests we build a real resolver from injected
// maps and a fakeSemanticMatcher.
func resolverBridgeFromFake(f *fakeAliasResolver) *DeterministicAliasResolver {
	// Build a resolver that will always return the faked result by wiring maps such that the first
	// candidate resolves to the same canonical id as the required skill when f.ok is true, or builds
	// empty maps when f.ok is false so there is no match.
	if f.ok {
		// canonical id "test-id" for both sides causes alias match
		nameToID := map[string]string{"required skill": "test-id", "candidate skill": "test-id"}
		return newResolverFromMaps(nameToID, nil, nil)
	}
	return newResolverFromMaps(nil, nil, nil)
}

// chainedTestRequired and chainedTestCands are fixed inputs used in chained resolver tests.
var chainedTestRequired = engine.RequiredSkill{SkillID: "test-id", Name: "Required Skill"}
var chainedTestCands = []engine.CandidateSkill{{SkillID: "test-id", Name: "Candidate Skill"}}

// TestChainedResolver_ResolverWins: when the alias resolver matches, the semantic matcher is not
// called and the resolver result is returned.
func TestChainedResolver_ResolverWins(t *testing.T) {
	resolverMatch := engine.SkillMatch{
		CandidateSkillID: "test-id",
		CandidateName:    "Candidate Skill",
		Similarity:       decimal.NewFromInt(1),
		Exact:            true,
		AliasMatched:     true,
		Matched:          true,
	}

	// Build a real resolver that will return a match for chainedTestRequired vs chainedTestCands:
	// both sides share canonical id "test-id" via nameToID.
	nameToID := map[string]string{
		"required skill":  "test-id",
		"candidate skill": "test-id",
	}
	resolver := newResolverFromMaps(nameToID, nil, nil)

	semantic := &fakeSemanticMatcher{ok: false}
	c := NewChainedResolver(resolver, semantic)

	m, ok := c.Match(context.Background(), chainedTestRequired, chainedTestCands, decimal.RequireFromString("0.62"))
	if !ok {
		t.Fatal("expected match from resolver, got none")
	}
	if semantic.calls != 0 {
		t.Errorf("semantic matcher should not be called when resolver wins, got %d calls", semantic.calls)
	}
	// The resolver result has AliasMatched true, Exact true.
	_ = resolverMatch
	if !m.AliasMatched {
		t.Error("AliasMatched should be true (resolver sourced)")
	}
}

// TestChainedResolver_SemanticRunsOnResolverMiss: when the resolver returns no match, the semantic
// matcher is called and its result is returned.
func TestChainedResolver_SemanticRunsOnResolverMiss(t *testing.T) {
	semanticMatch := engine.SkillMatch{
		CandidateSkillID: "sk-adjacent",
		CandidateName:    "Adjacent Skill",
		Similarity:       decimal.RequireFromString("0.75"),
		Exact:            false,
		Matched:          true,
	}
	// empty maps: resolver will never match
	resolver := newResolverFromMaps(nil, nil, nil)
	semantic := &fakeSemanticMatcher{match: semanticMatch, ok: true}
	c := NewChainedResolver(resolver, semantic)

	required := engine.RequiredSkill{SkillID: "sk-req", Name: "Required"}
	cands := []engine.CandidateSkill{{SkillID: "sk-adjacent", Name: "Adjacent Skill"}}

	m, ok := c.Match(context.Background(), required, cands, decimal.RequireFromString("0.62"))
	if !ok {
		t.Fatal("expected semantic match, got none")
	}
	if semantic.calls != 1 {
		t.Errorf("semantic matcher should be called exactly once, got %d calls", semantic.calls)
	}
	if !m.Similarity.Equal(decimal.RequireFromString("0.75")) {
		t.Errorf("Similarity = %s, want 0.75", m.Similarity)
	}
}

// TestChainedResolver_NilSemanticDegrades: a nil semantic matcher plus a resolver that returns no
// match yields (SkillMatch{}, false), not a panic.
func TestChainedResolver_NilSemanticDegrades(t *testing.T) {
	resolver := newResolverFromMaps(nil, nil, nil)
	c := NewChainedResolver(resolver, nil)

	required := engine.RequiredSkill{SkillID: "sk-req", Name: "Required"}
	cands := []engine.CandidateSkill{{SkillID: "sk-other", Name: "Other"}}

	_, ok := c.Match(context.Background(), required, cands, decimal.RequireFromString("0.62"))
	if ok {
		t.Fatal("expected no match when resolver misses and semantic is nil")
	}
}