moneygo/internal/handlers/transactions_test.go

package handlers_test

import (
	"fmt"
	"github.com/aclindsa/moneygo/internal/handlers"
	"net/http"
	"net/url"
	"strconv"
	"testing"
	"time"
)

func createTransaction(client *http.Client, transaction *handlers.Transaction) (*handlers.Transaction, error) {
	var s handlers.Transaction
	err := create(client, transaction, &s, "/v1/transactions/", "transaction")
	return &s, err
}

func getTransaction(client *http.Client, transactionid int64) (*handlers.Transaction, error) {
	var s handlers.Transaction
	err := read(client, &s, "/v1/transactions/"+strconv.FormatInt(transactionid, 10), "transaction")
	if err != nil {
		return nil, err
	}
	return &s, nil
}

func getTransactions(client *http.Client) (*handlers.TransactionList, error) {
	var tl handlers.TransactionList
	err := read(client, &tl, "/v1/transactions/", "transactions")
	if err != nil {
		return nil, err
	}
	return &tl, nil
}

func getAccountTransactions(client *http.Client, accountid, page, limit int64, sort string) (*handlers.AccountTransactionsList, error) {
	var atl handlers.AccountTransactionsList
	params := url.Values{}

	query := fmt.Sprintf("/v1/accounts/%d/transactions/", accountid)
	if page != 0 {
		params.Set("page", fmt.Sprintf("%d", page))
	}
	if limit != 0 {
		params.Set("limit", fmt.Sprintf("%d", limit))
	}
	if len(sort) != 0 {
		params.Set("sort", sort)
		query += "?" + params.Encode()
	}

	err := read(client, &atl, query, "accounttransactions")
	if err != nil {
		return nil, err
	}
	return &atl, nil
}

func updateTransaction(client *http.Client, transaction *handlers.Transaction) (*handlers.Transaction, error) {
	var s handlers.Transaction
	err := update(client, transaction, &s, "/v1/transactions/"+strconv.FormatInt(transaction.TransactionId, 10), "transaction")
	if err != nil {
		return nil, err
	}
	return &s, nil
}

func deleteTransaction(client *http.Client, s *handlers.Transaction) error {
	err := remove(client, "/v1/transactions/"+strconv.FormatInt(s.TransactionId, 10), "transaction")
	if err != nil {
		return err
	}
	return nil
}

func ensureTransactionsMatch(t *testing.T, expected, tran *handlers.Transaction, accounts *[]handlers.Account, matchtransactionids, matchsplitids bool) {
	t.Helper()

	if tran.TransactionId == 0 {
		t.Errorf("TransactionId is 0")
	}

	if matchtransactionids && tran.TransactionId != expected.TransactionId {
		t.Errorf("TransactionId (%d) doesn't match what's expected (%d)", tran.TransactionId, expected.TransactionId)
	}
	if tran.Description != expected.Description {
		t.Errorf("Description doesn't match")
	}
	if tran.Date != expected.Date {
		t.Errorf("Date doesn't match")
	}

	if len(tran.Splits) != len(expected.Splits) {
		t.Fatalf("Expected %d splits, received %d", len(expected.Splits), len(tran.Splits))
	}

	foundIds := make(map[int64]bool)
	for j := 0; j < len(expected.Splits); j++ {
		origsplit := expected.Splits[j]

		if tran.Splits[j].TransactionId != tran.TransactionId {
			t.Fatalf("Split TransactionId doesn't match transaction's")
		}

		found := false
		for _, s := range tran.Splits {
			if s.SplitId == 0 {
				t.Errorf("Found SplitId that's 0")
			}
			accountid := origsplit.AccountId
			if accounts != nil {
				accountid = (*accounts)[accountid].AccountId
			}
			if origsplit.Status == s.Status &&
				origsplit.ImportSplitType == s.ImportSplitType &&
				s.AccountId == accountid &&
				s.SecurityId == -1 &&
				origsplit.RemoteId == origsplit.RemoteId &&
				origsplit.Number == s.Number &&
				origsplit.Memo == s.Memo &&
				origsplit.Amount == s.Amount &&
				(!matchsplitids || origsplit.SplitId == s.SplitId) {

				if _, ok := foundIds[s.SplitId]; ok {
					continue
				}
				foundIds[s.SplitId] = true
				found = true
				break
			}
		}
		if !found {
			t.Errorf("Unable to find matching split: %+v", origsplit)
		}
	}
}

