connection_test.go

package apns

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"net"
	"testing"
	"time"
)

/**
 * Tests related to connection write errors
 */
type MockConnErrorOnWrite struct {
	WrittenBytes *bytes.Buffer
	CloseChannel chan bool
}

func (conn MockConnErrorOnWrite) Read(b []byte) (n int, err error) {
	<-conn.CloseChannel
	return -1, errors.New("Socket Closed")
}
func (conn MockConnErrorOnWrite) Write(b []byte) (n int, err error) {
	conn.WrittenBytes.Write(b)
	return len(b), errors.New("Socket Closed")
}
func (conn MockConnErrorOnWrite) Close() error {
	defer func() { conn.CloseChannel <- true }()
	return nil
}
func (conn MockConnErrorOnWrite) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnWrite) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnWrite) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnWrite) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnWrite) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldCloseOnWriteError(t *testing.T) {
	socket := MockConnErrorOnWrite{
		WrittenBytes: new(bytes.Buffer),
		CloseChannel: make(chan bool),
	}

	apn := socketAPNSConnection(socket,
		&APNSConfig{
			InFlightPayloadBufferSize: 10000,
			FramingTimeout:            10,
			MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
			MaxPayloadSize:            2048,
		})

	payload := &Payload{
		AlertText: "Testing",
		Token:     "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8f",
	}

	apn.SendChannel <- payload
	connectionClose := <-apn.CloseChannel

	if connectionClose.Error.ErrorCode != CONNECTION_CLOSED_UNKNOWN {
		fmt.Printf("Should have received error CONNECTION_CLOSED_UNKNOWN for closed socket but received %v\n", connectionClose.Error)
		t.FailNow()
	}
}

/**
 * Tests related to connection write errors
 */
type MockConnErrorOnWrite2 struct {
	WrittenBytes *bytes.Buffer
	CloseChannel chan bool
}

func (conn MockConnErrorOnWrite2) Read(b []byte) (n int, err error) {
	fmt.Printf("Read %v\n", conn.CloseChannel)
	return -1, errors.New("Socket Closed on Read")
}
func (conn MockConnErrorOnWrite2) Write(b []byte) (n int, err error) {
	<-conn.CloseChannel
	return len(b), errors.New("Socket Closed on Write")
}
func (conn MockConnErrorOnWrite2) Close() error {
	fmt.Printf("conn close called %v\n", conn.CloseChannel)
	defer func() { conn.CloseChannel <- true }()
	return nil
}
func (conn MockConnErrorOnWrite2) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnWrite2) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnWrite2) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnWrite2) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnWrite2) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldCloseOnReadError(t *testing.T) {

	extSendChannel := make(chan *Payload)
	syncChan := make(chan bool)

	go func() {
		socket := MockConnErrorOnWrite2{
			WrittenBytes: new(bytes.Buffer),
			CloseChannel: make(chan bool),
		}

		apn := socketAPNSConnection(socket,
			&APNSConfig{
				InFlightPayloadBufferSize: 10000,
				FramingTimeout:            10,
				MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
				MaxPayloadSize:            2048,
			})

		for {
			select {
			case p := <-extSendChannel:
				apn.SendChannel <- p
				break
			case connectionClose := <-apn.CloseChannel:
				if connectionClose.Error.ErrorCode != CONNECTION_CLOSED_UNKNOWN {
					fmt.Printf("Should have received error CONNECTION_CLOSED_UNKNOWN for closed socket but received %v\n", connectionClose.Error)
					syncChan <- true
					t.FailNow()
				}
				syncChan <- true
				return
			}
		}
	}()

	<-syncChan
}

/**
 * Tests related to apple returned errors
 */
type MockConnErrorOnToken struct {
	WrittenBytes *bytes.Buffer
	CloseChannel chan uint32
}

func (conn MockConnErrorOnToken) Read(b []byte) (n int, err error) {
	errorId := <-conn.CloseChannel
	b[0] = uint8(8) //command
	b[1] = uint8(8) //invalid token
	//write error id in big endian
	b[2] = byte(errorId >> 24)
	b[3] = byte(errorId >> 16)
	b[4] = byte(errorId >> 8)
	b[5] = byte(errorId)
	return 6, nil
}
func (conn MockConnErrorOnToken) Write(b []byte) (n int, err error) {
	conn.WrittenBytes.Write(b)
	defer func() { conn.CloseChannel <- 1 }()
	return len(b), nil
}
func (conn MockConnErrorOnToken) Close() error {
	return nil
}
func (conn MockConnErrorOnToken) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldCloseOnAppleResponse(t *testing.T) {
	socket := MockConnErrorOnToken{
		WrittenBytes: new(bytes.Buffer),
		CloseChannel: make(chan uint32),
	}

	apn := socketAPNSConnection(socket,
		&APNSConfig{
			InFlightPayloadBufferSize: 10000,
			FramingTimeout:            10,
			MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
			MaxPayloadSize:            2048,
		})

	token := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8f"

	payload := &Payload{
		AlertText: "Testing",
		Token:     token,
	}

	apn.SendChannel <- payload

	connectionClose := <-apn.CloseChannel

	if connectionClose.Error.ErrorCode != 8 {
		fmt.Printf("Should have received error 8 for closed socket but received %v\n", connectionClose.Error)
		t.FailNow()
	}

	if connectionClose.ErrorPayload == nil ||
		connectionClose.ErrorPayload.Token != token {
		fmt.Printf("Should have returned payload object but received %v\n", connectionClose.ErrorPayload)
		t.FailNow()
	}
}

