@tuturuuu/ui 0.16.0 → 0.18.0

package/src/components/ui/tu-do/hooks/__tests__/useTaskLabelManagement.test.tsx

@@ -1,572 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { act, renderHook, waitFor } from '@testing-library/react';
-import type { Task } from '@tuturuuu/types/primitives/Task';
-import type { ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { LABEL_COLOR_PRESETS } from '../../utils/label-colors';
-import { useTaskLabelManagement } from '../useTaskLabelManagement';
-
-// Mock modules with proper hoisting
-vi.mock('@tuturuuu/ui/sonner', () => ({
-  toast: {
-    error: vi.fn(),
-    success: vi.fn(),
-    info: vi.fn(),
-  },
-}));
-
-vi.mock('@tuturuuu/internal-api/tasks', () => ({
-  updateWorkspaceTask: vi.fn(),
-  addWorkspaceTaskLabel: vi.fn(),
-  removeWorkspaceTaskLabel: vi.fn(),
-  createWorkspaceLabel: vi.fn(),
-}));
-
-describe('useTaskLabelManagement', () => {
-  let queryClient: QueryClient;
-  let mockToast: any;
-  let mockUpdateWorkspaceTask: any;
-  let mockAddWorkspaceTaskLabel: any;
-  let mockRemoveWorkspaceTaskLabel: any;
-  let mockCreateWorkspaceLabel: any;
-
-  const mockTask: Task = {
-    id: 'task-1',
-    name: 'Test Task',
-    list_id: 'list-1',
-    created_at: '2025-01-01',
-    labels: [
-      { id: 'label-1', name: 'Bug', color: '#ef4444' },
-      { id: 'label-2', name: 'Feature', color: '#3b82f6' },
-    ],
-  } as Task;
-
-  const mockWorkspaceLabels = [
-    { id: 'label-1', name: 'Bug', color: '#ef4444', created_at: '2025-01-01' },
-    {
-      id: 'label-2',
-      name: 'Feature',
-      color: '#3b82f6',
-      created_at: '2025-01-01',
-    },
-    {
-      id: 'label-3',
-      name: 'Enhancement',
-      color: '#10b981',
-      created_at: '2025-01-01',
-    },
-  ];
-
-  const wrapper = ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-
-  beforeEach(async () => {
-    queryClient = new QueryClient({
-      defaultOptions: {
-        queries: { retry: false },
-        mutations: { retry: false },
-      },
-    });
-
-    // Import mocked modules
-    const { toast } = await import('@tuturuuu/ui/sonner');
-    const {
-      updateWorkspaceTask,
-      addWorkspaceTaskLabel,
-      removeWorkspaceTaskLabel,
-      createWorkspaceLabel,
-    } = await import('@tuturuuu/internal-api/tasks');
-
-    mockToast = toast as any;
-    mockUpdateWorkspaceTask = updateWorkspaceTask as any;
-    mockAddWorkspaceTaskLabel = addWorkspaceTaskLabel as any;
-    mockRemoveWorkspaceTaskLabel = removeWorkspaceTaskLabel as any;
-    mockCreateWorkspaceLabel = createWorkspaceLabel as any;
-
-    vi.clearAllMocks();
-    mockUpdateWorkspaceTask.mockResolvedValue({ task: { id: 'task-1' } });
-    mockAddWorkspaceTaskLabel.mockResolvedValue({ success: true });
-    mockRemoveWorkspaceTaskLabel.mockResolvedValue({ success: true });
-    mockCreateWorkspaceLabel.mockResolvedValue({
-      id: 'label-4',
-      name: 'New Label',
-      color: '#8b5cf6',
-    });
-  });
-
-  describe('initialization', () => {
-    it('should initialize with default state', () => {
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      expect(result.current.newLabelName).toBe('');
-      expect(LABEL_COLOR_PRESETS).toContain(result.current.newLabelColor);
-      expect(result.current.creatingLabel).toBe(false);
-    });
-  });
-
-  describe('toggleTaskLabel', () => {
-    it('should remove label when already active', async () => {
-      // Set up initial cache
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      await act(async () => {
-        await result.current.toggleTaskLabel('label-1');
-      });
-
-      // Check optimistic update
-      const cachedTasks = queryClient.getQueryData<Task[]>([
-        'tasks',
-        'board-1',
-      ]);
-      expect(cachedTasks?.[0]?.labels).toHaveLength(1);
-      expect(cachedTasks?.[0]?.labels?.[0]?.id).toBe('label-2');
-
-      expect(mockRemoveWorkspaceTaskLabel).toHaveBeenCalledWith(
-        'ws-1',
-        'task-1',
-        'label-1',
-        expect.anything()
-      );
-    });
-
-    it('should add label when not active', async () => {
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      await act(async () => {
-        await result.current.toggleTaskLabel('label-3');
-      });
-
-      // Check optimistic update
-      const cachedTasks = queryClient.getQueryData<Task[]>([
-        'tasks',
-        'board-1',
-      ]);
-      expect(cachedTasks?.[0]?.labels).toHaveLength(3);
-      expect(cachedTasks?.[0]?.labels?.some((l) => l.id === 'label-3')).toBe(
-        true
-      );
-
-      expect(mockAddWorkspaceTaskLabel).toHaveBeenCalledWith(
-        'ws-1',
-        'task-1',
-        'label-3',
-        expect.anything()
-      );
-    });
-
-    it('updates full-board and task detail caches without invalidating visible board queries', async () => {
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-      queryClient.setQueryData(['tasks-full', 'board-1', 'all'], [mockTask]);
-      queryClient.setQueryData(['task', 'task-1'], mockTask);
-      const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-            taskId: 'task-1',
-          }),
-        { wrapper }
-      );
-
-      await act(async () => {
-        await result.current.toggleTaskLabel('label-3');
-      });
-
-      expect(
-        queryClient
-          .getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])?.[0]
-          ?.labels?.some((label) => label.id === 'label-3')
-      ).toBe(true);
-      expect(
-        queryClient
-          .getQueryData<Task>(['task', 'task-1'])
-          ?.labels?.some((label) => label.id === 'label-3')
-      ).toBe(true);
-      expect(invalidateSpy).not.toHaveBeenCalledWith({
-        queryKey: ['tasks', 'board-1'],
-      });
-      expect(invalidateSpy).not.toHaveBeenCalledWith({
-        queryKey: ['tasks-full', 'board-1'],
-      });
-    });
-
-    it('should rollback on error and show toast', async () => {
-      mockRemoveWorkspaceTaskLabel.mockRejectedValueOnce(
-        new Error('Database error')
-      );
-
-      const originalTasks = [mockTask];
-      queryClient.setQueryData(['tasks', 'board-1'], originalTasks);
-      queryClient.setQueryData(['tasks-full', 'board-1', 'all'], originalTasks);
-      queryClient.setQueryData(['task', 'task-1'], mockTask);
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      await act(async () => {
-        await result.current.toggleTaskLabel('label-1');
-      });
-
-      // Check that cache was rolled back
-      const cachedTasks = queryClient.getQueryData<Task[]>([
-        'tasks',
-        'board-1',
-      ]);
-      expect(cachedTasks).toEqual(originalTasks);
-      expect(
-        queryClient.getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])
-      ).toEqual(originalTasks);
-      expect(queryClient.getQueryData<Task>(['task', 'task-1'])).toEqual(
-        mockTask
-      );
-
-      // Verify error toast was shown with the correct format
-      expect(mockToast.error).toHaveBeenCalledWith('Error', {
-        description: 'Failed to update label. Please try again.',
-      });
-    });
-  });
-
-  describe('createNewLabel', () => {
-    it('should create new label and apply to task', async () => {
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      // Set new label data
-      act(() => {
-        result.current.setNewLabelName('New Label');
-        result.current.setNewLabelColor('#8b5cf6');
-      });
-
-      await act(async () => {
-        await result.current.createNewLabel();
-      });
-
-      expect(mockCreateWorkspaceLabel).toHaveBeenCalledWith(
-        'ws-1',
-        {
-          name: 'New Label',
-          color: '#8b5cf6',
-        },
-        expect.anything()
-      );
-
-      // Verify label was applied to task
-      const cachedTasks = queryClient.getQueryData<Task[]>([
-        'tasks',
-        'board-1',
-      ]);
-      expect(cachedTasks?.[0]?.labels).toHaveLength(3);
-      expect(cachedTasks?.[0]?.labels?.some((l) => l.id === 'label-4')).toBe(
-        true
-      );
-
-      // Verify form was reset
-      expect(result.current.newLabelName).toBe('');
-      expect(LABEL_COLOR_PRESETS).toContain(result.current.newLabelColor);
-      expect(result.current.newLabelColor.toLowerCase()).not.toBe('#8b5cf6');
-    });
-
-    it('should not create label with empty name', async () => {
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      await act(async () => {
-        await result.current.createNewLabel();
-      });
-
-      expect(mockCreateWorkspaceLabel).not.toHaveBeenCalled();
-    });
-
-    it('should not create label without workspaceId', async () => {
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: undefined,
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelName('New Label');
-      });
-
-      await act(async () => {
-        await result.current.createNewLabel();
-      });
-
-      expect(mockCreateWorkspaceLabel).not.toHaveBeenCalled();
-    });
-
-    it('should handle API error when creating label', async () => {
-      mockCreateWorkspaceLabel.mockRejectedValueOnce(
-        new Error('Failed to create label')
-      );
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelName('New Label');
-      });
-
-      await act(async () => {
-        try {
-          await result.current.createNewLabel();
-        } catch (_) {
-          // Expected to throw
-        }
-      });
-
-      expect(mockToast.error).toHaveBeenCalledWith('Failed to create label');
-
-      expect(result.current.creatingLabel).toBe(false);
-    });
-
-    it('should show partial success toast when label created but not applied', async () => {
-      mockUpdateWorkspaceTask.mockRejectedValueOnce(new Error('Insert failed'));
-
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelName('New Label');
-      });
-
-      await act(async () => {
-        await result.current.createNewLabel();
-      });
-
-      // Should show error toast (not success)
-      expect(mockToast.error).toHaveBeenCalledWith(
-        'The label was created but could not be attached to the task. Refresh and try manually.'
-      );
-
-      // Should NOT show success toast
-      expect(mockToast.success).not.toHaveBeenCalled();
-    });
-
-    it('should set creatingLabel state during operation', async () => {
-      let resolvePromise: any;
-      mockCreateWorkspaceLabel.mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            resolvePromise = () =>
-              resolve({
-                id: 'label-4',
-                name: 'New Label',
-                color: '#8b5cf6',
-              });
-          })
-      );
-
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelName('New Label');
-      });
-
-      // Start the operation
-      let createPromise: Promise<any>;
-      act(() => {
-        createPromise = result.current.createNewLabel();
-      });
-
-      // Should be creating immediately after call
-      await waitFor(() => expect(result.current.creatingLabel).toBe(true));
-
-      // Resolve the promise
-      resolvePromise();
-      await act(async () => {
-        await createPromise!;
-      });
-
-      // Should be false after completion
-      expect(result.current.creatingLabel).toBe(false);
-    });
-
-    it('should optimistically update workspace labels cache after creation', async () => {
-      queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-      queryClient.setQueryData(
-        ['workspace-labels', 'ws-1'],
-        mockWorkspaceLabels
-      );
-      queryClient.setQueryData(
-        ['workspace-labels', 'route-ws'],
-        mockWorkspaceLabels
-      );
-
-      const setQueryDataSpy = vi.spyOn(queryClient, 'setQueryData');
-
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-            labelCacheWorkspaceIds: ['route-ws'],
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelName('New Label');
-      });
-
-      await act(async () => {
-        await result.current.createNewLabel();
-      });
-
-      // The implementation uses setQueryData for optimistic updates, not invalidateQueries
-      expect(setQueryDataSpy).toHaveBeenCalledWith(
-        ['workspace-labels', 'ws-1'],
-        expect.any(Function)
-      );
-      expect(setQueryDataSpy).toHaveBeenCalledWith(
-        ['workspace-labels', 'route-ws'],
-        expect.any(Function)
-      );
-
-      setQueryDataSpy.mockRestore();
-    });
-  });
-
-  describe('state setters', () => {
-    it('should update newLabelName', () => {
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelName('Updated Label');
-      });
-
-      expect(result.current.newLabelName).toBe('Updated Label');
-    });
-
-    it('should update newLabelColor', () => {
-      const { result } = renderHook(
-        () =>
-          useTaskLabelManagement({
-            task: mockTask,
-            boardId: 'board-1',
-            workspaceLabels: mockWorkspaceLabels,
-            workspaceId: 'ws-1',
-          }),
-        { wrapper }
-      );
-
-      act(() => {
-        result.current.setNewLabelColor('#f59e0b');
-      });
-
-      expect(result.current.newLabelColor).toBe('#f59e0b');
-    });
-  });
-});

