server_test.go

package gourd

import (
	"bufio"
	"fmt"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"net"
	"testing"
	"time"
)

func Test_wire_server_accepts_one_connection_on_the_specified_port(t *testing.T) {
	var specified_port uint = 2531
	testee := &gourd_wire_server{}
	done := start_wire_server(testee, specified_port)

	// Give the wire server some time to start accepting connection
	time.Sleep(time.Millisecond)

	conn, err := net.Dial("tcp", fmt.Sprintf("localhost:%d", specified_port))
	assert.Nil(t, err, "Wire server is not listening.")

	conn.Close()

	assert_wire_server_exits(t, done)
}

func Test_wire_server_forwards_commands_to_parser_without_newlines(t *testing.T) {
	parser := &parser_mock{}
	testee := &gourd_wire_server{parser}
	done := start_wire_server(testee, DefaultPort)

	expected_command := []byte(`["begin_scenario"]`)
	parser.On("parse", expected_command).Return("").Once()

	// Give the wire server some time to start accepting connection
	time.Sleep(time.Millisecond)

	conn, err := net.Dial("tcp", "localhost:1847")
	assert.Nil(t, err, "Wireserver is not listening.")

	command := append(expected_command, '\n')

	writer := bufio.NewWriter(conn)
	_, err = writer.Write(command)
	assert.Nil(t, err, "Failed to send command to wire server.")

	writer.Flush()
	conn.Close()

	assert_wire_server_exits(t, done)
	parser.Mock.AssertExpectations(t)
}

func Test_wire_server_reads_and_parses_line_by_line(t *testing.T) {
	parser := &parser_mock{}
	testee := &gourd_wire_server{parser}
	done := start_wire_server(testee, DefaultPort)

	// Give the wire server some time to start accepting connection
	time.Sleep(time.Millisecond)

	conn, err := net.Dial("tcp", "localhost:1847")
	assert.Nil(t, err, "Wireserver is not listening.")

	// First command
	command := []byte(`["begin_scenario"]`)
	parser.On("parse", command).Return("").Once()
	writer := bufio.NewWriter(conn)
	_, err = writer.Write(append(command, '\n'))
	assert.Nil(t, err, "Failed to send command to wire server.")

	writer.Flush()

	// Next command
	command = []byte(`["end_scenario"]`)
	parser.On("parse", command).Return("").Once()
	_, err = writer.Write(append(command, '\n'))
	assert.Nil(t, err, "Failed to send command to wire server.")

	writer.Flush()
	conn.Close()

	assert_wire_server_exits(t, done)
	parser.Mock.AssertExpectations(t)
}

func Test_wire_server_sends_response_from_parser_including_newline(t *testing.T) {
	parser := &parser_mock{}
	testee := &gourd_wire_server{parser}
	done := start_wire_server(testee, DefaultPort)

	response := `["success"]`
	parser.On("parse", mock.Anything).Return(response).Once()

	// Give the wire server some time to start accepting connection
	time.Sleep(time.Millisecond)

	conn, err := net.Dial("tcp", "localhost:1847")
	assert.Nil(t, err, "Wireserver is not listening.")

	command := []byte(`["begin_scenario"]`)
	writer := bufio.NewWriter(conn)
	_, err = writer.Write(append(command, '\n'))
	assert.Nil(t, err, "Failed to send command to wire server.")
	writer.Flush()

	expected_response := response + "\n"
	assert_wire_server_responds(t, conn, expected_response)

	conn.Close()

	assert_wire_server_exits(t, done)
	parser.Mock.AssertExpectations(t)
}

func start_wire_server(server *gourd_wire_server, port uint) chan bool {
	done := make(chan bool)
	go func() {
		server.listen(port)
		done <- true
	}()
	return done
}

func assert_wire_server_exits(t *testing.T, done chan bool) {
	select {
	case <-done:
	case <-time.After(1 * time.Second):
		assert.Fail(t, "Wireserver did not exit.")
	}
}

func assert_wire_server_responds(t *testing.T, conn net.Conn, response string) {
	done := make(chan bool)
	go func() {
		reader := bufio.NewReader(conn)
		line, err := reader.ReadString('\n')
		assert.Nil(t, err, "Failed to read response from wire server.")
		assert.Equal(t, response, line)
		done <- true
	}()

	select {
	case <-done:
	case <-time.After(1 * time.Second):
		assert.Fail(t, "Wireserver did not respond.")
	}
}