goagi.TestCmdControlStreamFile - Code Metrics - staskobzar/goagi - Measure and Improve Code Quality continuously with Scrutinizer

goagi.TestCmdControlStreamFile A
last analyzed 2024-06-21 00:34 UTC

↳ Parent: command_test.go

Complexity

Conditions

Size

Total Lines	21
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	18
nop	1
dl	0
loc	21
rs	9.5
c	0
b	0
f	0

package goagi

import (
	"bytes"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
)

func stubReaderWriter(response string) (*bytes.Buffer, *stubReader, *stubWriter) {
	buf := new(bytes.Buffer)
	response += "\n"
	reader := &stubReader{strings.NewReader(response)}
	writer := &stubWriter{buf}

	return buf, reader, writer
}

func mockAGI(response string) (*AGI, *bytes.Buffer) {
	buf, r, w := stubReaderWriter(response)
	return &AGI{reader: r, writer: w}, buf
}

const respOk = "200 result=1"

func TestCmdCommand(t *testing.T) {
	buf, r, w := stubReaderWriter(respOk)
	agi := &AGI{reader: r, writer: w}

	resp, err := agi.Command("ANSWER")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "ANSWER\n", buf.String())
}

func TestCmdAnswer(t *testing.T) {
	agi, buf := mockAGI("511 Command Not Permitted")
	resp, err := agi.Answer()
	assert.Nil(t, err)
	assert.Equal(t, 511, resp.Code())
	assert.Equal(t, "ANSWER\n", buf.String())
}

func TestCmdAsyncAGIBreak(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.AsyncAGIBreak()
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "ASYNCAGI BREAK\n", buf.String())
}

func TestCmdChannelStatus(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.ChannelStatus("SIP/0001-FA878E0")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "CHANNEL STATUS SIP/0001-FA878E0\n", buf.String())
}

func TestCmdControlStreamFile(t *testing.T) {
	agi, buf := mockAGI("200 result=1 endpos=10")
	resp, err := agi.ControlStreamFile("welcome", "")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.EqualValues(t, 10, resp.EndPos())
	assert.Equal(t, "CONTROL STREAM FILE welcome \"\"\n", buf.String())

	agi, buf = mockAGI("200 result=1 endpos=998877")
	resp, _ = agi.ControlStreamFile("welcome", "123", "1500")
	assert.EqualValues(t, 998877, resp.EndPos())
	assert.Equal(t, `CONTROL STREAM FILE welcome "123" "1500"`+"\n", buf.String())

	agi, buf = mockAGI("200 result=1 endpos=10")
	resp, _ = agi.ControlStreamFile("welcome", "123", "1500", "#", "0", "*", "1600")
	assert.Equal(t, `CONTROL STREAM FILE welcome "123" "1500" "#" "0" "*" "1600"`+"\n",
		buf.String())

	_, err = agi.ControlStreamFile("welcome", "123", "1500", "#", "0", "*", "1600", "a", "1")
	assert.NotNil(t, err)
	assert.Contains(t, err.Error(), "[a 1]")
}

func TestCmdDatabaseDel(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.DatabaseDel("channel/sip", "foo")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "DATABASE DEL channel/sip foo\n", buf.String())
}

func TestCmdDatabaseDelTree(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.DatabaseDelTree("channel", "sip")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "DATABASE DELTREE channel sip\n", buf.String())
}

func TestCmdDatabaseGet(t *testing.T) {
	agi, buf := mockAGI("200 result=1 (SIP/router01-000e57a5)\n")
	resp, err := agi.DatabaseGet("channel", "sip/111")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "SIP/router01-000e57a5", resp.Value())
	assert.Equal(t, "DATABASE GET channel sip/111\n", buf.String())
}

func TestCmdDatabasePut(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.DatabasePut("callwait", "sip/1111", "on")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "DATABASE PUT callwait sip/1111 on\n", buf.String())
}

func TestCmdExec(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.Exec("GoTo", "default,s,1")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, "EXEC GoTo \"default,s,1\"\n", buf.String())
}