type MockConnErrorOnToken2 struct {
	WrittenBytes *bytes.Buffer
	CloseChannel chan uint32
}

func (conn MockConnErrorOnToken2) Read(b []byte) (n int, err error) {
	errorId := <-conn.CloseChannel
	b[0] = uint8(8) //command
	b[1] = uint8(8) //invalid token
	//write error id in big endian
	b[2] = byte(errorId >> 24)
	b[3] = byte(errorId >> 16)
	b[4] = byte(errorId >> 8)
	b[5] = byte(errorId)
	return 6, nil
}
func (conn MockConnErrorOnToken2) Write(b []byte) (n int, err error) {
	conn.WrittenBytes.Write(b)
	defer func() { conn.CloseChannel <- 2 }()
	return len(b), nil
}
func (conn MockConnErrorOnToken2) Close() error {
	return nil
}
func (conn MockConnErrorOnToken2) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken2) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken2) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken2) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken2) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldCloseAndReturnUnsentOnAppleResponse(t *testing.T) {

	extSendChannel := make(chan *Payload)
	syncChan := make(chan bool)

	token := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8f"
	token2 := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8e"
	token3 := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8d"
	token4 := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8c"

	go func() {

		payload := &Payload{
			AlertText: "Testing",
			Token:     token,
		}
		payload2 := &Payload{
			AlertText: "Testing2",
			Token:     token2,
		}
		payload3 := &Payload{
			AlertText: "Testing3",
			Token:     token3,
		}
		payload4 := &Payload{
			AlertText: "Testing4",
			Token:     token4,
		}

		extSendChannel <- payload
		extSendChannel <- payload2
		extSendChannel <- payload3
		extSendChannel <- payload4
	}()

	go func() {
		socket := MockConnErrorOnToken2{
			WrittenBytes: new(bytes.Buffer),
			CloseChannel: make(chan uint32),
		}

		apn := socketAPNSConnection(socket,
			&APNSConfig{
				InFlightPayloadBufferSize: 10000,
				FramingTimeout:            10,
				MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
				MaxPayloadSize:            2048,
			})

		for {
			select {
			case p := <-extSendChannel:
				if p == nil {
					return
				}
				apn.SendChannel <- p
				break
			case connectionClose := <-apn.CloseChannel:
				if connectionClose.Error.ErrorCode != 8 {
					fmt.Printf("Should have received error 8 for closed socket but received %v\n", connectionClose.Error)
					syncChan <- true
					t.FailNow()
				}

				if connectionClose.ErrorPayload == nil ||
					connectionClose.ErrorPayload.Token != token2 {
					fmt.Printf("Should have returned payload object but received %v\n", connectionClose.ErrorPayload)
					syncChan <- true
					t.FailNow()
				}

				for e := connectionClose.UnsentPayloads.Front(); e != nil; e = e.Next() {
					fmt.Printf("Unsent payload %v\n", e.Value.(*Payload))
				}

				if connectionClose.UnsentPayloads == nil ||
					connectionClose.UnsentPayloads.Len() != 2 {
					fmt.Printf("Should have returned 2 unsent payload objects but received %v len %v\n", connectionClose.UnsentPayloads, connectionClose.UnsentPayloads.Len())
					syncChan <- true
					t.FailNow()
				}

				if connectionClose.UnsentPayloads.Front().Value.(*Payload).Token != token3 &&
					connectionClose.UnsentPayloads.Back().Value.(*Payload).Token != token4 {
					fmt.Printf("Expected to receive specific unsent payloads but received %v len %v\n", connectionClose.UnsentPayloads, connectionClose.UnsentPayloads.Len())
					syncChan <- true
					t.FailNow()
				}

				if connectionClose.UnsentPayloadBufferOverflow {
					fmt.Printf("Expected to NOT get buffer overflow indication but did\n")
					syncChan <- true
					t.FailNow()
				}

				syncChan <- true
				return
			}
		}
	}()

	<-syncChan
}

