add unit test

pkg/models/account_test.go

@@ -0,0 +1,51 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAccountInfoResponseSliceLess(t *testing.T) {
+	var accountRespSlice AccountInfoResponseSlice
+	accountRespSlice = append(accountRespSlice, &AccountInfoResponse{
+		Id:           1,
+		Category:     ACCOUNT_CATEGORY_DEBIT_CARD,
+		DisplayOrder: int32(1),
+	})
+	accountRespSlice = append(accountRespSlice, &AccountInfoResponse{
+		Id:           2,
+		Category:     ACCOUNT_CATEGORY_CASH,
+		DisplayOrder: int32(3),
+	})
+	accountRespSlice = append(accountRespSlice, &AccountInfoResponse{
+		Id:           3,
+		Category:     ACCOUNT_CATEGORY_CREDIT_CARD,
+		DisplayOrder: int32(2),
+	})
+	accountRespSlice = append(accountRespSlice, &AccountInfoResponse{
+		Id:           4,
+		Category:     ACCOUNT_CATEGORY_CASH,
+		DisplayOrder: int32(2),
+	})
+	accountRespSlice = append(accountRespSlice, &AccountInfoResponse{
+		Id:           5,
+		Category:     ACCOUNT_CATEGORY_CREDIT_CARD,
+		DisplayOrder: int32(1),
+	})
+	accountRespSlice = append(accountRespSlice, &AccountInfoResponse{
+		Id:           6,
+		Category:     ACCOUNT_CATEGORY_CASH,
+		DisplayOrder: int32(1),
+	})
+
+	sort.Sort(accountRespSlice)
+
+	assert.Equal(t, int64(6), accountRespSlice[0].Id)
+	assert.Equal(t, int64(4), accountRespSlice[1].Id)
+	assert.Equal(t, int64(2), accountRespSlice[2].Id)
+	assert.Equal(t, int64(1), accountRespSlice[3].Id)
+	assert.Equal(t, int64(5), accountRespSlice[4].Id)
+	assert.Equal(t, int64(3), accountRespSlice[5].Id)
+}

pkg/models/exchange_rate_test.go

@@ -0,0 +1,27 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLatestExchangeRateSliceLess(t *testing.T) {
+	var latestExchangeRateSlice LatestExchangeRateSlice
+	latestExchangeRateSlice = append(latestExchangeRateSlice, &LatestExchangeRate{
+		Currency: "USD",
+	})
+	latestExchangeRateSlice = append(latestExchangeRateSlice, &LatestExchangeRate{
+		Currency: "EUR",
+	})
+	latestExchangeRateSlice = append(latestExchangeRateSlice, &LatestExchangeRate{
+		Currency: "CNY",
+	})
+
+	sort.Sort(latestExchangeRateSlice)
+
+	assert.Equal(t, "CNY", latestExchangeRateSlice[0].Currency)
+	assert.Equal(t, "EUR", latestExchangeRateSlice[1].Currency)
+	assert.Equal(t, "USD", latestExchangeRateSlice[2].Currency)
+}

pkg/models/token_record_test.go

@@ -0,0 +1,30 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTokenInfoResponseSliceLess(t *testing.T) {
+	var tokenInfoRespSlice TokenInfoResponseSlice
+	tokenInfoRespSlice = append(tokenInfoRespSlice, &TokenInfoResponse{
+		TokenId:  "1",
+		LastSeen: int64(1),
+	})
+	tokenInfoRespSlice = append(tokenInfoRespSlice, &TokenInfoResponse{
+		TokenId:  "2",
+		LastSeen: int64(3),
+	})
+	tokenInfoRespSlice = append(tokenInfoRespSlice, &TokenInfoResponse{
+		TokenId:  "3",
+		LastSeen: int64(2),
+	})
+
+	sort.Sort(tokenInfoRespSlice)
+
+	assert.Equal(t, "2", tokenInfoRespSlice[0].TokenId)
+	assert.Equal(t, "3", tokenInfoRespSlice[1].TokenId)
+	assert.Equal(t, "1", tokenInfoRespSlice[2].TokenId)
+}