func TestCmdGetData(t *testing.T) {
	tests := []struct {
		response string
		file     string
		tout     int
		max      int
		code     int
		result   int
		value    string
		data     string
		exec     string
	}{
		{
			"200 result= (timeout)\n",
			"mainmenu", 0, 1,
			200, 0, "timeout", "",
			"GET DATA mainmenu 0 1\n",
		}, {
			"200 result=*123 (timeout)\n",
			"mainmenu", 1500, 4,
			200, 0, "timeout", "*123",
			"GET DATA mainmenu 1500 4\n",
		}, {
			"200 result=23\n",
			"hollidays", 2000, 2,
			200, 0, "", "23",
			"GET DATA hollidays 2000 2\n",
		}, {
			"200 result=-1\n",
			"hollidays", 3000, 3,
			200, -1, "", "",
			"GET DATA hollidays 3000 3\n",
		}, {
			"200 result=\n", // user press # only
			"hollidays", 3000, 3,
			200, 0, "", "",
			"GET DATA hollidays 3000 3\n",
		}, {
			"511 Command Not Permitted on a dead channel or intercept routine\n",
			"hollidays", 3000, 3,
			511, 0, "Command Not Permitted on a dead channel or intercept routine",
			"Command Not Permitted on a dead channel or intercept routine",
			"GET DATA hollidays 3000 3\n",
		},
	}

	for _, tc := range tests {
		agi, buf := mockAGI(tc.response)
		resp, err := agi.GetData(tc.file, tc.tout, tc.max)
		assert.Nil(t, err)
		assert.Equal(t, tc.code, resp.Code(), "Code:"+tc.response)
		assert.Equal(t, tc.result, resp.Result(), "Result:"+tc.response)
		assert.Equal(t, tc.value, resp.Value(), "Value:"+tc.response)
		assert.Equal(t, tc.data, resp.Data(), "Data:"+tc.response)
		assert.Equal(t, tc.exec, buf.String(), tc.response)
	}

	agi, _ := mockAGI("foo")
	resp, err := agi.GetData("hello", 1000, 3)
	assert.NotNil(t, err)
	assert.Contains(t, err.Error(), "Invalid input")
	assert.Nil(t, resp)
}

func TestCmdGetFullVariable(t *testing.T) {
	agi, buf := mockAGI("200 result=1 (fr)")
	resp, err := agi.GetFullVariable("CHANNEL(language)", "")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "fr", resp.Value())
	assert.Equal(t, "GET FULL VARIABLE CHANNEL(language)\n", buf.String())

	agi, buf = mockAGI("200 result=1 (Today is sunny)")
	resp, err = agi.GetFullVariable("WEATHER", "SIP/2222-12-00000008")
	assert.Nil(t, err)
	assert.Equal(t, "Today is sunny", resp.Value())
	assert.Equal(t, "GET FULL VARIABLE WEATHER SIP/2222-12-00000008\n", buf.String())
}

func TestCmdGetOption(t *testing.T) {
	agi, buf := mockAGI("200 result=0 endpos=7680")
	resp, err := agi.GetOption("welcome_menu", "", 500)
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, 0, resp.Result())
	assert.Equal(t, "GET OPTION welcome_menu \"\" 500\n", buf.String())
}

func TestCmdGetVariable(t *testing.T) {
	agi, buf := mockAGI(`200 result=1 ("Alice Foo" <5145553322>)`)
	resp, err := agi.GetVariable("CALLERID(all)")
	assert.Nil(t, err)
	assert.Equal(t, 200, resp.Code())
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "\"Alice Foo\" <5145553322>", resp.Value())
	assert.Equal(t, "GET VARIABLE CALLERID(all)\n", buf.String())
}

func TestCmdHangup(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.Hangup()
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "HANGUP\n", buf.String())

	agi, buf = mockAGI(respOk)
	resp, err = agi.Hangup("SIP/111-222")
	assert.Nil(t, err)
	assert.Equal(t, "HANGUP SIP/111-222\n", buf.String())

	agi, buf = mockAGI(respOk)
	resp, err = agi.Hangup("IAX/333-444", "SIP/111-222")
	assert.Nil(t, err)
	assert.Equal(t, "HANGUP IAX/333-444\n", buf.String())
}

func TestCmdReceiveChar(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.ReceiveChar(2000)
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "RECEIVE CHAR 2000\n", buf.String())
}

func TestCmdReceiveText(t *testing.T) {
	agi, buf := mockAGI("200 result=1 (Hello Bob)")
	resp, err := agi.ReceiveText(2000)
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "Hello Bob", resp.Value())
	assert.Equal(t, "RECEIVE TEXT 2000\n", buf.String())
}

