david
38e640c617
- Create pagination package with Params and Response structs - Add FindActiveByUserIDWithPagination and CountActiveByUserID methods to HabitRepository interface - Implement pagination in SQLite repository using LIMIT and OFFSET - Update GetUserHabitsHandler to support optional pagination parameters - Modify HTTP endpoint to parse 'page' and 'page_size' query params (default: page=1, page_size=50, max=100) - Add GetUserHabitsResponse DTO with pagination metadata - Maintain backward compatibility - endpoint works with and without pagination params - Add comprehensive tests for pagination logic in repository, handler, and pagination package - Update all mock repositories to implement new pagination methods
425 lines
9.5 KiB
Go
425 lines
9.5 KiB
Go
package sqlite
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"apocapoc-api/internal/domain/entities"
|
|
"apocapoc-api/internal/domain/value_objects"
|
|
"apocapoc-api/internal/shared/errors"
|
|
"apocapoc-api/internal/shared/pagination"
|
|
)
|
|
|
|
func TestHabitRepositoryCreate(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
habit := entities.NewHabit(
|
|
"user-123",
|
|
"Morning Exercise",
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyDaily,
|
|
false,
|
|
false,
|
|
)
|
|
habit.Description = "Exercise every morning"
|
|
|
|
err := repo.Create(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Create failed: %v", err)
|
|
}
|
|
|
|
if habit.ID == "" {
|
|
t.Error("Expected habit ID to be generated, got empty string")
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryCreateWithSpecificDays(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
habit := entities.NewHabit(
|
|
"user-123",
|
|
"Weekly Workout",
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyWeekly,
|
|
false,
|
|
false,
|
|
)
|
|
habit.SpecificDays = []int{1, 3, 5}
|
|
|
|
err := repo.Create(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Create failed: %v", err)
|
|
}
|
|
|
|
found, err := repo.FindByID(ctx, habit.ID)
|
|
if err != nil {
|
|
t.Fatalf("FindByID failed: %v", err)
|
|
}
|
|
|
|
if len(found.SpecificDays) != 3 {
|
|
t.Errorf("Expected 3 specific days, got %d", len(found.SpecificDays))
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryFindByID(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
habit := entities.NewHabit(
|
|
"user-456",
|
|
"Read Books",
|
|
value_objects.HabitTypeCounter,
|
|
value_objects.FrequencyDaily,
|
|
true,
|
|
false,
|
|
)
|
|
targetValue := 30.0
|
|
habit.TargetValue = &targetValue
|
|
|
|
err := repo.Create(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Create failed: %v", err)
|
|
}
|
|
|
|
found, err := repo.FindByID(ctx, habit.ID)
|
|
if err != nil {
|
|
t.Fatalf("FindByID failed: %v", err)
|
|
}
|
|
|
|
if found.ID != habit.ID {
|
|
t.Errorf("Expected ID %s, got %s", habit.ID, found.ID)
|
|
}
|
|
if found.Name != habit.Name {
|
|
t.Errorf("Expected name %s, got %s", habit.Name, found.Name)
|
|
}
|
|
if found.CarryOver != habit.CarryOver {
|
|
t.Errorf("Expected carry_over %v, got %v", habit.CarryOver, found.CarryOver)
|
|
}
|
|
if found.TargetValue == nil || *found.TargetValue != 30.0 {
|
|
t.Errorf("Expected target_value 30.0, got %v", found.TargetValue)
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryFindByIDNotFound(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
_, err := repo.FindByID(ctx, "non-existent-id")
|
|
if err != errors.ErrNotFound {
|
|
t.Errorf("Expected ErrNotFound, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryFindActiveByUserID(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
userID := "user-789"
|
|
|
|
habit1 := entities.NewHabit(userID, "Habit 1", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false, false)
|
|
habit2 := entities.NewHabit(userID, "Habit 2", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false, false)
|
|
habit3 := entities.NewHabit(userID, "Habit 3", value_objects.HabitTypeBoolean, value_objects.FrequencyDaily, false, false)
|
|
|
|
repo.Create(ctx, habit1)
|
|
repo.Create(ctx, habit2)
|
|
repo.Create(ctx, habit3)
|
|
|
|
now := time.Now()
|
|
habit2.ArchivedAt = &now
|
|
repo.Update(ctx, habit2)
|
|
|
|
habits, err := repo.FindActiveByUserID(ctx, userID)
|
|
if err != nil {
|
|
t.Fatalf("FindActiveByUserID failed: %v", err)
|
|
}
|
|
|
|
if len(habits) != 2 {
|
|
t.Errorf("Expected 2 active habits, got %d", len(habits))
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryUpdate(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
habit := entities.NewHabit(
|
|
"user-999",
|
|
"Original Name",
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyDaily,
|
|
false,
|
|
false,
|
|
)
|
|
|
|
err := repo.Create(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Create failed: %v", err)
|
|
}
|
|
|
|
habit.Name = "Updated Name"
|
|
habit.Description = "Updated description"
|
|
habit.CarryOver = true
|
|
|
|
err = repo.Update(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Update failed: %v", err)
|
|
}
|
|
|
|
found, err := repo.FindByID(ctx, habit.ID)
|
|
if err != nil {
|
|
t.Fatalf("FindByID failed: %v", err)
|
|
}
|
|
|
|
if found.Name != "Updated Name" {
|
|
t.Errorf("Expected name 'Updated Name', got %s", found.Name)
|
|
}
|
|
if found.Description != "Updated description" {
|
|
t.Errorf("Expected description 'Updated description', got %s", found.Description)
|
|
}
|
|
if !found.CarryOver {
|
|
t.Error("Expected carry_over to be true")
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryUpdateNotFound(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
habit := entities.NewHabit(
|
|
"user-123",
|
|
"Test",
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyDaily,
|
|
false,
|
|
false,
|
|
)
|
|
habit.ID = "non-existent"
|
|
|
|
err := repo.Update(ctx, habit)
|
|
if err != errors.ErrNotFound {
|
|
t.Errorf("Expected ErrNotFound, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryArchive(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
habit := entities.NewHabit(
|
|
"user-archive",
|
|
"To Archive",
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyDaily,
|
|
false,
|
|
false,
|
|
)
|
|
|
|
err := repo.Create(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Create failed: %v", err)
|
|
}
|
|
|
|
now := time.Now()
|
|
habit.ArchivedAt = &now
|
|
|
|
err = repo.Update(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Update failed: %v", err)
|
|
}
|
|
|
|
found, err := repo.FindByID(ctx, habit.ID)
|
|
if err != nil {
|
|
t.Fatalf("FindByID failed: %v", err)
|
|
}
|
|
|
|
if found.ArchivedAt == nil {
|
|
t.Error("Expected habit to be archived")
|
|
}
|
|
}
|
|
|
|
func TestHabitRepositoryFindActiveByUserIDWithPagination(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
userID := "user-pagination-test"
|
|
|
|
for i := 1; i <= 10; i++ {
|
|
habit := entities.NewHabit(
|
|
userID,
|
|
"Habit "+string(rune(i+'0')),
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyDaily,
|
|
false,
|
|
false,
|
|
)
|
|
err := repo.Create(ctx, habit)
|
|
if err != nil {
|
|
t.Fatalf("Create failed: %v", err)
|
|
}
|
|
time.Sleep(1 * time.Millisecond)
|
|
}
|
|
|
|
now := time.Now()
|
|
allHabits, _ := repo.FindActiveByUserID(ctx, userID)
|
|
allHabits[0].ArchivedAt = &now
|
|
repo.Update(ctx, allHabits[0])
|
|
|
|
t.Run("FirstPage", func(t *testing.T) {
|
|
params := pagination.NewParams(1, 5)
|
|
habits, err := repo.FindActiveByUserIDWithPagination(ctx, userID, params)
|
|
if err != nil {
|
|
t.Fatalf("FindActiveByUserIDWithPagination failed: %v", err)
|
|
}
|
|
|
|
if len(habits) != 5 {
|
|
t.Errorf("Expected 5 habits on first page, got %d", len(habits))
|
|
}
|
|
})
|
|
|
|
t.Run("SecondPage", func(t *testing.T) {
|
|
params := pagination.NewParams(2, 5)
|
|
habits, err := repo.FindActiveByUserIDWithPagination(ctx, userID, params)
|
|
if err != nil {
|
|
t.Fatalf("FindActiveByUserIDWithPagination failed: %v", err)
|
|
}
|
|
|
|
if len(habits) != 4 {
|
|
t.Errorf("Expected 4 habits on second page (9 total active), got %d", len(habits))
|
|
}
|
|
})
|
|
|
|
t.Run("PageBeyondTotal", func(t *testing.T) {
|
|
params := pagination.NewParams(10, 5)
|
|
habits, err := repo.FindActiveByUserIDWithPagination(ctx, userID, params)
|
|
if err != nil {
|
|
t.Fatalf("FindActiveByUserIDWithPagination failed: %v", err)
|
|
}
|
|
|
|
if len(habits) != 0 {
|
|
t.Errorf("Expected 0 habits beyond total pages, got %d", len(habits))
|
|
}
|
|
})
|
|
|
|
t.Run("CustomPageSize", func(t *testing.T) {
|
|
params := pagination.NewParams(1, 3)
|
|
habits, err := repo.FindActiveByUserIDWithPagination(ctx, userID, params)
|
|
if err != nil {
|
|
t.Fatalf("FindActiveByUserIDWithPagination failed: %v", err)
|
|
}
|
|
|
|
if len(habits) != 3 {
|
|
t.Errorf("Expected 3 habits with page_size=3, got %d", len(habits))
|
|
}
|
|
})
|
|
|
|
t.Run("ExcludesArchived", func(t *testing.T) {
|
|
params := pagination.NewParams(1, 20)
|
|
habits, err := repo.FindActiveByUserIDWithPagination(ctx, userID, params)
|
|
if err != nil {
|
|
t.Fatalf("FindActiveByUserIDWithPagination failed: %v", err)
|
|
}
|
|
|
|
if len(habits) != 9 {
|
|
t.Errorf("Expected 9 active habits (1 archived), got %d", len(habits))
|
|
}
|
|
|
|
for _, habit := range habits {
|
|
if habit.ArchivedAt != nil {
|
|
t.Error("Expected no archived habits in results")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestHabitRepositoryCountActiveByUserID(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer db.Close()
|
|
|
|
repo := NewHabitRepository(db)
|
|
ctx := context.Background()
|
|
|
|
userID := "user-count-test"
|
|
|
|
t.Run("NoHabits", func(t *testing.T) {
|
|
count, err := repo.CountActiveByUserID(ctx, "non-existent-user")
|
|
if err != nil {
|
|
t.Fatalf("CountActiveByUserID failed: %v", err)
|
|
}
|
|
|
|
if count != 0 {
|
|
t.Errorf("Expected count 0 for non-existent user, got %d", count)
|
|
}
|
|
})
|
|
|
|
for i := 1; i <= 7; i++ {
|
|
habit := entities.NewHabit(
|
|
userID,
|
|
"Habit "+string(rune(i+'0')),
|
|
value_objects.HabitTypeBoolean,
|
|
value_objects.FrequencyDaily,
|
|
false,
|
|
false,
|
|
)
|
|
repo.Create(ctx, habit)
|
|
}
|
|
|
|
t.Run("AllActive", func(t *testing.T) {
|
|
count, err := repo.CountActiveByUserID(ctx, userID)
|
|
if err != nil {
|
|
t.Fatalf("CountActiveByUserID failed: %v", err)
|
|
}
|
|
|
|
if count != 7 {
|
|
t.Errorf("Expected count 7, got %d", count)
|
|
}
|
|
})
|
|
|
|
t.Run("WithArchived", func(t *testing.T) {
|
|
habits, _ := repo.FindActiveByUserID(ctx, userID)
|
|
now := time.Now()
|
|
habits[0].ArchivedAt = &now
|
|
habits[1].ArchivedAt = &now
|
|
repo.Update(ctx, habits[0])
|
|
repo.Update(ctx, habits[1])
|
|
|
|
count, err := repo.CountActiveByUserID(ctx, userID)
|
|
if err != nil {
|
|
t.Fatalf("CountActiveByUserID failed: %v", err)
|
|
}
|
|
|
|
if count != 5 {
|
|
t.Errorf("Expected count 5 (7 total - 2 archived), got %d", count)
|
|
}
|
|
})
|
|
}
|