Consolidate task logic into single source of truth (DRY refactor)
This refactor eliminates duplicate task logic across the codebase by creating a centralized task package with three layers: - predicates/: Pure Go functions defining task state logic (IsCompleted, IsOverdue, IsDueSoon, IsUpcoming, IsActive, IsInProgress, EffectiveDate) - scopes/: GORM scope functions mirroring predicates for database queries - categorization/: Chain of Responsibility pattern for kanban column assignment Key fixes: - Fixed PostgreSQL DATE vs TIMESTAMP comparison bug in scopes (added explicit ::timestamp casts) that caused summary/kanban count mismatches - Fixed models/task.go IsOverdue() and IsDueSoon() to use EffectiveDate (NextDueDate ?? DueDate) instead of only DueDate - Removed duplicate isTaskCompleted() helpers from task_repo.go and task_button_types.go Files refactored to use consolidated logic: - task_repo.go: Uses scopes for statistics, predicates for filtering - task_button_types.go: Uses predicates instead of inline logic - responses/task.go: Delegates to categorization package - dashboard_handler.go: Uses scopes for task statistics - residence_service.go: Uses predicates for report generation - worker/jobs/handler.go: Documented SQL with predicate references Added comprehensive tests: - predicates_test.go: Unit tests for all predicate functions - scopes_test.go: Integration tests verifying scopes match predicates - consistency_test.go: Three-layer consistency tests ensuring predicates, scopes, and categorization all return identical results 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Trey t
@@ -1,12 +1,11 @@
|
||||
package categorization
|
||||
package categorization_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"github.com/treytartt/casera-api/internal/models"
|
||||
"github.com/treytartt/casera-api/internal/task/categorization"
|
||||
)
|
||||
|
||||
// Helper to create a time pointer
|
||||
@@ -14,362 +13,224 @@ func timePtr(t time.Time) *time.Time {
|
||||
return &t
|
||||
}
|
||||
|
||||
// Helper to create a uint pointer
|
||||
func uintPtr(v uint) *uint {
|
||||
return &v
|
||||
}
|
||||
func TestCategorizeTask_PriorityOrder(t *testing.T) {
|
||||
now := time.Now().UTC()
|
||||
yesterday := now.AddDate(0, 0, -1)
|
||||
in5Days := now.AddDate(0, 0, 5)
|
||||
in60Days := now.AddDate(0, 0, 60)
|
||||
inProgressStatus := &models.TaskStatus{Name: "In Progress"}
|
||||
daysThreshold := 30
|
||||
|
||||
// Helper to create a completion with an ID
|
||||
func makeCompletion(id uint) models.TaskCompletion {
|
||||
c := models.TaskCompletion{CompletedAt: time.Now()}
|
||||
c.ID = id
|
||||
return c
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
task *models.Task
|
||||
expected categorization.KanbanColumn
|
||||
}{
|
||||
// Priority 1: Cancelled
|
||||
{
|
||||
name: "cancelled takes priority over everything",
|
||||
task: &models.Task{
|
||||
IsCancelled: true,
|
||||
NextDueDate: timePtr(yesterday), // Would be overdue
|
||||
Status: inProgressStatus, // Would be in progress
|
||||
Completions: []models.TaskCompletion{{BaseModel: models.BaseModel{ID: 1}}}, // Would be completed if NextDueDate was nil
|
||||
},
|
||||
expected: categorization.ColumnCancelled,
|
||||
},
|
||||
|
||||
// Helper to create a task with an ID
|
||||
func makeTask(id uint) models.Task {
|
||||
t := models.Task{}
|
||||
t.ID = id
|
||||
return t
|
||||
}
|
||||
// Priority 2: Completed
|
||||
{
|
||||
name: "completed: NextDueDate nil with completions",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: nil,
|
||||
DueDate: timePtr(yesterday), // Would be overdue if not completed
|
||||
Completions: []models.TaskCompletion{{BaseModel: models.BaseModel{ID: 1}}},
|
||||
},
|
||||
expected: categorization.ColumnCompleted,
|
||||
},
|
||||
{
|
||||
name: "not completed when NextDueDate set (recurring task with completions)",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: timePtr(in5Days),
|
||||
Completions: []models.TaskCompletion{{BaseModel: models.BaseModel{ID: 1}}},
|
||||
},
|
||||
expected: categorization.ColumnDueSoon, // Falls through to due soon
|
||||
},
|
||||
|
||||
func TestCancelledHandler(t *testing.T) {
|
||||
chain := NewChain()
|
||||
// Priority 3: In Progress
|
||||
{
|
||||
name: "in progress takes priority over overdue",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: timePtr(yesterday), // Would be overdue
|
||||
Status: inProgressStatus,
|
||||
Completions: []models.TaskCompletion{},
|
||||
},
|
||||
expected: categorization.ColumnInProgress,
|
||||
},
|
||||
|
||||
t.Run("cancelled task goes to cancelled column", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
IsCancelled: true,
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnCancelled, result)
|
||||
})
|
||||
// Priority 4: Overdue
|
||||
{
|
||||
name: "overdue: effective date in past",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: timePtr(yesterday),
|
||||
Completions: []models.TaskCompletion{},
|
||||
},
|
||||
expected: categorization.ColumnOverdue,
|
||||
},
|
||||
{
|
||||
name: "overdue: uses DueDate when NextDueDate nil (no completions)",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: nil,
|
||||
DueDate: timePtr(yesterday),
|
||||
Completions: []models.TaskCompletion{},
|
||||
},
|
||||
expected: categorization.ColumnOverdue,
|
||||
},
|
||||
|
||||
t.Run("cancelled task with due date still goes to cancelled", func(t *testing.T) {
|
||||
dueDate := time.Now().AddDate(0, 0, -10) // 10 days ago (overdue)
|
||||
task := &models.Task{
|
||||
IsCancelled: true,
|
||||
DueDate: &dueDate,
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnCancelled, result)
|
||||
})
|
||||
}
|
||||
// Priority 5: Due Soon
|
||||
{
|
||||
name: "due soon: within threshold",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: timePtr(in5Days),
|
||||
Completions: []models.TaskCompletion{},
|
||||
},
|
||||
expected: categorization.ColumnDueSoon,
|
||||
},
|
||||
|
||||
func TestCompletedHandler(t *testing.T) {
|
||||
chain := NewChain()
|
||||
// Priority 6: Upcoming (default)
|
||||
{
|
||||
name: "upcoming: beyond threshold",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: timePtr(in60Days),
|
||||
Completions: []models.TaskCompletion{},
|
||||
},
|
||||
expected: categorization.ColumnUpcoming,
|
||||
},
|
||||
{
|
||||
name: "upcoming: no due date",
|
||||
task: &models.Task{
|
||||
IsCancelled: false,
|
||||
IsArchived: false,
|
||||
NextDueDate: nil,
|
||||
DueDate: nil,
|
||||
Completions: []models.TaskCompletion{},
|
||||
},
|
||||
expected: categorization.ColumnUpcoming,
|
||||
},
|
||||
}
|
||||
|
||||
t.Run("one-time task with completion and no next_due_date goes to completed", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
NextDueDate: nil,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnCompleted, result)
|
||||
})
|
||||
|
||||
t.Run("recurring task with completion but has next_due_date does NOT go to completed", func(t *testing.T) {
|
||||
nextDue := time.Now().AddDate(0, 0, 30)
|
||||
task := &models.Task{
|
||||
NextDueDate: &nextDue,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
// Should go to due_soon or upcoming, not completed
|
||||
assert.NotEqual(t, ColumnCompleted, result)
|
||||
})
|
||||
|
||||
t.Run("task with no completions does not go to completed", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
NextDueDate: nil,
|
||||
Completions: []models.TaskCompletion{},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.NotEqual(t, ColumnCompleted, result)
|
||||
})
|
||||
}
|
||||
|
||||
func TestInProgressHandler(t *testing.T) {
|
||||
chain := NewChain()
|
||||
|
||||
t.Run("task with In Progress status goes to in_progress column", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
Status: &models.TaskStatus{Name: "In Progress"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnInProgress, result)
|
||||
})
|
||||
|
||||
t.Run("task with Pending status does not go to in_progress", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.NotEqual(t, ColumnInProgress, result)
|
||||
})
|
||||
|
||||
t.Run("task with nil status does not go to in_progress", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
Status: nil,
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.NotEqual(t, ColumnInProgress, result)
|
||||
})
|
||||
}
|
||||
|
||||
func TestOverdueHandler(t *testing.T) {
|
||||
chain := NewChain()
|
||||
|
||||
t.Run("task with past next_due_date goes to overdue", func(t *testing.T) {
|
||||
pastDate := time.Now().AddDate(0, 0, -5) // 5 days ago
|
||||
task := &models.Task{
|
||||
NextDueDate: &pastDate,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnOverdue, result)
|
||||
})
|
||||
|
||||
t.Run("task with past due_date (no next_due_date) goes to overdue", func(t *testing.T) {
|
||||
pastDate := time.Now().AddDate(0, 0, -5) // 5 days ago
|
||||
task := &models.Task{
|
||||
DueDate: &pastDate,
|
||||
NextDueDate: nil,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnOverdue, result)
|
||||
})
|
||||
|
||||
t.Run("next_due_date takes precedence over due_date", func(t *testing.T) {
|
||||
pastDueDate := time.Now().AddDate(0, 0, -10) // 10 days ago
|
||||
futureNextDue := time.Now().AddDate(0, 0, 60) // 60 days from now
|
||||
task := &models.Task{
|
||||
DueDate: &pastDueDate,
|
||||
NextDueDate: &futureNextDue,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
// Should be upcoming (60 days > 30 day threshold), not overdue
|
||||
assert.Equal(t, ColumnUpcoming, result)
|
||||
})
|
||||
}
|
||||
|
||||
func TestDueSoonHandler(t *testing.T) {
|
||||
chain := NewChain()
|
||||
|
||||
t.Run("task due within threshold goes to due_soon", func(t *testing.T) {
|
||||
dueDate := time.Now().AddDate(0, 0, 15) // 15 days from now
|
||||
task := &models.Task{
|
||||
NextDueDate: &dueDate,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30) // 30 day threshold
|
||||
assert.Equal(t, ColumnDueSoon, result)
|
||||
})
|
||||
|
||||
t.Run("task due exactly at threshold goes to due_soon", func(t *testing.T) {
|
||||
dueDate := time.Now().AddDate(0, 0, 29) // Just under 30 days
|
||||
task := &models.Task{
|
||||
NextDueDate: &dueDate,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnDueSoon, result)
|
||||
})
|
||||
|
||||
t.Run("custom threshold is respected", func(t *testing.T) {
|
||||
dueDate := time.Now().AddDate(0, 0, 10) // 10 days from now
|
||||
task := &models.Task{
|
||||
NextDueDate: &dueDate,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
// With 7 day threshold, 10 days out should be upcoming, not due_soon
|
||||
result := chain.Categorize(task, 7)
|
||||
assert.Equal(t, ColumnUpcoming, result)
|
||||
})
|
||||
}
|
||||
|
||||
func TestUpcomingHandler(t *testing.T) {
|
||||
chain := NewChain()
|
||||
|
||||
t.Run("task with future next_due_date beyond threshold goes to upcoming", func(t *testing.T) {
|
||||
futureDate := time.Now().AddDate(0, 0, 60) // 60 days from now
|
||||
task := &models.Task{
|
||||
NextDueDate: &futureDate,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnUpcoming, result)
|
||||
})
|
||||
|
||||
t.Run("task with no due date goes to upcoming (default)", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
DueDate: nil,
|
||||
NextDueDate: nil,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnUpcoming, result)
|
||||
})
|
||||
}
|
||||
|
||||
func TestChainPriorityOrder(t *testing.T) {
|
||||
chain := NewChain()
|
||||
|
||||
t.Run("cancelled takes priority over everything", func(t *testing.T) {
|
||||
pastDate := time.Now().AddDate(0, 0, -10)
|
||||
task := &models.Task{
|
||||
IsCancelled: true,
|
||||
DueDate: &pastDate,
|
||||
NextDueDate: nil,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
Status: &models.TaskStatus{Name: "In Progress"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnCancelled, result)
|
||||
})
|
||||
|
||||
t.Run("completed takes priority over in_progress", func(t *testing.T) {
|
||||
task := &models.Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: nil,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
Status: &models.TaskStatus{Name: "In Progress"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnCompleted, result)
|
||||
})
|
||||
|
||||
t.Run("in_progress takes priority over overdue", func(t *testing.T) {
|
||||
pastDate := time.Now().AddDate(0, 0, -10)
|
||||
task := &models.Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: &pastDate,
|
||||
Status: &models.TaskStatus{Name: "In Progress"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnInProgress, result)
|
||||
})
|
||||
|
||||
t.Run("overdue takes priority over due_soon", func(t *testing.T) {
|
||||
pastDate := time.Now().AddDate(0, 0, -1)
|
||||
task := &models.Task{
|
||||
IsCancelled: false,
|
||||
NextDueDate: &pastDate,
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnOverdue, result)
|
||||
})
|
||||
}
|
||||
|
||||
func TestRecurringTaskScenarios(t *testing.T) {
|
||||
chain := NewChain()
|
||||
|
||||
t.Run("annual task just completed should go to upcoming (next_due_date is 1 year out)", func(t *testing.T) {
|
||||
nextYear := time.Now().AddDate(1, 0, 0)
|
||||
task := &models.Task{
|
||||
NextDueDate: &nextYear,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
Status: &models.TaskStatus{Name: "Pending"}, // Reset after completion
|
||||
Frequency: &models.TaskFrequency{Name: "Annually", Days: intPtr(365)},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnUpcoming, result)
|
||||
})
|
||||
|
||||
t.Run("monthly task due in 2 weeks should go to due_soon", func(t *testing.T) {
|
||||
twoWeeks := time.Now().AddDate(0, 0, 14)
|
||||
task := &models.Task{
|
||||
NextDueDate: &twoWeeks,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
Frequency: &models.TaskFrequency{Name: "Monthly", Days: intPtr(30)},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnDueSoon, result)
|
||||
})
|
||||
|
||||
t.Run("weekly task that is overdue should go to overdue", func(t *testing.T) {
|
||||
yesterday := time.Now().AddDate(0, 0, -1)
|
||||
task := &models.Task{
|
||||
NextDueDate: &yesterday,
|
||||
Completions: []models.TaskCompletion{makeCompletion(1)},
|
||||
Status: &models.TaskStatus{Name: "Pending"},
|
||||
Frequency: &models.TaskFrequency{Name: "Weekly", Days: intPtr(7)},
|
||||
}
|
||||
result := chain.Categorize(task, 30)
|
||||
assert.Equal(t, ColumnOverdue, result)
|
||||
})
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := categorization.CategorizeTask(tt.task, daysThreshold)
|
||||
if result != tt.expected {
|
||||
t.Errorf("CategorizeTask() = %v, expected %v", result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCategorizeTasksIntoColumns(t *testing.T) {
|
||||
now := time.Now()
|
||||
pastDate := now.AddDate(0, 0, -5)
|
||||
soonDate := now.AddDate(0, 0, 15)
|
||||
futureDate := now.AddDate(0, 0, 60)
|
||||
now := time.Now().UTC()
|
||||
yesterday := now.AddDate(0, 0, -1)
|
||||
in5Days := now.AddDate(0, 0, 5)
|
||||
in60Days := now.AddDate(0, 0, 60)
|
||||
daysThreshold := 30
|
||||
|
||||
// Create tasks with proper IDs
|
||||
task1 := makeTask(1)
|
||||
task1.IsCancelled = true
|
||||
tasks := []models.Task{
|
||||
{BaseModel: models.BaseModel{ID: 1}, IsCancelled: true}, // Cancelled
|
||||
{BaseModel: models.BaseModel{ID: 2}, NextDueDate: nil, Completions: []models.TaskCompletion{{BaseModel: models.BaseModel{ID: 1}}}}, // Completed
|
||||
{BaseModel: models.BaseModel{ID: 3}, Status: &models.TaskStatus{Name: "In Progress"}}, // In Progress
|
||||
{BaseModel: models.BaseModel{ID: 4}, NextDueDate: timePtr(yesterday)}, // Overdue
|
||||
{BaseModel: models.BaseModel{ID: 5}, NextDueDate: timePtr(in5Days)}, // Due Soon
|
||||
{BaseModel: models.BaseModel{ID: 6}, NextDueDate: timePtr(in60Days)}, // Upcoming
|
||||
{BaseModel: models.BaseModel{ID: 7}}, // Upcoming (no due date)
|
||||
}
|
||||
|
||||
task2 := makeTask(2)
|
||||
task2.NextDueDate = nil
|
||||
task2.Completions = []models.TaskCompletion{makeCompletion(1)}
|
||||
result := categorization.CategorizeTasksIntoColumns(tasks, daysThreshold)
|
||||
|
||||
task3 := makeTask(3)
|
||||
task3.Status = &models.TaskStatus{Name: "In Progress"}
|
||||
|
||||
task4 := makeTask(4)
|
||||
task4.NextDueDate = &pastDate
|
||||
task4.Status = &models.TaskStatus{Name: "Pending"}
|
||||
|
||||
task5 := makeTask(5)
|
||||
task5.NextDueDate = &soonDate
|
||||
task5.Status = &models.TaskStatus{Name: "Pending"}
|
||||
|
||||
task6 := makeTask(6)
|
||||
task6.NextDueDate = &futureDate
|
||||
task6.Status = &models.TaskStatus{Name: "Pending"}
|
||||
|
||||
tasks := []models.Task{task1, task2, task3, task4, task5, task6}
|
||||
|
||||
result := CategorizeTasksIntoColumns(tasks, 30)
|
||||
|
||||
assert.Len(t, result[ColumnCancelled], 1)
|
||||
assert.Equal(t, uint(1), result[ColumnCancelled][0].ID)
|
||||
|
||||
assert.Len(t, result[ColumnCompleted], 1)
|
||||
assert.Equal(t, uint(2), result[ColumnCompleted][0].ID)
|
||||
|
||||
assert.Len(t, result[ColumnInProgress], 1)
|
||||
assert.Equal(t, uint(3), result[ColumnInProgress][0].ID)
|
||||
|
||||
assert.Len(t, result[ColumnOverdue], 1)
|
||||
assert.Equal(t, uint(4), result[ColumnOverdue][0].ID)
|
||||
|
||||
assert.Len(t, result[ColumnDueSoon], 1)
|
||||
assert.Equal(t, uint(5), result[ColumnDueSoon][0].ID)
|
||||
|
||||
assert.Len(t, result[ColumnUpcoming], 1)
|
||||
assert.Equal(t, uint(6), result[ColumnUpcoming][0].ID)
|
||||
// Check each column has the expected tasks
|
||||
if len(result[categorization.ColumnCancelled]) != 1 || result[categorization.ColumnCancelled][0].ID != 1 {
|
||||
t.Errorf("Expected task 1 in Cancelled column")
|
||||
}
|
||||
if len(result[categorization.ColumnCompleted]) != 1 || result[categorization.ColumnCompleted][0].ID != 2 {
|
||||
t.Errorf("Expected task 2 in Completed column")
|
||||
}
|
||||
if len(result[categorization.ColumnInProgress]) != 1 || result[categorization.ColumnInProgress][0].ID != 3 {
|
||||
t.Errorf("Expected task 3 in InProgress column")
|
||||
}
|
||||
if len(result[categorization.ColumnOverdue]) != 1 || result[categorization.ColumnOverdue][0].ID != 4 {
|
||||
t.Errorf("Expected task 4 in Overdue column")
|
||||
}
|
||||
if len(result[categorization.ColumnDueSoon]) != 1 || result[categorization.ColumnDueSoon][0].ID != 5 {
|
||||
t.Errorf("Expected task 5 in DueSoon column")
|
||||
}
|
||||
if len(result[categorization.ColumnUpcoming]) != 2 {
|
||||
t.Errorf("Expected 2 tasks in Upcoming column, got %d", len(result[categorization.ColumnUpcoming]))
|
||||
}
|
||||
}
|
||||
|
||||
func TestDefaultThreshold(t *testing.T) {
|
||||
func TestDetermineKanbanColumn_ReturnsString(t *testing.T) {
|
||||
task := &models.Task{IsCancelled: true}
|
||||
result := categorization.DetermineKanbanColumn(task, 30)
|
||||
|
||||
if result != "cancelled_tasks" {
|
||||
t.Errorf("DetermineKanbanColumn() = %v, expected %v", result, "cancelled_tasks")
|
||||
}
|
||||
}
|
||||
|
||||
func TestKanbanColumnConstants(t *testing.T) {
|
||||
// Verify column string values match expected API values
|
||||
tests := []struct {
|
||||
column categorization.KanbanColumn
|
||||
expected string
|
||||
}{
|
||||
{categorization.ColumnOverdue, "overdue_tasks"},
|
||||
{categorization.ColumnDueSoon, "due_soon_tasks"},
|
||||
{categorization.ColumnUpcoming, "upcoming_tasks"},
|
||||
{categorization.ColumnInProgress, "in_progress_tasks"},
|
||||
{categorization.ColumnCompleted, "completed_tasks"},
|
||||
{categorization.ColumnCancelled, "cancelled_tasks"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
if tt.column.String() != tt.expected {
|
||||
t.Errorf("Column %v.String() = %v, expected %v", tt.column, tt.column.String(), tt.expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewContext_DefaultThreshold(t *testing.T) {
|
||||
task := &models.Task{}
|
||||
|
||||
// Test that 0 or negative threshold defaults to 30
|
||||
ctx1 := NewContext(task, 0)
|
||||
assert.Equal(t, 30, ctx1.DaysThreshold)
|
||||
// Zero threshold should default to 30
|
||||
ctx := categorization.NewContext(task, 0)
|
||||
if ctx.DaysThreshold != 30 {
|
||||
t.Errorf("NewContext with 0 threshold should default to 30, got %d", ctx.DaysThreshold)
|
||||
}
|
||||
|
||||
ctx2 := NewContext(task, -5)
|
||||
assert.Equal(t, 30, ctx2.DaysThreshold)
|
||||
// Negative threshold should default to 30
|
||||
ctx = categorization.NewContext(task, -5)
|
||||
if ctx.DaysThreshold != 30 {
|
||||
t.Errorf("NewContext with negative threshold should default to 30, got %d", ctx.DaysThreshold)
|
||||
}
|
||||
|
||||
ctx3 := NewContext(task, 14)
|
||||
assert.Equal(t, 14, ctx3.DaysThreshold)
|
||||
}
|
||||
|
||||
// Helper to create int pointer
|
||||
func intPtr(v int) *int {
|
||||
return &v
|
||||
// Positive threshold should be used
|
||||
ctx = categorization.NewContext(task, 45)
|
||||
if ctx.DaysThreshold != 45 {
|
||||
t.Errorf("NewContext with 45 threshold should be 45, got %d", ctx.DaysThreshold)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user