func TestCmdRecordFile(t *testing.T) {
	tests := []struct {
		input              string
		file, ftype, digit string
		tout, offset       int
		beep               bool
		silence            int
		result             int
		value, data        string
		endpos             int64
		cmd                string
	}{
		{
			"200 result=1 (timeout) endpos=86435\n",
			"new_rec", "wav", "029", -1, 0, false, 0,
			1, "timeout", "", 86435,
			"RECORD FILE new_rec wav \"029\" -1\n",
		}, {
			"200 result=* (dtmf) endpos=1554\n",
			"new_rec", "wav", "*#", 1000, 600, false, 0,
			1, "dtmf", "*", 1554,
			"RECORD FILE new_rec wav \"*#\" 1000 600\n",
		}, {
			"200 result=-1 (hangup) endpos=0\n",
			"new_rec", "wav", "*#", 1000, 600, true, 500,
			-1, "hangup", "", 0,
			"RECORD FILE new_rec wav \"*#\" 1000 600 BEEP s=500\n",
		}, {
			"200 result=4 (dtmf) endpos=0\n",
			"new_rec", "wav", "*#4", 1000, 600, false, 500,
			1, "dtmf", "4", 0,
			"RECORD FILE new_rec wav \"*#4\" 1000 600 s=500\n",
		},
	}

	for _, tc := range tests {
		agi, buf := mockAGI(tc.input)
		resp, err := agi.RecordFile(tc.file, tc.ftype, tc.digit, tc.tout, tc.offset,
			tc.beep, tc.silence)
		assert.Nil(t, err)
		assert.Equal(t, tc.result, resp.Result())
		assert.Equal(t, tc.value, resp.Value())
		assert.Equal(t, tc.data, resp.Data())
		assert.Equal(t, tc.endpos, resp.EndPos())
		assert.Equal(t, tc.cmd, buf.String())
	}

	agi, buf := mockAGI("")
	resp, err := agi.RecordFile("new_rec", "wav", "", 100, 0, false, 0)
	assert.NotNil(t, err)
	assert.Nil(t, resp)
	assert.Equal(t, "RECORD FILE new_rec wav \"\" 100\n", buf.String())
}

func TestCmdSayAlpha(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayAlpha("abc", "*1")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY ALPHA abc \"*1\"\n", buf.String())
}

func TestCmdSayDate(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayDate("1563844045", "")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY DATE 1563844045 \"\"\n", buf.String())
}

func TestCmdSayDatetime(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayDatetime("1563844045", "*#0", "dB", "UTC")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY DATETIME 1563844045 \"*#0\" \"dB\" \"UTC\"\n", buf.String())
}

func TestCmdSayDigits(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayDigits("2234", "")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY DIGITS 2234 \"\"\n", buf.String())
}

func TestCmdSayNumber(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayNumber("1000", "01")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY NUMBER 1000 \"01\"\n", buf.String())
}

func TestCmdSayPhonetic(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayPhonetic("welcome", "")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY PHONETIC welcome \"\"\n", buf.String())
}

func TestCmdSayTime(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SayTime("1563844046", "*#0123456789")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SAY TIME 1563844046 \"*#0123456789\"\n", buf.String())
}

func TestCmdSendImage(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SendImage("logo.png")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SEND IMAGE \"logo.png\"\n", buf.String())
}

func TestCmdSendText(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SendText("Hello there!")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SEND TEXT \"Hello there!\"\n", buf.String())
}

func TestCmdSetAutoHangup(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SetAutoHangup(0)
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SET AUTOHANGUP 0\n", buf.String())
}

func TestCmdSetCallerid(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SetCallerid("5145553322")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SET CALLERID \"5145553322\"\n", buf.String())
}

func TestCmdSetContext(t *testing.T) {
	agi, buf := mockAGI("200 result=0")
	resp, err := agi.SetContext("default")
	assert.Nil(t, err)
	assert.Equal(t, 0, resp.Result())
	assert.Equal(t, "SET CONTEXT default\n", buf.String())
}

func TestCmdSetExtension(t *testing.T) {
	agi, buf := mockAGI("200 result=0")
	resp, err := agi.SetExtension("s")
	assert.Nil(t, err)
	assert.Equal(t, 0, resp.Result())
	assert.Equal(t, "SET EXTENSION s\n", buf.String())
}

func TestCmdSetMusic(t *testing.T) {
	tests := []struct {
		enable bool
		class  string
		cmd    string
	}{
		{true, "", "SET MUSIC on \"\"\n"},
		{true, "jazz", "SET MUSIC on \"jazz\"\n"},
		{false, "lounge", "SET MUSIC off \"lounge\"\n"},
	}

	for _, tc := range tests {
		agi, buf := mockAGI(respOk)
		resp, err := agi.SetMusic(tc.enable, tc.class)
		assert.Nil(t, err)
		assert.Equal(t, 1, resp.Result())
		assert.Equal(t, tc.cmd, buf.String())
	}
}

func TestCmdSetPriority(t *testing.T) {
	agi, buf := mockAGI("200 result=0")
	resp, err := agi.SetPriority("1")
	assert.Nil(t, err)
	assert.Equal(t, 0, resp.Result())
	assert.Equal(t, "SET PRIORITY 1\n", buf.String())
}

func TestCmdSetVariable(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.SetVariable("CITY", "Toronto")
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "SET VARIABLE CITY \"Toronto\"\n", buf.String())

	agi, buf = mockAGI(respOk)
	resp, err = agi.SetVariable("CALLERID(all)", `"Alice Foo" <5145553322>`)
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, `SET VARIABLE CALLERID(all) "\"Alice Foo\" <5145553322>"`+"\n",
		buf.String())
}

func TestCmdStreamFile(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.StreamFile("rec109234", "", 0)
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "STREAM FILE rec109234 \"\" 0\n", buf.String())
}

