100 lines
4.8 KiB
Go
100 lines
4.8 KiB
Go
package domain_test
|
|
|
|
import (
|
|
selfcontract "git.cin.su/m/Assistant/contracts/self"
|
|
"git.cin.su/m/Assistant/modules/self/domain"
|
|
"git.cin.su/m/Assistant/platform/ids"
|
|
"testing"
|
|
)
|
|
|
|
func TestCompetenceCannotBeSelfDeclaredWithoutEvidence(t *testing.T) {
|
|
v := selfcontract.CompetenceAssessment{ID: "a", PrincipalID: "p", SubjectRef: selfcontract.SemanticReference{OwnerNamespace: "capability", SemanticKind: "skill", StableID: "s"}, Revision: 1, ConfidenceMillis: 1000, AssessedAt: 1}
|
|
if domain.ValidateCompetence(v) == nil {
|
|
t.Fatal("unsupported competence accepted")
|
|
}
|
|
v.EvidenceRefs = []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "evaluation", StableID: "e"}}
|
|
if err := domain.ValidateCompetence(v); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestShadowDivergenceCreatesProposalNotPromotion(t *testing.T) {
|
|
reflex := selfcontract.SemanticReference{OwnerNamespace: "capability", SemanticKind: "reflex", StableID: "r"}
|
|
evidence := []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "experience", StableID: "e"}}
|
|
need, ledger, err := domain.ImprovementForReflexDivergence("p", reflex, evidence, 1)
|
|
if err != nil || need.State != "OPEN" || ledger.Decision != "PROPOSE_REVALIDATION" {
|
|
t.Fatalf("need=%#v ledger=%#v err=%v", need, ledger, err)
|
|
}
|
|
}
|
|
|
|
func signal(kind selfcontract.LearningSignalKind, id, scope string, at int64) selfcontract.LearningSignal {
|
|
return selfcontract.LearningSignal{ID: id, PrincipalID: "p", Kind: kind, TaskPattern: "recall", ScopeKey: scope, SubjectRef: selfcontract.SemanticReference{OwnerNamespace: "interaction", SemanticKind: "assertion", StableID: ids.StableID("x")}, EvidenceRefs: []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "experience", StableID: ids.StableID(id)}}, ObservedAt: at, Severity: 2, UserImpact: 1}
|
|
}
|
|
|
|
func TestRepeatedSignalsCreateScopedWeaknessButSingleDoesNot(t *testing.T) {
|
|
a, b := signal(selfcontract.SignalUserCorrection, "e1", "company-a", 1), signal(selfcontract.SignalUserCorrection, "e2", "company-a", 2)
|
|
if _, created, err := domain.BuildWeaknessPattern("p", "recall", "company-a", "v1", []selfcontract.LearningSignal{a}, "context", "strategy"); err != nil || created {
|
|
t.Fatalf("single incident created weakness: %v %v", created, err)
|
|
}
|
|
w, created, err := domain.BuildWeaknessPattern("p", "recall", "company-a", "v1", []selfcontract.LearningSignal{a, b}, "context", "strategy")
|
|
if err != nil || !created || w.Frequency != 2 || w.ScopeKey != "company-a" {
|
|
t.Fatalf("weakness=%#v created=%v err=%v", w, created, err)
|
|
}
|
|
}
|
|
|
|
func TestDiagnosisCandidateAndMustNotWorsen(t *testing.T) {
|
|
s := signal(selfcontract.SignalReflexDivergence, "e3", "company-a", 3)
|
|
d := domain.AttributeFailure(s)
|
|
if d.Class != selfcontract.DiagnosisReflexFailure || d.Status != selfcontract.EpistemicHypothesis {
|
|
t.Fatalf("diagnosis=%#v", d)
|
|
}
|
|
n, err := domain.BuildImprovementNeed(s, d, "reflex")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
c, err := domain.BuildCandidate(n, "creator", "evaluator", s.EvidenceRefs, 3)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
decision, err := domain.EvaluateCandidate(c, selfcontract.ImprovementEvaluation{Evaluator: "evaluator", EvidenceRefs: s.EvidenceRefs, ExpectedQuality: 800, ActualQuality: 800, ExpectedLatency: 100, ActualLatency: 250, MustNotWorsenPass: true})
|
|
if err != nil || decision != selfcontract.CandidateRejected {
|
|
t.Fatalf("decision=%v err=%v", decision, err)
|
|
}
|
|
}
|
|
|
|
func TestScopedEvidenceIsDeduplicatedAndBounded(t *testing.T) {
|
|
s := signal(selfcontract.SignalSkillFallback, "e4", "company-a", 4)
|
|
d := domain.AttributeFailure(s)
|
|
n, err := domain.BuildImprovementNeed(s, d, "skill")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = domain.BuildCandidate(n, "creator", "evaluator", append(s.EvidenceRefs, s.EvidenceRefs...), 4); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := domain.ClassifyDecisionRegret(selfcontract.LearningSignal{DecisionRegret: selfcontract.RegretIgnoredInContext}); got != selfcontract.RegretIgnoredInContext {
|
|
t.Fatal(got)
|
|
}
|
|
}
|
|
|
|
func TestBenchmarkAndLedgerReferenceEvidence(t *testing.T) {
|
|
s := signal(selfcontract.SignalOutcomeMismatch, "e5", "company-a", 5)
|
|
caseRef, err := domain.BuildBenchmarkCase("p", "memory-recall", s.EvidenceRefs, 5)
|
|
if err != nil || !caseRef.Valid() {
|
|
t.Fatalf("benchmark=%#v err=%v", caseRef, err)
|
|
}
|
|
d := domain.AttributeFailure(s)
|
|
n, err := domain.BuildImprovementNeed(s, d, "verification")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
c, err := domain.BuildCandidate(n, "creator", "evaluator", s.EvidenceRefs, 5)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
l, err := domain.AppendLedgerOutcome(n, c, selfcontract.ImprovementEvaluation{Evaluator: "evaluator", EvidenceRefs: s.EvidenceRefs}, selfcontract.CandidateRejected, 6)
|
|
if err != nil || l.Decision != string(selfcontract.CandidateRejected) || len(l.EvidenceRefs) == 0 {
|
|
t.Fatalf("ledger=%#v err=%v", l, err)
|
|
}
|
|
}
|