type MockConnErrorOnToken3 struct {
	WrittenBytes *bytes.Buffer
	CloseChannel chan uint32
}

func (conn MockConnErrorOnToken3) Read(b []byte) (n int, err error) {
	errorId := <-conn.CloseChannel
	b[0] = uint8(8) //command
	b[1] = uint8(8) //invalid token
	//write error id in big endian
	b[2] = byte(errorId >> 24)
	b[3] = byte(errorId >> 16)
	b[4] = byte(errorId >> 8)
	b[5] = byte(errorId)
	return 6, nil
}
func (conn MockConnErrorOnToken3) Write(b []byte) (n int, err error) {
	conn.WrittenBytes.Write(b)
	dataSize := binary.BigEndian.Uint16(b[1:3])
	idStart := 3 + uint64(dataSize) - 4 - 4 - 1
	id := binary.BigEndian.Uint32(b[idStart : idStart+4])
	//after #4 written, say an error happened on id 2
	if id == 4 {
		defer func() { conn.CloseChannel <- 2 }()
	}
	return len(b), nil
}
func (conn MockConnErrorOnToken3) Close() error {
	return nil
}
func (conn MockConnErrorOnToken3) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken3) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken3) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken3) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken3) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldCloseAndReturnUnsentUpToBufferSizeOnAppleResponse(t *testing.T) {

	extSendChannel := make(chan *Payload)
	syncChan := make(chan bool)

	token := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8f"
	token2 := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8e"
	token3 := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8d"
	token4 := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8c"

	go func() {

		payload := &Payload{
			AlertText: "Testing",
			Token:     token,
		}
		payload2 := &Payload{
			AlertText: "Testing2",
			Token:     token2,
		}
		payload3 := &Payload{
			AlertText: "Testing3",
			Token:     token3,
		}
		payload4 := &Payload{
			AlertText: "Testing4",
			Token:     token4,
		}

		extSendChannel <- payload
		extSendChannel <- payload2
		extSendChannel <- payload3
		extSendChannel <- payload4
	}()

	go func() {
		socket := MockConnErrorOnToken2{
			WrittenBytes: new(bytes.Buffer),
			CloseChannel: make(chan uint32),
		}

		apn := socketAPNSConnection(socket,
			&APNSConfig{
				InFlightPayloadBufferSize: 1,
				FramingTimeout:            10,
				MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
				MaxPayloadSize:            2048,
			})

		for {
			select {
			case p := <-extSendChannel:
				if p == nil {
					return
				}
				apn.SendChannel <- p
				break
			case connectionClose := <-apn.CloseChannel:
				if connectionClose.Error.ErrorCode != 8 {
					fmt.Printf("Should have received error 8 for closed socket but received %v\n", connectionClose.Error)
					syncChan <- true
					t.FailNow()
				}

				if connectionClose.ErrorPayload != nil {
					fmt.Printf("Should have returned payload object but received %v\n", connectionClose.ErrorPayload)
					syncChan <- true
					t.FailNow()
				}

				for e := connectionClose.UnsentPayloads.Front(); e != nil; e = e.Next() {
					fmt.Printf("Unsent payload %v\n", e.Value.(*Payload))
				}

				if connectionClose.UnsentPayloads == nil ||
					connectionClose.UnsentPayloads.Len() != 1 {
					fmt.Printf("Should have returned 1 unsent payload objects but received %v len %v\n", connectionClose.UnsentPayloads, connectionClose.UnsentPayloads.Len())
					syncChan <- true
					t.FailNow()
				}

				if connectionClose.UnsentPayloads.Front().Value.(*Payload).Token != token4 {
					fmt.Printf("Expected to receive specific unsent payloads but received %v len %v\n", connectionClose.UnsentPayloads, connectionClose.UnsentPayloads.Len())
					syncChan <- true
					t.FailNow()
				}

				if !connectionClose.UnsentPayloadBufferOverflow {
					fmt.Printf("Expected to get buffer overflow indication but didn't\n")
					syncChan <- true
					t.FailNow()
				}

				syncChan <- true
				return
			}
		}
	}()

	<-syncChan
}

type MockConnErrorOnToken4 struct {
	WrittenBytes *bytes.Buffer
	DisconnectChannel chan bool
}

