staskobzar / goagi

import (

	"bytes"

	"io"

	"io/ioutil"

	"log"

	"net"

	"os"

	"strings"

	"testing"

	"github.com/stretchr/testify/assert"

)

type stubReader struct {

	io.Reader

}

type stubWriter struct {

	io.Writer

}

var agiSetupInput = []string{

	"agi_network: yes",

	"agi_network_script: foo?",

	"agi_request: agi://127.0.0.1/foo?",

	"agi_channel: SIP/2222@default-00000023",

	"agi_language: en",

	"agi_type: SIP",

	"agi_uniqueid: 1397044468.0",

	"agi_version: 0.1",

	"agi_callerid: 5001",

	"agi_calleridname: Alice",

	"agi_callingpres: 67",

	"agi_callingani2: 0",

	"agi_callington: 0",

	"agi_callingtns: 0",

	"agi_dnid: 123456",

	"agi_rdnis: unknown",

	"agi_context: default",

	"agi_extension: 2222",

	"agi_priority: 1",

	"agi_enhanced: 0.0",

	"agi_accountcode: 0",

	"agi_threadid: 140536028174080",

	"agi_arg_1: argument1",

	"agi_arg_2: argument2",

}

func TestNew(t *testing.T) {

	input := strings.Join(agiSetupInput, "\n")

	input += "\n\n"

	logBuffer := new(bytes.Buffer)

	logger := log.New(logBuffer, "agi: ", log.Lmicroseconds)

	reader := &stubReader{strings.NewReader(input)}

	writer := &stubWriter{ioutil.Discard}

	agi, err := New(reader, writer, logger)

	assert.Nil(t, err)

	assert.Equal(t, "SIP/2222@default-00000023", agi.Env("channel"))

	assert.Equal(t, "2222", agi.Env("extension"))

	assert.Empty(t, agi.Env("invalid_name"))

	assert.Equal(t, 2, len(agi.EnvArgs()))

	assert.Contains(t, logBuffer.String(), "agi_network: yes")

	assert.Contains(t, logBuffer.String(), "agi_threadid: 140536028174080")

}

func TestNewFail(t *testing.T) {

	reader, writer, err := os.Pipe()

	assert.Nil(t, err)

	reader.Close()

	agi, err := New(reader, writer, nil)

	assert.Nil(t, agi)

	assert.NotNil(t, err)

	assert.Contains(t, err.Error(), "closed")

}

func TestNewIOPipe(t *testing.T) {

	reader, writer, err := os.Pipe()

	assert.Nil(t, err)

	input := strings.Join(agiSetupInput, "\n")

	input += "\n\n"

	writer.WriteString(input)

	agi, err := New(reader, writer, nil)

	assert.Nil(t, err)

	assert.Equal(t, "2222", agi.Env("extension"))

	assert.Equal(t, 2, len(agi.EnvArgs()))

}

func TestNewNetPipe(t *testing.T) {

	reader, writer := net.Pipe()

	input := strings.Join(agiSetupInput, "\n")

	input += "\n\n"

	go writer.Write([]byte(input))

	agi, err := New(reader, writer, nil)

	assert.Nil(t, err)

	assert.Equal(t, "2222", agi.Env("extension"))

	assert.Equal(t, 2, len(agi.EnvArgs()))

}

func TestSessionInitDeviceFail(t *testing.T) {

	stdin, _, err := os.Pipe()

	assert.Nil(t, err)

	agi := &AGI{reader: stdin}

	stdin.Close()

	_, err = agi.sessionInit()

	assert.NotNil(t, err)

	assert.Contains(t, err.Error(), "closed")

}

}

func TestReadResponseWithHangup(t *testing.T) {

	reader := &stubReader{strings.NewReader("HANGUP\n200 result=1\n")}

	agi := &AGI{reader: reader}

	res, code, err := agi.read()

	assert.Nil(t, err)

	assert.Equal(t, "200 result=1\n", res)

	assert.Equal(t, codeSucc, code)

	assert.True(t, agi.IsHungup())

}

