chat_back_go/internal/domain/date_test.go

package domain

import (
	"encoding/json"
	"github.com/stretchr/testify/assert"
	"testing"
	"time"
)

func TestCustomDate_UnmarshalJSON(t *testing.T) {
	testTable := []struct {
		name      string
		input     string
		expectErr bool
		expected  time.Time
	}{
		{
			name:     "ok",
			input:    `"2024-02-25"`,
			expected: time.Date(2024, 2, 25, 0, 0, 0, 0, time.UTC),
		},
		{
			name:      "invalid_format",
			input:     `"25-02-2024"`,
			expectErr: true,
		},
		{
			name:      "invalid_characters",
			input:     `"invalid-date"`,
			expectErr: true,
		},
		{
			name:      "empty_string",
			input:     `""`,
			expectErr: true,
		},
		{
			name:      "whitespace",
			input:     `"   "`,
			expectErr: true,
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {
			var cd CustomDate
			err := json.Unmarshal([]byte(tc.input), &cd)

			assert.Equal(t, tc.expectErr, err != nil)
			assert.True(t, cd.Time.Equal(tc.expected) || tc.expectErr)
		})
	}
}

func TestCustomDate_MarshalJSON(t *testing.T) {
	testTable := []struct {
		name     string
		date     CustomDate
		expected string
	}{
		{
			name:     "ok_1",
			date:     CustomDate{Time: time.Date(2024, 2, 25, 0, 0, 0, 0, time.UTC)},
			expected: `"2024-02-25"`,
		},
		{
			name:     "ok_2",
			date:     CustomDate{Time: time.Date(2023, 8, 10, 0, 0, 0, 0, time.UTC)},
			expected: `"2023-08-10"`,
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {
			result, err := json.Marshal(tc.date)
			assert.NoError(t, err)
			assert.Equal(t, tc.expected, string(result))
		})
	}
}

func TestCustomDate_String(t *testing.T) {
	testTable := []struct {
		name     string
		date     CustomDate
		expected string
	}{
		{
			name:     "ok_1",
			date:     CustomDate{Time: time.Date(2024, 2, 25, 0, 0, 0, 0, time.UTC)},
			expected: "2024-02-25",
		},
		{
			name:     "ok_2",
			date:     CustomDate{Time: time.Date(2023, 8, 10, 0, 0, 0, 0, time.UTC)},
			expected: "2023-08-10",
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {
			result := tc.date.String()

			assert.Equal(t, tc.expected, result)
		})
	}
}

func TestCustomDate_Scan(t *testing.T) {
	testTable := []struct {
		name        string
		dbValue     any
		expected    CustomDate
		expectedErr error
		panics      bool
	}{
		{
			name:     "ok_1",
			dbValue:  "2023-08-10",
			expected: CustomDate{Time: time.Date(2023, 8, 10, 0, 0, 0, 0, time.UTC)},
		},
		{
			name:     "ok_2",
			dbValue:  time.Date(2023, 8, 10, 0, 0, 0, 0, time.UTC),
			expected: CustomDate{Time: time.Date(2023, 8, 10, 0, 0, 0, 0, time.UTC)},
		},
		{
			name:        "invalid_date",
			dbValue:     "",
			expectedErr: &time.ParseError{},
		},
		{
			name:   "invalid_type",
			panics: true,
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {
			if tc.panics {
				defer func() {
					if r := recover(); r != nil {
						assert.Equal(t, "incorrect time type received", r)
					}
				}()
			}

			date := &CustomDate{}

			err := date.Scan(tc.dbValue)

			if tc.expectedErr != nil {
				assert.ErrorAs(t, err, &tc.expectedErr)
			} else {
				assert.NoError(t, err)
			}
			assert.Equal(t, tc.expected, *date)
		})
	}
}

func TestCustomDate_Value(t *testing.T) {
	testTable := []struct {
		name     string
		date     CustomDate
		expected string
	}{
		{
			name:     "ok_1",
			date:     CustomDate{Time: time.Date(2024, 2, 25, 0, 0, 0, 0, time.UTC)},
			expected: "2024-02-25",
		},
		{
			name:     "ok_2",
			date:     CustomDate{Time: time.Date(2023, 8, 10, 0, 0, 0, 0, time.UTC)},
			expected: "2023-08-10",
		},
	}

	for _, tc := range testTable {
		t.Run(tc.name, func(t *testing.T) {
			result, err := tc.date.Value()
			assert.NoError(t, err)

			date, ok := result.(string)
			assert.True(t, ok)
			assert.Equal(t, tc.expected, date)
		})
	}
}