func TestCmdTDDMode(t *testing.T) {
	tests := []struct {
		mode, cmd string
	}{
		{"on", "TDD MODE on\n"},
		{"off", "TDD MODE off\n"},
		{"mate", "TDD MODE mate\n"},
		{"tdd", "TDD MODE tdd\n"},
		{"foo", "TDD MODE off\n"},
	}

	for _, tc := range tests {
		agi, buf := mockAGI(respOk)
		resp, err := agi.TDDMode(tc.mode)
		assert.Nil(t, err)
		assert.Equal(t, 1, resp.Result())
		assert.Equal(t, tc.cmd, buf.String())
	}
}

func TestCmdVerbose(t *testing.T) {
	agi, buf := mockAGI(respOk)
	agi.Verbose("Debug message", 3)
	assert.Equal(t, "VERBOSE \"Debug message\" 3\n", buf.String())

	agi, buf = mockAGI(respOk)
	agi.Verbose("Debug message")
	assert.Equal(t, "VERBOSE \"Debug message\" 1\n", buf.String())

	agi, buf = mockAGI(respOk)
	agi.Verbose("Debug message", 0)
	assert.Equal(t, "VERBOSE \"Debug message\" 1\n", buf.String())

	agi, buf = mockAGI(respOk)
	agi.Verbose("Debug message", 10)
	assert.Equal(t, "VERBOSE \"Debug message\" 1\n", buf.String())
}

func TestCmdWaitForDigit(t *testing.T) {
	agi, buf := mockAGI(respOk)
	resp, err := agi.WaitForDigit(1000)
	assert.Nil(t, err)
	assert.Equal(t, 1, resp.Result())
	assert.Equal(t, "WAIT FOR DIGIT 1000\n", buf.String())
}


