mailbox_test.go

package sbanken

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"reflect"
	"testing"
	"time"

	"github.com/engvik/sbanken-go/internal/transport"
)

var testMailboxMessage = MailboxMessage{
	Subject:      "Test Subject",
	Category:     "category",
	Source:       "source",
	Status:       "status",
	LinkName:     "link-name",
	LinkURL:      "https://example.com",
	ReceivedDate: time.Now().String(),
	ID:           1337,
	Flag:         1,
	AttachmentID: 7331,
}

func testListMessagesEndpointResponse(behavior string) ([]byte, int, error) {
	d := struct {
		Messages []MailboxMessage `json:"items"`
		transport.HTTPResponse
	}{
		Messages: []MailboxMessage{testMailboxMessage},
	}

	if behavior == "fail" {
		d.IsError = testHTTPResponseError.IsError
		d.ErrorCode = testHTTPResponseError.ErrorCode
		d.ErrorMessage = testHTTPResponseError.ErrorMessage
		d.ErrorType = testHTTPResponseError.ErrorType
	}

	b, err := json.Marshal(d)
	if err != nil {
		return nil, 0, err
	}

	if behavior == "fail" {
		return b, http.StatusInternalServerError, nil
	}

	return b, http.StatusOK, nil
}

func testReadAndDeleteMessageEndpointResponse(behavior string) ([]byte, int, error) {
	d := testMailboxMessage

	b, err := json.Marshal(d)
	if err != nil {
		return nil, 0, err
	}

	switch behavior {
	case "fail":
		return b, http.StatusInternalServerError, nil
	case "delete":
		return b, http.StatusNoContent, nil
	default:
		return b, http.StatusOK, nil
	}
}

func testMoveMessageEndpointResponse(behavior string) ([]byte, int, error) {
	if behavior == "fail" {
		return nil, http.StatusInternalServerError, nil
	}

	return nil, http.StatusOK, nil
}

func testUpdateMessageReadStatusEndpointResponse(behavior string) ([]byte, int, error) {
	if behavior == "fail" {
		return nil, http.StatusInternalServerError, nil
	}

	return nil, http.StatusNoContent, nil
}

func testGetMessageCountEndpointResponse(behavior string) ([]byte, int, error) {
	if behavior == "fail" {
		return nil, http.StatusInternalServerError, nil
	}

	return []byte("1337"), http.StatusOK, nil
}

func TestMailboxListQuery(t *testing.T) {
	timestamp := time.Now()
	qsTimestamp := url.QueryEscape(timestamp.Format(time.RFC3339))

	tests := []struct {
		name string
		q    *MailboxListQuery
		exp  string
	}{
		{
			name: "should create correct query string",
			q:    &MailboxListQuery{},
			exp:  "",
		},
		{
			name: "should create correct query string",
			q:    &MailboxListQuery{StartDate: timestamp},
			exp:  fmt.Sprintf("startDate=%s", qsTimestamp),
		},
		{
			name: "should create correct query string",
			q: &MailboxListQuery{
				StartDate: timestamp,
				EndDate:   timestamp,
			},
			exp: fmt.Sprintf("endDate=%s&startDate=%s", qsTimestamp, qsTimestamp),
		},
		{
			name: "should create correct query string",
			q:    &MailboxListQuery{Status: "test"},
			exp:  "status=test",
		},
		{
			name: "should create correct query string",
			q:    &MailboxListQuery{Index: "1", Length: "5"},
			exp:  "index=1&length=5",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			u, err := tc.q.QueryString("https://example.com")
			if err != nil {
				t.Errorf("unexpected error: got %s", err)

				return
			}

			if u != tc.exp {
				t.Errorf("unexpected query string: got %s, exp %s", u, tc.exp)
			}
		})
	}
}

