arbeitszeitmessung/Backend/helper/time_test.go

package helper

import (
	"fmt"
	"testing"
	"time"
)

func TestGetMonday(t *testing.T) {
	isMonday, err := time.Parse(time.DateOnly, "2025-07-14")
	isSunday, err := time.Parse(time.DateOnly, "2025-07-20")
	notMonday, err := time.Parse(time.DateOnly, "2025-07-16")
	if err != nil || isMonday.Equal(notMonday) {
		t.Errorf("U stupid? %e", err)
	}
	if GetMonday(isMonday) != isMonday {
		t.Error("Wrong date conversion!")
	}

	if GetMonday(notMonday) != isMonday {
		t.Error("Wrong date conversion (notMonday)!")
	}

	if GetMonday(isSunday) != isMonday {
		t.Error("Wrong date conversion (isSunday)!")
	}
}

func TestIsMonday_ReturnsTrueForMonday(t *testing.T) {
	monday := time.Date(2023, 4, 3, 0, 0, 0, 0, time.UTC)

	if !IsMonday(monday) {
		t.Errorf("Expected IsMonday to return true for Monday, got false")
	}
}

func TestIsMonday_ReturnsFalseForNonMonday(t *testing.T) {
	tuesday := time.Date(2023, 4, 4, 0, 0, 0, 0, time.UTC)

	if IsMonday(tuesday) {
		t.Errorf("Expected IsMonday to return false for Tuesday, got true")
	}
}

func TestGenerateDateRange(t *testing.T) {
	start := time.Date(2026, 2, 9, 0, 0, 0, 0, time.UTC)
	end := time.Date(2026, 2, 11, 0, 0, 0, 0, time.UTC)

	dates := GenerateDateRange(start, end)

	if len(dates) != 3 {
		t.Fatalf("expected 3 dates, got %d", len(dates))
	}

	expected := []string{"2026-02-09", "2026-02-10", "2026-02-11"}
	for i, d := range dates {
		got := d.Format("2006-01-02")
		if got != expected[i] {
			t.Errorf("expected %s, got %s", expected[i], got)
		}
	}
}

func TestGetMondays_ReturnsOnlyMondays(t *testing.T) {
	startDate := time.Date(2026, 01, 01, 0, 0, 0, 0, time.UTC)
	endDate := time.Date(2026, 01, 31, 0, 0, 0, 0, time.UTC)

	daysInMonth := GenerateDateRange(startDate, endDate)
	result := GetMondays(daysInMonth, false)
	if len(result) < 5 {
		t.Errorf("Expected 5 monday, got %d", len(result))
	} else if len(result) > 5 {
		t.Errorf("Expected 5 monday, got %d", len(result))
	}

	if result[0] != time.Date(2025, 12, 29, 0, 0, 0, 0, time.UTC) {
		t.Errorf("Expected first monday to be %v, got %v", "2025-12-29", result[0])
	}
}

func TestGetMondays_ReturnsOnlyMondaysInRange(t *testing.T) {
	startDate := time.Date(2026, 01, 01, 0, 0, 0, 0, time.UTC)
	endDate := time.Date(2026, 01, 31, 0, 0, 0, 0, time.UTC)

	daysInMonth := GenerateDateRange(startDate, endDate)
	result := GetMondays(daysInMonth, true)
	if len(result) < 4 {
		t.Errorf("Expected 4 monday, got %d", len(result))
	} else if len(result) > 4 {
		t.Errorf("Expected 4 monday, got %d", len(result))
	}

	if result[0] != time.Date(2026, 1, 5, 0, 0, 0, 0, time.UTC) {
		t.Errorf("Expected first monday to be %v, got %v", "2026-01-05", result[0])
	}
}