func (conn MockConnErrorOnToken4) Read(b []byte) (n int, err error) {
	<-conn.DisconnectChannel
	return 0, fmt.Errorf("Connection closed")
}
func (conn MockConnErrorOnToken4) Write(b []byte) (n int, err error) {
	conn.WrittenBytes.Write(b)
	return len(b), nil
}
func (conn MockConnErrorOnToken4) Close() error {
	return nil
}
func (conn MockConnErrorOnToken4) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken4) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken4) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken4) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken4) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldNotReturnErrorOnDisconnect(t *testing.T) {
	socket := MockConnErrorOnToken4{
		WrittenBytes: new(bytes.Buffer),
		DisconnectChannel: make(chan bool),
	}

	apn := socketAPNSConnection(socket,
		&APNSConfig{
			InFlightPayloadBufferSize: 10000,
			FramingTimeout:            10,
			MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
			MaxPayloadSize:            2048,
		})

	token := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8f"

	payload := &Payload{
		AlertText: "Testing",
		Token:     token,
	}

	apn.SendChannel <- payload

	apn.Disconnect()

	socket.DisconnectChannel <- true

	connectionClose := <-apn.CloseChannel

	if connectionClose.Error != nil {
		fmt.Printf("Should NOT have received error but received %v\n", connectionClose.Error)
		t.FailNow()
	}

	if connectionClose.ErrorPayload != nil {
		fmt.Printf("Should NOT have received error payload but received %v\n", connectionClose.ErrorPayload)
		t.FailNow()
	}
}

type MockConnErrorOnToken5 struct {
	WrittenBytes *bytes.Buffer
	DisconnectChannel chan bool
}

func (conn MockConnErrorOnToken5) Read(b []byte) (n int, err error) {
	<-conn.DisconnectChannel
	return 0, fmt.Errorf("Connection closed")
}
func (conn MockConnErrorOnToken5) Write(b []byte) (n int, err error) {
	conn.WrittenBytes.Write(b)
	return len(b), nil
}
func (conn MockConnErrorOnToken5) Close() error {
	return nil
}
func (conn MockConnErrorOnToken5) LocalAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken5) RemoteAddr() net.Addr {
	return nil
}
func (conn MockConnErrorOnToken5) SetDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken5) SetReadDeadline(t time.Time) error {
	return nil
}
func (conn MockConnErrorOnToken5) SetWriteDeadline(t time.Time) error {
	return nil
}

func TestConnectionShouldReturnErrorOnRandomSocketClose(t *testing.T) {
	socket := MockConnErrorOnToken5{
		WrittenBytes: new(bytes.Buffer),
		DisconnectChannel: make(chan bool),
	}

	apn := socketAPNSConnection(socket,
		&APNSConfig{
			InFlightPayloadBufferSize: 10000,
			FramingTimeout:            10,
			MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
			MaxPayloadSize:            2048,
		})

	token := "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8f"

	payload := &Payload{
		AlertText: "Testing",
		Token:     token,
	}

	apn.SendChannel <- payload

	socket.DisconnectChannel <- true

	connectionClose := <-apn.CloseChannel

	if connectionClose.Error == nil {
		fmt.Printf("Should have received error but received %v\n", connectionClose.Error)
		t.FailNow()
	}

	if connectionClose.Error.ErrorCode != CONNECTION_CLOSED_UNKNOWN {
		fmt.Printf("Should have received error code CONNECTION_CLOSED_UNKNOWN but received %v\n", connectionClose.Error.ErrorCode)
		t.FailNow()
	}

	if connectionClose.ErrorPayload != nil {
		fmt.Printf("Should NOT have received error payload but received %v\n", connectionClose.ErrorPayload)
		t.FailNow()
	}
}

func TestShouldNotWritePayloadOnBadToken(t *testing.T) {
	socket := MockConnErrorOnWrite{
		WrittenBytes: new(bytes.Buffer),
		CloseChannel: make(chan bool),
	}

	apn := socketAPNSConnection(socket,
		&APNSConfig{
			InFlightPayloadBufferSize: 10000,
			FramingTimeout:            10,
			MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
			MaxPayloadSize:            2048,
		})

	payload := &Payload{
		AlertText: "Testing",
		Token:     "4ec500",
	}

	apn.SendChannel <- payload

	apn.Disconnect()

	if socket.WrittenBytes.Len() != 0 {
		fmt.Printf("Expected no bytes to be written but bytes were written\n")
		t.FailNow()
	}
}

func TestShouldNotWritePayloadIfUnableToMarshall(t *testing.T) {
	socket := MockConnErrorOnWrite{
		WrittenBytes: new(bytes.Buffer),
		CloseChannel: make(chan bool),
	}

	apn := socketAPNSConnection(socket,
		&APNSConfig{
			InFlightPayloadBufferSize: 10000,
			FramingTimeout:            10,
			MaxOutboundTCPFrameSize:   TCP_FRAME_MAX,
			MaxPayloadSize:            10,
		})

	payload := &Payload{
		AlertText: "Testing this payload",
		Token:     "4ec500020d8350072d2417ba566feda10b2b266558371a65ba67fede21393c8c",
	}

	apn.SendChannel <- payload

	apn.Disconnect()

	if socket.WrittenBytes.Len() != 0 {
		fmt.Printf("Expected no bytes to be written but bytes were written\n")
		t.FailNow()
	}
}