From a570a51bdfbabd638f47255dc57e6905af70f354 Mon Sep 17 00:00:00 2001 From: MaysWind Date: Mon, 5 Apr 2021 14:47:41 +0800 Subject: [PATCH] add unit test --- pkg/utils/converter_test.go | 101 +++++++++++++++++++++++++++ pkg/utils/datetimes_test.go | 79 +++++++++++++++++++++ pkg/utils/object_test.go | 26 +++++++ pkg/utils/slices_test.go | 132 ++++++++++++++++++++++++++++++++++++ pkg/utils/strings_test.go | 110 ++++++++++++++++++++++++++++++ 5 files changed, 448 insertions(+) create mode 100644 pkg/utils/converter_test.go create mode 100644 pkg/utils/datetimes_test.go create mode 100644 pkg/utils/object_test.go create mode 100644 pkg/utils/slices_test.go create mode 100644 pkg/utils/strings_test.go diff --git a/pkg/utils/converter_test.go b/pkg/utils/converter_test.go new file mode 100644 index 00000000..c410a5a4 --- /dev/null +++ b/pkg/utils/converter_test.go @@ -0,0 +1,101 @@ +package utils + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestInt32ToString(t *testing.T) { + expectedValue := "-123456789" + actualValue := Int32ToString(-123456789) + assert.Equal(t, expectedValue, actualValue) +} + +func TestStringToInt32(t *testing.T) { + expectedValue := -123456789 + actualValue, err := StringToInt32("-123456789") + assert.Equal(t, nil, err) + assert.Equal(t, expectedValue, actualValue) +} + +func TestStringToInt32_InvalidNumber(t *testing.T) { + _, err := StringToInt32("") + assert.NotEqual(t, nil, err) + + _, err = StringToInt32("null") + assert.NotEqual(t, nil, err) +} + +func TestStringTryToInt32_InvalidNumber(t *testing.T) { + expectedValue := -1 + actualValue := StringTryToInt32("", -1) + assert.Equal(t, expectedValue, actualValue) + + actualValue = StringTryToInt32("null", -1) + assert.Equal(t, expectedValue, actualValue) +} + +func TestInt64ToString(t *testing.T) { + expectedValue := "-123456789012345" + actualValue := Int64ToString(-123456789012345) + assert.Equal(t, expectedValue, actualValue) +} + +func TestInt64ArrayToStringArray(t *testing.T) { + expectedValue := []string{"0", "1", "-123456789012345", "12345678", "1234567890123456"} + actualValue := Int64ArrayToStringArray([]int64{0, 1, -123456789012345, 12345678, 1234567890123456}) + assert.EqualValues(t, expectedValue, actualValue) +} + +func TestStringToInt64(t *testing.T) { + expectedValue := int64(-123456789012345) + actualValue, err := StringToInt64("-123456789012345") + assert.Equal(t, nil, err) + assert.Equal(t, expectedValue, actualValue) +} + +func TestStringToInt64_InvalidNumber(t *testing.T) { + _, err := StringToInt64("") + assert.NotEqual(t, nil, err) + + _, err = StringToInt64("null") + assert.NotEqual(t, nil, err) +} + +func TestStringArrayToInt64Array(t *testing.T) { + expectedValue := []int64{0, 1, -123456789012345, 12345678, 1234567890123456} + actualValue, err := StringArrayToInt64Array([]string{"0", "1", "-123456789012345", "12345678", "1234567890123456"}) + assert.Equal(t, nil, err) + assert.EqualValues(t, expectedValue, actualValue) +} + +func TestStringArrayToInt64Array_InvalidNumber(t *testing.T) { + _, err := StringArrayToInt64Array([]string{"0", "1", "", "12345678", "1234567890123456"}) + assert.NotEqual(t, nil, err) + + _, err = StringArrayToInt64Array([]string{"0", "1", "null", "12345678", "1234567890123456"}) + assert.NotEqual(t, nil, err) +} + +func TestStringTryToInt64_InvalidNumber(t *testing.T) { + expectedValue := int64(-1) + actualValue := StringTryToInt64("", -1) + assert.Equal(t, expectedValue, actualValue) + + actualValue = StringTryToInt64("null", -1) + assert.Equal(t, expectedValue, actualValue) +} + +func TestFloat64ToString(t *testing.T) { + expectedValue := "-123456789.123456" + actualValue := Float64ToString(-123456789.123456) + assert.Equal(t, expectedValue, actualValue) +} + +func TestStringToFloat64(t *testing.T) { + expectedValue := -123456789.123456 + actualValue, err := StringToFloat64("-123456789.123456") + assert.Equal(t, nil, err) + assert.Equal(t, expectedValue, actualValue) +} diff --git a/pkg/utils/datetimes_test.go b/pkg/utils/datetimes_test.go new file mode 100644 index 00000000..4654270f --- /dev/null +++ b/pkg/utils/datetimes_test.go @@ -0,0 +1,79 @@ +package utils + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestFormatUnixTimeToLongDateTimeWithoutSecond(t *testing.T) { + unixTime := int64(1617228083) + utcTimezone := time.FixedZone("Test Timezone", 0) // UTC + utc8Timezone := time.FixedZone("Test Timezone", 28800) // UTC+8 + + expectedValue := "2021-03-31 22:01" + actualValue := FormatUnixTimeToLongDateTimeWithoutSecond(unixTime, utcTimezone) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "2021-04-01 06:01" + actualValue = FormatUnixTimeToLongDateTimeWithoutSecond(unixTime, utc8Timezone) + assert.Equal(t, expectedValue, actualValue) +} + +func TestFormatUnixTimeToYearMonth(t *testing.T) { + unixTime := int64(1617228083) + utcTimezone := time.FixedZone("Test Timezone", 0) // UTC + utc8Timezone := time.FixedZone("Test Timezone", 28800) // UTC+8 + + expectedValue := "2021-03" + actualValue := FormatUnixTimeToYearMonth(unixTime, utcTimezone) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "2021-04" + actualValue = FormatUnixTimeToYearMonth(unixTime, utc8Timezone) + assert.Equal(t, expectedValue, actualValue) +} + +func TestParseFromUnixTime(t *testing.T) { + expectedValue := int64(1617228083) + actualTime := ParseFromUnixTime(expectedValue) + actualValue := actualTime.Unix() + assert.Equal(t, expectedValue, actualValue) +} + +func TestParseFromLongDateTime(t *testing.T) { + expectedValue := int64(1617228083) + actualTime, err := ParseFromLongDateTime("2021-04-01 06:01:23", 480) + assert.Equal(t, nil, err) + + actualValue := actualTime.Unix() + assert.Equal(t, expectedValue, actualValue) +} + +func TestParseFromShortDateTime(t *testing.T) { + expectedValue := int64(1617228083) + actualTime, err := ParseFromShortDateTime("2021-4-1 6:1:23", 480) + assert.Equal(t, nil, err) + + actualValue := actualTime.Unix() + assert.Equal(t, expectedValue, actualValue) +} + +func TestGetMinTransactionTimeFromUnixTime(t *testing.T) { + expectedValue := int64(1617228083000) + actualValue := GetMinTransactionTimeFromUnixTime(1617228083) + assert.Equal(t, expectedValue, actualValue) +} + +func TestGetMaxTransactionTimeFromUnixTime(t *testing.T) { + expectedValue := int64(1617228083999) + actualValue := GetMaxTransactionTimeFromUnixTime(1617228083) + assert.Equal(t, expectedValue, actualValue) +} + +func TestGetUnixTimeFromTransactionTime(t *testing.T) { + expectedValue := int64(1617228083) + actualValue := GetUnixTimeFromTransactionTime(1617228083999) + assert.Equal(t, expectedValue, actualValue) +} diff --git a/pkg/utils/object_test.go b/pkg/utils/object_test.go new file mode 100644 index 00000000..ad4ac60c --- /dev/null +++ b/pkg/utils/object_test.go @@ -0,0 +1,26 @@ +package utils + +import ( + "github.com/stretchr/testify/assert" + "testing" + + "github.com/mayswind/lab/pkg/settings" +) + +func TestClone(t *testing.T) { + expectedObject := &settings.Config{ + AppName: "lab", + Mode: settings.MODE_PRODUCTION, + DatabaseConfig: &settings.DatabaseConfig{ + DatabaseType: settings.MySqlDbType, + DatabaseHost: "localhost", + ConnectionMaxLifeTime: 60, + }, + LogModes: []string{"console", "file"}, + } + actualObject := &settings.Config{} + err := Clone(expectedObject, actualObject) + + assert.Equal(t, nil, err) + assert.EqualValues(t, expectedObject, actualObject) +} diff --git a/pkg/utils/slices_test.go b/pkg/utils/slices_test.go new file mode 100644 index 00000000..16f742ce --- /dev/null +++ b/pkg/utils/slices_test.go @@ -0,0 +1,132 @@ +package utils + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestInt64SliceEquals_Equals(t *testing.T) { + s1 := []int64{0, 1, 2, 3} + s2 := []int64{0, 1, 2, 3} + expectedValue := true + actualValue := Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) +} + +func TestInt64SliceEquals_NotEquals(t *testing.T) { + s1 := []int64{0, 1, 2, 3} + s2 := []int64{0, 1, 3, 2} + expectedValue := false + actualValue := Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = []int64{0} + expectedValue = false + actualValue = Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = []int64{} + expectedValue = false + actualValue = Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) +} + +func TestInt64SliceEquals_NilOrEmpty(t *testing.T) { + var s1 []int64 = nil + s2 := []int64{0, 1, 2, 3} + expectedValue := false + actualValue := Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = nil + expectedValue = false + actualValue = Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = nil + s2 = nil + expectedValue = true + actualValue = Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{} + s2 = []int64{} + expectedValue = true + actualValue = Int64SliceEquals(s1, s2) + assert.Equal(t, expectedValue, actualValue) +} + +func TestInt64SliceMinus(t *testing.T) { + s1 := []int64{0, 1, 2, 3} + s2 := []int64{0, 1, 2, 3} + expectedValue := []int64{} + actualValue := Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = []int64{0, 2} + expectedValue = []int64{1, 3} + actualValue = Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = []int64{} + expectedValue = []int64{0, 1, 2, 3} + actualValue = Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{} + s2 = []int64{0, 1, 2, 3} + expectedValue = []int64{} + actualValue = Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = []int64{1, 2, 3, 4} + expectedValue = []int64{0} + actualValue = Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) +} + +func TestInt64SliceMinus_NilOrEmpty(t *testing.T) { + var s1 []int64 = nil + s2 := []int64{0, 1, 2, 3} + var expectedValue []int64 = nil + actualValue := Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = []int64{0, 1, 2, 3} + s2 = nil + expectedValue = []int64{0, 1, 2, 3} + actualValue = Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) + + s1 = nil + s2 = nil + expectedValue = nil + actualValue = Int64SliceMinus(s1, s2) + assert.Equal(t, expectedValue, actualValue) +} + +func TestToUniqueInt64Slice(t *testing.T) { + arr := []int64{0, 1, 2, 3, 2, 4, 0} + expectedValue := []int64{0, 1, 2, 3, 4} + actualValue := ToUniqueInt64Slice(arr) + assert.Equal(t, expectedValue, actualValue) +} + +func TestToUniqueInt64Slice_NilOrEmpty(t *testing.T) { + var arr []int64 = nil + expectedValue := []int64{} + actualValue := ToUniqueInt64Slice(arr) + assert.Equal(t, expectedValue, actualValue) + + arr = []int64{} + expectedValue = []int64{} + actualValue = ToUniqueInt64Slice(arr) + assert.Equal(t, expectedValue, actualValue) +} diff --git a/pkg/utils/strings_test.go b/pkg/utils/strings_test.go new file mode 100644 index 00000000..39f99b9e --- /dev/null +++ b/pkg/utils/strings_test.go @@ -0,0 +1,110 @@ +package utils + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSubString(t *testing.T) { + str := "foobar" + expectedValue := "f" + actualValue := SubString(str, 0, 1) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "fo" + actualValue = SubString(str, 0, 2) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "oba" + actualValue = SubString(str, 2, 3) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "foobar" + actualValue = SubString(str, 0, 6) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "ba" + actualValue = SubString(str, -3, 2) + assert.Equal(t, expectedValue, actualValue) +} + +func TestSubString_EmptyStr(t *testing.T) { + str := "" + expectedValue := "" + actualValue := SubString(str, 0, 1) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "" + actualValue = SubString(str, 0, 2) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "" + actualValue = SubString(str, 2, 3) + assert.Equal(t, expectedValue, actualValue) +} + +func TestSubString_OverBoundary(t *testing.T) { + str := "foobar" + expectedValue := "" + actualValue := SubString(str, 100, 1) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "foobar" + actualValue = SubString(str, 0, 100) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "obar" + actualValue = SubString(str, 2, 100) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "bar" + actualValue = SubString(str, -3, 100) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "foobar" + actualValue = SubString(str, -100, 100) + assert.Equal(t, expectedValue, actualValue) + + expectedValue = "" + actualValue = SubString(str, 0, -100) + assert.Equal(t, expectedValue, actualValue) +} + +func TestGetRandomString(t *testing.T) { + actualValue, err := GetRandomString(10) + assert.Equal(t, nil, err) + assert.Len(t, actualValue, 10) +} + +func TestGetRandomNumberOrLetter(t *testing.T) { + actualValue, err := GetRandomNumberOrLetter(10) + assert.Equal(t, nil, err) + assert.Len(t, actualValue, 10) +} + +func TestMD5Encode(t *testing.T) { + str := "foobar" + expectedValue := "3858f62230ac3c915f300c664312c63f" + actualData := MD5Encode([]byte(str)) + actualValue := fmt.Sprintf("%x", actualData) + assert.Equal(t, expectedValue, actualValue) + + str = "" + expectedValue = "d41d8cd98f00b204e9800998ecf8427e" + actualData = MD5Encode([]byte(str)) + actualValue = fmt.Sprintf("%x", actualData) + assert.Equal(t, expectedValue, actualValue) +} + +func TestEncryptSecretAndDecryptSecret(t *testing.T) { + str := "foo" + key := "bar" + expectedValue := str + + encryptedStr, err := EncryptSecret(str, key) + actualValue, err := DecryptSecret(encryptedStr, key) + assert.Equal(t, nil, err) + assert.Equal(t, expectedValue, actualValue) +}