pkg/models/transaction_category_test.go

@@ -0,0 +1,30 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTransactionCategoryInfoResponseSliceLess(t *testing.T) {
+	var transactionCategoryRespSlice TransactionCategoryInfoResponseSlice
+	transactionCategoryRespSlice = append(transactionCategoryRespSlice, &TransactionCategoryInfoResponse{
+		Id:           1,
+		DisplayOrder: 3,
+	})
+	transactionCategoryRespSlice = append(transactionCategoryRespSlice, &TransactionCategoryInfoResponse{
+		Id:           2,
+		DisplayOrder: 1,
+	})
+	transactionCategoryRespSlice = append(transactionCategoryRespSlice, &TransactionCategoryInfoResponse{
+		Id:           3,
+		DisplayOrder: 2,
+	})
+
+	sort.Sort(transactionCategoryRespSlice)
+
+	assert.Equal(t, int64(2), transactionCategoryRespSlice[0].Id)
+	assert.Equal(t, int64(3), transactionCategoryRespSlice[1].Id)
+	assert.Equal(t, int64(1), transactionCategoryRespSlice[2].Id)
+}

pkg/models/transaction_picture_info_test.go

@@ -0,0 +1,27 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTransactionPictureInfoBasicResponseSliceLess(t *testing.T) {
+	var pictureInfoSlice TransactionPictureInfoBasicResponseSlice
+	pictureInfoSlice = append(pictureInfoSlice, &TransactionPictureInfoBasicResponse{
+		PictureId: 2,
+	})
+	pictureInfoSlice = append(pictureInfoSlice, &TransactionPictureInfoBasicResponse{
+		PictureId: 3,
+	})
+	pictureInfoSlice = append(pictureInfoSlice, &TransactionPictureInfoBasicResponse{
+		PictureId: 1,
+	})
+
+	sort.Sort(pictureInfoSlice)
+
+	assert.Equal(t, int64(1), pictureInfoSlice[0].PictureId)
+	assert.Equal(t, int64(2), pictureInfoSlice[1].PictureId)
+	assert.Equal(t, int64(3), pictureInfoSlice[2].PictureId)
+}

pkg/models/transaction_tag_test.go

@@ -0,0 +1,30 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTransactionTagInfoResponseSliceLess(t *testing.T) {
+	var transactionTagRespSlice TransactionTagInfoResponseSlice
+	transactionTagRespSlice = append(transactionTagRespSlice, &TransactionTagInfoResponse{
+		Id:           1,
+		DisplayOrder: 3,
+	})
+	transactionTagRespSlice = append(transactionTagRespSlice, &TransactionTagInfoResponse{
+		Id:           2,
+		DisplayOrder: 1,
+	})
+	transactionTagRespSlice = append(transactionTagRespSlice, &TransactionTagInfoResponse{
+		Id:           3,
+		DisplayOrder: 2,
+	})
+
+	sort.Sort(transactionTagRespSlice)
+
+	assert.Equal(t, int64(2), transactionTagRespSlice[0].Id)
+	assert.Equal(t, int64(3), transactionTagRespSlice[1].Id)
+	assert.Equal(t, int64(1), transactionTagRespSlice[2].Id)
+}

pkg/models/transaction_template_test.go

@@ -0,0 +1,36 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTransactionTemplateInfoResponseSliceLess(t *testing.T) {
+	var transactionTemplateRespSlice TransactionTemplateInfoResponseSlice
+	transactionTemplateRespSlice = append(transactionTemplateRespSlice, &TransactionTemplateInfoResponse{
+		TransactionInfoResponse: &TransactionInfoResponse{
+			Id: 1,
+		},
+		DisplayOrder: 3,
+	})
+	transactionTemplateRespSlice = append(transactionTemplateRespSlice, &TransactionTemplateInfoResponse{
+		TransactionInfoResponse: &TransactionInfoResponse{
+			Id: 2,
+		},
+		DisplayOrder: 1,
+	})
+	transactionTemplateRespSlice = append(transactionTemplateRespSlice, &TransactionTemplateInfoResponse{
+		TransactionInfoResponse: &TransactionInfoResponse{
+			Id: 3,
+		},
+		DisplayOrder: 2,
+	})
+
+	sort.Sort(transactionTemplateRespSlice)
+
+	assert.Equal(t, int64(2), transactionTemplateRespSlice[0].Id)
+	assert.Equal(t, int64(3), transactionTemplateRespSlice[1].Id)
+	assert.Equal(t, int64(1), transactionTemplateRespSlice[2].Id)
+}