func getAccountVersionMap(t *testing.T, client *http.Client, tran *handlers.Transaction) map[int64]*handlers.Account {
	t.Helper()
	accountMap := make(map[int64]*handlers.Account)
	for _, split := range tran.Splits {
		account, err := getAccount(client, split.AccountId)
		if err != nil {
			t.Fatalf("Error fetching split's account while updating transaction: %s\n", err)
		}
		accountMap[account.AccountId] = account
	}
	return accountMap
}

func checkAccountVersionsUpdated(t *testing.T, client *http.Client, accountMap map[int64]*handlers.Account, tran *handlers.Transaction) {
	for _, split := range tran.Splits {
		account, err := getAccount(client, split.AccountId)
		if err != nil {
			t.Fatalf("Error fetching split's account after updating transaction: %s\n", err)
		}
		if account.AccountVersion <= accountMap[split.AccountId].AccountVersion {
			t.Errorf("Failed to update account version when updating transaction split\n")
		}
	}
}

func TestCreateTransaction(t *testing.T) {
	RunWith(t, &data[0], func(t *testing.T, d *TestData) {
		for i, orig := range data[0].transactions {
			transaction := d.transactions[i]

			ensureTransactionsMatch(t, &orig, &transaction, &d.accounts, false, false)

			accountMap := getAccountVersionMap(t, d.clients[orig.UserId], &transaction)
			_, err := createTransaction(d.clients[orig.UserId], &transaction)
			if err != nil {
				t.Fatalf("Unxpected error creating transaction")
			}
			checkAccountVersionsUpdated(t, d.clients[orig.UserId], accountMap, &transaction)
		}

		// Don't allow imbalanced transactions
		tran := handlers.Transaction{
			UserId:      d.users[0].UserId,
			Description: "Imbalanced",
			Date:        time.Date(2017, time.September, 1, 0, 00, 00, 0, time.UTC),
			Splits: []*handlers.Split{
				&handlers.Split{
					Status:     handlers.Reconciled,
					AccountId:  d.accounts[1].AccountId,
					SecurityId: -1,
					Amount:     "-39.98",
				},
				&handlers.Split{
					Status:     handlers.Entered,
					AccountId:  d.accounts[4].AccountId,
					SecurityId: -1,
					Amount:     "39.99",
				},
			},
		}
		_, err := createTransaction(d.clients[0], &tran)
		if err == nil {
			t.Fatalf("Expected error creating imbalanced transaction")
		}
		if herr, ok := err.(*handlers.Error); ok {
			if herr.ErrorId != 3 { // Invalid requeset
				t.Fatalf("Unexpected API error creating imbalanced transaction: %s", herr)
			}
		} else {
			t.Fatalf("Unexpected error creating imbalanced transaction")
		}

		// Don't allow transactions with 0 splits
		tran.Splits = []*handlers.Split{}
		_, err = createTransaction(d.clients[0], &tran)
		if err == nil {
			t.Fatalf("Expected error creating with zero splits")
		}
		if herr, ok := err.(*handlers.Error); ok {
			if herr.ErrorId != 3 { // Invalid requeset
				t.Fatalf("Unexpected API error creating with zero splits: %s", herr)
			}
		} else {
			t.Fatalf("Unexpected error creating zero splits")
		}

		// Don't allow creating a transaction for another user
		tran.UserId = d.users[1].UserId
		_, err = createTransaction(d.clients[0], &tran)
		if err == nil {
			t.Fatalf("Expected error creating transaction for another user")
		}
		if herr, ok := err.(*handlers.Error); ok {
			if herr.ErrorId != 3 { // Invalid request
				t.Fatalf("Unexpected API error creating transction for another user: %s", herr)
			}
		} else {
			t.Fatalf("Unexpected error creating transaction for another user")
		}
	})
}

