From 1d43eda9b7910e7c696df246b612475981e79f3f Mon Sep 17 00:00:00 2001 From: MaysWind Date: Tue, 3 Sep 2024 00:16:41 +0800 Subject: [PATCH] add unit test --- pkg/models/account_test.go | 51 ++++++++++ pkg/models/exchange_rate_test.go | 27 +++++ pkg/models/token_record_test.go | 30 ++++++ pkg/models/transaction_category_test.go | 30 ++++++ pkg/models/transaction_picture_info_test.go | 27 +++++ pkg/models/transaction_tag_test.go | 30 ++++++ pkg/models/transaction_template_test.go | 36 +++++++ pkg/models/transaction_test.go | 96 ++++++++++++++++++ pkg/models/user_test.go | 107 ++++++++++++++++++++ 9 files changed, 434 insertions(+) create mode 100644 pkg/models/account_test.go create mode 100644 pkg/models/exchange_rate_test.go create mode 100644 pkg/models/token_record_test.go create mode 100644 pkg/models/transaction_category_test.go create mode 100644 pkg/models/transaction_picture_info_test.go create mode 100644 pkg/models/transaction_tag_test.go create mode 100644 pkg/models/transaction_template_test.go create mode 100644 pkg/models/transaction_test.go create mode 100644 pkg/models/user_test.go diff --git a/pkg/models/account_test.go b/pkg/models/account_test.go new file mode 100644 index 00000000..5682cee7 --- /dev/null +++ b/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) +} diff --git a/pkg/models/exchange_rate_test.go b/pkg/models/exchange_rate_test.go new file mode 100644 index 00000000..205407f9 --- /dev/null +++ b/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) +} diff --git a/pkg/models/token_record_test.go b/pkg/models/token_record_test.go new file mode 100644 index 00000000..e1dcd254 --- /dev/null +++ b/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) +} diff --git a/pkg/models/transaction_category_test.go b/pkg/models/transaction_category_test.go new file mode 100644 index 00000000..c4ca86b8 --- /dev/null +++ b/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) +} diff --git a/pkg/models/transaction_picture_info_test.go b/pkg/models/transaction_picture_info_test.go new file mode 100644 index 00000000..1fa41d3d --- /dev/null +++ b/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) +} diff --git a/pkg/models/transaction_tag_test.go b/pkg/models/transaction_tag_test.go new file mode 100644 index 00000000..a3f6d859 --- /dev/null +++ b/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) +} diff --git a/pkg/models/transaction_template_test.go b/pkg/models/transaction_template_test.go new file mode 100644 index 00000000..649cb91a --- /dev/null +++ b/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) +} diff --git a/pkg/models/transaction_test.go b/pkg/models/transaction_test.go new file mode 100644 index 00000000..d6ee9eb3 --- /dev/null +++ b/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) +} diff --git a/pkg/models/user_test.go b/pkg/models/user_test.go new file mode 100644 index 00000000..65a0f369 --- /dev/null +++ b/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())) +}