108 lines
3.6 KiB
Go
108 lines
3.6 KiB
Go
package dispatcher
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.ipao.vip/rogee/go-sip/contracts"
|
|
agentv1 "git.ipao.vip/rogee/go-sip/gen/agent/v1"
|
|
"git.ipao.vip/rogee/go-sip/internal/agent"
|
|
"git.ipao.vip/rogee/go-sip/internal/ai"
|
|
"git.ipao.vip/rogee/go-sip/internal/contract"
|
|
"git.ipao.vip/rogee/go-sip/internal/health"
|
|
"git.ipao.vip/rogee/go-sip/internal/store"
|
|
)
|
|
|
|
func TestLocalContractBackedFlowEvidence(t *testing.T) {
|
|
now := time.Date(2026, 9, 18, 0, 0, 30, 0, time.UTC)
|
|
|
|
artifactRaw, err := contracts.Read("examples/static-cell-artifact.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := contract.ValidateStaticArtifact(artifactRaw, contract.StaticArtifactExpectation{
|
|
CellID: "cell-a",
|
|
Mode: "mock",
|
|
SourceRelease: "management-snapshot-1",
|
|
SourceDigest: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
|
ConfigSHA256: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
|
|
AllowedEgressPoolIDs: []string{"egress-mock"},
|
|
RequiredTrunkIDs: []string{"trunk-mock"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
snapshotRaw, err := contracts.Read("examples/agent-version-asr-only.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot, err := ai.ValidateForMode(snapshotRaw, ai.ModeASROnly)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
authorizationRaw, err := contracts.Read("examples/ai-authorization.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := ai.ValidateAuthorization(authorizationRaw, snapshot, "tenant-1", "tenant-demo-key", "egress-mock", now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sample := (health.Sampler{Now: func() time.Time { return now }}).Sample(context.Background(), t.TempDir())
|
|
if sample.SampleFresh || sample.MissingReason == "" {
|
|
t.Fatalf("resource sample must remain explicitly partial/unknown: %+v", sample)
|
|
}
|
|
|
|
st, err := store.Open(":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer st.Close()
|
|
for _, scope := range []string{"tenant:tenant-demo-key", "global", "cell:cell-a"} {
|
|
if err := st.SetQuota(scope, 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
d, err := New(st, nil, func() time.Time { return now })
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
callRaw, err := contracts.Read("examples/call.execute.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := d.AcceptCommand(callRaw, "agent-call.tenant.tenant-demo-key.call.execute"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := d.ReserveTask("tenant-demo-key", "reservation-local-flow", []string{"tenant:tenant-demo-key", "global", "cell:cell-a"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
coordinator := NewAgentCoordinator(func() time.Time { return now })
|
|
status := agentStatusForLocalFlow()
|
|
client := startMockAgent(t, &status)
|
|
if err := coordinator.Register("agent-a", client); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := coordinator.Activate(context.Background(), "agent-a", "cell-a", "boot-a", "epoch-a", 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := d.ExecuteReserved(context.Background(), coordinator, "agent-a", task, callRaw, "reservation-local-flow", snapshot.Digest)
|
|
if err != nil || result.Unknown || result.Permit == nil || result.Receipt == nil {
|
|
t.Fatalf("local execution result=%+v err=%v", result, err)
|
|
}
|
|
|
|
event, err := (agent.EventWriter{TenantID: "tenant-1", TenantKey: "tenant-demo-key", TraceID: "trace-local"}).TranscriptUpdated(now, "event-local", "call-local", "turn-local", "segment-local", "customer", "hello", 1, true, 0, 100)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := contract.ValidateEvent(event); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func agentStatusForLocalFlow() agentv1.AgentStatus {
|
|
return agentv1.AgentStatus{AgentId: "agent-a", CellId: "cell-a"}
|
|
}
|