1			package goagi
2
3			import (
4			"bytes"
5			"strings"
6			"testing"
7
8			"github.com/stretchr/testify/assert"
9			)
10
11			func stubReaderWriter(response string) (bytes.Buffer, stubReader, *stubWriter) {
12			buf := new(bytes.Buffer)
13			response += "\n"
14			reader := &stubReader{strings.NewReader(response)}
15			writer := &stubWriter{buf}
16
17			return buf, reader, writer
18			}
19
20			func mockAGI(response string) (AGI, bytes.Buffer) {
21			buf, r, w := stubReaderWriter(response)
22			return &AGI{reader: r, writer: w}, buf
23			}
24
25			const respOk = "200 result=1"
26
27			func TestCmdCommand(t *testing.T) {
28			buf, r, w := stubReaderWriter(respOk)
29			agi := &AGI{reader: r, writer: w}
30
31			resp, err := agi.Command("ANSWER")
32			assert.Nil(t, err)
33			assert.Equal(t, 200, resp.Code())
34			assert.Equal(t, "ANSWER\n", buf.String())
35			}
36
37			func TestCmdAnswer(t *testing.T) {
38			agi, buf := mockAGI("511 Command Not Permitted")
39			resp, err := agi.Answer()
40			assert.Nil(t, err)
41			assert.Equal(t, 511, resp.Code())
42			assert.Equal(t, "ANSWER\n", buf.String())
43			}
44
45			func TestCmdAsyncAGIBreak(t *testing.T) {
46			agi, buf := mockAGI(respOk)
47			resp, err := agi.AsyncAGIBreak()
48			assert.Nil(t, err)
49			assert.Equal(t, 200, resp.Code())
50			assert.Equal(t, "ASYNCAGI BREAK\n", buf.String())
51			}
52
53			func TestCmdChannelStatus(t *testing.T) {
54			agi, buf := mockAGI(respOk)
55			resp, err := agi.ChannelStatus("SIP/0001-FA878E0")
56			assert.Nil(t, err)
57			assert.Equal(t, 200, resp.Code())
58			assert.Equal(t, "CHANNEL STATUS SIP/0001-FA878E0\n", buf.String())
59			}
60
61			func TestCmdControlStreamFile(t *testing.T) {
62			agi, buf := mockAGI("200 result=1 endpos=10")
63			resp, err := agi.ControlStreamFile("welcome", "")
64			assert.Nil(t, err)
65			assert.Equal(t, 200, resp.Code())
66			assert.EqualValues(t, 10, resp.EndPos())
67			assert.Equal(t, "CONTROL STREAM FILE welcome \"\"\n", buf.String())
68
69			agi, buf = mockAGI("200 result=1 endpos=998877")
70			resp, _ = agi.ControlStreamFile("welcome", "123", "1500")
71			assert.EqualValues(t, 998877, resp.EndPos())
72			assert.Equal(t, `CONTROL STREAM FILE welcome "123" "1500"`+"\n", buf.String())
73
74			agi, buf = mockAGI("200 result=1 endpos=10")
75			resp, _ = agi.ControlStreamFile("welcome", "123", "1500", "#", "0", "*", "1600")
76			assert.Equal(t, `CONTROL STREAM FILE welcome "123" "1500" "#" "0" "*" "1600"`+"\n",
77			buf.String())
78
79			_, err = agi.ControlStreamFile("welcome", "123", "1500", "#", "0", "*", "1600", "a", "1")
80			assert.NotNil(t, err)
81			assert.Contains(t, err.Error(), "[a 1]")
82			}
83
84			func TestCmdDatabaseDel(t *testing.T) {
85			agi, buf := mockAGI(respOk)
86			resp, err := agi.DatabaseDel("channel/sip", "foo")
87			assert.Nil(t, err)
88			assert.Equal(t, 200, resp.Code())
89			assert.Equal(t, "DATABASE DEL channel/sip foo\n", buf.String())
90			}
91
92			func TestCmdDatabaseDelTree(t *testing.T) {
93			agi, buf := mockAGI(respOk)
94			resp, err := agi.DatabaseDelTree("channel", "sip")
95			assert.Nil(t, err)
96			assert.Equal(t, 200, resp.Code())
97			assert.Equal(t, "DATABASE DELTREE channel sip\n", buf.String())
98			}
99
100			func TestCmdDatabaseGet(t *testing.T) {
101			agi, buf := mockAGI("200 result=1 (SIP/router01-000e57a5)\n")
102			resp, err := agi.DatabaseGet("channel", "sip/111")
103			assert.Nil(t, err)
104			assert.Equal(t, 200, resp.Code())
105			assert.Equal(t, "SIP/router01-000e57a5", resp.Value())
106			assert.Equal(t, "DATABASE GET channel sip/111\n", buf.String())
107			}
108
109			func TestCmdDatabasePut(t *testing.T) {
110			agi, buf := mockAGI(respOk)
111			resp, err := agi.DatabasePut("callwait", "sip/1111", "on")
112			assert.Nil(t, err)
113			assert.Equal(t, 200, resp.Code())
114			assert.Equal(t, "DATABASE PUT callwait sip/1111 on\n", buf.String())
115			}
116
117			func TestCmdExec(t *testing.T) {
118			agi, buf := mockAGI(respOk)
119			resp, err := agi.Exec("GoTo", "default,s,1")
120			assert.Nil(t, err)
121			assert.Equal(t, 200, resp.Code())
122			assert.Equal(t, "EXEC GoTo \"default,s,1\"\n", buf.String())
123			}
124
125			func TestCmdGetData(t *testing.T) {
126			tests := []struct {
127			response string
128			file string
129			tout int
130			max int
131			code int
132			result int
133			value string
134			data string
135			exec string
136			}{
137			{
138			"200 result= (timeout)\n",
139			"mainmenu", 0, 1,
140			200, 0, "timeout", "",
141			"GET DATA mainmenu 0 1\n",
142			}, {
143			"200 result=*123 (timeout)\n",
144			"mainmenu", 1500, 4,
145			200, 0, "timeout", "*123",
146			"GET DATA mainmenu 1500 4\n",
147			}, {
148			"200 result=23\n",
149			"hollidays", 2000, 2,
150			200, 0, "", "23",
151			"GET DATA hollidays 2000 2\n",
152			}, {
153			"200 result=-1\n",
154			"hollidays", 3000, 3,
155			200, -1, "", "",
156			"GET DATA hollidays 3000 3\n",
157			}, {
158			"200 result=\n", // user press # only
159			"hollidays", 3000, 3,
160			200, 0, "", "",
161			"GET DATA hollidays 3000 3\n",
162			}, {
163			"511 Command Not Permitted on a dead channel or intercept routine\n",
164			"hollidays", 3000, 3,
165			511, 0, "Command Not Permitted on a dead channel or intercept routine",
166			"Command Not Permitted on a dead channel or intercept routine",
167			"GET DATA hollidays 3000 3\n",
168			},
169			}
170
171			for _, tc := range tests {
172			agi, buf := mockAGI(tc.response)
173			resp, err := agi.GetData(tc.file, tc.tout, tc.max)
174			assert.Nil(t, err)
175			assert.Equal(t, tc.code, resp.Code(), "Code:"+tc.response)
176			assert.Equal(t, tc.result, resp.Result(), "Result:"+tc.response)
177			assert.Equal(t, tc.value, resp.Value(), "Value:"+tc.response)
178			assert.Equal(t, tc.data, resp.Data(), "Data:"+tc.response)
179			assert.Equal(t, tc.exec, buf.String(), tc.response)
180			}
181
182			agi, _ := mockAGI("foo")
183			resp, err := agi.GetData("hello", 1000, 3)
184			assert.NotNil(t, err)
185			assert.Contains(t, err.Error(), "Invalid input")
186			assert.Nil(t, resp)
187			}
188
189			func TestCmdGetFullVariable(t *testing.T) {
190			agi, buf := mockAGI("200 result=1 (fr)")
191			resp, err := agi.GetFullVariable("CHANNEL(language)", "")
192			assert.Nil(t, err)
193			assert.Equal(t, 200, resp.Code())
194			assert.Equal(t, 1, resp.Result())
195			assert.Equal(t, "fr", resp.Value())
196			assert.Equal(t, "GET FULL VARIABLE CHANNEL(language)\n", buf.String())
197
198			agi, buf = mockAGI("200 result=1 (Today is sunny)")
199			resp, err = agi.GetFullVariable("WEATHER", "SIP/2222-12-00000008")
200			assert.Nil(t, err)
201			assert.Equal(t, "Today is sunny", resp.Value())
202			assert.Equal(t, "GET FULL VARIABLE WEATHER SIP/2222-12-00000008\n", buf.String())
203			}
204
205			func TestCmdGetOption(t *testing.T) {
206			agi, buf := mockAGI("200 result=0 endpos=7680")
207			resp, err := agi.GetOption("welcome_menu", "", 500)
208			assert.Nil(t, err)
209			assert.Equal(t, 200, resp.Code())
210			assert.Equal(t, 0, resp.Result())
211			assert.Equal(t, "GET OPTION welcome_menu \"\" 500\n", buf.String())
212			}
213
214			func TestCmdGetVariable(t *testing.T) {
215			agi, buf := mockAGI(`200 result=1 ("Alice Foo" <5145553322>)`)
216			resp, err := agi.GetVariable("CALLERID(all)")
217			assert.Nil(t, err)
218			assert.Equal(t, 200, resp.Code())
219			assert.Equal(t, 1, resp.Result())
220			assert.Equal(t, "\"Alice Foo\" <5145553322>", resp.Value())
221			assert.Equal(t, "GET VARIABLE CALLERID(all)\n", buf.String())
222			}
223
224			func TestCmdHangup(t *testing.T) {
225			agi, buf := mockAGI(respOk)
226			resp, err := agi.Hangup()
227			assert.Nil(t, err)
228			assert.Equal(t, 1, resp.Result())
229			assert.Equal(t, "HANGUP\n", buf.String())
230
231			agi, buf = mockAGI(respOk)
232			resp, err = agi.Hangup("SIP/111-222")
233			assert.Nil(t, err)
234			assert.Equal(t, "HANGUP SIP/111-222\n", buf.String())
235
236			agi, buf = mockAGI(respOk)
237			resp, err = agi.Hangup("IAX/333-444", "SIP/111-222")
238			assert.Nil(t, err)
239			assert.Equal(t, "HANGUP IAX/333-444\n", buf.String())
240			}
241
242			func TestCmdReceiveChar(t *testing.T) {
243			agi, buf := mockAGI(respOk)
244			resp, err := agi.ReceiveChar(2000)
245			assert.Nil(t, err)
246			assert.Equal(t, 1, resp.Result())
247			assert.Equal(t, "RECEIVE CHAR 2000\n", buf.String())
248			}
249
250			func TestCmdReceiveText(t *testing.T) {
251			agi, buf := mockAGI("200 result=1 (Hello Bob)")
252			resp, err := agi.ReceiveText(2000)
253			assert.Nil(t, err)
254			assert.Equal(t, 1, resp.Result())
255			assert.Equal(t, "Hello Bob", resp.Value())
256			assert.Equal(t, "RECEIVE TEXT 2000\n", buf.String())
257			}
258
259			func TestCmdRecordFile(t *testing.T) {
260			tests := []struct {
261			input string
262			file, ftype, digit string
263			tout, offset int
264			beep bool
265			silence int
266			result int
267			value, data string
268			endpos int64
269			cmd string
270			}{
271			{
272			"200 result=1 (timeout) endpos=86435\n",
273			"new_rec", "wav", "029", -1, 0, false, 0,
274			1, "timeout", "", 86435,
275			"RECORD FILE new_rec wav \"029\" -1\n",
276			}, {
277			"200 result=* (dtmf) endpos=1554\n",
278			"new_rec", "wav", "*#", 1000, 600, false, 0,
279			1, "dtmf", "*", 1554,
280			"RECORD FILE new_rec wav \"*#\" 1000 600\n",
281			}, {
282			"200 result=-1 (hangup) endpos=0\n",
283			"new_rec", "wav", "*#", 1000, 600, true, 500,
284			-1, "hangup", "", 0,
285			"RECORD FILE new_rec wav \"*#\" 1000 600 BEEP s=500\n",
286			}, {
287			"200 result=4 (dtmf) endpos=0\n",
288			"new_rec", "wav", "*#4", 1000, 600, false, 500,
289			1, "dtmf", "4", 0,
290			"RECORD FILE new_rec wav \"*#4\" 1000 600 s=500\n",
291			},
292			}
293
294			for _, tc := range tests {
295			agi, buf := mockAGI(tc.input)
296			resp, err := agi.RecordFile(tc.file, tc.ftype, tc.digit, tc.tout, tc.offset,
297			tc.beep, tc.silence)
298			assert.Nil(t, err)
299			assert.Equal(t, tc.result, resp.Result())
300			assert.Equal(t, tc.value, resp.Value())
301			assert.Equal(t, tc.data, resp.Data())
302			assert.Equal(t, tc.endpos, resp.EndPos())
303			assert.Equal(t, tc.cmd, buf.String())
304			}
305
306			agi, buf := mockAGI("")
307			resp, err := agi.RecordFile("new_rec", "wav", "", 100, 0, false, 0)
308			assert.NotNil(t, err)
309			assert.Nil(t, resp)
310			assert.Equal(t, "RECORD FILE new_rec wav \"\" 100\n", buf.String())
311			}
312
313			func TestCmdSayAlpha(t *testing.T) {
314			agi, buf := mockAGI(respOk)
315			resp, err := agi.SayAlpha("abc", "*1")
316			assert.Nil(t, err)
317			assert.Equal(t, 1, resp.Result())
318			assert.Equal(t, "SAY ALPHA abc \"*1\"\n", buf.String())
319			}
320
321			func TestCmdSayDate(t *testing.T) {
322			agi, buf := mockAGI(respOk)
323			resp, err := agi.SayDate("1563844045", "")
324			assert.Nil(t, err)
325			assert.Equal(t, 1, resp.Result())
326			assert.Equal(t, "SAY DATE 1563844045 \"\"\n", buf.String())
327			}
328
329			func TestCmdSayDatetime(t *testing.T) {
330			agi, buf := mockAGI(respOk)
331			resp, err := agi.SayDatetime("1563844045", "*#0", "dB", "UTC")
332			assert.Nil(t, err)
333			assert.Equal(t, 1, resp.Result())
334			assert.Equal(t, "SAY DATETIME 1563844045 \"*#0\" \"dB\" \"UTC\"\n", buf.String())
335			}
336
337			func TestCmdSayDigits(t *testing.T) {
338			agi, buf := mockAGI(respOk)
339			resp, err := agi.SayDigits("2234", "")
340			assert.Nil(t, err)
341			assert.Equal(t, 1, resp.Result())
342			assert.Equal(t, "SAY DIGITS 2234 \"\"\n", buf.String())
343			}
344
345			func TestCmdSayNumber(t *testing.T) {
346			agi, buf := mockAGI(respOk)
347			resp, err := agi.SayNumber("1000", "01")
348			assert.Nil(t, err)
349			assert.Equal(t, 1, resp.Result())
350			assert.Equal(t, "SAY NUMBER 1000 \"01\"\n", buf.String())
351			}
352
353			func TestCmdSayPhonetic(t *testing.T) {
354			agi, buf := mockAGI(respOk)
355			resp, err := agi.SayPhonetic("welcome", "")
356			assert.Nil(t, err)
357			assert.Equal(t, 1, resp.Result())
358			assert.Equal(t, "SAY PHONETIC welcome \"\"\n", buf.String())
359			}
360
361			func TestCmdSayTime(t *testing.T) {
362			agi, buf := mockAGI(respOk)
363			resp, err := agi.SayTime("1563844046", "*#0123456789")
364			assert.Nil(t, err)
365			assert.Equal(t, 1, resp.Result())
366			assert.Equal(t, "SAY TIME 1563844046 \"*#0123456789\"\n", buf.String())
367			}
368
369			func TestCmdSendImage(t *testing.T) {
370			agi, buf := mockAGI(respOk)
371			resp, err := agi.SendImage("logo.png")
372			assert.Nil(t, err)
373			assert.Equal(t, 1, resp.Result())
374			assert.Equal(t, "SEND IMAGE \"logo.png\"\n", buf.String())
375			}
376
377			func TestCmdSendText(t *testing.T) {
378			agi, buf := mockAGI(respOk)
379			resp, err := agi.SendText("Hello there!")
380			assert.Nil(t, err)
381			assert.Equal(t, 1, resp.Result())
382			assert.Equal(t, "SEND TEXT \"Hello there!\"\n", buf.String())
383			}
384
385			func TestCmdSetAutoHangup(t *testing.T) {
386			agi, buf := mockAGI(respOk)
387			resp, err := agi.SetAutoHangup(0)
388			assert.Nil(t, err)
389			assert.Equal(t, 1, resp.Result())
390			assert.Equal(t, "SET AUTOHANGUP 0\n", buf.String())
391			}
392
393			func TestCmdSetCallerid(t *testing.T) {
394			agi, buf := mockAGI(respOk)
395			resp, err := agi.SetCallerid("5145553322")
396			assert.Nil(t, err)
397			assert.Equal(t, 1, resp.Result())
398			assert.Equal(t, "SET CALLERID \"5145553322\"\n", buf.String())
399			}
400
401			func TestCmdSetContext(t *testing.T) {
402			agi, buf := mockAGI("200 result=0")
403			resp, err := agi.SetContext("default")
404			assert.Nil(t, err)
405			assert.Equal(t, 0, resp.Result())
406			assert.Equal(t, "SET CONTEXT default\n", buf.String())
407			}
408
409			func TestCmdSetExtension(t *testing.T) {
410			agi, buf := mockAGI("200 result=0")
411			resp, err := agi.SetExtension("s")
412			assert.Nil(t, err)
413			assert.Equal(t, 0, resp.Result())
414			assert.Equal(t, "SET EXTENSION s\n", buf.String())
415			}
416
417			func TestCmdSetMusic(t *testing.T) {
418			tests := []struct {
419			enable bool
420			class string
421			cmd string
422			}{
423			{true, "", "SET MUSIC on \"\"\n"},
424			{true, "jazz", "SET MUSIC on \"jazz\"\n"},
425			{false, "lounge", "SET MUSIC off \"lounge\"\n"},
426			}
427
428			for _, tc := range tests {
429			agi, buf := mockAGI(respOk)
430			resp, err := agi.SetMusic(tc.enable, tc.class)
431			assert.Nil(t, err)
432			assert.Equal(t, 1, resp.Result())
433			assert.Equal(t, tc.cmd, buf.String())
434			}
435			}
436
437			func TestCmdSetPriority(t *testing.T) {
438			agi, buf := mockAGI("200 result=0")
439			resp, err := agi.SetPriority("1")
440			assert.Nil(t, err)
441			assert.Equal(t, 0, resp.Result())
442			assert.Equal(t, "SET PRIORITY 1\n", buf.String())
443			}
444
445			func TestCmdSetVariable(t *testing.T) {
446			agi, buf := mockAGI(respOk)
447			resp, err := agi.SetVariable("CITY", "Toronto")
448			assert.Nil(t, err)
449			assert.Equal(t, 1, resp.Result())
450			assert.Equal(t, "SET VARIABLE CITY \"Toronto\"\n", buf.String())
451
452			agi, buf = mockAGI(respOk)
453			resp, err = agi.SetVariable("CALLERID(all)", `"Alice Foo" <5145553322>`)
454			assert.Nil(t, err)
455			assert.Equal(t, 1, resp.Result())
456			assert.Equal(t, `SET VARIABLE CALLERID(all) "\"Alice Foo\" <5145553322>"`+"\n",
457			buf.String())
458			}
459
460			func TestCmdStreamFile(t *testing.T) {
461			agi, buf := mockAGI(respOk)
462			resp, err := agi.StreamFile("rec109234", "", 0)
463			assert.Nil(t, err)
464			assert.Equal(t, 1, resp.Result())
465			assert.Equal(t, "STREAM FILE rec109234 \"\" 0\n", buf.String())
466			}
467
468			func TestCmdTDDMode(t *testing.T) {
469			tests := []struct {
470			mode, cmd string
471			}{
472			{"on", "TDD MODE on\n"},
473			{"off", "TDD MODE off\n"},
474			{"mate", "TDD MODE mate\n"},
475			{"tdd", "TDD MODE tdd\n"},
476			{"foo", "TDD MODE off\n"},
477			}
478
479			for _, tc := range tests {
480			agi, buf := mockAGI(respOk)
481			resp, err := agi.TDDMode(tc.mode)
482			assert.Nil(t, err)
483			assert.Equal(t, 1, resp.Result())
484			assert.Equal(t, tc.cmd, buf.String())
485			}
486			}
487
488			func TestCmdVerbose(t *testing.T) {
489			agi, buf := mockAGI(respOk)
490			agi.Verbose("Debug message", 3)
491			assert.Equal(t, "VERBOSE \"Debug message\" 3\n", buf.String())
492
493			agi, buf = mockAGI(respOk)
494			agi.Verbose("Debug message")
495			assert.Equal(t, "VERBOSE \"Debug message\" 1\n", buf.String())
496
497			agi, buf = mockAGI(respOk)
498			agi.Verbose("Debug message", 0)
499			assert.Equal(t, "VERBOSE \"Debug message\" 1\n", buf.String())
500
501			agi, buf = mockAGI(respOk)
502			agi.Verbose("Debug message", 10)
503			assert.Equal(t, "VERBOSE \"Debug message\" 1\n", buf.String())
504			}
505
506			func TestCmdWaitForDigit(t *testing.T) {
507			agi, buf := mockAGI(respOk)
508			resp, err := agi.WaitForDigit(1000)
509			assert.Nil(t, err)
510			assert.Equal(t, 1, resp.Result())
511			assert.Equal(t, "WAIT FOR DIGIT 1000\n", buf.String())
512			}
513

staskobzar / goagi

goagi.TestCmdControlStreamFile A last analyzed 2024-06-21 00:34 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

goagi.TestCmdControlStreamFile A
last analyzed 2024-06-21 00:34 UTC