mirror of
https://github.com/Xevion/banner.git
synced 2025-12-06 05:14:26 -06:00
230 lines
7.0 KiB
Go
230 lines
7.0 KiB
Go
package config_test
|
|
|
|
import (
|
|
"banner/internal/config"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestGetCurrentTerm(t *testing.T) {
|
|
// Initialize location for testing
|
|
loc, _ := time.LoadLocation("America/Chicago")
|
|
|
|
// Use current year to avoid issues with global state
|
|
currentYear := uint16(time.Now().Year())
|
|
ranges := config.GetYearDayRange(loc, currentYear)
|
|
|
|
tests := []struct {
|
|
name string
|
|
date time.Time
|
|
expectedCurrent *config.Term
|
|
expectedNext *config.Term
|
|
}{
|
|
{
|
|
name: "Spring term",
|
|
date: time.Date(int(currentYear), 3, 15, 12, 0, 0, 0, loc),
|
|
expectedCurrent: &config.Term{Year: currentYear, Season: config.Spring},
|
|
expectedNext: &config.Term{Year: currentYear, Season: config.Summer},
|
|
},
|
|
{
|
|
name: "Summer term",
|
|
date: time.Date(int(currentYear), 6, 15, 12, 0, 0, 0, loc),
|
|
expectedCurrent: &config.Term{Year: currentYear, Season: config.Summer},
|
|
expectedNext: &config.Term{Year: currentYear, Season: config.Fall},
|
|
},
|
|
{
|
|
name: "Fall term",
|
|
date: time.Date(int(currentYear), 9, 15, 12, 0, 0, 0, loc),
|
|
expectedCurrent: &config.Term{Year: currentYear + 1, Season: config.Fall},
|
|
expectedNext: nil,
|
|
},
|
|
{
|
|
name: "Between Spring and Summer",
|
|
date: time.Date(int(currentYear), 5, 20, 12, 0, 0, 0, loc),
|
|
expectedCurrent: nil,
|
|
expectedNext: &config.Term{Year: currentYear, Season: config.Summer},
|
|
},
|
|
{
|
|
name: "Between Summer and Fall",
|
|
date: time.Date(int(currentYear), 8, 16, 12, 0, 0, 0, loc),
|
|
expectedCurrent: nil,
|
|
expectedNext: &config.Term{Year: currentYear + 1, Season: config.Fall},
|
|
},
|
|
{
|
|
name: "Between Fall and Spring",
|
|
date: time.Date(int(currentYear), 12, 15, 12, 0, 0, 0, loc),
|
|
expectedCurrent: nil,
|
|
expectedNext: &config.Term{Year: currentYear + 1, Season: config.Spring},
|
|
},
|
|
{
|
|
name: "Early January before Spring",
|
|
date: time.Date(int(currentYear), 1, 10, 12, 0, 0, 0, loc),
|
|
expectedCurrent: nil,
|
|
expectedNext: &config.Term{Year: currentYear, Season: config.Spring},
|
|
},
|
|
{
|
|
name: "Spring start date",
|
|
date: time.Date(int(currentYear), 1, 14, 0, 0, 0, 0, loc),
|
|
expectedCurrent: &config.Term{Year: currentYear, Season: config.Spring},
|
|
expectedNext: &config.Term{Year: currentYear, Season: config.Summer},
|
|
},
|
|
{
|
|
name: "Summer start date",
|
|
date: time.Date(int(currentYear), 5, 25, 0, 0, 0, 0, loc),
|
|
expectedCurrent: &config.Term{Year: currentYear, Season: config.Summer},
|
|
expectedNext: &config.Term{Year: currentYear, Season: config.Fall},
|
|
},
|
|
{
|
|
name: "Fall start date",
|
|
date: time.Date(int(currentYear), 8, 18, 0, 0, 0, 0, loc),
|
|
expectedCurrent: &config.Term{Year: currentYear + 1, Season: config.Fall},
|
|
expectedNext: nil,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
current, next := config.GetCurrentTerm(ranges, tt.date)
|
|
|
|
if !termsEqual(current, tt.expectedCurrent) {
|
|
t.Errorf("GetCurrentTerm() current = %v, want %v", current, tt.expectedCurrent)
|
|
}
|
|
|
|
if !termsEqual(next, tt.expectedNext) {
|
|
t.Errorf("GetCurrentTerm() next = %v, want %v", next, tt.expectedNext)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetYearDayRange(t *testing.T) {
|
|
loc, _ := time.LoadLocation("America/Chicago")
|
|
|
|
ranges := config.GetYearDayRange(loc, 2024)
|
|
|
|
// Verify Spring range (Jan 14 to May 1)
|
|
expectedSpringStart := time.Date(2024, 1, 14, 0, 0, 0, 0, loc).YearDay()
|
|
expectedSpringEnd := time.Date(2024, 5, 1, 0, 0, 0, 0, loc).YearDay()
|
|
|
|
if ranges.Spring.Start != uint16(expectedSpringStart) {
|
|
t.Errorf("Spring start = %d, want %d", ranges.Spring.Start, expectedSpringStart)
|
|
}
|
|
if ranges.Spring.End != uint16(expectedSpringEnd) {
|
|
t.Errorf("Spring end = %d, want %d", ranges.Spring.End, expectedSpringEnd)
|
|
}
|
|
|
|
// Verify Summer range (May 25 to Aug 15)
|
|
expectedSummerStart := time.Date(2024, 5, 25, 0, 0, 0, 0, loc).YearDay()
|
|
expectedSummerEnd := time.Date(2024, 8, 15, 0, 0, 0, 0, loc).YearDay()
|
|
|
|
if ranges.Summer.Start != uint16(expectedSummerStart) {
|
|
t.Errorf("Summer start = %d, want %d", ranges.Summer.Start, expectedSummerStart)
|
|
}
|
|
if ranges.Summer.End != uint16(expectedSummerEnd) {
|
|
t.Errorf("Summer end = %d, want %d", ranges.Summer.End, expectedSummerEnd)
|
|
}
|
|
|
|
// Verify Fall range (Aug 18 to Dec 10)
|
|
expectedFallStart := time.Date(2024, 8, 18, 0, 0, 0, 0, loc).YearDay()
|
|
expectedFallEnd := time.Date(2024, 12, 10, 0, 0, 0, 0, loc).YearDay()
|
|
|
|
if ranges.Fall.Start != uint16(expectedFallStart) {
|
|
t.Errorf("Fall start = %d, want %d", ranges.Fall.Start, expectedFallStart)
|
|
}
|
|
if ranges.Fall.End != uint16(expectedFallEnd) {
|
|
t.Errorf("Fall end = %d, want %d", ranges.Fall.End, expectedFallEnd)
|
|
}
|
|
}
|
|
|
|
func TestParseTerm(t *testing.T) {
|
|
tests := []struct {
|
|
code string
|
|
expected config.Term
|
|
}{
|
|
{"202410", config.Term{Year: 2024, Season: config.Fall}},
|
|
{"202420", config.Term{Year: 2024, Season: config.Spring}},
|
|
{"202430", config.Term{Year: 2024, Season: config.Summer}},
|
|
{"202510", config.Term{Year: 2025, Season: config.Fall}},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.code, func(t *testing.T) {
|
|
result := config.ParseTerm(tt.code)
|
|
if result != tt.expected {
|
|
t.Errorf("ParseTerm(%s) = %v, want %v", tt.code, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTermToString(t *testing.T) {
|
|
tests := []struct {
|
|
term config.Term
|
|
expected string
|
|
}{
|
|
{config.Term{Year: 2024, Season: config.Fall}, "202410"},
|
|
{config.Term{Year: 2024, Season: config.Spring}, "202420"},
|
|
{config.Term{Year: 2024, Season: config.Summer}, "202430"},
|
|
{config.Term{Year: 2025, Season: config.Fall}, "202510"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.expected, func(t *testing.T) {
|
|
result := tt.term.ToString()
|
|
if result != tt.expected {
|
|
t.Errorf("Term{Year: %d, Season: %d}.ToString() = %s, want %s",
|
|
tt.term.Year, tt.term.Season, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDefaultTerm(t *testing.T) {
|
|
loc, _ := time.LoadLocation("America/Chicago")
|
|
ranges := config.GetYearDayRange(loc, 2024)
|
|
|
|
tests := []struct {
|
|
name string
|
|
date time.Time
|
|
expected config.Term
|
|
}{
|
|
{
|
|
name: "During Spring term",
|
|
date: time.Date(2024, 3, 15, 12, 0, 0, 0, loc),
|
|
expected: config.Term{Year: 2024, Season: config.Spring},
|
|
},
|
|
{
|
|
name: "Between terms - returns next term",
|
|
date: time.Date(2024, 5, 20, 12, 0, 0, 0, loc),
|
|
expected: config.Term{Year: 2024, Season: config.Summer},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
currentTerm, nextTerm := config.GetCurrentTerm(ranges, tt.date)
|
|
var result config.Term
|
|
if currentTerm == nil {
|
|
result = *nextTerm
|
|
} else {
|
|
result = *currentTerm
|
|
}
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("DefaultTerm() = %v, want %v", result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Helper function to compare terms, handling nil cases
|
|
func termsEqual(a, b *config.Term) bool {
|
|
if a == nil && b == nil {
|
|
return true
|
|
}
|
|
if a == nil || b == nil {
|
|
return false
|
|
}
|
|
return *a == *b
|
|
}
|