4c9a818bd9
Predicates (20 cases): IsRecurring, IsOneTime, IsDueSoon, HasCompletions, GetCompletionCount, IsUpcoming edge cases Task creation (10): NextDueDate initialization, all frequency types, past dates, all optional fields, access validation One-time completion (8): NextDueDate→nil, InProgress reset, notes/cost/rating, double completion, backdated completed_at Recurring completion (16): Daily/Weekly/BiWeekly/Monthly/Quarterly/ Yearly/Custom frequencies, late/early completion timing, multiple sequential completions, no-original-DueDate, CompletedFromColumn capture QuickComplete (5): one-time, recurring, widget notes, 404, 403 State transitions (10): Cancel→Complete, Archive→Complete, InProgress cycles, recurring full lifecycle, Archive→Unarchive column restore Kanban column priority (7): verify chain priority order for all columns Optimistic locking (7): correct/stale version, conflict on complete/ cancel/archive/mark-in-progress, rollback verification Deletion (5): single/multi/middle completion deletion, NextDueDate recalculation, InProgress restore behavior documented Edge cases (9): boundary dates, late/early recurring, nil/zero frequency days, custom intervals, version conflicts Handler validation (4): rating bounds, title/description length, custom interval validation All 679 tests pass.
3049 lines
109 KiB
Go
3049 lines
109 KiB
Go
package services
|
|
|
|
import (
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/shopspring/decimal"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/treytartt/honeydue-api/internal/dto/requests"
|
|
"github.com/treytartt/honeydue-api/internal/models"
|
|
"github.com/treytartt/honeydue-api/internal/repositories"
|
|
"github.com/treytartt/honeydue-api/internal/testutil"
|
|
)
|
|
|
|
func setupTaskService(t *testing.T) (*TaskService, *repositories.TaskRepository, *repositories.ResidenceRepository) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
return service, taskRepo, residenceRepo
|
|
}
|
|
|
|
func TestTaskService_CreateTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Fix leaky faucet",
|
|
Description: "Kitchen faucet is dripping",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotZero(t, resp.Data.ID)
|
|
assert.Equal(t, "Fix leaky faucet", resp.Data.Title)
|
|
assert.Equal(t, "Kitchen faucet is dripping", resp.Data.Description)
|
|
}
|
|
|
|
func TestTaskService_CreateTask_WithOptionalFields(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
// Get category and priority IDs
|
|
var category models.TaskCategory
|
|
var priority models.TaskPriority
|
|
db.First(&category)
|
|
db.First(&priority)
|
|
|
|
dueDate := requests.FlexibleDate{Time: time.Now().Add(7 * 24 * time.Hour).UTC()}
|
|
cost := decimal.NewFromFloat(150.50)
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Fix leaky faucet",
|
|
CategoryID: &category.ID,
|
|
PriorityID: &priority.ID,
|
|
DueDate: &dueDate,
|
|
EstimatedCost: &cost,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
// Note: Category and Priority are no longer preloaded for performance
|
|
// Client resolves from cache using CategoryID and PriorityID
|
|
assert.NotNil(t, resp.Data.CategoryID, "CategoryID should be set")
|
|
assert.NotNil(t, resp.Data.PriorityID, "PriorityID should be set")
|
|
assert.NotNil(t, resp.Data.DueDate)
|
|
assert.NotNil(t, resp.Data.EstimatedCost)
|
|
}
|
|
|
|
func TestTaskService_CreateTask_AccessDenied(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
owner := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
otherUser := testutil.CreateTestUser(t, db, "other", "other@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, owner.ID, "Test House")
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Test Task",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
_, err := service.CreateTask(req, otherUser.ID, now)
|
|
// When creating a task, residence access is checked first
|
|
testutil.AssertAppError(t, err, http.StatusForbidden, "error.residence_access_denied")
|
|
}
|
|
|
|
func TestTaskService_GetTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
resp, err := service.GetTask(task.ID, user.ID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, task.ID, resp.ID)
|
|
assert.Equal(t, "Test Task", resp.Title)
|
|
}
|
|
|
|
func TestTaskService_GetTask_AccessDenied(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
owner := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
otherUser := testutil.CreateTestUser(t, db, "other", "other@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, owner.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, owner.ID, "Test Task")
|
|
|
|
_, err := service.GetTask(task.ID, otherUser.ID)
|
|
testutil.AssertAppError(t, err, http.StatusForbidden, "error.task_access_denied")
|
|
}
|
|
|
|
func TestTaskService_ListTasks(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
testutil.CreateTestTask(t, db, residence.ID, user.ID, "Task 1")
|
|
testutil.CreateTestTask(t, db, residence.ID, user.ID, "Task 2")
|
|
testutil.CreateTestTask(t, db, residence.ID, user.ID, "Task 3")
|
|
|
|
resp, err := service.ListTasks(user.ID, 30, time.Now().UTC())
|
|
require.NoError(t, err)
|
|
// ListTasks returns a KanbanBoardResponse with columns
|
|
// Count total tasks across all columns
|
|
totalTasks := 0
|
|
for _, col := range resp.Columns {
|
|
totalTasks += col.Count
|
|
}
|
|
assert.Equal(t, 3, totalTasks)
|
|
}
|
|
|
|
func TestTaskService_UpdateTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Original Title")
|
|
|
|
newTitle := "Updated Title"
|
|
newDesc := "Updated description"
|
|
req := &requests.UpdateTaskRequest{
|
|
Title: &newTitle,
|
|
Description: &newDesc,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.UpdateTask(task.ID, user.ID, req, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Updated Title", resp.Data.Title)
|
|
assert.Equal(t, "Updated description", resp.Data.Description)
|
|
}
|
|
|
|
func TestTaskService_DeleteTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
_, err := service.DeleteTask(task.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
_, err = service.GetTask(task.ID, user.ID)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestTaskService_CancelTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CancelTask(task.ID, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.True(t, resp.Data.IsCancelled)
|
|
}
|
|
|
|
func TestTaskService_CancelTask_AlreadyCancelled(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
now := time.Now().UTC()
|
|
service.CancelTask(task.ID, user.ID, now)
|
|
_, err := service.CancelTask(task.ID, user.ID, now)
|
|
testutil.AssertAppError(t, err, http.StatusBadRequest, "error.task_already_cancelled")
|
|
}
|
|
|
|
func TestTaskService_UncancelTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
now := time.Now().UTC()
|
|
service.CancelTask(task.ID, user.ID, now)
|
|
resp, err := service.UncancelTask(task.ID, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.False(t, resp.Data.IsCancelled)
|
|
}
|
|
|
|
func TestTaskService_ArchiveTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.ArchiveTask(task.ID, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.True(t, resp.Data.IsArchived)
|
|
}
|
|
|
|
func TestTaskService_UnarchiveTask(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
now := time.Now().UTC()
|
|
service.ArchiveTask(task.ID, user.ID, now)
|
|
resp, err := service.UnarchiveTask(task.ID, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.False(t, resp.Data.IsArchived)
|
|
}
|
|
|
|
func TestTaskService_MarkInProgress(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.MarkInProgress(task.ID, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.True(t, resp.Data.InProgress)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
req := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Completed successfully",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateCompletion(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotZero(t, resp.Data.ID)
|
|
assert.Equal(t, task.ID, resp.Data.TaskID)
|
|
assert.Equal(t, "Completed successfully", resp.Data.Notes)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_RecurringTask_ResetsInProgress(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var monthlyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Monthly").First(&monthlyFrequency)
|
|
|
|
// Create a recurring task that is in progress
|
|
dueDate := time.Now().AddDate(0, 0, 7) // Due in 7 days
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Recurring Task",
|
|
InProgress: true,
|
|
FrequencyID: &monthlyFrequency.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete the task
|
|
req := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Monthly maintenance done",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateCompletion(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotZero(t, resp.Data.ID)
|
|
|
|
// Verify the task in the response has InProgress reset to false
|
|
require.NotNil(t, resp.Data.Task, "Response should include the updated task")
|
|
assert.False(t, resp.Data.Task.InProgress, "Recurring task InProgress should be reset to false after completion")
|
|
|
|
// Verify NextDueDate was updated (should be ~30 days from now for monthly)
|
|
require.NotNil(t, resp.Data.Task.NextDueDate, "Recurring task should have NextDueDate set")
|
|
expectedNextDue := time.Now().AddDate(0, 0, 30) // Monthly = 30 days
|
|
assert.WithinDuration(t, expectedNextDue, *resp.Data.Task.NextDueDate, 24*time.Hour, "NextDueDate should be approximately 30 days from now")
|
|
|
|
// Also verify by reloading from database directly
|
|
var reloadedTask models.Task
|
|
db.First(&reloadedTask, task.ID)
|
|
assert.False(t, reloadedTask.InProgress, "Database should show InProgress=false")
|
|
}
|
|
|
|
func TestTaskService_GetCompletion(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
completion := &models.TaskCompletion{
|
|
TaskID: task.ID,
|
|
CompletedByID: user.ID,
|
|
CompletedAt: time.Now().UTC(),
|
|
Notes: "Test notes",
|
|
}
|
|
db.Create(completion)
|
|
|
|
resp, err := service.GetCompletion(completion.ID, user.ID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, completion.ID, resp.ID)
|
|
assert.Equal(t, "Test notes", resp.Notes)
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Test Task")
|
|
|
|
completion := &models.TaskCompletion{
|
|
TaskID: task.ID,
|
|
CompletedByID: user.ID,
|
|
CompletedAt: time.Now().UTC(),
|
|
}
|
|
db.Create(completion)
|
|
|
|
_, err := service.DeleteCompletion(completion.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
_, err = service.GetCompletion(completion.ID, user.ID)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_TransactionIntegrity(t *testing.T) {
|
|
// Verifies P1-5 / P1-6: completion creation and task update are atomic.
|
|
// After completion, both the completion record AND the task's NextDueDate update
|
|
// should succeed together, and errors should be propagated (not swallowed).
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
// Create a one-time task with a due date
|
|
dueDate := time.Now().AddDate(0, 0, 7).UTC()
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "One-time Task",
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
req := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Done",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateCompletion(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotZero(t, resp.Data.ID)
|
|
|
|
// Verify the task was updated: NextDueDate should be nil for a one-time task
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.Nil(t, reloaded.NextDueDate, "One-time task NextDueDate should be nil after completion")
|
|
assert.False(t, reloaded.InProgress, "InProgress should be false after completion")
|
|
|
|
// Verify completion record exists
|
|
var completion models.TaskCompletion
|
|
err = db.Where("task_id = ?", task.ID).First(&completion).Error
|
|
require.NoError(t, err, "Completion record should exist")
|
|
assert.Equal(t, "Done", completion.Notes)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_UpdateError_ReturnedNotSwallowed(t *testing.T) {
|
|
// Verifies P1-5 and P1-6: the completion creation and task update are wrapped
|
|
// in a transaction, and update errors are returned (not swallowed).
|
|
//
|
|
// Strategy: We trigger a version conflict by using a goroutine that bumps
|
|
// the task version after the service reads the task but during the transaction.
|
|
// Since SQLite serializes writes, we instead verify the behavior by deleting
|
|
// the task between the service read and the transactional update. When UpdateTx
|
|
// tries to match the row by id+version, 0 rows are affected and ErrVersionConflict
|
|
// is returned. The transaction then rolls back the completion insert.
|
|
//
|
|
// However, because the entire CreateCompletion flow is synchronous and we cannot
|
|
// inject failures between steps, we instead verify the transactional guarantee
|
|
// indirectly: we confirm that a concurrent version bump (set before the call
|
|
// but after the SELECT) causes the version conflict to propagate. Since FindByID
|
|
// re-reads the current version, we must verify via a custom test that invokes
|
|
// the transaction layer directly.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := time.Now().AddDate(0, 0, 7).UTC()
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Conflict Task",
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Directly test that the transactional path returns an error on version conflict:
|
|
// Use a stale task object (version=1) when the DB has been bumped to version=999.
|
|
db.Model(&models.Task{}).Where("id = ?", task.ID).Update("version", 999)
|
|
|
|
completion := &models.TaskCompletion{
|
|
TaskID: task.ID,
|
|
CompletedByID: user.ID,
|
|
CompletedAt: time.Now().UTC(),
|
|
Notes: "Should be rolled back",
|
|
}
|
|
|
|
// Simulate the transaction that CreateCompletion now uses (task still has version=1)
|
|
txErr := taskRepo.DB().Transaction(func(tx *gorm.DB) error {
|
|
if err := taskRepo.CreateCompletionTx(tx, completion); err != nil {
|
|
return err
|
|
}
|
|
// task.Version is 1 but DB has 999 -> version conflict
|
|
if err := taskRepo.UpdateTx(tx, task); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
require.Error(t, txErr, "Transaction should fail due to version conflict")
|
|
assert.ErrorIs(t, txErr, repositories.ErrVersionConflict, "Error should be ErrVersionConflict")
|
|
|
|
// Verify the completion was rolled back
|
|
var count int64
|
|
db.Model(&models.TaskCompletion{}).Where("task_id = ?", task.ID).Count(&count)
|
|
assert.Equal(t, int64(0), count, "Completion should not exist when transaction rolls back")
|
|
|
|
// Also verify that CreateCompletion (full service method) would propagate the error.
|
|
// Re-create the task with a normal version so FindByID works, then bump it.
|
|
db.Model(&models.Task{}).Where("id = ?", task.ID).Update("version", 1)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
req := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Test error propagation",
|
|
}
|
|
now := time.Now().UTC()
|
|
// This call will succeed because FindByID loads version=1, UpdateTx uses version=1, DB has version=1.
|
|
// To verify error propagation, we use the direct transaction test above.
|
|
resp, err := service.CreateCompletion(req, user.ID, now)
|
|
require.NoError(t, err, "CreateCompletion should succeed with matching versions")
|
|
assert.NotZero(t, resp.Data.ID)
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_OneTime_RestoresOriginalDueDate(t *testing.T) {
|
|
// Verifies P1-7: deleting the only completion on a one-time task
|
|
// should restore NextDueDate to the original DueDate.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
// Create a one-time task with a due date
|
|
originalDueDate := time.Date(2026, 4, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "One-time Task",
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
// No FrequencyID = one-time task
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete the task (sets NextDueDate to nil for one-time tasks)
|
|
req := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Completed",
|
|
}
|
|
now := time.Now().UTC()
|
|
completionResp, err := service.CreateCompletion(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Confirm NextDueDate is nil after completion
|
|
var taskAfterComplete models.Task
|
|
db.First(&taskAfterComplete, task.ID)
|
|
assert.Nil(t, taskAfterComplete.NextDueDate, "NextDueDate should be nil after one-time completion")
|
|
|
|
// Delete the completion
|
|
_, err = service.DeleteCompletion(completionResp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// Verify NextDueDate is restored to the original DueDate
|
|
var taskAfterDelete models.Task
|
|
db.First(&taskAfterDelete, task.ID)
|
|
require.NotNil(t, taskAfterDelete.NextDueDate, "NextDueDate should be restored after deleting completion")
|
|
assert.Equal(t, originalDueDate.Year(), taskAfterDelete.NextDueDate.Year())
|
|
assert.Equal(t, originalDueDate.Month(), taskAfterDelete.NextDueDate.Month())
|
|
assert.Equal(t, originalDueDate.Day(), taskAfterDelete.NextDueDate.Day())
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_Recurring_RecalculatesFromLastCompletion(t *testing.T) {
|
|
// Verifies P1-7: deleting the latest completion on a recurring task
|
|
// should recalculate NextDueDate from the remaining latest completion.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var monthlyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Monthly").First(&monthlyFrequency)
|
|
|
|
// Create a recurring task
|
|
originalDueDate := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Recurring Task",
|
|
FrequencyID: &monthlyFrequency.ID,
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// First completion on Jan 15
|
|
firstCompletedAt := time.Date(2026, 1, 15, 10, 0, 0, 0, time.UTC)
|
|
firstReq := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "First completion",
|
|
CompletedAt: &firstCompletedAt,
|
|
}
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(firstReq, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Second completion on Feb 15
|
|
secondCompletedAt := time.Date(2026, 2, 15, 10, 0, 0, 0, time.UTC)
|
|
secondReq := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Second completion",
|
|
CompletedAt: &secondCompletedAt,
|
|
}
|
|
resp, err := service.CreateCompletion(secondReq, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// NextDueDate should be Feb 15 + 30 days = Mar 17
|
|
var taskAfterSecond models.Task
|
|
db.First(&taskAfterSecond, task.ID)
|
|
require.NotNil(t, taskAfterSecond.NextDueDate)
|
|
expectedAfterSecond := secondCompletedAt.AddDate(0, 0, 30)
|
|
assert.Equal(t, expectedAfterSecond.Year(), taskAfterSecond.NextDueDate.Year())
|
|
assert.Equal(t, expectedAfterSecond.Month(), taskAfterSecond.NextDueDate.Month())
|
|
assert.Equal(t, expectedAfterSecond.Day(), taskAfterSecond.NextDueDate.Day())
|
|
|
|
// Delete the second (latest) completion
|
|
_, err = service.DeleteCompletion(resp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// NextDueDate should be recalculated from the first completion: Jan 15 + 30 = Feb 14
|
|
var taskAfterDelete models.Task
|
|
db.First(&taskAfterDelete, task.ID)
|
|
require.NotNil(t, taskAfterDelete.NextDueDate, "NextDueDate should be set after deleting latest completion")
|
|
expectedRecalculated := firstCompletedAt.AddDate(0, 0, 30)
|
|
assert.Equal(t, expectedRecalculated.Year(), taskAfterDelete.NextDueDate.Year())
|
|
assert.Equal(t, expectedRecalculated.Month(), taskAfterDelete.NextDueDate.Month())
|
|
assert.Equal(t, expectedRecalculated.Day(), taskAfterDelete.NextDueDate.Day())
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_LastCompletion_RestoresDueDate(t *testing.T) {
|
|
// Verifies P1-7: deleting the only completion on a recurring task
|
|
// should restore NextDueDate to the original DueDate.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFrequency)
|
|
|
|
// Create a recurring task
|
|
originalDueDate := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Weekly Task",
|
|
FrequencyID: &weeklyFrequency.ID,
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete the task
|
|
completedAt := time.Date(2026, 3, 2, 10, 0, 0, 0, time.UTC)
|
|
req := &requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "First completion",
|
|
CompletedAt: &completedAt,
|
|
}
|
|
now := time.Now().UTC()
|
|
completionResp, err := service.CreateCompletion(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Verify NextDueDate was set to completedAt + 7 days
|
|
var taskAfterComplete models.Task
|
|
db.First(&taskAfterComplete, task.ID)
|
|
require.NotNil(t, taskAfterComplete.NextDueDate)
|
|
|
|
// Delete the only completion
|
|
_, err = service.DeleteCompletion(completionResp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// NextDueDate should be restored to original DueDate since no completions remain
|
|
var taskAfterDelete models.Task
|
|
db.First(&taskAfterDelete, task.ID)
|
|
require.NotNil(t, taskAfterDelete.NextDueDate, "NextDueDate should be restored to original DueDate")
|
|
assert.Equal(t, originalDueDate.Year(), taskAfterDelete.NextDueDate.Year())
|
|
assert.Equal(t, originalDueDate.Month(), taskAfterDelete.NextDueDate.Month())
|
|
assert.Equal(t, originalDueDate.Day(), taskAfterDelete.NextDueDate.Day())
|
|
}
|
|
|
|
func TestTaskService_GetCategories(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
categories, err := service.GetCategories()
|
|
require.NoError(t, err)
|
|
assert.Greater(t, len(categories), 0)
|
|
|
|
// Check JSON structure
|
|
for _, cat := range categories {
|
|
assert.NotZero(t, cat.ID)
|
|
assert.NotEmpty(t, cat.Name)
|
|
}
|
|
}
|
|
|
|
func TestTaskService_GetPriorities(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
priorities, err := service.GetPriorities()
|
|
require.NoError(t, err)
|
|
assert.Greater(t, len(priorities), 0)
|
|
|
|
// Check order by level
|
|
for i := 1; i < len(priorities); i++ {
|
|
assert.GreaterOrEqual(t, priorities[i].Level, priorities[i-1].Level)
|
|
}
|
|
}
|
|
|
|
func TestTaskService_GetFrequencies(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
frequencies, err := service.GetFrequencies()
|
|
require.NoError(t, err)
|
|
assert.Greater(t, len(frequencies), 0)
|
|
}
|
|
|
|
func TestTaskService_SharedUserAccess(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
owner := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
sharedUser := testutil.CreateTestUser(t, db, "shared", "shared@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, owner.ID, "Test House")
|
|
|
|
// Share residence
|
|
residenceRepo.AddUser(residence.ID, sharedUser.ID)
|
|
|
|
// Create task as owner
|
|
task := testutil.CreateTestTask(t, db, residence.ID, owner.ID, "Test Task")
|
|
|
|
// Shared user should be able to see the task
|
|
resp, err := service.GetTask(task.ID, sharedUser.ID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, task.ID, resp.ID)
|
|
|
|
// Shared user should be able to create tasks
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Shared User Task",
|
|
}
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateTask(req, sharedUser.ID, now)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// =============================================================================
|
|
// Task Creation: NextDueDate Initialization
|
|
// =============================================================================
|
|
|
|
func TestTaskService_CreateTask_NextDueDateEqualsDueDate(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := requests.FlexibleDate{Time: time.Now().AddDate(0, 0, 14).UTC()}
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Task with due date",
|
|
DueDate: &dueDate,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, resp.Data.DueDate, "DueDate should be set")
|
|
require.NotNil(t, resp.Data.NextDueDate, "NextDueDate should be initialized")
|
|
assert.Equal(t, resp.Data.DueDate.Format("2006-01-02"), resp.Data.NextDueDate.Format("2006-01-02"),
|
|
"NextDueDate should equal DueDate on creation")
|
|
}
|
|
|
|
func TestTaskService_CreateTask_NoDueDate_NextDueDateNil(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Task without due date",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, resp.Data.DueDate, "DueDate should be nil")
|
|
assert.Nil(t, resp.Data.NextDueDate, "NextDueDate should be nil when no DueDate")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Task Creation: Recurring Tasks
|
|
// =============================================================================
|
|
|
|
func TestTaskService_CreateTask_WithWeeklyFrequency(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := requests.FlexibleDate{Time: time.Now().AddDate(0, 0, 7).UTC()}
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Weekly cleaning",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, resp.Data.FrequencyID, "FrequencyID should be saved")
|
|
assert.Equal(t, weeklyFreq.ID, *resp.Data.FrequencyID, "FrequencyID should match Weekly")
|
|
}
|
|
|
|
func TestTaskService_CreateTask_WithCustomFrequencyAndInterval(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
// Create a custom frequency
|
|
days14 := 14
|
|
customFreq := &models.TaskFrequency{Name: "Custom", Days: &days14, DisplayOrder: 10}
|
|
db.Create(customFreq)
|
|
|
|
customDays := 14
|
|
dueDate := requests.FlexibleDate{Time: time.Now().AddDate(0, 0, 7).UTC()}
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Bi-weekly inspection",
|
|
FrequencyID: &customFreq.ID,
|
|
CustomIntervalDays: &customDays,
|
|
DueDate: &dueDate,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, resp.Data.FrequencyID, "FrequencyID should be saved")
|
|
assert.NotNil(t, resp.Data.CustomIntervalDays, "CustomIntervalDays should be saved")
|
|
assert.Equal(t, 14, *resp.Data.CustomIntervalDays, "CustomIntervalDays should be 14")
|
|
}
|
|
|
|
func TestTaskService_CreateTask_FrequencyWithoutDueDate(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Recurring no due date",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, resp.Data.FrequencyID, "FrequencyID should be saved")
|
|
assert.Nil(t, resp.Data.NextDueDate, "NextDueDate should be nil when no DueDate")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Task Creation: Edge Cases
|
|
// =============================================================================
|
|
|
|
func TestTaskService_CreateTask_WithPastDueDate(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
pastDate := requests.FlexibleDate{Time: time.Now().AddDate(0, 0, -30).UTC()}
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Overdue from start",
|
|
DueDate: &pastDate,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err, "Creating task with past due date should not error")
|
|
require.NotNil(t, resp.Data.DueDate, "DueDate should be set")
|
|
assert.True(t, resp.Data.DueDate.Before(time.Now()), "DueDate should be in the past")
|
|
}
|
|
|
|
func TestTaskService_CreateTask_WithInProgressTrue(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Already started",
|
|
InProgress: true,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.True(t, resp.Data.InProgress, "InProgress should be true in response")
|
|
|
|
// Verify in database
|
|
var reloaded models.Task
|
|
db.First(&reloaded, resp.Data.ID)
|
|
assert.True(t, reloaded.InProgress, "InProgress should be true in DB")
|
|
}
|
|
|
|
func TestTaskService_CreateTask_AllOptionalFields(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
assignee := testutil.CreateTestUser(t, db, "assignee", "assignee@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
// Add assignee to residence so they have access
|
|
residenceRepo.AddUser(residence.ID, assignee.ID)
|
|
|
|
contractor := testutil.CreateTestContractor(t, db, residence.ID, user.ID, "Joe's Plumbing")
|
|
|
|
var category models.TaskCategory
|
|
var priority models.TaskPriority
|
|
var weeklyFreq models.TaskFrequency
|
|
db.First(&category)
|
|
db.First(&priority)
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := requests.FlexibleDate{Time: time.Now().AddDate(0, 0, 7).UTC()}
|
|
cost := decimal.NewFromFloat(250.00)
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Full task with all fields",
|
|
Description: "A comprehensive task",
|
|
CategoryID: &category.ID,
|
|
PriorityID: &priority.ID,
|
|
FrequencyID: &weeklyFreq.ID,
|
|
InProgress: true,
|
|
AssignedToID: &assignee.ID,
|
|
DueDate: &dueDate,
|
|
EstimatedCost: &cost,
|
|
ContractorID: &contractor.ID,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "Full task with all fields", resp.Data.Title)
|
|
assert.Equal(t, "A comprehensive task", resp.Data.Description)
|
|
assert.NotNil(t, resp.Data.CategoryID, "CategoryID should be set")
|
|
assert.Equal(t, category.ID, *resp.Data.CategoryID)
|
|
assert.NotNil(t, resp.Data.PriorityID, "PriorityID should be set")
|
|
assert.Equal(t, priority.ID, *resp.Data.PriorityID)
|
|
assert.NotNil(t, resp.Data.FrequencyID, "FrequencyID should be set")
|
|
assert.Equal(t, weeklyFreq.ID, *resp.Data.FrequencyID)
|
|
assert.True(t, resp.Data.InProgress, "InProgress should be true")
|
|
assert.NotNil(t, resp.Data.AssignedToID, "AssignedToID should be set")
|
|
assert.Equal(t, assignee.ID, *resp.Data.AssignedToID)
|
|
assert.NotNil(t, resp.Data.DueDate, "DueDate should be set")
|
|
assert.NotNil(t, resp.Data.EstimatedCost, "EstimatedCost should be set")
|
|
assert.NotNil(t, resp.Data.ContractorID, "ContractorID should be set")
|
|
assert.Equal(t, contractor.ID, *resp.Data.ContractorID)
|
|
}
|
|
|
|
func TestTaskService_CreateTask_CustomIntervalDaysWithoutFrequency(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
customDays := 10
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Custom interval without frequency",
|
|
CustomIntervalDays: &customDays,
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(req, user.ID, now)
|
|
require.NoError(t, err, "Should save even without FrequencyID")
|
|
assert.NotNil(t, resp.Data.CustomIntervalDays, "CustomIntervalDays should be saved")
|
|
assert.Equal(t, 10, *resp.Data.CustomIntervalDays)
|
|
assert.Nil(t, resp.Data.FrequencyID, "FrequencyID should be nil")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Task Creation: Validation (service-level)
|
|
// =============================================================================
|
|
|
|
func TestTaskService_CreateTask_InvalidResidenceAccess(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
owner := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
stranger := testutil.CreateTestUser(t, db, "stranger", "stranger@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, owner.ID, "Owner's House")
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Should be denied",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
_, err := service.CreateTask(req, stranger.ID, now)
|
|
testutil.AssertAppError(t, err, http.StatusForbidden, "error.residence_access_denied")
|
|
}
|
|
|
|
func TestTaskService_CreateTask_NonExistentResidence(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
|
|
req := &requests.CreateTaskRequest{
|
|
ResidenceID: 99999,
|
|
Title: "Nowhere to live",
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
_, err := service.CreateTask(req, user.ID, now)
|
|
require.Error(t, err, "Should error for non-existent residence")
|
|
// Should return forbidden since user has no access to non-existent residence
|
|
testutil.AssertAppError(t, err, http.StatusForbidden, "error.residence_access_denied")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Part 1: Completion Deletion Tests (TDD)
|
|
// =============================================================================
|
|
|
|
func TestTaskService_DeleteCompletion_OneTime_RestoresAndExitsKanbanCompleted(t *testing.T) {
|
|
// Verifies: deleting the only completion on a one-time task restores NextDueDate
|
|
// to original DueDate, and the task is no longer in the "completed" kanban state.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
originalDueDate := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "One-time KanbanCheck",
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete the task (sets NextDueDate to nil)
|
|
now := time.Now().UTC()
|
|
completionResp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Done",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Confirm completed state: NextDueDate nil, has completion
|
|
var taskAfterComplete models.Task
|
|
db.Preload("Completions").First(&taskAfterComplete, task.ID)
|
|
assert.Nil(t, taskAfterComplete.NextDueDate, "NextDueDate should be nil after one-time completion")
|
|
assert.True(t, len(taskAfterComplete.Completions) > 0, "Should have completion")
|
|
// IsCompleted: NextDueDate == nil && HasCompletions
|
|
assert.True(t, taskAfterComplete.NextDueDate == nil && len(taskAfterComplete.Completions) > 0,
|
|
"Task should be in completed state")
|
|
|
|
// Delete the completion
|
|
_, err = service.DeleteCompletion(completionResp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// Verify NextDueDate restored to original DueDate
|
|
var taskAfterDelete models.Task
|
|
db.Preload("Completions").First(&taskAfterDelete, task.ID)
|
|
require.NotNil(t, taskAfterDelete.NextDueDate, "NextDueDate should be restored")
|
|
assert.Equal(t, originalDueDate.Year(), taskAfterDelete.NextDueDate.Year())
|
|
assert.Equal(t, originalDueDate.Month(), taskAfterDelete.NextDueDate.Month())
|
|
assert.Equal(t, originalDueDate.Day(), taskAfterDelete.NextDueDate.Day())
|
|
|
|
// Verify no completions remain
|
|
assert.Equal(t, 0, len(taskAfterDelete.Completions), "No completions should remain")
|
|
|
|
// Verify NOT in completed state anymore
|
|
assert.False(t, taskAfterDelete.NextDueDate == nil && len(taskAfterDelete.Completions) > 0,
|
|
"Task should NOT be in completed state after deleting its only completion")
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_Recurring_RestoresToOriginalDueDate(t *testing.T) {
|
|
// Verifies: deleting the only completion on a recurring task restores NextDueDate
|
|
// to the original DueDate.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFrequency)
|
|
|
|
originalDueDate := time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Recurring Restore Test",
|
|
FrequencyID: &weeklyFrequency.ID,
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete on Apr 3
|
|
completedAt := time.Date(2026, 4, 3, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
completionResp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Weekly done", CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Confirm NextDueDate advanced to Apr 10 (Apr 3 + 7)
|
|
var taskAfterComplete models.Task
|
|
db.First(&taskAfterComplete, task.ID)
|
|
require.NotNil(t, taskAfterComplete.NextDueDate)
|
|
assert.Equal(t, 10, taskAfterComplete.NextDueDate.Day())
|
|
|
|
// Delete the completion
|
|
_, err = service.DeleteCompletion(completionResp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// Verify NextDueDate restored to original DueDate (Apr 1)
|
|
var taskAfterDelete models.Task
|
|
db.First(&taskAfterDelete, task.ID)
|
|
require.NotNil(t, taskAfterDelete.NextDueDate)
|
|
assert.Equal(t, originalDueDate.Year(), taskAfterDelete.NextDueDate.Year())
|
|
assert.Equal(t, originalDueDate.Month(), taskAfterDelete.NextDueDate.Month())
|
|
assert.Equal(t, originalDueDate.Day(), taskAfterDelete.NextDueDate.Day())
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_MultipleCompletions_SequentialDeletion(t *testing.T) {
|
|
// Verifies: deleting completions one-by-one from newest to oldest on a recurring task
|
|
// properly recalculates NextDueDate at each step.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFrequency)
|
|
|
|
originalDueDate := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "3-completion Task",
|
|
FrequencyID: &weeklyFrequency.ID,
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
|
|
// Completion 1: Jan 5
|
|
c1At := time.Date(2026, 1, 5, 10, 0, 0, 0, time.UTC)
|
|
c1Resp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Completion 1", CompletedAt: &c1At,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Completion 2: Jan 12
|
|
c2At := time.Date(2026, 1, 12, 10, 0, 0, 0, time.UTC)
|
|
c2Resp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Completion 2", CompletedAt: &c2At,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Completion 3: Jan 19
|
|
c3At := time.Date(2026, 1, 19, 10, 0, 0, 0, time.UTC)
|
|
c3Resp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Completion 3", CompletedAt: &c3At,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// After 3 completions: NextDueDate = Jan 19 + 7 = Jan 26
|
|
var taskAfter3 models.Task
|
|
db.First(&taskAfter3, task.ID)
|
|
require.NotNil(t, taskAfter3.NextDueDate)
|
|
assert.Equal(t, 26, taskAfter3.NextDueDate.Day())
|
|
|
|
// Delete completion 3 (latest) -> recalc from completion 2: Jan 12 + 7 = Jan 19
|
|
_, err = service.DeleteCompletion(c3Resp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
var taskAfterDel3 models.Task
|
|
db.First(&taskAfterDel3, task.ID)
|
|
require.NotNil(t, taskAfterDel3.NextDueDate)
|
|
assert.Equal(t, 19, taskAfterDel3.NextDueDate.Day(),
|
|
"NextDueDate should be Jan 19 (completion 2: Jan 12 + 7)")
|
|
|
|
// Delete completion 2 (now latest) -> recalc from completion 1: Jan 5 + 7 = Jan 12
|
|
_, err = service.DeleteCompletion(c2Resp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
var taskAfterDel2 models.Task
|
|
db.First(&taskAfterDel2, task.ID)
|
|
require.NotNil(t, taskAfterDel2.NextDueDate)
|
|
assert.Equal(t, 12, taskAfterDel2.NextDueDate.Day(),
|
|
"NextDueDate should be Jan 12 (completion 1: Jan 5 + 7)")
|
|
|
|
// Delete completion 1 (last remaining) -> restore to original DueDate: Jan 1
|
|
_, err = service.DeleteCompletion(c1Resp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
var taskAfterDel1 models.Task
|
|
db.First(&taskAfterDel1, task.ID)
|
|
require.NotNil(t, taskAfterDel1.NextDueDate)
|
|
assert.Equal(t, 1, taskAfterDel1.NextDueDate.Day(),
|
|
"NextDueDate should be restored to original DueDate Jan 1")
|
|
assert.Equal(t, time.January, taskAfterDel1.NextDueDate.Month())
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_MiddleCompletion_KeepsLatest(t *testing.T) {
|
|
// Verifies: deleting the middle (2nd) completion leaves NextDueDate based on the latest (3rd).
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFrequency)
|
|
|
|
originalDueDate := time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Middle Deletion Task",
|
|
FrequencyID: &weeklyFrequency.ID,
|
|
DueDate: &originalDueDate,
|
|
NextDueDate: &originalDueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
|
|
// Create 3 completions
|
|
c1At := time.Date(2026, 2, 3, 10, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "First", CompletedAt: &c1At,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
c2At := time.Date(2026, 2, 10, 10, 0, 0, 0, time.UTC)
|
|
c2Resp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Second", CompletedAt: &c2At,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
c3At := time.Date(2026, 2, 17, 10, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Third", CompletedAt: &c3At,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// After 3 completions: NextDueDate = Feb 17 + 7 = Feb 24
|
|
var taskBefore models.Task
|
|
db.First(&taskBefore, task.ID)
|
|
require.NotNil(t, taskBefore.NextDueDate)
|
|
assert.Equal(t, 24, taskBefore.NextDueDate.Day())
|
|
|
|
// Delete the MIDDLE completion (2nd)
|
|
_, err = service.DeleteCompletion(c2Resp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// NextDueDate should still be based on the latest (3rd): Feb 17 + 7 = Feb 24
|
|
var taskAfter models.Task
|
|
db.First(&taskAfter, task.ID)
|
|
require.NotNil(t, taskAfter.NextDueDate)
|
|
assert.Equal(t, 24, taskAfter.NextDueDate.Day(),
|
|
"Deleting middle completion should not change NextDueDate when latest still exists")
|
|
}
|
|
|
|
func TestTaskService_DeleteCompletion_DoesNotRestoreInProgress(t *testing.T) {
|
|
// Documents behavior: DeleteCompletion does NOT restore InProgress.
|
|
// It only recalculates NextDueDate.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "InProgress Task",
|
|
InProgress: true,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete it (sets InProgress = false)
|
|
now := time.Now().UTC()
|
|
completionResp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Completed",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var taskAfterComplete models.Task
|
|
db.First(&taskAfterComplete, task.ID)
|
|
assert.False(t, taskAfterComplete.InProgress, "InProgress should be false after completion")
|
|
|
|
// Delete the completion
|
|
_, err = service.DeleteCompletion(completionResp.Data.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
// InProgress is NOT restored by DeleteCompletion
|
|
var taskAfterDelete models.Task
|
|
db.First(&taskAfterDelete, task.ID)
|
|
assert.False(t, taskAfterDelete.InProgress,
|
|
"DeleteCompletion does not restore InProgress; it only recalculates NextDueDate")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Part 2: Edge Case Tests (TDD)
|
|
// =============================================================================
|
|
|
|
func TestTaskService_TaskWithNoDates(t *testing.T) {
|
|
// Task with no DueDate, no frequency: upcoming before completion, completed after.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
createReq := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "No Date Task",
|
|
}
|
|
now := time.Now().UTC()
|
|
createResp, err := service.CreateTask(createReq, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
// Verify dates are nil
|
|
assert.Nil(t, createResp.Data.DueDate, "DueDate should be nil")
|
|
assert.Nil(t, createResp.Data.NextDueDate, "NextDueDate should be nil")
|
|
|
|
// Kanban: upcoming (no date = upcoming for uncompleted tasks)
|
|
assert.Equal(t, "upcoming_tasks", createResp.Data.KanbanColumn,
|
|
"Task with no due date should be in upcoming column")
|
|
|
|
// Complete it
|
|
completionResp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: createResp.Data.ID, Notes: "Done",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotZero(t, completionResp.Data.ID)
|
|
|
|
// Verify NextDueDate remains nil (one-time, no frequency)
|
|
var taskAfterComplete models.Task
|
|
db.Preload("Completions").First(&taskAfterComplete, createResp.Data.ID)
|
|
assert.Nil(t, taskAfterComplete.NextDueDate, "NextDueDate remains nil for dateless one-time task")
|
|
assert.True(t, len(taskAfterComplete.Completions) > 0, "Should have completion")
|
|
|
|
// Now in completed state: NextDueDate==nil && HasCompletions
|
|
assert.True(t, taskAfterComplete.NextDueDate == nil && len(taskAfterComplete.Completions) > 0,
|
|
"Task should be in completed state")
|
|
}
|
|
|
|
func TestTaskService_TaskDueExactlyToday_Boundary(t *testing.T) {
|
|
// Task due today is NOT overdue (today is not "past").
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
today := time.Date(2026, 6, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Due Today Task",
|
|
DueDate: &today,
|
|
NextDueDate: &today,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// NOT overdue
|
|
assert.False(t, task.IsOverdueAt(today), "Task due today should NOT be overdue")
|
|
|
|
// Complete it
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Done today",
|
|
}, user.ID, today)
|
|
require.NoError(t, err)
|
|
|
|
// Verify transition: NextDueDate nil (one-time)
|
|
var taskAfter models.Task
|
|
db.First(&taskAfter, task.ID)
|
|
assert.Nil(t, taskAfter.NextDueDate, "One-time task NextDueDate should be nil after completion")
|
|
}
|
|
|
|
func TestTaskService_TaskDueYesterday_IsOverdue(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
today := time.Date(2026, 6, 15, 0, 0, 0, 0, time.UTC)
|
|
yesterday := today.AddDate(0, 0, -1)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Due Yesterday Task",
|
|
DueDate: &yesterday,
|
|
NextDueDate: &yesterday,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
assert.True(t, task.IsOverdueAt(today), "Task due yesterday should be overdue")
|
|
|
|
// Complete it
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Done late",
|
|
}, user.ID, today)
|
|
require.NoError(t, err)
|
|
|
|
// Completed task is not overdue
|
|
var taskAfter models.Task
|
|
db.Preload("Completions").First(&taskAfter, task.ID)
|
|
assert.Nil(t, taskAfter.NextDueDate)
|
|
assert.True(t, len(taskAfter.Completions) > 0)
|
|
assert.False(t, taskAfter.IsOverdueAt(today), "Completed task should not be overdue")
|
|
}
|
|
|
|
func TestTaskService_TaskVeryFarFuture(t *testing.T) {
|
|
// Task due in 2099 is in "upcoming" column.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
farFuture := time.Date(2099, 12, 31, 0, 0, 0, 0, time.UTC)
|
|
createReq := &requests.CreateTaskRequest{
|
|
ResidenceID: residence.ID,
|
|
Title: "Far Future Task",
|
|
DueDate: &requests.FlexibleDate{Time: farFuture},
|
|
}
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateTask(createReq, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "upcoming_tasks", resp.Data.KanbanColumn,
|
|
"Task due in 2099 should be in upcoming column")
|
|
}
|
|
|
|
func TestTaskService_RecurringTask_CompletedLate(t *testing.T) {
|
|
// Weekly task due Dec 10, completed Dec 15 -> NextDueDate = Dec 22 (CompletedAt + 7)
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFrequency)
|
|
|
|
dueDate := time.Date(2026, 12, 10, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Late Completion Task",
|
|
FrequencyID: &weeklyFrequency.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 12, 15, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Late", CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
// NextDueDate = Dec 15 + 7 = Dec 22, NOT Dec 10 + 7 = Dec 17
|
|
assert.Equal(t, 22, reloaded.NextDueDate.Day(),
|
|
"NextDueDate should be CompletedAt+7 (Dec 22), not DueDate+7 (Dec 17)")
|
|
}
|
|
|
|
func TestTaskService_RecurringTask_CompletedEarly(t *testing.T) {
|
|
// Weekly task due Dec 17, completed Dec 14 -> NextDueDate = Dec 21 (CompletedAt + 7)
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFrequency)
|
|
|
|
dueDate := time.Date(2026, 12, 17, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Early Completion Task",
|
|
FrequencyID: &weeklyFrequency.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 12, 14, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Early", CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
assert.Equal(t, 21, reloaded.NextDueDate.Day(),
|
|
"NextDueDate should be CompletedAt+7 (Dec 21)")
|
|
assert.Equal(t, time.December, reloaded.NextDueDate.Month())
|
|
}
|
|
|
|
func TestTaskService_CustomIntervalEdgeCases(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
// Create a "Custom" frequency (Days=0, overridden by task's CustomIntervalDays)
|
|
customDays := 0
|
|
customFrequency := &models.TaskFrequency{
|
|
Name: "Custom",
|
|
Days: &customDays,
|
|
DisplayOrder: 10,
|
|
}
|
|
err := db.Create(customFrequency).Error
|
|
require.NoError(t, err)
|
|
|
|
t.Run("CustomIntervalDays=1_daily", func(t *testing.T) {
|
|
interval := 1
|
|
dueDate := time.Date(2026, 6, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Daily Custom Task",
|
|
FrequencyID: &customFrequency.ID,
|
|
CustomIntervalDays: &interval,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
assert.Equal(t, 2, reloaded.NextDueDate.Day(), "NextDueDate = Jun 1 + 1 = Jun 2")
|
|
})
|
|
|
|
t.Run("CustomIntervalDays=365_yearly", func(t *testing.T) {
|
|
interval := 365
|
|
dueDate := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Yearly Custom Task",
|
|
FrequencyID: &customFrequency.ID,
|
|
CustomIntervalDays: &interval,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
assert.Equal(t, 2027, reloaded.NextDueDate.Year(), "NextDueDate year should be 2027")
|
|
assert.Equal(t, time.January, reloaded.NextDueDate.Month())
|
|
assert.Equal(t, 1, reloaded.NextDueDate.Day())
|
|
})
|
|
}
|
|
|
|
func TestTaskService_FrequencyWithNilOrZeroDays(t *testing.T) {
|
|
// Frequency with Days=nil or Days=0 is treated as one-time on completion.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
t.Run("frequency_with_nil_days", func(t *testing.T) {
|
|
var onceFrequency models.TaskFrequency
|
|
db.Where("name = ?", "Once").First(&onceFrequency)
|
|
require.Nil(t, onceFrequency.Days, "Once frequency should have nil Days")
|
|
|
|
dueDate := time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Once Frequency Task",
|
|
FrequencyID: &onceFrequency.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Done once",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.Nil(t, reloaded.NextDueDate,
|
|
"Frequency with Days=nil should be treated as one-time: NextDueDate=nil")
|
|
})
|
|
|
|
t.Run("frequency_with_zero_days", func(t *testing.T) {
|
|
zeroDays := 0
|
|
zeroFreq := &models.TaskFrequency{
|
|
Name: "ZeroTest", Days: &zeroDays, DisplayOrder: 99,
|
|
}
|
|
err := db.Create(zeroFreq).Error
|
|
require.NoError(t, err)
|
|
|
|
dueDate := time.Date(2026, 7, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Zero Days Frequency Task",
|
|
FrequencyID: &zeroFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err = db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Done zero",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.Nil(t, reloaded.NextDueDate,
|
|
"Frequency with Days=0 should be treated as one-time: NextDueDate=nil")
|
|
})
|
|
}
|
|
|
|
func TestTaskService_VersionConflict(t *testing.T) {
|
|
// Verifies: UpdateTx / Update checks version and returns ErrVersionConflict on stale version.
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Conflict Task")
|
|
|
|
// First update succeeds
|
|
newTitle := "Updated Once"
|
|
now := time.Now().UTC()
|
|
resp, err := service.UpdateTask(task.ID, user.ID, &requests.UpdateTaskRequest{
|
|
Title: &newTitle,
|
|
}, now)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Updated Once", resp.Data.Title)
|
|
|
|
// Simulate stale version: read current, then bump version in DB
|
|
staleTask := &models.Task{}
|
|
db.First(staleTask, task.ID)
|
|
currentVersion := staleTask.Version
|
|
|
|
db.Model(&models.Task{}).Where("id = ?", task.ID).Update("version", currentVersion+10)
|
|
|
|
// Try update with stale version -> ErrVersionConflict
|
|
staleTask.Title = "Should Fail"
|
|
err = taskRepo.Update(staleTask)
|
|
assert.ErrorIs(t, err, repositories.ErrVersionConflict,
|
|
"Update with stale version should return ErrVersionConflict")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Part 1: One-Time Task Completion Tests (TDD)
|
|
// =============================================================================
|
|
|
|
// seedAllFrequencies creates frequency records beyond what SeedLookupData provides
|
|
// (Once, Weekly, Monthly). Adds Daily, Bi-Weekly, Quarterly, Yearly, Custom.
|
|
func seedAllFrequencies(t *testing.T, db *gorm.DB) {
|
|
t.Helper()
|
|
|
|
var existing int64
|
|
db.Model(&models.TaskFrequency{}).Where("name = ?", "Daily").Count(&existing)
|
|
if existing > 0 {
|
|
return
|
|
}
|
|
|
|
days1 := 1
|
|
days14 := 14
|
|
days90 := 90
|
|
days365 := 365
|
|
|
|
extraFreqs := []models.TaskFrequency{
|
|
{Name: "Daily", Days: &days1, DisplayOrder: 0},
|
|
{Name: "Bi-Weekly", Days: &days14, DisplayOrder: 3},
|
|
{Name: "Quarterly", Days: &days90, DisplayOrder: 5},
|
|
{Name: "Yearly", Days: &days365, DisplayOrder: 6},
|
|
{Name: "Custom", Days: nil, DisplayOrder: 7},
|
|
}
|
|
for i := range extraFreqs {
|
|
err := db.Create(&extraFreqs[i]).Error
|
|
require.NoError(t, err, "failed to seed frequency: %s", extraFreqs[i].Name)
|
|
}
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_OneTime_NextDueDateBecomesNil(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := time.Date(2026, 4, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "One-time Task",
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Done",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.Nil(t, reloaded.NextDueDate, "One-time task NextDueDate should be nil after completion")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_OneTime_InProgressBecomesFalse(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := time.Date(2026, 4, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "In-progress One-time",
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
InProgress: true,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.False(t, reloaded.InProgress, "One-time task InProgress should be false after completion")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_OneTime_CompletionRecordFields(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Record Fields Task")
|
|
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Check all fields",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
assert.NotZero(t, resp.Data.ID, "Completion ID should be set")
|
|
assert.Equal(t, task.ID, resp.Data.TaskID, "TaskID should match")
|
|
assert.Equal(t, "Check all fields", resp.Data.Notes, "Notes should match")
|
|
|
|
var completion models.TaskCompletion
|
|
err = db.Where("task_id = ?", task.ID).First(&completion).Error
|
|
require.NoError(t, err)
|
|
assert.Equal(t, user.ID, completion.CompletedByID, "CompletedByID should match user")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_OneTime_WithNotesActualCostRating(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Full Fields Task")
|
|
|
|
cost := decimal.NewFromFloat(75.50)
|
|
rating := 4
|
|
now := time.Now().UTC()
|
|
resp, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
Notes: "Detailed notes",
|
|
ActualCost: &cost,
|
|
Rating: &rating,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "Detailed notes", resp.Data.Notes)
|
|
require.NotNil(t, resp.Data.ActualCost, "ActualCost should be set")
|
|
assert.True(t, resp.Data.ActualCost.Equal(cost), "ActualCost should match")
|
|
require.NotNil(t, resp.Data.Rating, "Rating should be set")
|
|
assert.Equal(t, 4, *resp.Data.Rating)
|
|
|
|
// Verify in database
|
|
var completion models.TaskCompletion
|
|
err = db.Where("task_id = ?", task.ID).First(&completion).Error
|
|
require.NoError(t, err)
|
|
require.NotNil(t, completion.ActualCost)
|
|
assert.True(t, completion.ActualCost.Equal(cost))
|
|
require.NotNil(t, completion.Rating)
|
|
assert.Equal(t, 4, *completion.Rating)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_AlreadyCompleted_SecondCompletionCreated(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := time.Date(2026, 4, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Double Complete Task",
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
|
|
// First completion
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "First",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var afterFirst models.Task
|
|
db.First(&afterFirst, task.ID)
|
|
assert.Nil(t, afterFirst.NextDueDate, "NextDueDate should be nil after first completion")
|
|
|
|
// Second completion on already-completed task
|
|
resp2, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Second",
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
assert.NotZero(t, resp2.Data.ID, "Second completion should be created")
|
|
|
|
// NextDueDate should remain nil
|
|
var afterSecond models.Task
|
|
db.First(&afterSecond, task.ID)
|
|
assert.Nil(t, afterSecond.NextDueDate, "NextDueDate should remain nil after second completion")
|
|
|
|
// Two completions should exist
|
|
var count int64
|
|
db.Model(&models.TaskCompletion{}).Where("task_id = ?", task.ID).Count(&count)
|
|
assert.Equal(t, int64(2), count, "Two completions should exist")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_WithBackdatedCompletedAt(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Backdated Task")
|
|
|
|
backdated := time.Date(2026, 1, 15, 14, 30, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err := service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Backdated", CompletedAt: &backdated,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var completion models.TaskCompletion
|
|
err = db.Where("task_id = ?", task.ID).First(&completion).Error
|
|
require.NoError(t, err)
|
|
assert.Equal(t, backdated.Year(), completion.CompletedAt.Year())
|
|
assert.Equal(t, backdated.Month(), completion.CompletedAt.Month())
|
|
assert.Equal(t, backdated.Day(), completion.CompletedAt.Day())
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_BackdatedCompletedAt_NextDueFromThatDate(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Recurring Backdated",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
backdated := time.Date(2026, 1, 10, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, Notes: "Backdated recurring", CompletedAt: &backdated,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := backdated.AddDate(0, 0, 7)
|
|
assert.Equal(t, expected.Year(), reloaded.NextDueDate.Year())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(),
|
|
"NextDueDate should be calculated from backdated CompletedAt, not current time")
|
|
}
|
|
|
|
// =============================================================================
|
|
// Part 2: Recurring Task Completion Tests - ALL FREQUENCY TYPES (TDD)
|
|
// =============================================================================
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Daily(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
seedAllFrequencies(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var dailyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Daily").First(&dailyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 26, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Daily Task",
|
|
FrequencyID: &dailyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
completedAt1 := time.Date(2026, 3, 26, 9, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt1,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected1 := completedAt1.AddDate(0, 0, 1)
|
|
assert.Equal(t, expected1.Year(), reloaded.NextDueDate.Year())
|
|
assert.Equal(t, expected1.Month(), reloaded.NextDueDate.Month())
|
|
assert.Equal(t, expected1.Day(), reloaded.NextDueDate.Day(),
|
|
"Daily: NextDueDate should be CompletedAt + 1 day")
|
|
|
|
// Complete again
|
|
completedAt2 := time.Date(2026, 3, 27, 10, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt2,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected2 := completedAt2.AddDate(0, 0, 1)
|
|
assert.Equal(t, expected2.Day(), reloaded.NextDueDate.Day(),
|
|
"Daily: Second completion NextDueDate should be new CompletedAt + 1 day")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Weekly_OnTime(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 20, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Weekly OnTime",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 3, 20, 15, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, 7)
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Weekly_CompletedLate_NextDueFromCompletedAt(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 20, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Weekly Late",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
// Complete 3 days late
|
|
completedAt := time.Date(2026, 3, 23, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, 7) // Mar 30, NOT Mar 27
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(),
|
|
"NextDueDate should be CompletedAt+7 (Mar 30), not DueDate+7 (Mar 27)")
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_BiWeekly(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
seedAllFrequencies(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var biWeeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Bi-Weekly").First(&biWeeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Bi-Weekly Task",
|
|
FrequencyID: &biWeeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 3, 1, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, 14)
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month(),
|
|
"Bi-Weekly: NextDueDate should be CompletedAt + 14 days")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Monthly_Dedicated(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var monthlyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Monthly").First(&monthlyFreq)
|
|
|
|
dueDate := time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Monthly Dedicated",
|
|
FrequencyID: &monthlyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 2, 5, 12, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, 30)
|
|
assert.Equal(t, expected.Year(), reloaded.NextDueDate.Year())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(),
|
|
"Monthly: NextDueDate should be CompletedAt + 30 days")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Quarterly(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
seedAllFrequencies(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var quarterlyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Quarterly").First(&quarterlyFreq)
|
|
|
|
dueDate := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Quarterly Task",
|
|
FrequencyID: &quarterlyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 1, 5, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, 90)
|
|
assert.Equal(t, expected.Year(), reloaded.NextDueDate.Year())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(),
|
|
"Quarterly: NextDueDate should be CompletedAt + 90 days")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Yearly(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
seedAllFrequencies(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var yearlyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Yearly").First(&yearlyFreq)
|
|
|
|
dueDate := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Yearly Task",
|
|
FrequencyID: &yearlyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 1, 10, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, 365)
|
|
assert.Equal(t, expected.Year(), reloaded.NextDueDate.Year())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(),
|
|
"Yearly: NextDueDate should be CompletedAt + 365 days")
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_Custom_Intervals(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
seedAllFrequencies(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var customFreq models.TaskFrequency
|
|
db.Where("name = ?", "Custom").First(&customFreq)
|
|
|
|
tests := []struct {
|
|
name string
|
|
intervalDays int
|
|
}{
|
|
{"Custom_10_days", 10},
|
|
{"Custom_45_days", 45},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
dueDate := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)
|
|
customDays := tc.intervalDays
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: tc.name,
|
|
FrequencyID: &customFreq.ID,
|
|
CustomIntervalDays: &customDays,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 3, 5, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
expected := completedAt.AddDate(0, 0, tc.intervalDays)
|
|
assert.Equal(t, expected.Year(), reloaded.NextDueDate.Year())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(),
|
|
"Custom %d days: NextDueDate should be CompletedAt + %d days", tc.intervalDays, tc.intervalDays)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_NoDueDate_NextDueFromCompletion(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Recurring No Due Date",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: nil,
|
|
NextDueDate: nil,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 3, 26, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate,
|
|
"Recurring task with no original DueDate should have NextDueDate after completion")
|
|
expected := completedAt.AddDate(0, 0, 7)
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day())
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month())
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_ThreeSequentialCompletions(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Weekly 3x Complete",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
var reloaded models.Task
|
|
|
|
// Completion 1: Mar 1 -> NextDueDate = Mar 8
|
|
c1 := time.Date(2026, 3, 1, 10, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &c1,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
assert.Equal(t, 8, reloaded.NextDueDate.Day(), "After 1st: NextDueDate should be Mar 8")
|
|
|
|
// Completion 2: Mar 8 -> NextDueDate = Mar 15
|
|
c2 := time.Date(2026, 3, 8, 10, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &c2,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
assert.Equal(t, 15, reloaded.NextDueDate.Day(), "After 2nd: NextDueDate should be Mar 15")
|
|
|
|
// Completion 3: Mar 15 -> NextDueDate = Mar 22
|
|
c3 := time.Date(2026, 3, 15, 10, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &c3,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
assert.Equal(t, 22, reloaded.NextDueDate.Day(), "After 3rd: NextDueDate should be Mar 22")
|
|
|
|
var count int64
|
|
db.Model(&models.TaskCompletion{}).Where("task_id = ?", task.ID).Count(&count)
|
|
assert.Equal(t, int64(3), count)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_Recurring_InProgressResetForNextCycle(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "InProgress Recurring",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
InProgress: true,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.False(t, reloaded.InProgress,
|
|
"Recurring task InProgress should be reset to false after completion for next cycle")
|
|
require.NotNil(t, reloaded.NextDueDate)
|
|
}
|
|
|
|
func TestTaskService_CreateCompletion_CompletedFromColumn_Capture(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
t.Run("overdue_task", func(t *testing.T) {
|
|
pastDue := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Overdue Column Task",
|
|
DueDate: &pastDue,
|
|
NextDueDate: &pastDue,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Date(2026, 3, 26, 0, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var completion models.TaskCompletion
|
|
db.Where("task_id = ?", task.ID).First(&completion)
|
|
assert.Equal(t, "overdue_tasks", completion.CompletedFromColumn,
|
|
"CompletedFromColumn should be 'overdue_tasks'")
|
|
})
|
|
|
|
t.Run("in_progress_task", func(t *testing.T) {
|
|
futureDue := time.Date(2027, 6, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "InProgress Column Task",
|
|
DueDate: &futureDue,
|
|
NextDueDate: &futureDue,
|
|
InProgress: true,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
now := time.Date(2026, 3, 26, 0, 0, 0, 0, time.UTC)
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var completion models.TaskCompletion
|
|
db.Where("task_id = ?", task.ID).First(&completion)
|
|
assert.Equal(t, "in_progress_tasks", completion.CompletedFromColumn,
|
|
"CompletedFromColumn should be 'in_progress_tasks'")
|
|
})
|
|
}
|
|
|
|
// Table-driven test: all standard frequency types
|
|
func TestTaskService_CreateCompletion_AllFrequencyTypes_TableDriven(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
seedAllFrequencies(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
tests := []struct {
|
|
freqName string
|
|
expectedDays int
|
|
}{
|
|
{"Daily", 1},
|
|
{"Weekly", 7},
|
|
{"Bi-Weekly", 14},
|
|
{"Monthly", 30},
|
|
{"Quarterly", 90},
|
|
{"Yearly", 365},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.freqName, func(t *testing.T) {
|
|
var freq models.TaskFrequency
|
|
err := db.Where("name = ?", tc.freqName).First(&freq).Error
|
|
require.NoError(t, err, "Frequency %s should exist", tc.freqName)
|
|
|
|
dueDate := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "Freq " + tc.freqName,
|
|
FrequencyID: &freq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err = db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
completedAt := time.Date(2026, 3, 5, 10, 0, 0, 0, time.UTC)
|
|
now := time.Now().UTC()
|
|
_, err = service.CreateCompletion(&requests.CreateTaskCompletionRequest{
|
|
TaskID: task.ID, CompletedAt: &completedAt,
|
|
}, user.ID, now)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate, "%s: NextDueDate should not be nil", tc.freqName)
|
|
expected := completedAt.AddDate(0, 0, tc.expectedDays)
|
|
assert.Equal(t, expected.Year(), reloaded.NextDueDate.Year(), "%s: year", tc.freqName)
|
|
assert.Equal(t, expected.Month(), reloaded.NextDueDate.Month(), "%s: month", tc.freqName)
|
|
assert.Equal(t, expected.Day(), reloaded.NextDueDate.Day(), "%s: day", tc.freqName)
|
|
})
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Part 3: QuickComplete Tests (TDD)
|
|
// =============================================================================
|
|
|
|
func TestTaskService_QuickComplete_OneTime_ClearsNextDueDate(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
dueDate := time.Date(2026, 4, 15, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "QuickComplete One-time",
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
err = service.QuickComplete(task.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
assert.Nil(t, reloaded.NextDueDate, "One-time QuickComplete should set NextDueDate to nil")
|
|
|
|
var completion models.TaskCompletion
|
|
err = db.Where("task_id = ?", task.ID).First(&completion).Error
|
|
require.NoError(t, err, "Completion record should be created")
|
|
assert.NotZero(t, completion.ID)
|
|
}
|
|
|
|
func TestTaskService_QuickComplete_Recurring_RecalculatesNextDueDate(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
|
|
var weeklyFreq models.TaskFrequency
|
|
db.Where("name = ?", "Weekly").First(&weeklyFreq)
|
|
|
|
dueDate := time.Date(2026, 3, 20, 0, 0, 0, 0, time.UTC)
|
|
task := &models.Task{
|
|
ResidenceID: residence.ID,
|
|
CreatedByID: user.ID,
|
|
Title: "QuickComplete Recurring",
|
|
FrequencyID: &weeklyFreq.ID,
|
|
DueDate: &dueDate,
|
|
NextDueDate: &dueDate,
|
|
IsCancelled: false,
|
|
IsArchived: false,
|
|
Version: 1,
|
|
}
|
|
err := db.Create(task).Error
|
|
require.NoError(t, err)
|
|
|
|
err = service.QuickComplete(task.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
var reloaded models.Task
|
|
db.First(&reloaded, task.ID)
|
|
require.NotNil(t, reloaded.NextDueDate, "Recurring QuickComplete should set NextDueDate")
|
|
expectedApprox := time.Now().UTC().AddDate(0, 0, 7)
|
|
assert.WithinDuration(t, expectedApprox, *reloaded.NextDueDate, 2*time.Minute,
|
|
"NextDueDate should be ~7 days from now")
|
|
}
|
|
|
|
func TestTaskService_QuickComplete_SetsWidgetNotes(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, user.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, user.ID, "Widget Task")
|
|
|
|
err := service.QuickComplete(task.ID, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
var completion models.TaskCompletion
|
|
err = db.Where("task_id = ?", task.ID).First(&completion).Error
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Completed from widget", completion.Notes,
|
|
"QuickComplete should set notes to 'Completed from widget'")
|
|
}
|
|
|
|
func TestTaskService_QuickComplete_NonExistentTask_ReturnsNotFound(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
user := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
|
|
err := service.QuickComplete(99999, user.ID)
|
|
testutil.AssertAppErrorCode(t, err, http.StatusNotFound)
|
|
}
|
|
|
|
func TestTaskService_QuickComplete_AccessDenied_ReturnsForbidden(t *testing.T) {
|
|
db := testutil.SetupTestDB(t)
|
|
testutil.SeedLookupData(t, db)
|
|
taskRepo := repositories.NewTaskRepository(db)
|
|
residenceRepo := repositories.NewResidenceRepository(db)
|
|
service := NewTaskService(taskRepo, residenceRepo)
|
|
|
|
owner := testutil.CreateTestUser(t, db, "owner", "owner@test.com", "password")
|
|
otherUser := testutil.CreateTestUser(t, db, "other", "other@test.com", "password")
|
|
residence := testutil.CreateTestResidence(t, db, owner.ID, "Test House")
|
|
task := testutil.CreateTestTask(t, db, residence.ID, owner.ID, "Private Task")
|
|
|
|
err := service.QuickComplete(task.ID, otherUser.ID)
|
|
testutil.AssertAppError(t, err, http.StatusForbidden, "error.task_access_denied")
|
|
}
|