sgx-aa/provider_test.go

package main

import (
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
	"testing"
)

const (
	testHostname = "https://example.com"
)

var newAndrewsArnoldProviderTest = []struct {
	descr   string
	options []ProviderOption
	err     error
}{
	{
		descr:   "empty hostname in report handler",
		options: []ProviderOption{WithReportHandler("")},
		err:     fmt.Errorf("cannot use report handler with empty hostname"),
	},
}

func TestNewAndrewsArnoldProvider(t *testing.T) {
	for _, tt := range newAndrewsArnoldProviderTest {
		t.Run(tt.descr, func(t *testing.T) {
			_, err := NewAndrewsArnoldProvider(tt.options...)
			if err != nil && tt.err == nil {
				t.Errorf("NewAndrewsArnoldProvider(): want error 'nil', have '%s'", err)
			} else if err == nil && tt.err != nil {
				t.Errorf("NewAndrewsArnoldProvider(): want error '%s', have 'nil'", tt.err)
			} else if err != nil && tt.err != nil && err.Error() != tt.err.Error() {
				t.Errorf("NewAndrewsArnoldProvider(): want error '%s', have '%s'", tt.err, err)
			}
		})
	}
}

var sendMessageTest = []struct {
	descr     string
	user      User
	message   Message
	transport *mockTransport
	values    url.Values
	err       error
}{
	{
		descr: "empty username",
		user:  User{},
		err:   fmt.Errorf("cannot send message for incomplete user information"),
	},
	{
		descr: "empty password",
		user:  User{tel: "+447700900000"},
		err:   fmt.Errorf("cannot send message for incomplete user information"),
	},
	{
		descr: "empty destination number",
		user:  User{tel: "+447700900000", password: "some secret!"},
		err:   fmt.Errorf("cannot send message for empty destination number"),
	},
	{
		descr:   "empty body",
		user:    User{tel: "+447700900000", password: "some secret!"},
		message: Message{Dest: "+447700900001"},
	},
	{
		descr:     "error in HTTP request",
		user:      User{tel: "+447700900000", password: "some secret!"},
		message:   Message{Dest: "+447700900001", Body: "hello world"},
		transport: &mockTransport{err: fmt.Errorf("some darn error!")},
		err:       fmt.Errorf(`failed sending HTTP request for message: Post "%s": some darn error!`, upstreamEndpoint),
	},
	{
		descr:     "upstream error message",
		user:      User{tel: "+447700900000", password: "some secret!"},
		message:   Message{Dest: "+447700900001", Body: "hello world"},
		transport: &mockTransport{body: "ERR:what is the what?"},
		err:       fmt.Errorf("failed sending HTTP request for message: what is the what?"),
	},
	{
		descr:     "upstream error code",
		user:      User{tel: "+447700900000", password: "some secret!"},
		message:   Message{Dest: "+447700900001", Body: "hello world"},
		transport: &mockTransport{status: 403},
		err:       fmt.Errorf("failed sending HTTP request for message: 403 Forbidden"),
	},
	{
		descr:   "valid form body",
		user:    User{tel: "+447700900000", password: "some secret!"},
		message: Message{Dest: "+447700900001", Body: "hello world"},
		values: url.Values{
			"username":   {"+447700900000"},
			"password":   {"some secret!"},
			"da":         {"+447700900001"},
			"ud":         {"hello world"},
			"limit":      {"3"},
			"costcentre": {"sgx-aa"},
		},
	},
	{
		descr:   "valid form body with message ID",
		user:    User{tel: "+447700900000", password: "some secret!"},
		message: Message{Dest: "+447700900001", Body: "hello world", ID: "foo bar"},
		values: url.Values{
			"username":   {"+447700900000"},
			"password":   {"some secret!"},
			"da":         {"+447700900001"},
			"ud":         {"hello world"},
			"limit":      {"3"},
			"costcentre": {"sgx-aa"},
			"srr":        {"https://example.com/c77f0ea3dcd450b6df09deb5dc8d7a92a1415cc6b4b86b0e62db668361fc1baf/sms/srr?code=%code&da=%da&oa=%oa&stanzaId=foo+bar"},
		},
	},
}

func TestSendMessage(t *testing.T) {
	for _, tt := range sendMessageTest {
		t.Run(tt.descr, func(t *testing.T) {
			p, err := NewAndrewsArnoldProvider(WithReportHandler(testHostname))
			if err != nil {
				t.Fatalf("NewAndrewsArnoldProvider: %s", err)
			}

			tr := &mockTransport{}
			if tt.transport != nil {
				tr = tt.transport
			}
			p.client = &http.Client{Transport: tr}

			err = p.SendMessage(tt.user, tt.message)
			if err != nil && tt.err == nil {
				t.Errorf("SendMessage(): want error 'nil', have '%s'", err)
			} else if err == nil && tt.err != nil {
				t.Errorf("SendMessage(): want error '%s', have 'nil'", tt.err)
			} else if err != nil && tt.err != nil && err.Error() != tt.err.Error() {
				t.Errorf("SendMessage(): want error '%s', have '%s'", tt.err, err)
			} else if err != nil && tt.err != nil {
				return
			} else if expect := tt.values.Encode(); expect != tr.body {
				t.Errorf("SendMessage(): want request body '%s', have '%s'", expect, tr.body)
			}
		})
	}
}

type mockTransport struct {
	status int
	body   string
	err    error
}

func (tr *mockTransport) RoundTrip(r *http.Request) (*http.Response, error) {
	if tr.err != nil {
		return nil, tr.err
	}

	if tr.body == "" {
		if err := r.ParseForm(); err != nil {
			return nil, err
		}
		tr.body = r.Form.Encode()
	}

	if tr.status == 0 {
		tr.status = http.StatusOK
	}

	resp := &http.Response{
		StatusCode: tr.status,
		Body:       io.NopCloser(strings.NewReader(tr.body)),
	}

	return resp, nil
}