Migrate from Gin to Echo framework and add comprehensive integration tests
Major changes: - Migrate all handlers from Gin to Echo framework - Add new apperrors, echohelpers, and validator packages - Update middleware for Echo compatibility - Add ArchivedHandler to task categorization chain (archived tasks go to cancelled_tasks column) - Add 6 new integration tests: - RecurringTaskLifecycle: NextDueDate advancement for weekly/monthly tasks - MultiUserSharing: Complex sharing with user removal - TaskStateTransitions: All state transitions and kanban column changes - DateBoundaryEdgeCases: Threshold boundary testing - CascadeOperations: Residence deletion cascade effects - MultiUserOperations: Shared residence collaboration - Add single-purpose repository functions for kanban columns (GetOverdueTasks, GetDueSoonTasks, etc.) - Fix RemoveUser route param mismatch (userId -> user_id) - Fix determineExpectedColumn helper to correctly prioritize in_progress over overdue 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Trey t
@@ -109,14 +109,21 @@ func (Task) TableName() string {
|
||||
// single source of truth for task logic. It uses EffectiveDate (NextDueDate ?? DueDate)
|
||||
// rather than just DueDate, ensuring consistency with kanban categorization.
|
||||
//
|
||||
// Uses day-based comparison: a task due TODAY is NOT overdue, it only becomes
|
||||
// overdue the NEXT day.
|
||||
//
|
||||
// Deprecated: Prefer using task.IsOverdue(t, time.Now().UTC()) directly for explicit time control.
|
||||
func (t *Task) IsOverdue() bool {
|
||||
// Delegate to predicates package - single source of truth
|
||||
// Import is avoided here to prevent circular dependency.
|
||||
return t.IsOverdueAt(time.Now().UTC())
|
||||
}
|
||||
|
||||
// IsOverdueAt returns true if the task would be overdue at the given time.
|
||||
// Uses day-based comparison: a task due on the same day as `now` is NOT overdue.
|
||||
func (t *Task) IsOverdueAt(now time.Time) bool {
|
||||
// Logic must match predicates.IsOverdue exactly:
|
||||
// - Check active (not cancelled, not archived)
|
||||
// - Check not completed (NextDueDate != nil || no completions)
|
||||
// - Check effective date < now
|
||||
// - Check effective date < start of today
|
||||
if t.IsCancelled || t.IsArchived {
|
||||
return false
|
||||
}
|
||||
@@ -134,7 +141,9 @@ func (t *Task) IsOverdue() bool {
|
||||
if effectiveDate == nil {
|
||||
return false
|
||||
}
|
||||
return effectiveDate.Before(time.Now().UTC())
|
||||
// Day-based comparison: compare against start of today
|
||||
startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
|
||||
return effectiveDate.Before(startOfDay)
|
||||
}
|
||||
|
||||
// IsDueSoon returns true if the task is due within the specified days.
|
||||
@@ -169,6 +178,88 @@ func (t *Task) IsDueSoon(days int) bool {
|
||||
return !effectiveDate.Before(now) && effectiveDate.Before(threshold)
|
||||
}
|
||||
|
||||
// GetKanbanColumn returns the kanban column name for this task using the
|
||||
// Chain of Responsibility pattern from the categorization package.
|
||||
// Uses UTC time for categorization.
|
||||
//
|
||||
// For timezone-aware categorization, use GetKanbanColumnWithTimezone.
|
||||
func (t *Task) GetKanbanColumn(daysThreshold int) string {
|
||||
// Import would cause circular dependency, so we inline the logic
|
||||
// This delegates to the categorization package via internal/task re-export
|
||||
return t.GetKanbanColumnWithTimezone(daysThreshold, time.Now().UTC())
|
||||
}
|
||||
|
||||
// GetKanbanColumnWithTimezone returns the kanban column name using a specific
|
||||
// time (in the user's timezone). The time is used to determine "today" for
|
||||
// overdue/due-soon calculations.
|
||||
//
|
||||
// Example: For a user in Tokyo, pass time.Now().In(tokyoLocation) to get
|
||||
// accurate categorization relative to their local date.
|
||||
func (t *Task) GetKanbanColumnWithTimezone(daysThreshold int, now time.Time) string {
|
||||
// Note: We can't import categorization directly due to circular dependency.
|
||||
// Instead, this method implements the categorization logic inline.
|
||||
// The logic MUST match categorization.Chain exactly.
|
||||
|
||||
if daysThreshold <= 0 {
|
||||
daysThreshold = 30
|
||||
}
|
||||
|
||||
// Start of day normalization
|
||||
startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
|
||||
threshold := startOfDay.AddDate(0, 0, daysThreshold)
|
||||
|
||||
// Priority 1: Cancelled
|
||||
if t.IsCancelled {
|
||||
return "cancelled_tasks"
|
||||
}
|
||||
|
||||
// Priority 2: Archived (goes to cancelled column - both are "inactive" states)
|
||||
if t.IsArchived {
|
||||
return "cancelled_tasks"
|
||||
}
|
||||
|
||||
// Priority 3: Completed (NextDueDate nil with completions)
|
||||
hasCompletions := len(t.Completions) > 0 || t.CompletionCount > 0
|
||||
if t.NextDueDate == nil && hasCompletions {
|
||||
return "completed_tasks"
|
||||
}
|
||||
|
||||
// Priority 4: In Progress
|
||||
if t.InProgress {
|
||||
return "in_progress_tasks"
|
||||
}
|
||||
|
||||
// Get effective date: NextDueDate ?? DueDate
|
||||
var effectiveDate *time.Time
|
||||
if t.NextDueDate != nil {
|
||||
effectiveDate = t.NextDueDate
|
||||
} else {
|
||||
effectiveDate = t.DueDate
|
||||
}
|
||||
|
||||
if effectiveDate != nil {
|
||||
// Normalize effective date to same timezone for calendar date comparison
|
||||
// Task dates are stored as UTC but represent calendar dates (YYYY-MM-DD)
|
||||
normalizedEffective := time.Date(
|
||||
effectiveDate.Year(), effectiveDate.Month(), effectiveDate.Day(),
|
||||
0, 0, 0, 0, now.Location(),
|
||||
)
|
||||
|
||||
// Priority 5: Overdue (effective date before today)
|
||||
if normalizedEffective.Before(startOfDay) {
|
||||
return "overdue_tasks"
|
||||
}
|
||||
|
||||
// Priority 6: Due Soon (effective date before threshold)
|
||||
if normalizedEffective.Before(threshold) {
|
||||
return "due_soon_tasks"
|
||||
}
|
||||
}
|
||||
|
||||
// Priority 7: Upcoming (default)
|
||||
return "upcoming_tasks"
|
||||
}
|
||||
|
||||
// TaskCompletion represents the task_taskcompletion table
|
||||
type TaskCompletion struct {
|
||||
BaseModel
|
||||
|
||||
@@ -247,3 +247,197 @@ func TestDocument_JSONSerialization(t *testing.T) {
|
||||
assert.Equal(t, "HVAC-123", result["serial_number"])
|
||||
assert.Equal(t, "5000", result["purchase_price"]) // Decimal serializes as string
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// TASK KANBAN COLUMN TESTS
|
||||
// These tests verify GetKanbanColumn and GetKanbanColumnWithTimezone methods
|
||||
// ============================================================================
|
||||
|
||||
func timePtr(t time.Time) *time.Time {
|
||||
return &t
|
||||
}
|
||||
|
||||
func TestTask_GetKanbanColumn_PriorityOrder(t *testing.T) {
|
||||
now := time.Date(2025, 12, 16, 12, 0, 0, 0, time.UTC)
|
||||
yesterday := time.Date(2025, 12, 15, 0, 0, 0, 0, time.UTC)
|
||||
in5Days := time.Date(2025, 12, 21, 0, 0, 0, 0, time.UTC)
|
||||
in60Days := time.Date(2026, 2, 14, 0, 0, 0, 0, time.UTC)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
task *Task
|
||||
expected string
|
||||
}{
|
||||
// Priority 1: Cancelled
|
||||
{
|
||||
name: "cancelled takes highest priority",
|
||||
task: &Task{
|
||||
IsCancelled: true,
|
||||
NextDueDate: timePtr(yesterday),
|
||||
InProgress: true,
|
||||
},
|
||||
expected: "cancelled_tasks",
|
||||
},
|
||||
|
||||
// Priority 2: Completed
|
||||
{
|
||||
name: "completed: NextDueDate nil with completions",
|
||||
task: &Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: nil,
|
||||
DueDate: timePtr(yesterday),
|
||||
Completions: []TaskCompletion{{BaseModel: BaseModel{ID: 1}}},
|
||||
},
|
||||
expected: "completed_tasks",
|
||||
},
|
||||
|
||||
// Priority 3: In Progress
|
||||
{
|
||||
name: "in progress takes priority over overdue",
|
||||
task: &Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: timePtr(yesterday),
|
||||
InProgress: true,
|
||||
},
|
||||
expected: "in_progress_tasks",
|
||||
},
|
||||
|
||||
// Priority 4: Overdue
|
||||
{
|
||||
name: "overdue: effective date in past",
|
||||
task: &Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: timePtr(yesterday),
|
||||
},
|
||||
expected: "overdue_tasks",
|
||||
},
|
||||
|
||||
// Priority 5: Due Soon
|
||||
{
|
||||
name: "due soon: within 30-day threshold",
|
||||
task: &Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: timePtr(in5Days),
|
||||
},
|
||||
expected: "due_soon_tasks",
|
||||
},
|
||||
|
||||
// Priority 6: Upcoming
|
||||
{
|
||||
name: "upcoming: beyond threshold",
|
||||
task: &Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: timePtr(in60Days),
|
||||
},
|
||||
expected: "upcoming_tasks",
|
||||
},
|
||||
{
|
||||
name: "upcoming: no due date",
|
||||
task: &Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: nil,
|
||||
DueDate: nil,
|
||||
},
|
||||
expected: "upcoming_tasks",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.task.GetKanbanColumnWithTimezone(30, now)
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTask_GetKanbanColumnWithTimezone_TimezoneAware(t *testing.T) {
|
||||
// Task due Dec 17, 2025
|
||||
taskDueDate := time.Date(2025, 12, 17, 0, 0, 0, 0, time.UTC)
|
||||
|
||||
task := &Task{
|
||||
NextDueDate: timePtr(taskDueDate),
|
||||
IsCancelled: false,
|
||||
}
|
||||
|
||||
// At 11 PM UTC on Dec 16 (UTC user) - task is tomorrow, due_soon
|
||||
utcDec16Evening := time.Date(2025, 12, 16, 23, 0, 0, 0, time.UTC)
|
||||
result := task.GetKanbanColumnWithTimezone(30, utcDec16Evening)
|
||||
assert.Equal(t, "due_soon_tasks", result, "UTC Dec 16 evening")
|
||||
|
||||
// At 8 AM UTC on Dec 17 (UTC user) - task is today, due_soon
|
||||
utcDec17Morning := time.Date(2025, 12, 17, 8, 0, 0, 0, time.UTC)
|
||||
result = task.GetKanbanColumnWithTimezone(30, utcDec17Morning)
|
||||
assert.Equal(t, "due_soon_tasks", result, "UTC Dec 17 morning")
|
||||
|
||||
// At 8 AM UTC on Dec 18 (UTC user) - task was yesterday, overdue
|
||||
utcDec18Morning := time.Date(2025, 12, 18, 8, 0, 0, 0, time.UTC)
|
||||
result = task.GetKanbanColumnWithTimezone(30, utcDec18Morning)
|
||||
assert.Equal(t, "overdue_tasks", result, "UTC Dec 18 morning")
|
||||
|
||||
// Tokyo user at 11 PM UTC Dec 16 = 8 AM Dec 17 Tokyo
|
||||
// Task due Dec 17 is TODAY for Tokyo user - due_soon
|
||||
tokyo, _ := time.LoadLocation("Asia/Tokyo")
|
||||
tokyoDec17Morning := utcDec16Evening.In(tokyo)
|
||||
result = task.GetKanbanColumnWithTimezone(30, tokyoDec17Morning)
|
||||
assert.Equal(t, "due_soon_tasks", result, "Tokyo Dec 17 morning")
|
||||
|
||||
// Tokyo at 8 AM Dec 18 UTC = 5 PM Dec 18 Tokyo
|
||||
// Task due Dec 17 was YESTERDAY for Tokyo - overdue
|
||||
tokyoDec18 := utcDec18Morning.In(tokyo)
|
||||
result = task.GetKanbanColumnWithTimezone(30, tokyoDec18)
|
||||
assert.Equal(t, "overdue_tasks", result, "Tokyo Dec 18")
|
||||
}
|
||||
|
||||
func TestTask_GetKanbanColumnWithTimezone_DueSoonThreshold(t *testing.T) {
|
||||
now := time.Date(2025, 12, 16, 12, 0, 0, 0, time.UTC)
|
||||
|
||||
// Task due in 29 days - within 30-day threshold
|
||||
due29Days := time.Date(2026, 1, 14, 0, 0, 0, 0, time.UTC)
|
||||
task29 := &Task{NextDueDate: timePtr(due29Days)}
|
||||
result := task29.GetKanbanColumnWithTimezone(30, now)
|
||||
assert.Equal(t, "due_soon_tasks", result, "29 days should be due_soon")
|
||||
|
||||
// Task due in exactly 30 days - at threshold boundary (upcoming, not due_soon)
|
||||
due30Days := time.Date(2026, 1, 15, 0, 0, 0, 0, time.UTC)
|
||||
task30 := &Task{NextDueDate: timePtr(due30Days)}
|
||||
result = task30.GetKanbanColumnWithTimezone(30, now)
|
||||
assert.Equal(t, "upcoming_tasks", result, "30 days should be upcoming (at boundary)")
|
||||
|
||||
// Task due in 31 days - beyond threshold
|
||||
due31Days := time.Date(2026, 1, 16, 0, 0, 0, 0, time.UTC)
|
||||
task31 := &Task{NextDueDate: timePtr(due31Days)}
|
||||
result = task31.GetKanbanColumnWithTimezone(30, now)
|
||||
assert.Equal(t, "upcoming_tasks", result, "31 days should be upcoming")
|
||||
}
|
||||
|
||||
func TestTask_GetKanbanColumn_CompletionCount(t *testing.T) {
|
||||
// Test that CompletionCount is also used for completion detection
|
||||
task := &Task{
|
||||
NextDueDate: nil,
|
||||
CompletionCount: 1, // Using CompletionCount instead of Completions slice
|
||||
Completions: []TaskCompletion{},
|
||||
}
|
||||
|
||||
result := task.GetKanbanColumn(30)
|
||||
assert.Equal(t, "completed_tasks", result)
|
||||
}
|
||||
|
||||
func TestTask_IsOverdueAt_DayBased(t *testing.T) {
|
||||
// Test that IsOverdueAt uses day-based comparison
|
||||
now := time.Date(2025, 12, 16, 15, 0, 0, 0, time.UTC) // 3 PM UTC
|
||||
|
||||
// Task due today (midnight) - NOT overdue
|
||||
todayMidnight := time.Date(2025, 12, 16, 0, 0, 0, 0, time.UTC)
|
||||
taskToday := &Task{NextDueDate: timePtr(todayMidnight)}
|
||||
assert.False(t, taskToday.IsOverdueAt(now), "Task due today should NOT be overdue")
|
||||
|
||||
// Task due yesterday - IS overdue
|
||||
yesterday := time.Date(2025, 12, 15, 0, 0, 0, 0, time.UTC)
|
||||
taskYesterday := &Task{NextDueDate: timePtr(yesterday)}
|
||||
assert.True(t, taskYesterday.IsOverdueAt(now), "Task due yesterday should be overdue")
|
||||
|
||||
// Task due tomorrow - NOT overdue
|
||||
tomorrow := time.Date(2025, 12, 17, 0, 0, 0, 0, time.UTC)
|
||||
taskTomorrow := &Task{NextDueDate: timePtr(tomorrow)}
|
||||
assert.False(t, taskTomorrow.IsOverdueAt(now), "Task due tomorrow should NOT be overdue")
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user