func TestMailboxCountQuery(t *testing.T) {
	timestamp := time.Now()
	qsTimestamp := url.QueryEscape(timestamp.Format(time.RFC3339))

	tests := []struct {
		name string
		q    *MailboxCountQuery
		exp  string
	}{
		{
			name: "should create correct query string",
			q:    &MailboxCountQuery{},
			exp:  "",
		},
		{
			name: "should create correct query string",
			q:    &MailboxCountQuery{StartDate: timestamp},
			exp:  fmt.Sprintf("startDate=%s", qsTimestamp),
		},
		{
			name: "should create correct query string",
			q: &MailboxCountQuery{
				StartDate: timestamp,
				EndDate:   timestamp,
			},
			exp: fmt.Sprintf("endDate=%s&startDate=%s", qsTimestamp, qsTimestamp),
		},
		{
			name: "should create correct query string",
			q:    &MailboxCountQuery{Status: "test"},
			exp:  "status=test",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			u, err := tc.q.QueryString("https://example.com")
			if err != nil {
				t.Errorf("unexpected error: got %s", err)

				return
			}

			if u != tc.exp {
				t.Errorf("unexpected query string: got %s, exp %s", u, tc.exp)
			}
		})
	}
}

func TestListArchiveMessages(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name     string
		q        *MailboxListQuery
		behavior string
		exp      []MailboxMessage
		expErr   error
	}{
		{
			name:     "should return error when error occurs",
			q:        nil,
			behavior: "fail",
			exp:      nil,
			expErr:   getTestError("ListArchiveMessages"),
		},
		{
			name:   "should list archive mailbox messages without query",
			q:      nil,
			exp:    []MailboxMessage{testMailboxMessage},
			expErr: nil,
		},
		{
			name:   "should list archive mailbox messages with query",
			q:      &MailboxListQuery{Index: "1"},
			exp:    []MailboxMessage{testMailboxMessage},
			expErr: nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			a, err := c.ListArchiveMessages(ctx, tc.q)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.expErr.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}

				return
			}

			if !reflect.DeepEqual(a, tc.exp) {
				t.Errorf("unexpected efaktura: got %v, exp %v", a, tc.exp)
			}
		})
	}
}

func TestListInboxMessages(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name     string
		q        *MailboxListQuery
		behavior string
		exp      []MailboxMessage
		expErr   error
	}{
		{
			name:     "should return error when error occurs",
			q:        nil,
			behavior: "fail",
			exp:      nil,
			expErr:   getTestError("ListInboxMessages"),
		},
		{
			name:   "should list inbox mailbox messages without query",
			q:      nil,
			exp:    []MailboxMessage{testMailboxMessage},
			expErr: nil,
		},
		{
			name:   "should list inbox mailbox messages with query",
			q:      &MailboxListQuery{Index: "1"},
			exp:    []MailboxMessage{testMailboxMessage},
			expErr: nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			a, err := c.ListInboxMessages(ctx, tc.q)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.expErr.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}

				return
			}

			if !reflect.DeepEqual(a, tc.exp) {
				t.Errorf("unexpected efaktura: got %v, exp %v", a, tc.exp)
			}
		})
	}
}

func TestReadArchiveMessage(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		messageID int
		behavior  string
		exp       MailboxMessage
		expErr    error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       testMailboxMessage,
			expErr:    getTestBasicError("ReadArchiveMessage"),
		},
		{
			name:      "should return mailbox message",
			messageID: 1337,
			exp:       testMailboxMessage,
			expErr:    nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			a, err := c.ReadArchiveMessage(ctx, tc.messageID)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.expErr.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}

				return
			}

			if !reflect.DeepEqual(a, tc.exp) {
				t.Errorf("unexpected efaktura: got %v, exp %v", a, tc.exp)
			}
		})
	}
}

func TestReadInboxMessage(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		messageID int
		behavior  string
		exp       MailboxMessage
		expErr    error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       testMailboxMessage,
			expErr:    getTestBasicError("ReadInboxMessage"),
		},
		{
			name:      "should return mailbox message",
			messageID: 1337,
			exp:       testMailboxMessage,
			expErr:    nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			a, err := c.ReadInboxMessage(ctx, tc.messageID)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.expErr.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}

				return
			}

			if !reflect.DeepEqual(a, tc.exp) {
				t.Errorf("unexpected efaktura: got %v, exp %v", a, tc.exp)
			}
		})
	}
}

