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:
@@ -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
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user