func TestDaysInRange(t *testing.T) {
	days := []time.Time{
		time.Date(2023, 4, 3, 0, 0, 0, 0, time.UTC), // Tuesday
		time.Date(2023, 4, 4, 0, 0, 0, 0, time.UTC), // Wednesday
		time.Date(2023, 4, 5, 0, 0, 0, 0, time.UTC), // Thursday
		time.Date(2023, 4, 6, 0, 0, 0, 0, time.UTC), // Friday
	}

	start := time.Date(2023, 4, 3, 0, 0, 0, 0, time.UTC)
	end := time.Date(2023, 4, 5, 0, 0, 0, 0, time.UTC)

	daysInRange := DaysInRange(days, start, end)

	if len(daysInRange) != 3 {
		t.Errorf("Expected 3 days in range, got %d", len(daysInRange))
	}

	if daysInRange[0] != days[0] {
		t.Errorf("Expected first day in range to be %v, got %v", days[0], daysInRange[0])
	}

	if daysInRange[2] != days[2] {
		t.Errorf("Expected third day in range to be %v, got %v", days[2], daysInRange[2])
	}
}

func TestFormatDurationFill(t *testing.T) {
	testCases := []struct {
		name     string
		duration time.Duration
		fill     bool
	}{
		{"2h", time.Duration(120 * time.Minute), true},
		{"30min", time.Duration(30 * time.Minute), true},
		{"1h 30min", time.Duration(90 * time.Minute), true},
		{"-1h 30min", time.Duration(-90 * time.Minute), true},
		{"0min", 0, true},
		{"", 0, false},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if FormatDurationFill(tc.duration, tc.fill) != tc.name {
				t.Error("Format missmatch in Formatduration.")
			}
		})
	}
}

func TestFormatDuration(t *testing.T) {
	testCases := []struct {
		name     string
		duration time.Duration
	}{
		{"", 0},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if FormatDuration(tc.duration) != tc.name {
				t.Error("Format missmatch in Formatduration.")
			}
		})
	}
}

func TestIsSameDate(t *testing.T) {
	testCases := []struct {
		dateA  string
		dateB  string
		result bool
	}{
		{"2025-12-01 00:00:00", "2025-12-01 00:00:00", true},
		{"2025-12-03 00:00:00", "2025-12-02 00:00:00", false},
		{"2025-12-03 23:45:00", "2025-12-03 00:00:00", true},
		{"2025-12-04 24:12:00", "2025-12-04 00:12:00", false},
	}

	for _, tc := range testCases {
		t.Run(fmt.Sprintf("IsSameDateTest: %s date", tc.dateA), func(t *testing.T) {
			dateA, _ := time.Parse(time.DateTime, tc.dateA)
			dateB, _ := time.Parse(time.DateTime, tc.dateB)
			if IsSameDate(dateA, dateB) != tc.result {
				t.Errorf("Is SameDate did not match! Result %t", IsSameDate(dateA, dateB))
			}
		})
	}
}

func TestGetWorkingDays(t *testing.T) {
	testCases := []struct {
		start string
		end   string
		days  int
	}{
		{"2025-10-01", "2025-10-02", 2},
		{"2025-10-02", "2025-10-01", 0},
		{"2025-10-01", "2025-10-31", 23},
	}

	for _, tc := range testCases {
		t.Run(fmt.Sprintf("WorkingDayTest: %d days", tc.days), func(t *testing.T) {
			startDate, _ := time.Parse(time.DateOnly, tc.start)
			endDate, _ := time.Parse(time.DateOnly, tc.end)
			if GetWorkingDays(startDate, endDate) != tc.days {
				t.Error("Calculated workdays do not match target")
			}
		})
	}
}

func TestFormatGermanDayOfWeek(t *testing.T) {
	testCases := []struct {
		date   string
		result string
	}{
		{"2025-12-01", "Mo"},
		{"2025-12-02", "Di"},
		{"2025-12-03", "Mi"},
		{"2025-12-04", "Do"},
		{"2025-12-05", "Fr"},
		{"2025-12-06", "Sa"},
		{"2025-12-07", "So"},
	}

	for _, tc := range testCases {
		t.Run(fmt.Sprintf("FormatWeekDayTest: %s date", tc.date), func(t *testing.T) {
			date, _ := time.Parse(time.DateOnly, tc.date)
			if FormatGermanDayOfWeek(date) != tc.result {
				t.Error("Formatted workday did not match!")
			}
		})
	}
}