pkg/models/transaction_test.go

@@ -0,0 +1,96 @@
+package models
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTransactionInfoResponseSliceLess(t *testing.T) {
+	var transactionRespSlice TransactionInfoResponseSlice
+	transactionRespSlice = append(transactionRespSlice, &TransactionInfoResponse{
+		Id:   2,
+		Time: 3,
+	})
+	transactionRespSlice = append(transactionRespSlice, &TransactionInfoResponse{
+		Id:   3,
+		Time: 2,
+	})
+	transactionRespSlice = append(transactionRespSlice, &TransactionInfoResponse{
+		Id:   5,
+		Time: 2,
+	})
+	transactionRespSlice = append(transactionRespSlice, &TransactionInfoResponse{
+		Id:   4,
+		Time: 1,
+	})
+	transactionRespSlice = append(transactionRespSlice, &TransactionInfoResponse{
+		Id:   1,
+		Time: 3,
+	})
+
+	sort.Sort(transactionRespSlice)
+
+	assert.Equal(t, int64(2), transactionRespSlice[0].Id)
+	assert.Equal(t, int64(1), transactionRespSlice[1].Id)
+	assert.Equal(t, int64(5), transactionRespSlice[2].Id)
+	assert.Equal(t, int64(3), transactionRespSlice[3].Id)
+	assert.Equal(t, int64(4), transactionRespSlice[4].Id)
+}
+
+func TestTransactionStatisticTrendsItemSliceLess(t *testing.T) {
+	var transactionTrendsSlice TransactionStatisticTrendsItemSlice
+	transactionTrendsSlice = append(transactionTrendsSlice, &TransactionStatisticTrendsItem{
+		Year:  2024,
+		Month: 9,
+	})
+	transactionTrendsSlice = append(transactionTrendsSlice, &TransactionStatisticTrendsItem{
+		Year:  2022,
+		Month: 10,
+	})
+	transactionTrendsSlice = append(transactionTrendsSlice, &TransactionStatisticTrendsItem{
+		Year:  2023,
+		Month: 1,
+	})
+	transactionTrendsSlice = append(transactionTrendsSlice, &TransactionStatisticTrendsItem{
+		Year:  2022,
+		Month: 2,
+	})
+	transactionTrendsSlice = append(transactionTrendsSlice, &TransactionStatisticTrendsItem{
+		Year:  2024,
+		Month: 1,
+	})
+
+	sort.Sort(transactionTrendsSlice)
+
+	assert.Equal(t, int32(2022), transactionTrendsSlice[0].Year)
+	assert.Equal(t, int32(2), transactionTrendsSlice[0].Month)
+	assert.Equal(t, int32(2022), transactionTrendsSlice[1].Year)
+	assert.Equal(t, int32(10), transactionTrendsSlice[1].Month)
+	assert.Equal(t, int32(2023), transactionTrendsSlice[2].Year)
+	assert.Equal(t, int32(1), transactionTrendsSlice[2].Month)
+	assert.Equal(t, int32(2024), transactionTrendsSlice[3].Year)
+	assert.Equal(t, int32(1), transactionTrendsSlice[3].Month)
+	assert.Equal(t, int32(2024), transactionTrendsSlice[4].Year)
+	assert.Equal(t, int32(9), transactionTrendsSlice[4].Month)
+}
+
+func TestTransactionAmountsResponseItemAmountInfoSliceLess(t *testing.T) {
+	var amountInfoSlice TransactionAmountsResponseItemAmountInfoSlice
+	amountInfoSlice = append(amountInfoSlice, &TransactionAmountsResponseItemAmountInfo{
+		Currency: "USD",
+	})
+	amountInfoSlice = append(amountInfoSlice, &TransactionAmountsResponseItemAmountInfo{
+		Currency: "EUR",
+	})
+	amountInfoSlice = append(amountInfoSlice, &TransactionAmountsResponseItemAmountInfo{
+		Currency: "CNY",
+	})
+
+	sort.Sort(amountInfoSlice)
+
+	assert.Equal(t, "CNY", amountInfoSlice[0].Currency)
+	assert.Equal(t, "EUR", amountInfoSlice[1].Currency)
+	assert.Equal(t, "USD", amountInfoSlice[2].Currency)
+}

