196 lines
9.0 KiB
Go
196 lines
9.0 KiB
Go
package dispatcher
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.ipao.vip/rogee/go-sip/internal/configread"
|
|
)
|
|
|
|
func policySnapshot(t *testing.T) configread.Snapshot {
|
|
t.Helper()
|
|
var snapshot configread.Snapshot
|
|
if err := json.Unmarshal(configExample(t, "config-read-task-asr"), &snapshot.Task); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sip := string(configExample(t, "config-read-sip"))
|
|
for _, replacement := range [][2]string{{`"transport":null`, `"transport":"udp"`}, {`"auth_mode":null`, `"auth_mode":"ip"`}, {`"registration_required":null`, `"registration_required":false`}, {`"max_concurrent_calls":null`, `"max_concurrent_calls":2`}} {
|
|
sip = strings.Replace(sip, replacement[0], replacement[1], 1)
|
|
}
|
|
if err := json.Unmarshal([]byte(sip), &snapshot.SIP); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal(configExample(t, "config-read-quota"), &snapshot.Quota); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var providerList struct {
|
|
Providers []configread.Provider `json:"providers"`
|
|
}
|
|
if err := json.Unmarshal(configExample(t, "config-read-providers"), &providerList); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot.Providers = make(map[string]configread.Provider, len(providerList.Providers))
|
|
for _, provider := range providerList.Providers {
|
|
snapshot.Providers[provider.Code] = provider
|
|
}
|
|
return snapshot
|
|
}
|
|
|
|
func monday(hour, minute int) time.Time {
|
|
return time.Date(2026, 9, 21, hour, minute, 0, 0, time.FixedZone("Asia/Shanghai", 8*60*60))
|
|
}
|
|
|
|
func TestSelectTrunkSaaSEventCalleeScheduleAndCaller(t *testing.T) {
|
|
snapshot := policySnapshot(t)
|
|
at := monday(9, 30)
|
|
selected, err := SelectTrunk(snapshot, "15003164745", at, map[string]int64{}, nil, map[string]int64{"trunk-mock": 8})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if selected.TrunkID != "trunk-mock" || selected.CallerID != "BD00000000" || selected.Callee != "15003164745" || selected.DialedCallee != "15003164745" || selected.Deadline.After(at.Add(120*time.Second)) || !selected.Deadline.After(at) || selected.MaxCallDurationMS != snapshot.Task.MaxCallDurationMS {
|
|
t.Fatalf("selected route/prefix/caller/deadline invalid: %+v", selected)
|
|
}
|
|
for _, number := range []string{"15803300952", "13900000000", "15003164746"} {
|
|
choice, err := SelectTrunk(snapshot, number, at, nil, nil, map[string]int64{"trunk-mock": 8})
|
|
if err != nil || choice.Callee != number || choice.DialedCallee != number {
|
|
t.Fatalf("SaaS event number changed or rejected: number=%q choice=%+v err=%v", number, choice, err)
|
|
}
|
|
}
|
|
for _, number := range []string{"", "abc", "15803300952x", "15803300952\n", strings.Repeat("7", 33)} {
|
|
if _, err := SelectTrunk(snapshot, number, at, nil, nil, map[string]int64{"trunk-mock": 8}); !errors.Is(err, ErrCalleeRejected) {
|
|
t.Fatalf("invalid raw dial route %q not rejected: %v", number, err)
|
|
}
|
|
}
|
|
for _, at := range []time.Time{monday(8, 59), monday(20, 0)} {
|
|
if _, err := SelectTrunk(snapshot, "15003164745", at, nil, nil, map[string]int64{"trunk-mock": 8}); !errors.Is(err, ErrRuleWait) {
|
|
t.Fatalf("outside half-open schedule did not wait: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSelectTrunkOptionalTaskSchedule(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
set map[string]any
|
|
at time.Time
|
|
deadline time.Time
|
|
wantErr error
|
|
}{
|
|
{name: "both omitted", at: monday(9, 30), deadline: monday(9, 32)},
|
|
{name: "null end", set: map[string]any{"ends_at": nil}, at: monday(9, 30), deadline: monday(9, 32)},
|
|
{name: "empty exclusions", set: map[string]any{"excluded_dates": []string{}}, at: monday(9, 30), deadline: monday(9, 32)},
|
|
{name: "weekly end still bounds call", at: monday(19, 59), deadline: monday(20, 0)},
|
|
{name: "weekly end remains exclusive", at: monday(20, 0), wantErr: ErrRuleWait},
|
|
{name: "before start", set: map[string]any{"starts_at": "2026-09-21T10:00:00+08:00"}, at: monday(9, 30), wantErr: ErrRuleWait},
|
|
{name: "at start", set: map[string]any{"starts_at": "2026-09-21T09:30:00+08:00"}, at: monday(9, 30), deadline: monday(9, 32)},
|
|
{name: "explicit end bounds call", set: map[string]any{"ends_at": "2026-09-21T09:31:00+08:00"}, at: monday(9, 30), deadline: monday(9, 31)},
|
|
{name: "at explicit end", set: map[string]any{"ends_at": "2026-09-21T09:30:00+08:00"}, at: monday(9, 30), wantErr: ErrRuleWait},
|
|
{name: "explicit excluded date", set: map[string]any{"excluded_dates": []string{"2026-09-21"}}, at: monday(9, 30), wantErr: ErrRuleWait},
|
|
{name: "other date not excluded", set: map[string]any{"excluded_dates": []string{"2026-09-22"}}, at: monday(9, 30), deadline: monday(9, 32)},
|
|
{name: "invalid end", set: map[string]any{"ends_at": "not-a-time"}, at: monday(9, 30), wantErr: ErrRuleInvalid},
|
|
{name: "end before start", set: map[string]any{"ends_at": "2026-09-20T20:00:00+08:00"}, at: monday(9, 30), wantErr: ErrRuleInvalid},
|
|
{name: "invalid excluded date", set: map[string]any{"excluded_dates": []string{"2026-02-30"}}, at: monday(9, 30), wantErr: ErrRuleInvalid},
|
|
{name: "duplicate excluded dates", set: map[string]any{"excluded_dates": []string{"2026-09-22", "2026-09-22"}}, at: monday(9, 30), wantErr: ErrRuleInvalid},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
snapshot := policySnapshot(t)
|
|
var schedule map[string]any
|
|
if err := json.Unmarshal(snapshot.Task.Schedule, &schedule); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
delete(schedule, "ends_at")
|
|
delete(schedule, "excluded_dates")
|
|
for field, value := range tc.set {
|
|
schedule[field] = value
|
|
}
|
|
var err error
|
|
snapshot.Task.Schedule, err = json.Marshal(schedule)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
loaded := map[string]int64{"trunk-mock": 8}
|
|
selected, err := SelectTrunk(snapshot, "15003164745", tc.at, nil, nil, loaded)
|
|
if tc.wantErr != nil {
|
|
if !errors.Is(err, tc.wantErr) {
|
|
t.Fatalf("schedule must be rejected with %v, got %v", tc.wantErr, err)
|
|
}
|
|
return
|
|
}
|
|
if err != nil || !selected.Deadline.Equal(tc.deadline) {
|
|
t.Fatalf("deadline=%v, want %v, err=%v", selected.Deadline, tc.deadline, err)
|
|
}
|
|
if _, err := SelectTrunk(snapshot, "15003164745", tc.at, nil, nil, nil); !errors.Is(err, ErrRuleWait) {
|
|
t.Fatalf("omitted schedule fields bypassed SIP loading: %v", err)
|
|
}
|
|
if _, err := SelectTrunk(snapshot, "15003164745", tc.at, nil, map[string]int64{"trunk-mock": 2}, loaded); !errors.Is(err, ErrRuleWait) {
|
|
t.Fatalf("omitted schedule fields bypassed task-line concurrency: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSelectTrunkUsesEachLinesOwnCaller(t *testing.T) {
|
|
snapshot := policySnapshot(t)
|
|
var trunks []trunkConfig
|
|
if err := json.Unmarshal(snapshot.SIP.Trunks, &trunks); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
second := trunks[0]
|
|
second.TrunkID, second.CallerID = "trunk-second", "mbkq"
|
|
trunks = append(trunks, second)
|
|
var err error
|
|
snapshot.SIP.Trunks, err = json.Marshal(trunks)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot.Task.AllowedTrunks = []configread.AllowedTrunk{{TrunkID: second.TrunkID, Concurrency: 2}}
|
|
chosen, err := SelectTrunk(snapshot, "15003164745", monday(9, 30), nil, nil, map[string]int64{second.TrunkID: 8})
|
|
if err != nil || chosen.TrunkID != second.TrunkID || chosen.CallerID != second.CallerID {
|
|
t.Fatalf("second line did not keep its own approved caller: %+v, %v", chosen, err)
|
|
}
|
|
trunks[1].CallerID = ""
|
|
snapshot.SIP.Trunks, err = json.Marshal(trunks)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := SelectTrunk(snapshot, "15003164745", monday(9, 30), nil, nil, map[string]int64{second.TrunkID: 8}); !errors.Is(err, ErrRuleInvalid) {
|
|
t.Fatalf("second line with missing caller did not fail closed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSelectTrunkFailsClosedForUnknownLineAndLimits(t *testing.T) {
|
|
snapshot := policySnapshot(t)
|
|
at := monday(9, 30)
|
|
if _, err := SelectTrunk(snapshot, "15003164745", at, nil, nil, nil); !errors.Is(err, ErrRuleWait) {
|
|
t.Fatalf("unloaded line did not hold command: %v", err)
|
|
}
|
|
if _, err := SelectTrunk(snapshot, "15003164745", at, map[string]int64{"trunk-mock": 2}, nil, map[string]int64{"trunk-mock": 8}); !errors.Is(err, ErrRuleWait) {
|
|
t.Fatalf("full trunk did not hold command: %v", err)
|
|
}
|
|
sip := string(configExample(t, "config-read-sip"))
|
|
if err := json.Unmarshal([]byte(sip), &snapshot.SIP); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := SelectTrunk(snapshot, "15003164745", at, nil, nil, map[string]int64{"trunk-mock": 8}); !errors.Is(err, ErrRuleInvalid) {
|
|
t.Fatalf("unknown transport/auth/quota was not fail-closed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSelectTrunkCapsCallByAIAndPreservesPrefix(t *testing.T) {
|
|
snapshot := policySnapshot(t)
|
|
snapshot.Task.Agent.Mode = "full_ai"
|
|
snapshot.Task.Agent.Raw = []byte(`{"mode":"full_ai","conversation":{"max_duration_ms":60000}}`)
|
|
snapshot.SIP.Trunks = []byte(strings.Replace(string(snapshot.SIP.Trunks), `"dial_prefix":""`, `"dial_prefix":"7089"`, 1))
|
|
at := monday(9, 30)
|
|
selected, err := SelectTrunk(snapshot, "15830461047", at, nil, nil, map[string]int64{"trunk-mock": 8})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if selected.DialedCallee != "708915830461047" || selected.Callee != "15830461047" || !selected.Deadline.Equal(at.Add(time.Minute)) || selected.MaxCallDurationMS != 60000 {
|
|
t.Fatalf("wrong prefix/AI duration bound: %+v", selected)
|
|
}
|
|
}
|