times_test.go

package durations

import (
	"testing"
	"time"
)

func TestGetTimePlus(t *testing.T) {
	// Create a fixed time for testing
	baseTime := time.Date(2023, 6, 15, 12, 30, 45, 0, time.UTC)

	// Create a GetTime function that returns the base time
	baseGetTime := func() time.Time {
		return baseTime
	}

	tests := []struct {
		name     string
		duration time.Duration
		expected time.Time
	}{
		{
			name:     "Add positive duration - 1 hour",
			duration: time.Hour,
			expected: baseTime.Add(time.Hour),
		},
		{
			name:     "Add positive duration - 24 hours",
			duration: 24 * time.Hour,
			expected: baseTime.Add(24 * time.Hour),
		},
		{
			name:     "Add negative duration - 30 minutes",
			duration: -30 * time.Minute,
			expected: baseTime.Add(-30 * time.Minute),
		},
		{
			name:     "Add zero duration",
			duration: 0,
			expected: baseTime,
		},
		{
			name:     "Add complex duration",
			duration: 2*time.Hour + 15*time.Minute + 30*time.Second,
			expected: baseTime.Add(2*time.Hour + 15*time.Minute + 30*time.Second),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Call GetTimePlus with the base function and duration
			modifiedGetTime := GetTimePlus(baseGetTime, tt.duration)

			// Get the result
			result := modifiedGetTime()

			// Verify the result
			if !result.Equal(tt.expected) {
				t.Errorf("GetTimePlus() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestGetTimePlusChaining(t *testing.T) {
	// Test that GetTimePlus can be chained
	baseTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)

	baseGetTime := func() time.Time {
		return baseTime
	}

	// Chain multiple GetTimePlus calls
	plusOneHour := GetTimePlus(baseGetTime, time.Hour)
	plusTwoHours := GetTimePlus(plusOneHour, time.Hour)

	result := plusTwoHours()
	expected := baseTime.Add(2 * time.Hour)

	if !result.Equal(expected) {
		t.Errorf("Chained GetTimePlus() = %v, want %v", result, expected)
	}
}

func TestGetTimeIn(t *testing.T) {
	// Create a fixed time in UTC
	utcTime := time.Date(2023, 6, 15, 12, 30, 45, 0, time.UTC)

	// Create a GetTime function that returns the UTC time
	baseGetTime := func() time.Time {
		return utcTime
	}

	// Load different time zones for testing
	tokyo, err := time.LoadLocation("Asia/Tokyo")
	if err != nil {
		t.Fatalf("Failed to load Tokyo timezone: %v", err)
	}

	newYork, err := time.LoadLocation("America/New_York")
	if err != nil {
		t.Fatalf("Failed to load New York timezone: %v", err)
	}

	tests := []struct {
		name     string
		location *time.Location
	}{
		{
			name:     "Convert to Tokyo time",
			location: tokyo,
		},
		{
			name:     "Convert to New York time",
			location: newYork,
		},
		{
			name:     "Convert to UTC (same as original)",
			location: time.UTC,
		},
		{
			name:     "Convert to Local time",
			location: time.Local,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Call GetTimeIn with the base function and location
			modifiedGetTime := GetTimeIn(baseGetTime, tt.location)

			// Get the result
			result := modifiedGetTime()
			expected := utcTime.In(tt.location)

			// Verify the result
			if !result.Equal(expected) {
				t.Errorf("GetTimeIn() = %v, want %v", result, expected)
			}

			// Verify the location is correct
			if result.Location() != tt.location {
				t.Errorf("GetTimeIn() location = %v, want %v", result.Location(), tt.location)
			}

			// Verify the underlying instant is the same
			if !result.Equal(utcTime) {
				t.Errorf("GetTimeIn() should represent the same instant: %v vs %v", result, utcTime)
			}
		})
	}
}

func TestGetTimeInChaining(t *testing.T) {
	// Test that GetTimeIn can be chained with GetTimePlus
	baseTime := time.Date(2023, 6, 15, 12, 0, 0, 0, time.UTC)

	baseGetTime := func() time.Time {
		return baseTime
	}

	tokyo, err := time.LoadLocation("Asia/Tokyo")
	if err != nil {
		t.Fatalf("Failed to load Tokyo timezone: %v", err)
	}

	// Chain GetTimePlus and GetTimeIn
	plusOneHour := GetTimePlus(baseGetTime, time.Hour)
	inTokyo := GetTimeIn(plusOneHour, tokyo)

	result := inTokyo()
	expected := baseTime.Add(time.Hour).In(tokyo)

	if !result.Equal(expected) {
		t.Errorf("Chained GetTimePlus + GetTimeIn = %v, want %v", result, expected)
	}

	if result.Location() != tokyo {
		t.Errorf("Location should be Tokyo, got %v", result.Location())
	}
}

func TestGetTimeInReverse(t *testing.T) {
	// Test chaining in reverse order: GetTimeIn then GetTimePlus
	baseTime := time.Date(2023, 6, 15, 12, 0, 0, 0, time.UTC)

	baseGetTime := func() time.Time {
		return baseTime
	}

	tokyo, err := time.LoadLocation("Asia/Tokyo")
	if err != nil {
		t.Fatalf("Failed to load Tokyo timezone: %v", err)
	}

	// Chain GetTimeIn and GetTimePlus
	inTokyo := GetTimeIn(baseGetTime, tokyo)
	plusOneHour := GetTimePlus(inTokyo, time.Hour)

	result := plusOneHour()
	expected := baseTime.In(tokyo).Add(time.Hour)

	if !result.Equal(expected) {
		t.Errorf("Chained GetTimeIn + GetTimePlus = %v, want %v", result, expected)
	}

	if result.Location() != tokyo {
		t.Errorf("Location should be Tokyo, got %v", result.Location())
	}
}

func TestGetTimeWithRealTimeNow(t *testing.T) {
	// Test that the functions work with time.Now
	nowFunc := func() time.Time {
		return time.Now()
	}

	// Get current time
	before := time.Now()

	// Test GetTimePlus with time.Now
	plusOneHour := GetTimePlus(nowFunc, time.Hour)
	result := plusOneHour()

	after := time.Now()

	// The result should be approximately 1 hour from now
	// (within the test execution time)
	expectedMin := before.Add(time.Hour)
	expectedMax := after.Add(time.Hour)

	if result.Before(expectedMin) || result.After(expectedMax) {
		t.Errorf("GetTimePlus with time.Now produced unexpected result: %v (expected between %v and %v)",
			result, expectedMin, expectedMax)
	}
}