time_test.go

package utils

import (
	"reflect"
	"testing"
	"time"
)

var (
	TimeZoneUtc             = time.UTC
	TimeZoneCet             = time.FixedZone("CET", 1*60*60)
	TimeZoneCest            = time.FixedZone("CEST", 2*60*60)
	TimeZoneEuropeWarsaw, _ = time.LoadLocation("Europe/Warsaw")
)

func TestParseIsoDateTime(t *testing.T) {
	type testCase struct {
		name string
		arg  string
		want time.Time
		err  error
	}
	tests := []testCase{
		// ✅ Valid UTC and offsets
		{
			name: "1 UTC midnight",
			arg:  "2021-01-01T00:00:00Z",
			want: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "2 Europe/Warsaw offset +02:00",
			arg:  "2021-06-01T00:00:00+02:00",
			want: time.Date(2021, 6, 1, 0, 0, 0, 0, TimeZoneEuropeWarsaw),
		},
		{
			name: "3 CET offset +01:00",
			arg:  "2021-06-01T00:00:00+01:00",
			want: time.Date(2021, 6, 1, 0, 0, 0, 0, TimeZoneCet),
		},
		{
			name: "4 UTC with seconds and milliseconds",
			arg:  "2021-12-31T23:59:59.999Z",
			want: time.Date(2021, 12, 31, 23, 59, 59, 999000000, time.UTC),
		},

		// ❌ Invalid formats
		{
			name: "5 unsupported leap second",
			arg:  "2016-12-31T23:59:60Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "6 unsupported zone notation",
			arg:  "2021-06-01T00:00:00+02:00[Europe/Warsaw]",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "7 invalid month",
			arg:  "2021-13-01T00:00:00Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "8 invalid day",
			arg:  "2021-12-32T00:00:00Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "9 invalid date separator",
			arg:  "2021-12-31Y00:00:00Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "10 invalid hour",
			arg:  "2021-12-31T26:00:00Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "11 invalid minute",
			arg:  "2021-12-31T00:78:00Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "12 invalid second",
			arg:  "2021-12-31T00:00:89Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "13 missing T separator",
			arg:  "2021-12-31 00:00:00Z",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "14 missing timezone",
			arg:  "2021-12-31T00:00:00",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "15 empty string",
			arg:  "",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "16 invalid characters",
			arg:  "abcd-ef-ghTij:kl:mnZ",
			want: time.Time{},
			err:  &time.ParseError{},
		},

		// ✅ Edge cases
		{
			name: "17 year zero",
			arg:  "0000-01-01T00:00:00Z",
			want: time.Date(0, 1, 1, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "18 large year",
			arg:  "9999-12-31T23:59:59Z",
			want: time.Date(9999, 12, 31, 23, 59, 59, 0, time.UTC),
		},
		{
			name: "19 valid with fractional seconds",
			arg:  "2021-12-31T23:59:59.123456789Z",
			want: time.Date(2021, 12, 31, 23, 59, 59, 123456789, time.UTC),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := ParseIsoDateTime(tt.arg)
			if tt.err != nil {
				if reflect.TypeOf(err) != reflect.TypeOf(tt.err) {
					t.Errorf("ParseIsoDateTime() error = %v, wantErr %v", err, tt.err)
					return
				}
			} else {
				if err != nil {
					t.Errorf("ParseIsoDateTime() error = %v, wantErr %v", err, tt.err)
					return
				}
				if result.UTC() != tt.want.UTC() {
					t.Errorf("ParseIsoDateTime() = %v, want %v", result, tt.want)
					return
				}
				_, rzOffset := result.Zone()
				_, wzOffset := tt.want.Zone()
				if rzOffset != wzOffset {
					t.Errorf("ParseIsoDateTime() = %v, want %v", result, tt.want)
					return
				}
			}
		})
	}
}

func TestParseIsoDate(t *testing.T) {
	type testCase struct {
		name string
		arg  string
		want time.Time
		err  error
	}
	tests := []testCase{
		// ✅ Valid cases
		{
			name: "1 valid basic date",
			arg:  "2021-01-01",
			want: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "2 valid end of month",
			arg:  "2021-01-31",
			want: time.Date(2021, 1, 31, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "3 valid leap year date",
			arg:  "2020-02-29",
			want: time.Date(2020, 2, 29, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "4 valid non-leap year February",
			arg:  "2021-02-28",
			want: time.Date(2021, 2, 28, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "5 valid end of year",
			arg:  "1999-12-31",
			want: time.Date(1999, 12, 31, 0, 0, 0, 0, time.UTC),
		},

		// ❌ Invalid month/day
		{
			name: "6 invalid month (21)",
			arg:  "2021-21-01",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "7 invalid day (41)",
			arg:  "2021-01-41",
			want: time.Time{},
			err:  &time.ParseError{},
		},

		// ❌ Invalid leap year handling
		{
			name: "8 invalid non-leap year February 29",
			arg:  "2021-02-29",
			want: time.Time{},
			err:  &time.ParseError{},
		},

		// ❌ Invalid formatting
		{
			name: "9 invalid separator",
			arg:  "2021/01/01",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "10 invalid short date",
			arg:  "2021-1-1",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "11 invalid year only",
			arg:  "2021",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "12 empty string",
			arg:  "",
			want: time.Time{},
			err:  &time.ParseError{},
		},
		{
			name: "13 invalid characters",
			arg:  "abcd-ef-gh",
			want: time.Time{},
			err:  &time.ParseError{},
		},

		// ✅ Edge case boundaries
		{
			name: "14 year zero (0000-01-01)",
			arg:  "0000-01-01",
			want: time.Date(0, 1, 1, 0, 0, 0, 0, time.UTC),
		},
		{
			name: "15 large year (9999-12-31)",
			arg:  "9999-12-31",
			want: time.Date(9999, 12, 31, 0, 0, 0, 0, time.UTC),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := ParseIsoDate(tt.arg)
			if tt.err != nil {
				if reflect.TypeOf(err) != reflect.TypeOf(tt.err) {
					t.Errorf("ParseIsoDateTime() error = %v, wantErr %v", err, tt.err)
					return
				}
			} else {
				if err != nil {
					t.Errorf("ParseIsoDate() error = %v, wantErr %v", err, tt.err)
					return
				}
				if result != tt.want {
					t.Errorf("ParseIsoDate() = %v, want %v", result, tt.want)
					return
				}
			}
		})
	}
}