116 lines
3.0 KiB
Go
116 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.ipao.vip/rogee/go-sip/contracts"
|
|
"git.ipao.vip/rogee/go-sip/internal/contract"
|
|
"git.ipao.vip/rogee/go-sip/internal/dispatcher"
|
|
"git.ipao.vip/rogee/go-sip/internal/store"
|
|
)
|
|
|
|
func TestRootHasExplicitRoles(t *testing.T) {
|
|
root := newRootCommand()
|
|
if _, _, err := root.Find([]string{"agent"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, _, err := root.Find([]string{"dispatcher"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestWriteResultIsJSON(t *testing.T) {
|
|
var b bytes.Buffer
|
|
data, err := marshalResultForTest(map[string]string{"status": "ok"})
|
|
if err != nil || len(data) == 0 {
|
|
t.Fatalf("data=%q err=%v", data, err)
|
|
}
|
|
b.Write(data)
|
|
if b.Len() == 0 {
|
|
t.Fatal("empty result")
|
|
}
|
|
}
|
|
|
|
func TestValidateCallAISnapshotAllowsASROnly(t *testing.T) {
|
|
raw, err := contracts.Read("examples/agent-version-asr-only.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot, err := validateCallAISnapshot(raw)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if snapshot.Mode != "asr_only" {
|
|
t.Fatalf("snapshot mode=%q, want asr_only", snapshot.Mode)
|
|
}
|
|
}
|
|
|
|
func TestBuildCallEndpointUsesArtifactRoute(t *testing.T) {
|
|
raw, err := contracts.Read("examples/static-cell-artifact-real-v1.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
artifact, err := contract.ValidateStaticArtifact(raw, contract.StaticArtifactExpectation{CellID: "cell-single", Mode: "real"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
endpoint, err := buildCallEndpoint(artifact, "provider-third", "15830461047")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if endpoint != "PJSIP/mka75515830461047@provider-third" {
|
|
t.Fatalf("endpoint=%q", endpoint)
|
|
}
|
|
media, err := mediaForCall(artifact, "provider-third")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if media.Format != "alaw" || media.SampleRateHz != 8000 || media.PayloadType != 8 {
|
|
t.Fatalf("media=%+v", media)
|
|
}
|
|
if _, err := buildCallEndpoint(artifact, "provider-third", "10000000000"); err == nil {
|
|
t.Fatal("disallowed target was accepted")
|
|
}
|
|
}
|
|
|
|
type recordingPublisher struct{}
|
|
|
|
func (recordingPublisher) Publish(context.Context, string, string, []byte) error { return nil }
|
|
|
|
func TestFlushDispatcherOutboxPublishesPending(t *testing.T) {
|
|
st, err := store.Open(":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer st.Close()
|
|
|
|
d, err := dispatcher.New(st, recordingPublisher{}, time.Now)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
raw, err := contracts.Read("examples/call.execute.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := d.AcceptCommand(raw, "agent-call.tenant.tenant-demo-key.call.execute"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
go flushDispatcherOutbox(ctx, d, 1, time.Millisecond)
|
|
|
|
deadline := time.Now().Add(time.Second)
|
|
for time.Now().Before(deadline) {
|
|
var status string
|
|
if err := st.DB().QueryRow(`SELECT status FROM outbox LIMIT 1`).Scan(&status); err == nil && status == "published" {
|
|
return
|
|
}
|
|
time.Sleep(time.Millisecond)
|
|
}
|
|
t.Fatal("pending outbox was not published")
|
|
}
|