pkg/models/user_test.go

@@ -0,0 +1,107 @@
+package models
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/mayswind/ezbookkeeping/pkg/core"
+	"github.com/mayswind/ezbookkeeping/pkg/utils"
+)
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsNone(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_NONE,
+	}
+
+	assert.Equal(t, false, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(time.Now().Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsAll(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_ALL,
+	}
+
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(time.Now().Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsTodayOrLater(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_TODAY_OR_LATER,
+	}
+
+	now := time.Now()
+	todayFirstDatetime := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local)
+	yesterdayLastDatetime := todayFirstDatetime.Add(-1 * time.Second)
+	todayLastDatetime := yesterdayLastDatetime.Add(24 * time.Hour)
+
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(todayFirstDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(todayLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, false, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(yesterdayLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsLast24HourOrLater(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_LAST_24H_OR_LATER,
+	}
+
+	now := time.Now()
+	twentyfourHourBeforeDatetime := now.Add(-24 * time.Hour).Add(-1 * time.Second)
+
+	assert.Equal(t, false, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(twentyfourHourBeforeDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(twentyfourHourBeforeDatetime.Add(1*time.Second).Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsThisWeekOrLater(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_THIS_WEEK_OR_LATER,
+		FirstDayOfWeek:       core.WEEKDAY_MONDAY,
+	}
+
+	now := time.Now()
+	thisWeekFirstDatetime := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local)
+
+	if thisWeekFirstDatetime.Weekday() == time.Sunday {
+		thisWeekFirstDatetime = thisWeekFirstDatetime.Add(-6 * 24 * time.Hour)
+	} else if thisWeekFirstDatetime.Weekday() != time.Monday {
+		thisWeekFirstDatetime = thisWeekFirstDatetime.Add(time.Duration(1-thisWeekFirstDatetime.Weekday()) * 24 * time.Hour)
+	}
+
+	lastWeekLastDatetime := thisWeekFirstDatetime.Add(-1 * time.Second)
+	thisWeekLastDatetime := lastWeekLastDatetime.Add(24 * time.Hour)
+
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(thisWeekFirstDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(thisWeekLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, false, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(lastWeekLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsThisMonthOrLater(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_THIS_MONTH_OR_LATER,
+	}
+
+	now := time.Now()
+	thisMonthFirstDatetime := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, time.Local)
+	lastMonthLastDatetime := thisMonthFirstDatetime.Add(-1 * time.Second)
+	thisMonthLastDatetime := lastMonthLastDatetime.Add(24 * time.Hour)
+
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(thisMonthFirstDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(thisMonthLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, false, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(lastMonthLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}
+
+func TestUserCanEditTransactionByTransactionTime_ScopeIsThisYearOrLater(t *testing.T) {
+	user := &User{
+		TransactionEditScope: TRANSACTION_EDIT_SCOPE_THIS_YEAR_OR_LATER,
+	}
+
+	now := time.Now()
+	thisYearFirstDatetime := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.Local)
+	lastYearLastDatetime := thisYearFirstDatetime.Add(-1 * time.Second)
+	thisYearLastDatetime := lastYearLastDatetime.Add(24 * time.Hour)
+
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(thisYearFirstDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, true, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(thisYearLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+	assert.Equal(t, false, user.CanEditTransactionByTransactionTime(utils.GetMinTransactionTimeFromUnixTime(lastYearLastDatetime.Unix()), utils.GetServerTimezoneOffsetMinutes()))
+}