func TestDeleteArchiveMessage(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		messageID int
		behavior  string
		exp       error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       getTestBasicError("DeleteArchiveMessage"),
		},
		{
			name:      "should not return error if successful",
			messageID: 1337,
			behavior:  "delete",
			exp:       nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			err := c.DeleteArchiveMessage(ctx, tc.messageID)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.exp.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}
		})
	}
}

func TestDeleteInboxMessage(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		messageID int
		behavior  string
		exp       error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       getTestBasicError("DeleteInboxMessage"),
		},
		{
			name:      "should not return error if successful",
			messageID: 1337,
			behavior:  "delete",
			exp:       nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			err := c.DeleteInboxMessage(ctx, tc.messageID)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.exp.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}
		})
	}
}

func TestMoveArchiveMessage(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		messageID int
		behavior  string
		exp       error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       getTestBasicError("MoveArchiveMessage"),
		},
		{
			name:      "should not return error if successful",
			messageID: 1337,
			exp:       nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			err := c.MoveArchiveMessage(ctx, tc.messageID)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.exp.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}
		})
	}
}

func TestMoveInboxMessage(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		messageID int
		behavior  string
		exp       error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       getTestBasicError("MoveInboxMessage"),
		},
		{
			name:      "should not return error if successful",
			messageID: 1337,
			exp:       nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			err := c.MoveInboxMessage(ctx, tc.messageID)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.exp.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}
		})
	}
}

func TestUpdateArchiveMessageReadStatus(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		status    bool
		messageID int
		behavior  string
		exp       error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       getTestBasicError("UpdateArchiveMessageReadStatus"),
		},
		{
			name:      "should not return error if successful - read",
			status:    true,
			messageID: 1337,
			exp:       nil,
		},
		{
			name:      "should not return error if successful - unread",
			status:    false,
			messageID: 1337,
			exp:       nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			err := c.UpdateArchiveMessageReadStatus(ctx, tc.messageID, tc.status)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.exp.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}
		})
	}
}

func TestUpdateInboxMessageReadStatus(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name      string
		status    bool
		messageID int
		behavior  string
		exp       error
	}{
		{
			name:      "should return error when error occurs",
			messageID: 1337,
			behavior:  "fail",
			exp:       getTestBasicError("UpdateInboxMessageReadStatus"),
		},
		{
			name:      "should not return error if successful - read",
			status:    true,
			messageID: 1337,
			exp:       nil,
		},
		{
			name:      "should not return error if successful - unread",
			status:    false,
			messageID: 1337,
			exp:       nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			err := c.UpdateInboxMessageReadStatus(ctx, tc.messageID, tc.status)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.exp.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}
		})
	}
}

func TestGetArchiveMessageCount(t *testing.T) {
	ctx := context.Background()
	c, err := newTestClient(ctx, t)
	if err != nil {
		t.Fatalf("error setting up test: %v", err)
	}

	tests := []struct {
		name     string
		behavior string
		exp      int
		expErr   error
	}{
		{
			name:     "should return error when error occurs",
			behavior: "fail",
			exp:      0,
			expErr:   getTestBasicError("GetArchiveMessageCount"),
		},
		{
			name:   "should not return error if successful - read",
			exp:    1337,
			expErr: nil,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			ctx = context.WithValue(ctx, testBehavior("test-behavior"), tc.behavior)

			got, err := c.GetArchiveMessageCount(ctx, nil)
			if err != nil {
				errStr := err.Error()
				expErrStr := tc.expErr.Error()
				if errStr != expErrStr {
					t.Errorf("unexpected error: got %s, exp %s", errStr, expErrStr)
				}
			}

			if got != tc.exp {
				t.Errorf("unexpected count: got %d, exp %d", got, tc.exp)
			}
		})
	}
}