func TestReadResponseLongError520(t *testing.T) {

	input := "HANGUP\n520-Invalid command syntax.  Proper usage follows:\n" +

		"Usage: DATABASE GET\n" +

		"Retrieves an entry in the Asterisk database for a\n" +

		"given family and key.\n" +

		"Returns 0 if is not set. Returns 1 if \n" +

		"is set and returns the variable in parentheses.\n" +

		"Example return code: 200 result=1 (testvariable)\n" +

		"520 End of proper usage.\n"

	reader := &stubReader{strings.NewReader(input)}

	agi := &AGI{reader: reader}

	res, code, err := agi.read()

	assert.Nil(t, err)

	assert.Equal(t, input[7:], res)

	assert.Equal(t, codeE520, code)

	assert.True(t, agi.IsHungup())

}

func TestReadResponseGarbage(t *testing.T) {

	tests := []string{

		"Usage: DATABASE GET\n" +

			"Retrieves an entry in the Asterisk database for a\n" +

			"given family and key.\n" +

			"Returns 0 if is not set. Returns 1 if \n" +

			"is set and returns the variable in parentheses.\n" +

			"Example return code: 200 result=1 (testvariable)\n" +

			"520 End of proper usage.\n",

		"\n", // empty string

		"2222222\n",

		"-1 result=4\n",

		"780 result=0\n",

	}

	for _, input := range tests {

		reader := &stubReader{strings.NewReader(input)}

		agi := &AGI{reader: reader}

		_, code, err := agi.read()

		assert.NotNil(t, err)

		assert.Contains(t, err.Error(), "Invalid input")

		assert.Zero(t, code)

	}

}

func TestReadResponseFail(t *testing.T) {

	stdin, _, err := os.Pipe()

	assert.Nil(t, err)

	agi := &AGI{reader: stdin}

	stdin.Close()

	_, _, err = agi.read()

	assert.NotNil(t, err)

	assert.Contains(t, err.Error(), "closed")

}

func TestWriteStdIO(t *testing.T) {

	reader, writer, err := os.Pipe()

	assert.Nil(t, err)

	agi := &AGI{writer: writer}

	err = agi.write([]byte("NOOP\n"))

	assert.Nil(t, err)

	buf := make([]byte, 32)

	n, _ := reader.Read(buf)

	assert.Equal(t, "NOOP\n", string(buf[:n]))

}

func TestWriteNetConn(t *testing.T) {

	reader, writer := net.Pipe()

	agi := &AGI{writer: writer}

	go func() {

		agi.write([]byte("ANSWER\n"))

		writer.Close()

	}()

	buf, _ := ioutil.ReadAll(reader)

	assert.Equal(t, "ANSWER\n", string(buf))

}

func TestWriteFail(t *testing.T) {

	reader, writer, err := os.Pipe()

	assert.Nil(t, err)

	agi := &AGI{writer: writer}

	reader.Close()

	err = agi.write([]byte("HANGUP\n"))

	assert.NotNil(t, err)

	assert.Contains(t, err.Error(), "broken pipe")

}

func TestExecute(t *testing.T) {

	buf, reader, writer := stubReaderWriter("200 result=1")

	agi := &AGI{reader: reader, writer: writer}

	resp, err := agi.execute("NOOP\n")

	assert.Nil(t, err)

	assert.Equal(t, "NOOP\n", buf.String())

	assert.Equal(t, 200, resp.Code())

	assert.Equal(t, 1, resp.Result())

	resp, err = agi.execute("HANGUP\n")

	assert.NotNil(t, err)

	assert.Nil(t, resp)

	_, wr := net.Pipe()

	agi.writer = wr

	wr.Close()

	resp, err = agi.execute("HANGUP\n")

	assert.NotNil(t, err)

	assert.Contains(t, err.Error(), "closed")

}