func TestGetTransaction(t *testing.T) {
	RunWith(t, &data[0], func(t *testing.T, d *TestData) {
		for i := 0; i < len(data[0].transactions); i++ {
			orig := data[0].transactions[i]
			curr := d.transactions[i]

			tran, err := getTransaction(d.clients[orig.UserId], curr.TransactionId)
			if err != nil {
				t.Fatalf("Error fetching transaction: %s\n", err)
			}

			ensureTransactionsMatch(t, &curr, tran, nil, true, true)
		}
	})
}

func TestGetTransactions(t *testing.T) {
	RunWith(t, &data[0], func(t *testing.T, d *TestData) {
		tl, err := getTransactions(d.clients[0])
		if err != nil {
			t.Fatalf("Error fetching transactions: %s\n", err)
		}

		numtransactions := 0
		foundIds := make(map[int64]bool)
		for i := 0; i < len(data[0].transactions); i++ {
			orig := data[0].transactions[i]
			curr := d.transactions[i]

			if curr.UserId != d.users[0].UserId {
				continue
			}
			numtransactions += 1

			found := false
			for _, tran := range *tl.Transactions {
				if tran.TransactionId == curr.TransactionId {
					ensureTransactionsMatch(t, &curr, &tran, nil, true, true)
					if _, ok := foundIds[tran.TransactionId]; ok {
						continue
					}
					foundIds[tran.TransactionId] = true
					found = true
					break
				}
			}
			if !found {
				t.Errorf("Unable to find matching transaction: %+v", orig)
			}
		}

		if numtransactions != len(*tl.Transactions) {
			t.Fatalf("Expected %d transactions, received %d", numtransactions, len(*tl.Transactions))
		}
	})
}

func TestUpdateTransaction(t *testing.T) {
	RunWith(t, &data[0], func(t *testing.T, d *TestData) {
		for i := 0; i < len(data[0].transactions); i++ {
			orig := data[0].transactions[i]
			curr := d.transactions[i]

			curr.Description = "more money"
			curr.Date = time.Date(2017, time.October, 18, 10, 41, 40, 0, time.UTC)

			accountMap := getAccountVersionMap(t, d.clients[orig.UserId], &curr)

			tran, err := updateTransaction(d.clients[orig.UserId], &curr)
			if err != nil {
				t.Fatalf("Error updating transaction: %s\n", err)
			}

			checkAccountVersionsUpdated(t, d.clients[orig.UserId], accountMap, tran)
			checkAccountVersionsUpdated(t, d.clients[orig.UserId], accountMap, &curr)

			ensureTransactionsMatch(t, &curr, tran, nil, true, true)

			tran.Splits = []*handlers.Split{}
			for _, s := range curr.Splits {
				var split handlers.Split
				split = *s
				tran.Splits = append(tran.Splits, &split)
			}

			// Don't allow updating transactions for other/invalid users
			tran.UserId = tran.UserId + 1
			tran2, err := updateTransaction(d.clients[orig.UserId], tran)
			if tran2.UserId != curr.UserId {
				t.Fatalf("Allowed updating transaction to have wrong UserId\n")
			}
			tran.UserId = curr.UserId

			// Make sure we can't create an unbalanced transaction
			tran.Splits[len(tran.Splits)-1].Amount = "42"
			_, err = updateTransaction(d.clients[orig.UserId], tran)
			if err == nil {
				t.Fatalf("Expected error updating imbalanced transaction")
			}
			if herr, ok := err.(*handlers.Error); ok {
				if herr.ErrorId != 3 { // Invalid requeset
					t.Fatalf("Unexpected API error updating imbalanced transaction: %s", herr)
				}
			} else {
				t.Fatalf("Unexpected error updating imbalanced transaction")
			}

			// Don't allow transactions with 0 splits
			tran.Splits = []*handlers.Split{}
			_, err = updateTransaction(d.clients[orig.UserId], tran)
			if err == nil {
				t.Fatalf("Expected error updating with zero splits")
			}
			if herr, ok := err.(*handlers.Error); ok {
				if herr.ErrorId != 3 { // Invalid requeset
					t.Fatalf("Unexpected API error updating with zero splits: %s", herr)
				}
			} else {
				t.Fatalf("Unexpected error updating zero splits")
			}
		}
	})
}

