@nextsparkjs/core 0.1.0-beta.23 → 0.1.0-beta.25

package/templates/contents/themes/starter/tests/jest/services/tasks.service.test.ts

@@ -0,0 +1,547 @@
+/**
+ * Unit Tests - TasksService (Starter Theme)
+ *
+ * Tests for the TasksService class methods:
+ * - Input validation (required fields, empty strings)
+ * - Data transformation (database null → undefined)
+ * - Default values for optional fields
+ * - Error handling
+ *
+ * Focus on business logic WITHOUT actual database calls.
+ * Database functions are mocked to isolate the service logic.
+ *
+ * This is the starter theme version - it tests the read-only service methods.
+ * For full CRUD tests, see the default theme's tasks.service.test.ts
+ */
+
+// Mock the database module before importing the service
+jest.mock('@nextsparkjs/core/lib/db', () => ({
+  queryOneWithRLS: jest.fn(),
+  queryWithRLS: jest.fn(),
+}))
+
+import { TasksService } from '@/contents/themes/starter/entities/tasks/tasks.service'
+import type { Task, TaskStatus, TaskPriority } from '@/contents/themes/starter/entities/tasks/tasks.types'
+
+// Get the mocked functions
+const mockQueryOneWithRLS = jest.requireMock('@nextsparkjs/core/lib/db').queryOneWithRLS
+const mockQueryWithRLS = jest.requireMock('@nextsparkjs/core/lib/db').queryWithRLS
+
+// Helper to create a mock database task row
+const createMockDbTask = (overrides = {}) => ({
+  id: 'task-123',
+  title: 'Test Task',
+  description: 'Test description',
+  status: 'todo' as TaskStatus,
+  priority: 'medium' as TaskPriority,
+  tags: ['tag1', 'tag2'],
+  dueDate: '2025-12-31',
+  estimatedHours: 5,
+  completed: false,
+  createdAt: '2025-01-01T00:00:00Z',
+  updatedAt: '2025-01-01T00:00:00Z',
+  ...overrides,
+})
+
+describe('TasksService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  // ============================================================
+  // getById
+  // ============================================================
+  describe('getById', () => {
+    describe('Input Validation', () => {
+      it('should throw error when id is empty', async () => {
+        await expect(TasksService.getById('', 'user-123'))
+          .rejects.toThrow('Task ID is required')
+      })
+
+      it('should throw error when id is whitespace only', async () => {
+        await expect(TasksService.getById('   ', 'user-123'))
+          .rejects.toThrow('Task ID is required')
+      })
+
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.getById('task-123', ''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.getById('task-123', '   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Successful Retrieval', () => {
+      it('should return task when found', async () => {
+        const mockTask = createMockDbTask()
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result).not.toBeNull()
+        expect(result?.id).toBe('task-123')
+        expect(result?.title).toBe('Test Task')
+        expect(mockQueryOneWithRLS).toHaveBeenCalledWith(
+          expect.stringContaining('SELECT'),
+          ['task-123'],
+          'user-123'
+        )
+      })
+
+      it('should return null when task not found', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(null)
+
+        const result = await TasksService.getById('non-existent', 'user-123')
+
+        expect(result).toBeNull()
+      })
+    })
+
+    describe('Data Transformation', () => {
+      it('should transform null description to undefined', async () => {
+        const mockTask = createMockDbTask({ description: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.description).toBeUndefined()
+      })
+
+      it('should transform null tags to undefined', async () => {
+        const mockTask = createMockDbTask({ tags: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.tags).toBeUndefined()
+      })
+
+      it('should transform null dueDate to undefined', async () => {
+        const mockTask = createMockDbTask({ dueDate: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.dueDate).toBeUndefined()
+      })
+
+      it('should transform null estimatedHours to undefined', async () => {
+        const mockTask = createMockDbTask({ estimatedHours: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.estimatedHours).toBeUndefined()
+      })
+
+      it('should transform null completed to undefined', async () => {
+        const mockTask = createMockDbTask({ completed: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.completed).toBeUndefined()
+      })
+
+      it('should preserve non-null values', async () => {
+        const mockTask = createMockDbTask()
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.description).toBe('Test description')
+        expect(result?.tags).toEqual(['tag1', 'tag2'])
+        expect(result?.dueDate).toBe('2025-12-31')
+        expect(result?.estimatedHours).toBe(5)
+        expect(result?.completed).toBe(false)
+      })
+    })
+
+    describe('Error Handling', () => {
+      it('should wrap database errors with descriptive message', async () => {
+        mockQueryOneWithRLS.mockRejectedValue(new Error('Database connection failed'))
+
+        await expect(TasksService.getById('task-123', 'user-123'))
+          .rejects.toThrow('Database connection failed')
+      })
+    })
+  })
+
+  // ============================================================
+  // list
+  // ============================================================
+  describe('list', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.list(''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.list('   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Default Options', () => {
+      it('should use default limit of 10', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }]) // count query
+          .mockResolvedValueOnce([]) // data query
+
+        await TasksService.list('user-123')
+
+        // Second call is the data query with LIMIT
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('LIMIT')
+        expect(dataQueryCall[1]).toContain(10) // default limit
+      })
+
+      it('should use default offset of 0', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123')
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[1]).toContain(0) // default offset
+      })
+
+      it('should use default orderBy createdAt DESC', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123')
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('"createdAt"')
+        expect(dataQueryCall[0]).toContain('DESC')
+      })
+    })
+
+    describe('Filtering', () => {
+      it('should filter by status when provided', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '2' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { status: 'todo' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('status = $1')
+        expect(countQueryCall[1]).toContain('todo')
+      })
+
+      it('should filter by priority when provided', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '2' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { priority: 'high' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('priority = $1')
+        expect(countQueryCall[1]).toContain('high')
+      })
+
+      it('should combine multiple filters with AND', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '1' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { status: 'todo', priority: 'high' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('status = $1')
+        expect(countQueryCall[0]).toContain('priority = $2')
+        expect(countQueryCall[0]).toContain('AND')
+      })
+    })
+
+    describe('Ordering', () => {
+      const validOrderByFields = ['title', 'status', 'priority', 'dueDate', 'createdAt']
+
+      validOrderByFields.forEach(field => {
+        it(`should order by ${field} when specified`, async () => {
+          mockQueryWithRLS
+            .mockResolvedValueOnce([{ count: '5' }])
+            .mockResolvedValueOnce([])
+
+          await TasksService.list('user-123', { orderBy: field as any })
+
+          const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+          // dueDate and createdAt need quotes in SQL
+          const expectedColumn = ['dueDate', 'createdAt'].includes(field)
+            ? `"${field}"`
+            : field
+          expect(dataQueryCall[0]).toContain(expectedColumn)
+        })
+      })
+
+      it('should fallback to createdAt for invalid orderBy', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { orderBy: 'invalidField' as any })
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('"createdAt"')
+      })
+
+      it('should order ASC when orderDir is asc', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { orderDir: 'asc' })
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('ASC')
+      })
+
+      it('should order DESC when orderDir is desc', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { orderDir: 'desc' })
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('DESC')
+      })
+    })
+
+    describe('Result Structure', () => {
+      it('should return tasks array and total count', async () => {
+        const mockTasks = [createMockDbTask(), createMockDbTask({ id: 'task-456' })]
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '10' }])
+          .mockResolvedValueOnce(mockTasks)
+
+        const result = await TasksService.list('user-123')
+
+        expect(result.tasks).toHaveLength(2)
+        expect(result.total).toBe(10)
+      })
+
+      it('should transform database rows to Task type', async () => {
+        const mockTask = createMockDbTask({ description: null, tags: null })
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '1' }])
+          .mockResolvedValueOnce([mockTask])
+
+        const result = await TasksService.list('user-123')
+
+        expect(result.tasks[0].description).toBeUndefined()
+        expect(result.tasks[0].tags).toBeUndefined()
+      })
+
+      it('should return empty array when no tasks found', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '0' }])
+          .mockResolvedValueOnce([])
+
+        const result = await TasksService.list('user-123')
+
+        expect(result.tasks).toEqual([])
+        expect(result.total).toBe(0)
+      })
+    })
+  })
+
+  // ============================================================
+  // getByStatus
+  // ============================================================
+  describe('getByStatus', () => {
+    it('should call list with status filter', async () => {
+      mockQueryWithRLS
+        .mockResolvedValueOnce([{ count: '2' }])
+        .mockResolvedValueOnce([createMockDbTask(), createMockDbTask({ id: 'task-456' })])
+
+      const result = await TasksService.getByStatus('user-123', 'in-progress')
+
+      expect(result).toHaveLength(2)
+      const countQueryCall = mockQueryWithRLS.mock.calls[0]
+      expect(countQueryCall[1]).toContain('in-progress')
+    })
+
+    it('should order by priority DESC', async () => {
+      mockQueryWithRLS
+        .mockResolvedValueOnce([{ count: '1' }])
+        .mockResolvedValueOnce([createMockDbTask()])
+
+      await TasksService.getByStatus('user-123', 'todo')
+
+      const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+      expect(dataQueryCall[0]).toContain('priority')
+      expect(dataQueryCall[0]).toContain('DESC')
+    })
+
+    it('should use large limit to get all matching tasks', async () => {
+      mockQueryWithRLS
+        .mockResolvedValueOnce([{ count: '500' }])
+        .mockResolvedValueOnce([])
+
+      await TasksService.getByStatus('user-123', 'todo')
+
+      const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+      expect(dataQueryCall[1]).toContain(1000) // Large limit
+    })
+  })
+
+  // ============================================================
+  // getOverdue
+  // ============================================================
+  describe('getOverdue', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.getOverdue(''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.getOverdue('   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Query', () => {
+      it('should query tasks with dueDate before today', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('"dueDate" < CURRENT_DATE')
+      })
+
+      it('should exclude done tasks', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain("status != 'done'")
+      })
+
+      it('should exclude completed tasks', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('completed IS NULL OR completed = false')
+      })
+
+      it('should order by dueDate ascending', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('"dueDate" ASC')
+      })
+    })
+
+    describe('Result', () => {
+      it('should return array of overdue tasks', async () => {
+        const mockTasks = [
+          createMockDbTask({ dueDate: '2024-01-01' }),
+          createMockDbTask({ id: 'task-456', dueDate: '2024-06-01' }),
+        ]
+        mockQueryWithRLS.mockResolvedValue(mockTasks)
+
+        const result = await TasksService.getOverdue('user-123')
+
+        expect(result).toHaveLength(2)
+      })
+
+      it('should transform database rows correctly', async () => {
+        const mockTask = createMockDbTask({ description: null })
+        mockQueryWithRLS.mockResolvedValue([mockTask])
+
+        const result = await TasksService.getOverdue('user-123')
+
+        expect(result[0].description).toBeUndefined()
+      })
+    })
+  })
+
+  // ============================================================
+  // getDueToday
+  // ============================================================
+  describe('getDueToday', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.getDueToday(''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.getDueToday('   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Query', () => {
+      it('should query tasks with dueDate equal to today', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getDueToday('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('"dueDate" = CURRENT_DATE')
+      })
+
+      it('should exclude done tasks', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getDueToday('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain("status != 'done'")
+      })
+
+      it('should order by priority DESC then createdAt ASC', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getDueToday('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('priority DESC')
+        expect(queryCall[0]).toContain('"createdAt" ASC')
+      })
+    })
+
+    describe('Result', () => {
+      it('should return array of tasks due today', async () => {
+        const today = new Date().toISOString().split('T')[0]
+        const mockTasks = [
+          createMockDbTask({ dueDate: today }),
+          createMockDbTask({ id: 'task-456', dueDate: today }),
+        ]
+        mockQueryWithRLS.mockResolvedValue(mockTasks)
+
+        const result = await TasksService.getDueToday('user-123')
+
+        expect(result).toHaveLength(2)
+      })
+
+      it('should transform database rows correctly', async () => {
+        const mockTask = createMockDbTask({ description: null, tags: null })
+        mockQueryWithRLS.mockResolvedValue([mockTask])
+
+        const result = await TasksService.getDueToday('user-123')
+
+        expect(result[0].description).toBeUndefined()
+        expect(result[0].tags).toBeUndefined()
+      })
+    })
+  })
+})