Add comprehensive test suite (216 tests)

Test coverage for:
- Task package: models, repository (memory + SQLite), service, API handlers
- Agent package: registry, lifecycle manager, credentials manager, API handlers
- Orchestrator package: queue, scheduler, watcher, ACP message store
- Events package: in-memory event bus with pub/sub
- ACP protocol: message types, helpers, JSON marshaling

All tests pass with 'go test ./...'
This commit is contained in:
jcfs
2026-01-10 01:52:56 +00:00
parent ba919305c2
commit ffd288efea
16 changed files with 6317 additions and 0 deletions
+486
View File
@@ -0,0 +1,486 @@
package api
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
"github.com/gin-gonic/gin"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/events/bus"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/task/service"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
// MockEventBus implements bus.EventBus for testing
type MockEventBus struct {
mu sync.Mutex
}
func NewMockEventBus() *MockEventBus {
return &MockEventBus{}
}
func (m *MockEventBus) Publish(ctx context.Context, subject string, event *bus.Event) error {
return nil
}
func (m *MockEventBus) Subscribe(subject string, handler bus.EventHandler) (bus.Subscription, error) {
return nil, nil
}
func (m *MockEventBus) QueueSubscribe(subject, queue string, handler bus.EventHandler) (bus.Subscription, error) {
return nil, nil
}
func (m *MockEventBus) Request(ctx context.Context, subject string, event *bus.Event, timeout time.Duration) (*bus.Event, error) {
return nil, nil
}
func (m *MockEventBus) Close() {}
func (m *MockEventBus) IsConnected() bool {
return true
}
func setupTestHandler(t *testing.T) (*Handler, *repository.MemoryRepository, *gin.Engine) {
t.Helper()
gin.SetMode(gin.TestMode)
repo := repository.NewMemoryRepository()
eventBus := NewMockEventBus()
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(repo, eventBus, log)
handler := NewHandler(svc, log)
router := gin.New()
return handler, repo, router
}
// Task handler tests
func TestHandler_CreateTask(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
// Create board and column first
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do", State: v1.TaskStateTODO}
_ = repo.CreateColumn(ctx, column)
router.POST("/tasks", handler.CreateTask)
body := CreateTaskRequest{
BoardID: "board-123",
ColumnID: "col-123",
Title: "Test Task",
Description: "A test task",
Priority: 5,
}
jsonBody, _ := json.Marshal(body)
req := httptest.NewRequest(http.MethodPost, "/tasks", bytes.NewBuffer(jsonBody))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusCreated {
t.Errorf("expected status 201, got %d: %s", w.Code, w.Body.String())
}
var resp TaskResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Title != "Test Task" {
t.Errorf("expected title 'Test Task', got %s", resp.Title)
}
}
func TestHandler_GetTask(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test Task"}
_ = repo.CreateTask(ctx, task)
router.GET("/tasks/:taskId", handler.GetTask)
req := httptest.NewRequest(http.MethodGet, "/tasks/task-123", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp TaskResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Title != "Test Task" {
t.Errorf("expected title 'Test Task', got %s", resp.Title)
}
}
func TestHandler_GetTaskNotFound(t *testing.T) {
handler, _, router := setupTestHandler(t)
router.GET("/tasks/:taskId", handler.GetTask)
req := httptest.NewRequest(http.MethodGet, "/tasks/nonexistent", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusNotFound {
t.Errorf("expected status 404, got %d", w.Code)
}
}
func TestHandler_UpdateTask(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Original"}
_ = repo.CreateTask(ctx, task)
router.PUT("/tasks/:taskId", handler.UpdateTask)
body := UpdateTaskRequest{Title: stringPtr("Updated Title")}
jsonBody, _ := json.Marshal(body)
req := httptest.NewRequest(http.MethodPut, "/tasks/task-123", bytes.NewBuffer(jsonBody))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp TaskResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Title != "Updated Title" {
t.Errorf("expected title 'Updated Title', got %s", resp.Title)
}
}
func TestHandler_DeleteTask(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test"}
_ = repo.CreateTask(ctx, task)
router.DELETE("/tasks/:taskId", handler.DeleteTask)
req := httptest.NewRequest(http.MethodDelete, "/tasks/task-123", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusNoContent {
t.Errorf("expected status 204, got %d", w.Code)
}
// Verify task is deleted
_, err := repo.GetTask(ctx, "task-123")
if err == nil {
t.Error("expected task to be deleted")
}
}
func TestHandler_ListTasks(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
_ = repo.CreateTask(ctx, &models.Task{ID: "task-1", BoardID: "board-123", ColumnID: "col-123", Title: "Task 1"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-2", BoardID: "board-123", ColumnID: "col-123", Title: "Task 2"})
router.GET("/boards/:boardId/tasks", handler.ListTasks)
req := httptest.NewRequest(http.MethodGet, "/boards/board-123/tasks", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp TasksListResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if len(resp.Tasks) != 2 {
t.Errorf("expected 2 tasks, got %d", len(resp.Tasks))
}
}
// Board handler tests
func TestHandler_CreateBoard(t *testing.T) {
handler, _, router := setupTestHandler(t)
router.POST("/boards", handler.CreateBoard)
body := CreateBoardRequest{
Name: "Test Board",
Description: "A test board",
}
jsonBody, _ := json.Marshal(body)
req := httptest.NewRequest(http.MethodPost, "/boards", bytes.NewBuffer(jsonBody))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusCreated {
t.Errorf("expected status 201, got %d: %s", w.Code, w.Body.String())
}
var resp BoardResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Name != "Test Board" {
t.Errorf("expected name 'Test Board', got %s", resp.Name)
}
}
func TestHandler_GetBoard(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
router.GET("/boards/:boardId", handler.GetBoard)
req := httptest.NewRequest(http.MethodGet, "/boards/board-123", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp BoardResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Name != "Test Board" {
t.Errorf("expected name 'Test Board', got %s", resp.Name)
}
}
func TestHandler_GetBoardNotFound(t *testing.T) {
handler, _, router := setupTestHandler(t)
router.GET("/boards/:boardId", handler.GetBoard)
req := httptest.NewRequest(http.MethodGet, "/boards/nonexistent", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusNotFound {
t.Errorf("expected status 404, got %d", w.Code)
}
}
func TestHandler_UpdateBoard(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Original"}
_ = repo.CreateBoard(ctx, board)
router.PUT("/boards/:boardId", handler.UpdateBoard)
body := UpdateBoardRequest{Name: stringPtr("Updated")}
jsonBody, _ := json.Marshal(body)
req := httptest.NewRequest(http.MethodPut, "/boards/board-123", bytes.NewBuffer(jsonBody))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp BoardResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Name != "Updated" {
t.Errorf("expected name 'Updated', got %s", resp.Name)
}
}
func TestHandler_DeleteBoard(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
router.DELETE("/boards/:boardId", handler.DeleteBoard)
req := httptest.NewRequest(http.MethodDelete, "/boards/board-123", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusNoContent {
t.Errorf("expected status 204, got %d", w.Code)
}
// Verify board is deleted
_, err := repo.GetBoard(ctx, "board-123")
if err == nil {
t.Error("expected board to be deleted")
}
}
func TestHandler_ListBoards(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-1", Name: "Board 1"})
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-2", Name: "Board 2"})
router.GET("/boards", handler.ListBoards)
req := httptest.NewRequest(http.MethodGet, "/boards", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp BoardsListResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if len(resp.Boards) != 2 {
t.Errorf("expected 2 boards, got %d", len(resp.Boards))
}
}
// Column handler tests
func TestHandler_CreateColumn(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
router.POST("/boards/:boardId/columns", handler.CreateColumn)
body := CreateColumnRequest{
Name: "To Do",
Position: 0,
State: "TODO",
}
jsonBody, _ := json.Marshal(body)
req := httptest.NewRequest(http.MethodPost, "/boards/board-123/columns", bytes.NewBuffer(jsonBody))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusCreated {
t.Errorf("expected status 201, got %d: %s", w.Code, w.Body.String())
}
var resp ColumnResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Name != "To Do" {
t.Errorf("expected name 'To Do', got %s", resp.Name)
}
}
func TestHandler_GetColumn(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do"}
_ = repo.CreateColumn(ctx, column)
router.GET("/columns/:columnId", handler.GetColumn)
req := httptest.NewRequest(http.MethodGet, "/columns/col-123", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp ColumnResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Name != "To Do" {
t.Errorf("expected name 'To Do', got %s", resp.Name)
}
}
func TestHandler_ListColumns(t *testing.T) {
handler, repo, router := setupTestHandler(t)
ctx := context.Background()
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-1", BoardID: "board-123", Name: "To Do"})
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-2", BoardID: "board-123", Name: "Done"})
router.GET("/boards/:boardId/columns", handler.ListColumns)
req := httptest.NewRequest(http.MethodGet, "/boards/board-123/columns", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Errorf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
var resp ColumnsListResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if len(resp.Columns) != 2 {
t.Errorf("expected 2 columns, got %d", len(resp.Columns))
}
}
// Helper function
func stringPtr(s string) *string {
return &s
}
+216
View File
@@ -0,0 +1,216 @@
package models
import (
"testing"
"time"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
func TestTaskStateConstants(t *testing.T) {
tests := []struct {
name string
state v1.TaskState
expected string
}{
{"TODO state", v1.TaskStateTODO, "TODO"},
{"IN_PROGRESS state", v1.TaskStateInProgress, "IN_PROGRESS"},
{"BLOCKED state", v1.TaskStateBlocked, "BLOCKED"},
{"COMPLETED state", v1.TaskStateCompleted, "COMPLETED"},
{"FAILED state", v1.TaskStateFailed, "FAILED"},
{"CANCELLED state", v1.TaskStateCancelled, "CANCELLED"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if string(tt.state) != tt.expected {
t.Errorf("expected %s, got %s", tt.expected, string(tt.state))
}
})
}
}
func TestTaskStructInitialization(t *testing.T) {
now := time.Now().UTC()
task := Task{
ID: "task-123",
BoardID: "board-456",
ColumnID: "column-789",
Title: "Test Task",
Description: "A test task description",
State: v1.TaskStateTODO,
Priority: 5,
AgentType: "coding",
AssignedTo: "agent-001",
Position: 1,
Metadata: map[string]interface{}{"key": "value"},
CreatedAt: now,
UpdatedAt: now,
}
if task.ID != "task-123" {
t.Errorf("expected ID task-123, got %s", task.ID)
}
if task.BoardID != "board-456" {
t.Errorf("expected BoardID board-456, got %s", task.BoardID)
}
if task.ColumnID != "column-789" {
t.Errorf("expected ColumnID column-789, got %s", task.ColumnID)
}
if task.Title != "Test Task" {
t.Errorf("expected Title 'Test Task', got %s", task.Title)
}
if task.Description != "A test task description" {
t.Errorf("expected Description 'A test task description', got %s", task.Description)
}
if task.State != v1.TaskStateTODO {
t.Errorf("expected State TODO, got %s", task.State)
}
if task.Priority != 5 {
t.Errorf("expected Priority 5, got %d", task.Priority)
}
if task.AgentType != "coding" {
t.Errorf("expected AgentType 'coding', got %s", task.AgentType)
}
if task.AssignedTo != "agent-001" {
t.Errorf("expected AssignedTo 'agent-001', got %s", task.AssignedTo)
}
if task.Position != 1 {
t.Errorf("expected Position 1, got %d", task.Position)
}
if task.Metadata["key"] != "value" {
t.Errorf("expected Metadata key 'value', got %v", task.Metadata["key"])
}
}
func TestBoardStructInitialization(t *testing.T) {
now := time.Now().UTC()
board := Board{
ID: "board-123",
Name: "Test Board",
Description: "A test board",
OwnerID: "owner-456",
CreatedAt: now,
UpdatedAt: now,
}
if board.ID != "board-123" {
t.Errorf("expected ID board-123, got %s", board.ID)
}
if board.Name != "Test Board" {
t.Errorf("expected Name 'Test Board', got %s", board.Name)
}
if board.Description != "A test board" {
t.Errorf("expected Description 'A test board', got %s", board.Description)
}
if board.OwnerID != "owner-456" {
t.Errorf("expected OwnerID 'owner-456', got %s", board.OwnerID)
}
}
func TestColumnStructInitialization(t *testing.T) {
now := time.Now().UTC()
column := Column{
ID: "column-123",
BoardID: "board-456",
Name: "To Do",
Position: 0,
State: v1.TaskStateTODO,
CreatedAt: now,
UpdatedAt: now,
}
if column.ID != "column-123" {
t.Errorf("expected ID column-123, got %s", column.ID)
}
if column.BoardID != "board-456" {
t.Errorf("expected BoardID board-456, got %s", column.BoardID)
}
if column.Name != "To Do" {
t.Errorf("expected Name 'To Do', got %s", column.Name)
}
if column.Position != 0 {
t.Errorf("expected Position 0, got %d", column.Position)
}
if column.State != v1.TaskStateTODO {
t.Errorf("expected State TODO, got %s", column.State)
}
}
func TestTaskToAPI(t *testing.T) {
now := time.Now().UTC()
task := &Task{
ID: "task-123",
BoardID: "board-456",
ColumnID: "column-789",
Title: "Test Task",
Description: "A test task description",
State: v1.TaskStateInProgress,
Priority: 3,
AgentType: "coding",
AssignedTo: "agent-001",
Position: 2,
Metadata: map[string]interface{}{"key": "value"},
CreatedAt: now,
UpdatedAt: now,
}
apiTask := task.ToAPI()
if apiTask.ID != task.ID {
t.Errorf("expected ID %s, got %s", task.ID, apiTask.ID)
}
if apiTask.BoardID != task.BoardID {
t.Errorf("expected BoardID %s, got %s", task.BoardID, apiTask.BoardID)
}
if apiTask.Title != task.Title {
t.Errorf("expected Title %s, got %s", task.Title, apiTask.Title)
}
if apiTask.Description != task.Description {
t.Errorf("expected Description %s, got %s", task.Description, apiTask.Description)
}
if apiTask.State != task.State {
t.Errorf("expected State %s, got %s", task.State, apiTask.State)
}
if apiTask.Priority != task.Priority {
t.Errorf("expected Priority %d, got %d", task.Priority, apiTask.Priority)
}
if apiTask.AgentType == nil || *apiTask.AgentType != task.AgentType {
t.Errorf("expected AgentType %s, got %v", task.AgentType, apiTask.AgentType)
}
if apiTask.AssignedAgentID == nil || *apiTask.AssignedAgentID != task.AssignedTo {
t.Errorf("expected AssignedAgentID %s, got %v", task.AssignedTo, apiTask.AssignedAgentID)
}
if apiTask.Metadata["key"] != "value" {
t.Errorf("expected Metadata key 'value', got %v", apiTask.Metadata["key"])
}
}
func TestTaskToAPIWithEmptyOptionalFields(t *testing.T) {
now := time.Now().UTC()
task := &Task{
ID: "task-123",
BoardID: "board-456",
ColumnID: "column-789",
Title: "Test Task",
Description: "A test task description",
State: v1.TaskStateTODO,
Priority: 0,
AgentType: "",
AssignedTo: "",
Position: 0,
Metadata: nil,
CreatedAt: now,
UpdatedAt: now,
}
apiTask := task.ToAPI()
if apiTask.AgentType != nil {
t.Errorf("expected AgentType nil, got %v", apiTask.AgentType)
}
if apiTask.AssignedAgentID != nil {
t.Errorf("expected AssignedAgentID nil, got %v", apiTask.AssignedAgentID)
}
}
@@ -0,0 +1,337 @@
package repository
import (
"context"
"testing"
"github.com/kandev/kandev/internal/task/models"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
func TestNewMemoryRepository(t *testing.T) {
repo := NewMemoryRepository()
if repo == nil {
t.Fatal("expected non-nil repository")
}
if repo.tasks == nil {
t.Error("expected tasks map to be initialized")
}
if repo.boards == nil {
t.Error("expected boards map to be initialized")
}
if repo.columns == nil {
t.Error("expected columns map to be initialized")
}
}
func TestMemoryRepository_Close(t *testing.T) {
repo := NewMemoryRepository()
err := repo.Close()
if err != nil {
t.Errorf("expected no error on close, got %v", err)
}
}
// Board CRUD tests
func TestMemoryRepository_BoardCRUD(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
// Create
board := &models.Board{Name: "Test Board", Description: "A test board", OwnerID: "owner-123"}
if err := repo.CreateBoard(ctx, board); err != nil {
t.Fatalf("failed to create board: %v", err)
}
if board.ID == "" {
t.Error("expected board ID to be set")
}
if board.CreatedAt.IsZero() {
t.Error("expected CreatedAt to be set")
}
// Get
retrieved, err := repo.GetBoard(ctx, board.ID)
if err != nil {
t.Fatalf("failed to get board: %v", err)
}
if retrieved.Name != "Test Board" {
t.Errorf("expected name 'Test Board', got %s", retrieved.Name)
}
// Update
board.Name = "Updated Name"
if err := repo.UpdateBoard(ctx, board); err != nil {
t.Fatalf("failed to update board: %v", err)
}
retrieved, _ = repo.GetBoard(ctx, board.ID)
if retrieved.Name != "Updated Name" {
t.Errorf("expected name 'Updated Name', got %s", retrieved.Name)
}
// Delete
if err := repo.DeleteBoard(ctx, board.ID); err != nil {
t.Fatalf("failed to delete board: %v", err)
}
_, err = repo.GetBoard(ctx, board.ID)
if err == nil {
t.Error("expected board to be deleted")
}
}
func TestMemoryRepository_BoardNotFound(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_, err := repo.GetBoard(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent board")
}
err = repo.UpdateBoard(ctx, &models.Board{ID: "nonexistent", Name: "Test"})
if err == nil {
t.Error("expected error for updating nonexistent board")
}
err = repo.DeleteBoard(ctx, "nonexistent")
if err == nil {
t.Error("expected error for deleting nonexistent board")
}
}
func TestMemoryRepository_ListBoards(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-1", Name: "Board 1"})
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-2", Name: "Board 2"})
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-3", Name: "Board 3"})
boards, err := repo.ListBoards(ctx)
if err != nil {
t.Fatalf("failed to list boards: %v", err)
}
if len(boards) != 3 {
t.Errorf("expected 3 boards, got %d", len(boards))
}
}
// Column CRUD tests
func TestMemoryRepository_ColumnCRUD(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
// Create
column := &models.Column{BoardID: "board-123", Name: "To Do", Position: 0, State: v1.TaskStateTODO}
if err := repo.CreateColumn(ctx, column); err != nil {
t.Fatalf("failed to create column: %v", err)
}
if column.ID == "" {
t.Error("expected column ID to be set")
}
// Get
retrieved, err := repo.GetColumn(ctx, column.ID)
if err != nil {
t.Fatalf("failed to get column: %v", err)
}
if retrieved.Name != "To Do" {
t.Errorf("expected name 'To Do', got %s", retrieved.Name)
}
// Update
column.Name = "Done"
column.State = v1.TaskStateCompleted
if err := repo.UpdateColumn(ctx, column); err != nil {
t.Fatalf("failed to update column: %v", err)
}
retrieved, _ = repo.GetColumn(ctx, column.ID)
if retrieved.Name != "Done" {
t.Errorf("expected name 'Done', got %s", retrieved.Name)
}
// Delete
if err := repo.DeleteColumn(ctx, column.ID); err != nil {
t.Fatalf("failed to delete column: %v", err)
}
_, err = repo.GetColumn(ctx, column.ID)
if err == nil {
t.Error("expected column to be deleted")
}
}
func TestMemoryRepository_ColumnNotFound(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_, err := repo.GetColumn(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent column")
}
err = repo.UpdateColumn(ctx, &models.Column{ID: "nonexistent", Name: "Test"})
if err == nil {
t.Error("expected error for updating nonexistent column")
}
err = repo.DeleteColumn(ctx, "nonexistent")
if err == nil {
t.Error("expected error for deleting nonexistent column")
}
}
func TestMemoryRepository_ListColumns(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-1", BoardID: "board-123", Name: "To Do"})
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-2", BoardID: "board-123", Name: "In Progress"})
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-3", BoardID: "board-456", Name: "Done"})
columns, err := repo.ListColumns(ctx, "board-123")
if err != nil {
t.Fatalf("failed to list columns: %v", err)
}
if len(columns) != 2 {
t.Errorf("expected 2 columns for board-123, got %d", len(columns))
}
}
// Task CRUD tests
func TestMemoryRepository_TaskCRUD(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
// Create
task := &models.Task{
BoardID: "board-123",
ColumnID: "col-123",
Title: "Test Task",
Description: "A test task",
State: v1.TaskStateTODO,
Priority: 5,
}
if err := repo.CreateTask(ctx, task); err != nil {
t.Fatalf("failed to create task: %v", err)
}
if task.ID == "" {
t.Error("expected task ID to be set")
}
if task.CreatedAt.IsZero() {
t.Error("expected CreatedAt to be set")
}
// Get
retrieved, err := repo.GetTask(ctx, task.ID)
if err != nil {
t.Fatalf("failed to get task: %v", err)
}
if retrieved.Title != "Test Task" {
t.Errorf("expected title 'Test Task', got %s", retrieved.Title)
}
// Update
task.Title = "Updated Task"
task.Description = "Updated description"
if err := repo.UpdateTask(ctx, task); err != nil {
t.Fatalf("failed to update task: %v", err)
}
retrieved, _ = repo.GetTask(ctx, task.ID)
if retrieved.Title != "Updated Task" {
t.Errorf("expected title 'Updated Task', got %s", retrieved.Title)
}
// Delete
if err := repo.DeleteTask(ctx, task.ID); err != nil {
t.Fatalf("failed to delete task: %v", err)
}
_, err = repo.GetTask(ctx, task.ID)
if err == nil {
t.Error("expected task to be deleted")
}
}
func TestMemoryRepository_TaskNotFound(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_, err := repo.GetTask(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent task")
}
err = repo.UpdateTask(ctx, &models.Task{ID: "nonexistent", Title: "Test"})
if err == nil {
t.Error("expected error for updating nonexistent task")
}
err = repo.DeleteTask(ctx, "nonexistent")
if err == nil {
t.Error("expected error for deleting nonexistent task")
}
}
func TestMemoryRepository_UpdateTaskState(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test", State: v1.TaskStateTODO}
_ = repo.CreateTask(ctx, task)
err := repo.UpdateTaskState(ctx, "task-123", v1.TaskStateInProgress)
if err != nil {
t.Fatalf("failed to update task state: %v", err)
}
retrieved, _ := repo.GetTask(ctx, "task-123")
if retrieved.State != v1.TaskStateInProgress {
t.Errorf("expected state IN_PROGRESS, got %s", retrieved.State)
}
}
func TestMemoryRepository_UpdateTaskStateNotFound(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
err := repo.UpdateTaskState(ctx, "nonexistent", v1.TaskStateInProgress)
if err == nil {
t.Error("expected error for nonexistent task")
}
}
func TestMemoryRepository_ListTasks(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_ = repo.CreateTask(ctx, &models.Task{ID: "task-1", BoardID: "board-123", ColumnID: "col-1", Title: "Task 1"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-2", BoardID: "board-123", ColumnID: "col-1", Title: "Task 2"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-3", BoardID: "board-456", ColumnID: "col-2", Title: "Task 3"})
tasks, err := repo.ListTasks(ctx, "board-123")
if err != nil {
t.Fatalf("failed to list tasks: %v", err)
}
if len(tasks) != 2 {
t.Errorf("expected 2 tasks for board-123, got %d", len(tasks))
}
}
func TestMemoryRepository_ListTasksByColumn(t *testing.T) {
repo := NewMemoryRepository()
ctx := context.Background()
_ = repo.CreateTask(ctx, &models.Task{ID: "task-1", BoardID: "board-123", ColumnID: "col-1", Title: "Task 1"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-2", BoardID: "board-123", ColumnID: "col-1", Title: "Task 2"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-3", BoardID: "board-123", ColumnID: "col-2", Title: "Task 3"})
tasks, err := repo.ListTasksByColumn(ctx, "col-1")
if err != nil {
t.Fatalf("failed to list tasks by column: %v", err)
}
if len(tasks) != 2 {
t.Errorf("expected 2 tasks for col-1, got %d", len(tasks))
}
}
@@ -0,0 +1,426 @@
package repository
import (
"context"
"os"
"path/filepath"
"testing"
"github.com/kandev/kandev/internal/task/models"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
func createTestSQLiteRepo(t *testing.T) (*SQLiteRepository, func()) {
t.Helper()
tmpDir := t.TempDir()
dbPath := filepath.Join(tmpDir, "test.db")
repo, err := NewSQLiteRepository(dbPath)
if err != nil {
t.Fatalf("failed to create SQLite repository: %v", err)
}
cleanup := func() {
repo.Close()
os.Remove(dbPath)
}
return repo, cleanup
}
func TestNewSQLiteRepository(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
if repo == nil {
t.Fatal("expected non-nil repository")
}
if repo.db == nil {
t.Error("expected db to be initialized")
}
}
func TestSQLiteRepository_Close(t *testing.T) {
repo, _ := createTestSQLiteRepo(t)
err := repo.Close()
if err != nil {
t.Errorf("expected no error on close, got %v", err)
}
}
// Board CRUD tests
func TestSQLiteRepository_BoardCRUD(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
// Create
board := &models.Board{Name: "Test Board", Description: "A test board", OwnerID: "owner-123"}
if err := repo.CreateBoard(ctx, board); err != nil {
t.Fatalf("failed to create board: %v", err)
}
if board.ID == "" {
t.Error("expected board ID to be set")
}
if board.CreatedAt.IsZero() {
t.Error("expected CreatedAt to be set")
}
// Get
retrieved, err := repo.GetBoard(ctx, board.ID)
if err != nil {
t.Fatalf("failed to get board: %v", err)
}
if retrieved.Name != "Test Board" {
t.Errorf("expected name 'Test Board', got %s", retrieved.Name)
}
// Update
board.Name = "Updated Name"
if err := repo.UpdateBoard(ctx, board); err != nil {
t.Fatalf("failed to update board: %v", err)
}
retrieved, _ = repo.GetBoard(ctx, board.ID)
if retrieved.Name != "Updated Name" {
t.Errorf("expected name 'Updated Name', got %s", retrieved.Name)
}
// Delete
if err := repo.DeleteBoard(ctx, board.ID); err != nil {
t.Fatalf("failed to delete board: %v", err)
}
_, err = repo.GetBoard(ctx, board.ID)
if err == nil {
t.Error("expected board to be deleted")
}
}
func TestSQLiteRepository_BoardNotFound(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
_, err := repo.GetBoard(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent board")
}
err = repo.UpdateBoard(ctx, &models.Board{ID: "nonexistent", Name: "Test"})
if err == nil {
t.Error("expected error for updating nonexistent board")
}
err = repo.DeleteBoard(ctx, "nonexistent")
if err == nil {
t.Error("expected error for deleting nonexistent board")
}
}
func TestSQLiteRepository_ListBoards(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-1", Name: "Board 1"})
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-2", Name: "Board 2"})
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-3", Name: "Board 3"})
boards, err := repo.ListBoards(ctx)
if err != nil {
t.Fatalf("failed to list boards: %v", err)
}
if len(boards) != 3 {
t.Errorf("expected 3 boards, got %d", len(boards))
}
}
// Column CRUD tests
func TestSQLiteRepository_ColumnCRUD(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
// First create a board for foreign key
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
// Create column
column := &models.Column{BoardID: "board-123", Name: "To Do", Position: 0, State: v1.TaskStateTODO}
if err := repo.CreateColumn(ctx, column); err != nil {
t.Fatalf("failed to create column: %v", err)
}
if column.ID == "" {
t.Error("expected column ID to be set")
}
// Get
retrieved, err := repo.GetColumn(ctx, column.ID)
if err != nil {
t.Fatalf("failed to get column: %v", err)
}
if retrieved.Name != "To Do" {
t.Errorf("expected name 'To Do', got %s", retrieved.Name)
}
// Update
column.Name = "Done"
column.State = v1.TaskStateCompleted
if err := repo.UpdateColumn(ctx, column); err != nil {
t.Fatalf("failed to update column: %v", err)
}
retrieved, _ = repo.GetColumn(ctx, column.ID)
if retrieved.Name != "Done" {
t.Errorf("expected name 'Done', got %s", retrieved.Name)
}
// Delete
if err := repo.DeleteColumn(ctx, column.ID); err != nil {
t.Fatalf("failed to delete column: %v", err)
}
_, err = repo.GetColumn(ctx, column.ID)
if err == nil {
t.Error("expected column to be deleted")
}
}
func TestSQLiteRepository_ColumnNotFound(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
_, err := repo.GetColumn(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent column")
}
err = repo.UpdateColumn(ctx, &models.Column{ID: "nonexistent", Name: "Test"})
if err == nil {
t.Error("expected error for updating nonexistent column")
}
err = repo.DeleteColumn(ctx, "nonexistent")
if err == nil {
t.Error("expected error for deleting nonexistent column")
}
}
func TestSQLiteRepository_ListColumns(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-1", BoardID: "board-123", Name: "To Do"})
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-2", BoardID: "board-123", Name: "In Progress"})
columns, err := repo.ListColumns(ctx, "board-123")
if err != nil {
t.Fatalf("failed to list columns: %v", err)
}
if len(columns) != 2 {
t.Errorf("expected 2 columns, got %d", len(columns))
}
}
// Task CRUD tests
func TestSQLiteRepository_TaskCRUD(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
// Create board and column for foreign keys
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do"}
_ = repo.CreateColumn(ctx, column)
// Create task
task := &models.Task{
BoardID: "board-123",
ColumnID: "col-123",
Title: "Test Task",
Description: "A test task",
State: v1.TaskStateTODO,
Priority: 5,
Metadata: map[string]interface{}{"key": "value"},
}
if err := repo.CreateTask(ctx, task); err != nil {
t.Fatalf("failed to create task: %v", err)
}
if task.ID == "" {
t.Error("expected task ID to be set")
}
// Get
retrieved, err := repo.GetTask(ctx, task.ID)
if err != nil {
t.Fatalf("failed to get task: %v", err)
}
if retrieved.Title != "Test Task" {
t.Errorf("expected title 'Test Task', got %s", retrieved.Title)
}
if retrieved.Metadata["key"] != "value" {
t.Errorf("expected metadata key 'value', got %v", retrieved.Metadata["key"])
}
// Update
task.Title = "Updated Task"
if err := repo.UpdateTask(ctx, task); err != nil {
t.Fatalf("failed to update task: %v", err)
}
retrieved, _ = repo.GetTask(ctx, task.ID)
if retrieved.Title != "Updated Task" {
t.Errorf("expected title 'Updated Task', got %s", retrieved.Title)
}
// Delete
if err := repo.DeleteTask(ctx, task.ID); err != nil {
t.Fatalf("failed to delete task: %v", err)
}
_, err = repo.GetTask(ctx, task.ID)
if err == nil {
t.Error("expected task to be deleted")
}
}
func TestSQLiteRepository_TaskNotFound(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
_, err := repo.GetTask(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent task")
}
err = repo.UpdateTask(ctx, &models.Task{ID: "nonexistent", Title: "Test"})
if err == nil {
t.Error("expected error for updating nonexistent task")
}
err = repo.DeleteTask(ctx, "nonexistent")
if err == nil {
t.Error("expected error for deleting nonexistent task")
}
}
func TestSQLiteRepository_UpdateTaskState(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
// Create board, column, and task
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do"}
_ = repo.CreateColumn(ctx, column)
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test", State: v1.TaskStateTODO}
_ = repo.CreateTask(ctx, task)
err := repo.UpdateTaskState(ctx, "task-123", v1.TaskStateInProgress)
if err != nil {
t.Fatalf("failed to update task state: %v", err)
}
retrieved, _ := repo.GetTask(ctx, "task-123")
if retrieved.State != v1.TaskStateInProgress {
t.Errorf("expected state IN_PROGRESS, got %s", retrieved.State)
}
}
func TestSQLiteRepository_UpdateTaskStateNotFound(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
err := repo.UpdateTaskState(ctx, "nonexistent", v1.TaskStateInProgress)
if err == nil {
t.Error("expected error for nonexistent task")
}
}
func TestSQLiteRepository_ListTasks(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
// Create board and column
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do"}
_ = repo.CreateColumn(ctx, column)
_ = repo.CreateTask(ctx, &models.Task{ID: "task-1", BoardID: "board-123", ColumnID: "col-123", Title: "Task 1"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-2", BoardID: "board-123", ColumnID: "col-123", Title: "Task 2"})
tasks, err := repo.ListTasks(ctx, "board-123")
if err != nil {
t.Fatalf("failed to list tasks: %v", err)
}
if len(tasks) != 2 {
t.Errorf("expected 2 tasks, got %d", len(tasks))
}
}
func TestSQLiteRepository_ListTasksByColumn(t *testing.T) {
repo, cleanup := createTestSQLiteRepo(t)
defer cleanup()
ctx := context.Background()
// Create board and columns
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
col1 := &models.Column{ID: "col-1", BoardID: "board-123", Name: "To Do"}
col2 := &models.Column{ID: "col-2", BoardID: "board-123", Name: "Done"}
_ = repo.CreateColumn(ctx, col1)
_ = repo.CreateColumn(ctx, col2)
_ = repo.CreateTask(ctx, &models.Task{ID: "task-1", BoardID: "board-123", ColumnID: "col-1", Title: "Task 1"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-2", BoardID: "board-123", ColumnID: "col-1", Title: "Task 2"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-3", BoardID: "board-123", ColumnID: "col-2", Title: "Task 3"})
tasks, err := repo.ListTasksByColumn(ctx, "col-1")
if err != nil {
t.Fatalf("failed to list tasks by column: %v", err)
}
if len(tasks) != 2 {
t.Errorf("expected 2 tasks for col-1, got %d", len(tasks))
}
}
func TestSQLiteRepository_Persistence(t *testing.T) {
tmpDir := t.TempDir()
dbPath := filepath.Join(tmpDir, "persistence_test.db")
ctx := context.Background()
// Create repository and add data
repo1, err := NewSQLiteRepository(dbPath)
if err != nil {
t.Fatalf("failed to create first repository: %v", err)
}
board := &models.Board{ID: "persist-board", Name: "Persistent Board"}
_ = repo1.CreateBoard(ctx, board)
repo1.Close()
// Reopen repository and verify data persisted
repo2, err := NewSQLiteRepository(dbPath)
if err != nil {
t.Fatalf("failed to create second repository: %v", err)
}
defer repo2.Close()
retrieved, err := repo2.GetBoard(ctx, "persist-board")
if err != nil {
t.Fatalf("failed to get board after reopen: %v", err)
}
if retrieved.Name != "Persistent Board" {
t.Errorf("expected name 'Persistent Board', got %s", retrieved.Name)
}
}
@@ -0,0 +1,425 @@
package service
import (
"context"
"sync"
"testing"
"time"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/events/bus"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
// MockEventBus implements bus.EventBus for testing
type MockEventBus struct {
mu sync.Mutex
publishedEvents []*bus.Event
closed bool
}
func NewMockEventBus() *MockEventBus {
return &MockEventBus{
publishedEvents: make([]*bus.Event, 0),
}
}
func (m *MockEventBus) Publish(ctx context.Context, subject string, event *bus.Event) error {
m.mu.Lock()
defer m.mu.Unlock()
m.publishedEvents = append(m.publishedEvents, event)
return nil
}
func (m *MockEventBus) Subscribe(subject string, handler bus.EventHandler) (bus.Subscription, error) {
return nil, nil
}
func (m *MockEventBus) QueueSubscribe(subject, queue string, handler bus.EventHandler) (bus.Subscription, error) {
return nil, nil
}
func (m *MockEventBus) Request(ctx context.Context, subject string, event *bus.Event, timeout time.Duration) (*bus.Event, error) {
return nil, nil
}
func (m *MockEventBus) Close() {
m.mu.Lock()
defer m.mu.Unlock()
m.closed = true
}
func (m *MockEventBus) IsConnected() bool {
return !m.closed
}
func (m *MockEventBus) GetPublishedEvents() []*bus.Event {
m.mu.Lock()
defer m.mu.Unlock()
return m.publishedEvents
}
func (m *MockEventBus) ClearEvents() {
m.mu.Lock()
defer m.mu.Unlock()
m.publishedEvents = make([]*bus.Event, 0)
}
func createTestService(t *testing.T) (*Service, *MockEventBus, *repository.MemoryRepository) {
t.Helper()
repo := repository.NewMemoryRepository()
eventBus := NewMockEventBus()
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := NewService(repo, eventBus, log)
return svc, eventBus, repo
}
// Task tests
func TestService_CreateTask(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
// Create board and column first
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do", State: v1.TaskStateTODO}
_ = repo.CreateColumn(ctx, column)
req := &CreateTaskRequest{
BoardID: "board-123",
ColumnID: "col-123",
Title: "Test Task",
Description: "A test task",
Priority: 5,
}
task, err := svc.CreateTask(ctx, req)
if err != nil {
t.Fatalf("failed to create task: %v", err)
}
if task.ID == "" {
t.Error("expected task ID to be set")
}
if task.Title != "Test Task" {
t.Errorf("expected title 'Test Task', got %s", task.Title)
}
if task.State != v1.TaskStateTODO {
t.Errorf("expected state TODO, got %s", task.State)
}
// Check event was published
events := eventBus.GetPublishedEvents()
if len(events) != 1 {
t.Errorf("expected 1 event, got %d", len(events))
}
if events[0].Type != "task.created" {
t.Errorf("expected event type 'task.created', got %s", events[0].Type)
}
}
func TestService_GetTask(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
// Create a task directly in repo
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test Task"}
_ = repo.CreateTask(ctx, task)
retrieved, err := svc.GetTask(ctx, "task-123")
if err != nil {
t.Fatalf("failed to get task: %v", err)
}
if retrieved.Title != "Test Task" {
t.Errorf("expected title 'Test Task', got %s", retrieved.Title)
}
}
func TestService_GetTaskNotFound(t *testing.T) {
svc, _, _ := createTestService(t)
ctx := context.Background()
_, err := svc.GetTask(ctx, "nonexistent")
if err == nil {
t.Error("expected error for nonexistent task")
}
}
func TestService_UpdateTask(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Original"}
_ = repo.CreateTask(ctx, task)
eventBus.ClearEvents()
newTitle := "Updated Title"
req := &UpdateTaskRequest{Title: &newTitle}
updated, err := svc.UpdateTask(ctx, "task-123", req)
if err != nil {
t.Fatalf("failed to update task: %v", err)
}
if updated.Title != "Updated Title" {
t.Errorf("expected title 'Updated Title', got %s", updated.Title)
}
// Check event was published
events := eventBus.GetPublishedEvents()
if len(events) != 1 {
t.Errorf("expected 1 event, got %d", len(events))
}
if events[0].Type != "task.updated" {
t.Errorf("expected event type 'task.updated', got %s", events[0].Type)
}
}
func TestService_DeleteTask(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test"}
_ = repo.CreateTask(ctx, task)
eventBus.ClearEvents()
err := svc.DeleteTask(ctx, "task-123")
if err != nil {
t.Fatalf("failed to delete task: %v", err)
}
// Verify task is deleted
_, err = svc.GetTask(ctx, "task-123")
if err == nil {
t.Error("expected task to be deleted")
}
// Check event was published
events := eventBus.GetPublishedEvents()
if len(events) != 1 {
t.Errorf("expected 1 event, got %d", len(events))
}
}
func TestService_ListTasks(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateTask(ctx, &models.Task{ID: "task-1", BoardID: "board-123", ColumnID: "col-123", Title: "Task 1"})
_ = repo.CreateTask(ctx, &models.Task{ID: "task-2", BoardID: "board-123", ColumnID: "col-123", Title: "Task 2"})
tasks, err := svc.ListTasks(ctx, "board-123")
if err != nil {
t.Fatalf("failed to list tasks: %v", err)
}
if len(tasks) != 2 {
t.Errorf("expected 2 tasks, got %d", len(tasks))
}
}
func TestService_UpdateTaskState(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test", State: v1.TaskStateTODO}
_ = repo.CreateTask(ctx, task)
eventBus.ClearEvents()
updated, err := svc.UpdateTaskState(ctx, "task-123", v1.TaskStateInProgress)
if err != nil {
t.Fatalf("failed to update task state: %v", err)
}
if updated.State != v1.TaskStateInProgress {
t.Errorf("expected state IN_PROGRESS, got %s", updated.State)
}
// Check event was published
events := eventBus.GetPublishedEvents()
if len(events) != 1 {
t.Errorf("expected 1 event, got %d", len(events))
}
if events[0].Type != "task.state_changed" {
t.Errorf("expected event type 'task.state_changed', got %s", events[0].Type)
}
}
func TestService_MoveTask(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
// Create column with different state
column := &models.Column{ID: "col-done", BoardID: "board-123", Name: "Done", State: v1.TaskStateCompleted}
_ = repo.CreateColumn(ctx, column)
task := &models.Task{ID: "task-123", BoardID: "board-123", ColumnID: "col-123", Title: "Test", State: v1.TaskStateTODO}
_ = repo.CreateTask(ctx, task)
eventBus.ClearEvents()
moved, err := svc.MoveTask(ctx, "task-123", "col-done", 0)
if err != nil {
t.Fatalf("failed to move task: %v", err)
}
if moved.ColumnID != "col-done" {
t.Errorf("expected column 'col-done', got %s", moved.ColumnID)
}
if moved.State != v1.TaskStateCompleted {
t.Errorf("expected state COMPLETED, got %s", moved.State)
}
}
// Board tests
func TestService_CreateBoard(t *testing.T) {
svc, _, _ := createTestService(t)
ctx := context.Background()
req := &CreateBoardRequest{
Name: "Test Board",
Description: "A test board",
OwnerID: "owner-123",
}
board, err := svc.CreateBoard(ctx, req)
if err != nil {
t.Fatalf("failed to create board: %v", err)
}
if board.ID == "" {
t.Error("expected board ID to be set")
}
if board.Name != "Test Board" {
t.Errorf("expected name 'Test Board', got %s", board.Name)
}
}
func TestService_GetBoard(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
retrieved, err := svc.GetBoard(ctx, "board-123")
if err != nil {
t.Fatalf("failed to get board: %v", err)
}
if retrieved.Name != "Test Board" {
t.Errorf("expected name 'Test Board', got %s", retrieved.Name)
}
}
func TestService_UpdateBoard(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Original"}
_ = repo.CreateBoard(ctx, board)
newName := "Updated"
req := &UpdateBoardRequest{Name: &newName}
updated, err := svc.UpdateBoard(ctx, "board-123", req)
if err != nil {
t.Fatalf("failed to update board: %v", err)
}
if updated.Name != "Updated" {
t.Errorf("expected name 'Updated', got %s", updated.Name)
}
}
func TestService_DeleteBoard(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
err := svc.DeleteBoard(ctx, "board-123")
if err != nil {
t.Fatalf("failed to delete board: %v", err)
}
_, err = svc.GetBoard(ctx, "board-123")
if err == nil {
t.Error("expected board to be deleted")
}
}
func TestService_ListBoards(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-1", Name: "Board 1"})
_ = repo.CreateBoard(ctx, &models.Board{ID: "board-2", Name: "Board 2"})
boards, err := svc.ListBoards(ctx)
if err != nil {
t.Fatalf("failed to list boards: %v", err)
}
if len(boards) != 2 {
t.Errorf("expected 2 boards, got %d", len(boards))
}
}
// Column tests
func TestService_CreateColumn(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
board := &models.Board{ID: "board-123", Name: "Test Board"}
_ = repo.CreateBoard(ctx, board)
req := &CreateColumnRequest{
BoardID: "board-123",
Name: "To Do",
Position: 0,
State: v1.TaskStateTODO,
}
column, err := svc.CreateColumn(ctx, req)
if err != nil {
t.Fatalf("failed to create column: %v", err)
}
if column.ID == "" {
t.Error("expected column ID to be set")
}
if column.Name != "To Do" {
t.Errorf("expected name 'To Do', got %s", column.Name)
}
}
func TestService_GetColumn(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
column := &models.Column{ID: "col-123", BoardID: "board-123", Name: "To Do"}
_ = repo.CreateColumn(ctx, column)
retrieved, err := svc.GetColumn(ctx, "col-123")
if err != nil {
t.Fatalf("failed to get column: %v", err)
}
if retrieved.Name != "To Do" {
t.Errorf("expected name 'To Do', got %s", retrieved.Name)
}
}
func TestService_ListColumns(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-1", BoardID: "board-123", Name: "To Do"})
_ = repo.CreateColumn(ctx, &models.Column{ID: "col-2", BoardID: "board-123", Name: "Done"})
columns, err := svc.ListColumns(ctx, "board-123")
if err != nil {
t.Fatalf("failed to list columns: %v", err)
}
if len(columns) != 2 {
t.Errorf("expected 2 columns, got %d", len(columns))
}
}