func TestDeleteTransaction(t *testing.T) {
	RunWith(t, &data[0], func(t *testing.T, d *TestData) {
		for i := 0; i < len(data[0].transactions); i++ {
			orig := data[0].transactions[i]
			curr := d.transactions[i]

			accountMap := getAccountVersionMap(t, d.clients[orig.UserId], &curr)

			err := deleteTransaction(d.clients[orig.UserId], &curr)
			if err != nil {
				t.Fatalf("Error deleting transaction: %s\n", err)
			}
			checkAccountVersionsUpdated(t, d.clients[orig.UserId], accountMap, &curr)

			_, err = getTransaction(d.clients[orig.UserId], curr.TransactionId)
			if err == nil {
				t.Fatalf("Expected error fetching deleted transaction")
			}
			if herr, ok := err.(*handlers.Error); ok {
				if herr.ErrorId != 3 { // Invalid requeset
					t.Fatalf("Unexpected API error fetching deleted transaction: %s", herr)
				}
			} else {
				t.Fatalf("Unexpected error fetching deleted transaction")
			}
		}
	})
}

func helperTestAccountTransactions(t *testing.T, d *TestData, account *handlers.Account, limit int64, sort string) {
	if account.UserId != d.users[0].UserId {
		return
	}

	var transactions []handlers.Transaction
	var lastFetchCount int64

	for page := int64(0); page == 0 || lastFetchCount > 0; page++ {
		atl, err := getAccountTransactions(d.clients[0], account.AccountId, page, limit, sort)
		if err != nil {
			t.Fatalf("Error fetching account transactions: %s\n", err)
		}
		if limit != 0 && atl.Transactions != nil && int64(len(*atl.Transactions)) > limit {
			t.Errorf("Exceeded limit of %d transactions (returned %d)\n", limit, len(*atl.Transactions))
		}
		if atl.Transactions != nil {
			for _, tran := range *atl.Transactions {
				transactions = append(transactions, tran)
			}
			lastFetchCount = int64(len(*atl.Transactions))
		} else {
			lastFetchCount = -1
		}
	}

	var lastDate time.Time
	for _, tran := range transactions {
		if lastDate.IsZero() {
			lastDate = tran.Date
			continue
		} else if sort == "date-desc" && lastDate.Before(tran.Date) {
			t.Errorf("Sorted by date-desc, but later transaction has later date")
		} else if sort == "date-asc" && lastDate.After(tran.Date) {
			t.Errorf("Sorted by date-asc, but later transaction has earlier date")
		}
		lastDate = tran.Date
	}

	numtransactions := 0
	foundIds := make(map[int64]bool)
	for i := 0; i < len(d.transactions); i++ {
		curr := d.transactions[i]

		if curr.UserId != d.users[0].UserId {
			continue
		}

		// Don't consider this transaction if we didn't find a split
		// for the account we're considering
		account_found := false
		for _, s := range curr.Splits {
			if s.AccountId == account.AccountId {
				account_found = true
				break
			}
		}
		if !account_found {
			continue
		}

		numtransactions += 1

		found := false
		for _, tran := range transactions {
			if tran.TransactionId == curr.TransactionId {
				ensureTransactionsMatch(t, &curr, &tran, nil, true, true)
				if _, ok := foundIds[tran.TransactionId]; ok {
					continue
				}
				foundIds[tran.TransactionId] = true
				found = true
				break
			}
		}
		if !found {
			t.Errorf("Unable to find matching transaction: %+v", curr)
			t.Errorf("Transactions: %+v\n", transactions)
		}
	}

	if numtransactions != len(transactions) {
		t.Fatalf("Expected %d transactions, received %d", numtransactions, len(transactions))
	}
}

func TestAccountTransactions(t *testing.T) {
	RunWith(t, &data[0], func(t *testing.T, d *TestData) {
		for _, account := range d.accounts {
			helperTestAccountTransactions(t, d, &account, 0, "date-desc")
			helperTestAccountTransactions(t, d, &account, 0, "date-asc")
			helperTestAccountTransactions(t, d, &account, 1, "date-desc")
			helperTestAccountTransactions(t, d, &account, 1, "date-asc")
			helperTestAccountTransactions(t, d, &account, 2, "date-desc")
			helperTestAccountTransactions(t, d, &account, 2, "date-asc")
		}
	})
}