Merge pull request #114 from tribeti/unit-test

unit test

Author: tribeti

src/__test__/actions/auth.actions.test.ts

@@ -0,0 +1,47 @@
+import { checkEmailExistsAction, requestPasswordResetAction } from '@/app/actions/auth.actions';
+import { createClient } from '@/utils/supabase/server';
+
+jest.mock('@/utils/supabase/server', () => ({
+  createClient: jest.fn(),
+}));
+
+describe('Auth Actions (Server Actions)', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('checkEmailExistsAction', () => {
+    it('returns error for invalid email', async () => {
+      const result = await checkEmailExistsAction('invalid-email');
+      expect(result.exists).toBe(false);
+      expect(result.error).toBe('Email không đúng định dạng.');
+    });
+
+    it('returns true if email exists by calling Supabase RPC', async () => {
+      const mockRpc = jest.fn().mockResolvedValue({ data: true, error: null });
+      (createClient as jest.Mock).mockResolvedValue({ rpc: mockRpc });
+
+      const result = await checkEmailExistsAction('test@gmail.com');
+      expect(result.exists).toBe(true);
+      expect(mockRpc).toHaveBeenCalledWith('check_email_exists', { email_to_check: 'test@gmail.com' });
+    });
+  });
+
+  describe('requestPasswordResetAction', () => {
+    it('returns error for invalid email format', async () => {
+      const result = await requestPasswordResetAction('bad-email');
+      expect(result.error).toBe('Email không đúng định dạng.');
+    });
+
+    it('returns success on valid email by calling Supabase Auth API', async () => {
+      const mockReset = jest.fn().mockResolvedValue({ error: null });
+      (createClient as jest.Mock).mockResolvedValue({
+        auth: { resetPasswordForEmail: mockReset },
+      });
+
+      const result = await requestPasswordResetAction('user@example.com');
+      expect(result.success).toBe(true);
+      expect(mockReset).toHaveBeenCalledWith('user@example.com', expect.any(Object));
+    });
+  });
+});

src/__test__/actions/kanban.actions.test.ts

@@ -0,0 +1,81 @@
+import { createTaskAction, deleteTaskAction } from '@/app/actions/kanban.actions';
+import { createClient } from '@/utils/supabase/server';
+import { verifyBoardAccess, verifyTaskAccess } from '@/utils/board-access';
+import { revalidatePath } from 'next/cache';
+
+// Mocks
+jest.mock('@/utils/supabase/server', () => ({
+  createClient: jest.fn(),
+}));
+
+jest.mock('@/utils/supabase/admin', () => ({
+  createAdminClient: jest.fn().mockReturnValue({
+    from: jest.fn().mockReturnValue({
+      insert: jest.fn(),
+    })
+  }),
+}));
+
+jest.mock('@/utils/board-access', () => ({
+  verifyBoardAccess: jest.fn(),
+  verifyAllBoardsAccess: jest.fn(),
+  verifyTaskAccess: jest.fn(),
+  validateString: jest.fn((str) => str),
+}));
+
+jest.mock('next/cache', () => ({
+  revalidatePath: jest.fn(),
+}));
+
+describe('Kanban / Task Server Actions Test', () => {
+  let mockSupabase: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockSupabase = {
+      auth: {
+        getUser: jest.fn().mockResolvedValue({ data: { user: { id: 'user_123' } }, error: null }),
+      },
+      from: jest.fn().mockReturnThis(),
+      select: jest.fn().mockReturnThis(),
+      insert: jest.fn().mockReturnThis(),
+      update: jest.fn().mockReturnThis(),
+      delete: jest.fn().mockReturnThis(),
+      eq: jest.fn().mockReturnThis(),
+      single: jest.fn().mockResolvedValue({ data: { board_id: 1, id: 1 }, error: null }),
+    };
+
+    (createClient as jest.Mock).mockResolvedValue(mockSupabase);
+  });
+
+  describe('createTaskAction', () => {
+    it('creates a task successfully and revalidates page cache', async () => {
+      await createTaskAction({ column_id: 1, title: 'New Valid Task', position: 1 } as any);
+      
+      // Verification logic passes
+      expect(verifyBoardAccess).toHaveBeenCalled();
+      
+      // Makes DB insertion calls
+      expect(mockSupabase.from).toHaveBeenCalledWith('tasks');
+      expect(mockSupabase.insert).toHaveBeenCalled();
+      
+      // Updates Next.js Router cache
+      expect(revalidatePath).toHaveBeenCalledWith('/projects');
+    });
+
+    it('throws error if user is unauthenticated', async () => {
+      mockSupabase.auth.getUser.mockResolvedValue({ data: { user: null }, error: new Error('Auth Err') });
+      await expect(createTaskAction({ column_id: 1, title: 'Task' } as any)).rejects.toThrow('Unauthorized');
+    });
+  });
+
+  describe('deleteTaskAction', () => {
+    it('deletes a task successfully with proper row level security simulation', async () => {
+      await deleteTaskAction(10);
+      expect(verifyTaskAccess).toHaveBeenCalledWith(expect.any(Object), 'user_123', 10);
+      expect(mockSupabase.delete).toHaveBeenCalled();
+      expect(revalidatePath).toHaveBeenCalledWith('/projects');
+    });
+  });
+});

src/__test__/hooks/useProjects.test.ts

@@ -0,0 +1,41 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { useProjects } from '@/hooks/useProjects';
+import * as projectService from '@/services/project.service';
+
+// Mocking dependencies
+jest.mock('@/services/project.service');
+jest.mock('sonner', () => ({
+  toast: {
+    success: jest.fn(),
+    error: jest.fn(),
+    warning: jest.fn(),
+  }
+}));
+
+describe('useProjects Hook', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('initially has no boards and is not loading if no userId is provided', async () => {
+    const { result } = renderHook(() => useProjects());
+
+    expect(result.current.ownedBoards).toEqual([]);
+    expect(result.current.joinedBoards).toEqual([]);
+    expect(result.current.boardsLoading).toBe(false);
+  });
+
+  it('fetches boards if userId is provided', async () => {
+    const mockData = { ownedBoards: [{ id: 1, title: 'Test' } as any], joinedBoards: [] };
+    jest.mocked(projectService.fetchUserBoards).mockResolvedValue(mockData);
+
+    const { result } = renderHook(() => useProjects('user123'));
+
+    await waitFor(() => {
+        expect(result.current.boardsLoading).toBe(false);
+    });
+
+    expect(projectService.fetchUserBoards).toHaveBeenCalled();
+    expect(result.current.ownedBoards).toEqual(mockData.ownedBoards);
+  });
+});