package/src/components/ui/tu-do/hooks/__tests__/useTaskProjectManagement.test.tsx

@@ -1,144 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { act, renderHook } from '@testing-library/react';
-import type { Task } from '@tuturuuu/types/primitives/Task';
-import type { ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { useTaskProjectManagement } from '../useTaskProjectManagement';
-
-vi.mock('@tuturuuu/ui/sonner', () => ({
-  toast: {
-    error: vi.fn(),
-    success: vi.fn(),
-    warning: vi.fn(),
-  },
-}));
-
-vi.mock('@tuturuuu/internal-api/tasks', () => ({
-  createWorkspaceTaskProject: vi.fn(),
-  updateWorkspaceTask: vi.fn(),
-}));
-
-describe('useTaskProjectManagement', () => {
-  let queryClient: QueryClient;
-  let mockUpdateWorkspaceTask: any;
-
-  const project = {
-    id: 'project-1',
-    name: 'Roadmap',
-    status: 'active',
-  };
-
-  const mockTask = {
-    id: 'task-1',
-    name: 'Test Task',
-    list_id: 'list-1',
-    display_number: 1,
-    created_at: '2026-01-01T00:00:00.000Z',
-    projects: [],
-  } satisfies Task;
-
-  const wrapper = ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-
-  beforeEach(async () => {
-    queryClient = new QueryClient({
-      defaultOptions: {
-        queries: { retry: false },
-        mutations: { retry: false },
-      },
-    });
-
-    const { updateWorkspaceTask } = await import(
-      '@tuturuuu/internal-api/tasks'
-    );
-    mockUpdateWorkspaceTask = updateWorkspaceTask as any;
-
-    vi.clearAllMocks();
-    mockUpdateWorkspaceTask.mockResolvedValue({ task: { id: 'task-1' } });
-  });
-
-  it('updates full-board and task detail caches without invalidating visible board queries', async () => {
-    queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
-    queryClient.setQueryData(['tasks-full', 'board-1', 'all'], [mockTask]);
-    queryClient.setQueryData(['task', 'task-1'], mockTask);
-    const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
-
-    const { result } = renderHook(
-      () =>
-        useTaskProjectManagement({
-          task: mockTask,
-          boardId: 'board-1',
-          workspaceProjects: [project],
-          workspaceId: 'ws-1',
-          taskId: 'task-1',
-        }),
-      { wrapper }
-    );
-
-    await act(async () => {
-      await result.current.toggleTaskProject('project-1');
-    });
-
-    expect(
-      queryClient
-        .getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])?.[0]
-        ?.projects?.some((entry) => entry.id === 'project-1')
-    ).toBe(true);
-    expect(
-      queryClient
-        .getQueryData<Task>(['task', 'task-1'])
-        ?.projects?.some((entry) => entry.id === 'project-1')
-    ).toBe(true);
-    expect(invalidateSpy).not.toHaveBeenCalledWith({
-      queryKey: ['tasks', 'board-1'],
-    });
-    expect(invalidateSpy).not.toHaveBeenCalledWith({
-      queryKey: ['tasks-full', 'board-1'],
-    });
-  });
-
-  it('rolls back every visible cache when the project update fails', async () => {
-    const taskWithProject = {
-      ...mockTask,
-      projects: [project],
-    } as Task;
-    mockUpdateWorkspaceTask.mockRejectedValueOnce(new Error('Database error'));
-    queryClient.setQueryData(['tasks', 'board-1'], [taskWithProject]);
-    queryClient.setQueryData(
-      ['tasks-full', 'board-1', 'all'],
-      [taskWithProject]
-    );
-    queryClient.setQueryData(['task', 'task-1'], taskWithProject);
-
-    const { result } = renderHook(
-      () =>
-        useTaskProjectManagement({
-          task: taskWithProject,
-          boardId: 'board-1',
-          workspaceProjects: [project],
-          workspaceId: 'ws-1',
-          taskId: 'task-1',
-        }),
-      { wrapper }
-    );
-
-    await act(async () => {
-      await result.current.toggleTaskProject('project-1');
-    });
-
-    expect(queryClient.getQueryData<Task[]>(['tasks', 'board-1'])).toEqual([
-      taskWithProject,
-    ]);
-    expect(
-      queryClient.getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])
-    ).toEqual([taskWithProject]);
-    expect(queryClient.getQueryData<Task>(['task', 'task-1'])).toEqual(
-      taskWithProject
-    );
-  });
-});