@tuturuuu/ui 0.17.0 → 0.18.0

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/__tests__/use-task-overrides.test.ts

@@ -1,412 +0,0 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { useTaskOverrides } from '../use-task-overrides';
-
-// Hoisted mocks — vi.hoisted() makes these available at vi.mock() hoist time
-const { mockQueryClient, mockUseQuery, mockUseMutation, mockToastError } =
-  vi.hoisted(() => ({
-    mockQueryClient: {
-      cancelQueries: vi.fn(),
-      getQueryData: vi.fn(),
-      setQueryData: vi.fn(),
-      invalidateQueries: vi.fn(),
-    },
-    mockUseQuery: vi.fn(),
-    mockUseMutation: vi.fn(),
-    mockToastError: vi.fn(),
-  }));
-
-vi.mock('@tanstack/react-query', async () => {
-  const actual = await vi.importActual('@tanstack/react-query');
-  return {
-    ...actual,
-    useQuery: (...args: unknown[]) => mockUseQuery(...args),
-    useMutation: (...args: unknown[]) => mockUseMutation(...args),
-    useQueryClient: () => mockQueryClient,
-  };
-});
-
-vi.mock('@tuturuuu/ui/sonner', () => ({
-  toast: {
-    error: (...args: unknown[]) => mockToastError(...args),
-  },
-}));
-
-// Mock fetch
-global.fetch = vi.fn();
-
-describe('useTaskOverrides', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('fetches override on mount when taskId is provided', async () => {
-    const taskId = 'task-123';
-    const mockOverride = {
-      task_id: taskId,
-      user_id: 'user-1',
-      self_managed: false,
-      completed_at: null,
-      priority_override: 'high',
-      due_date_override: null,
-      estimation_override: null,
-      personally_unassigned: false,
-      notes: 'Test note',
-      created_at: '2026-01-01T00:00:00Z',
-      updated_at: '2026-01-01T00:00:00Z',
-    };
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ data: mockOverride }),
-    });
-
-    mockUseQuery.mockReturnValue({
-      data: mockOverride,
-      isLoading: false,
-      error: null,
-    });
-
-    mockUseMutation.mockReturnValue({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId));
-
-    expect(result.current.override).toEqual(mockOverride);
-  });
-
-  it('does not fetch when taskId is undefined', () => {
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    mockUseMutation.mockReturnValue({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    renderHook(() => useTaskOverrides(undefined));
-
-    // Verify enabled is false when taskId is undefined
-    expect(mockUseQuery).toHaveBeenCalledWith(
-      expect.objectContaining({ enabled: false })
-    );
-  });
-
-  it('handles fetch error', () => {
-    const taskId = 'task-123';
-    const mockError = new Error('Failed to fetch override');
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: mockError,
-    });
-
-    mockUseMutation.mockReturnValue({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId));
-
-    expect(result.current.error).toBeTruthy();
-  });
-
-  it('upsert sends PUT request with correct payload', async () => {
-    const taskId = 'task-123';
-    const mockResponse = {
-      data: {
-        task_id: taskId,
-        user_id: 'user-1',
-        priority_override: 'high',
-      },
-    };
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => mockResponse,
-    });
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    // First mutation (upsert)
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: async (vars: any) => {
-        const res = await fetch(`/api/v1/users/me/tasks/${taskId}/overrides`, {
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(vars),
-        });
-        if (!res.ok) throw new Error('Failed');
-        return res.json();
-      },
-      isPending: false,
-    });
-
-    // Second mutation (delete)
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId));
-
-    const input = { priority_override: 'high' as const };
-    await result.current.upsertAsync(input);
-
-    expect(global.fetch).toHaveBeenCalledWith(
-      `/api/v1/users/me/tasks/${taskId}/overrides`,
-      {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(input),
-      }
-    );
-  });
-
-  it('upsert calls onUpdate on success', async () => {
-    const taskId = 'task-123';
-    const onUpdate = vi.fn();
-    const mockResponse = { data: { task_id: taskId } };
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => mockResponse,
-    });
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    let capturedOnSettled: (() => void) | undefined;
-
-    // First mutation (upsert) - capture onSettled
-    mockUseMutation.mockImplementationOnce((options: any) => {
-      capturedOnSettled = options.onSettled;
-      return {
-        mutate: vi.fn(),
-        mutateAsync: async (vars: any) => {
-          const result = await options.mutationFn(vars);
-          capturedOnSettled?.();
-          return result;
-        },
-        isPending: false,
-      };
-    });
-
-    // Second mutation (delete)
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId, onUpdate));
-
-    await result.current.upsertAsync({ notes: 'Updated' });
-
-    await waitFor(() => {
-      expect(onUpdate).toHaveBeenCalled();
-    });
-  });
-
-  it('delete sends DELETE request', async () => {
-    const taskId = 'task-123';
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-    });
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    // First mutation (upsert)
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    // Second mutation (delete) - actual implementation
-    const mockMutate = vi.fn(async () => {
-      const res = await fetch(`/api/v1/users/me/tasks/${taskId}/overrides`, {
-        method: 'DELETE',
-      });
-      if (!res.ok) throw new Error('Failed');
-    });
-
-    mockUseMutation.mockImplementationOnce((options: any) => ({
-      mutate: mockMutate,
-      mutateAsync: async () => options.mutationFn(),
-      isPending: false,
-    }));
-
-    const { result } = renderHook(() => useTaskOverrides(taskId));
-
-    result.current.remove();
-
-    await waitFor(() => {
-      expect(global.fetch).toHaveBeenCalledWith(
-        `/api/v1/users/me/tasks/${taskId}/overrides`,
-        {
-          method: 'DELETE',
-        }
-      );
-    });
-  });
-
-  it('delete calls onUpdate on success', async () => {
-    const taskId = 'task-123';
-    const onUpdate = vi.fn();
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-    });
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    let capturedDeleteOnSettled: (() => void) | undefined;
-
-    // First mutation (upsert)
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    // Second mutation (delete) - capture onSettled
-    mockUseMutation.mockImplementationOnce((options: any) => {
-      capturedDeleteOnSettled = options.onSettled;
-      return {
-        mutate: vi.fn(async () => {
-          await options.mutationFn();
-          capturedDeleteOnSettled?.();
-        }),
-        mutateAsync: async () => {
-          const result = await options.mutationFn();
-          capturedDeleteOnSettled?.();
-          return result;
-        },
-        isPending: false,
-      };
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId, onUpdate));
-
-    result.current.remove();
-
-    await waitFor(() => {
-      expect(onUpdate).toHaveBeenCalled();
-    });
-  });
-
-  it('handles upsert API error', async () => {
-    const taskId = 'task-123';
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: false,
-      json: async () => ({ error: 'Update failed' }),
-    });
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    let capturedOnError:
-      | ((err: unknown, input: unknown, context: unknown) => void)
-      | undefined;
-
-    // First mutation (upsert) - capture onError
-    mockUseMutation.mockImplementationOnce(
-      (options: Record<string, unknown>) => {
-        capturedOnError = options.onError as typeof capturedOnError;
-        return {
-          mutate: vi.fn(),
-          mutateAsync: async (vars: unknown) => {
-            try {
-              return await (
-                options.mutationFn as (v: unknown) => Promise<unknown>
-              )(vars);
-            } catch (error) {
-              capturedOnError?.(error, vars, undefined);
-              throw error;
-            }
-          },
-          isPending: false,
-        };
-      }
-    );
-
-    // Second mutation (delete)
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId));
-
-    await expect(
-      result.current.upsertAsync({ notes: 'Fail' })
-    ).rejects.toThrow();
-
-    await waitFor(() => {
-      expect(mockToastError).toHaveBeenCalledWith(
-        'Failed to save personal override'
-      );
-    });
-  });
-
-  it('returns correct isSaving state', () => {
-    const taskId = 'task-123';
-
-    mockUseQuery.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: null,
-    });
-
-    // First mutation (upsert) - pending
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: true,
-    });
-
-    // Second mutation (delete) - not pending
-    mockUseMutation.mockReturnValueOnce({
-      mutate: vi.fn(),
-      mutateAsync: vi.fn(),
-      isPending: false,
-    });
-
-    const { result } = renderHook(() => useTaskOverrides(taskId));
-
-    expect(result.current.isSaving).toBe(true);
-  });
-});

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/__tests__/use-task-realtime-sync.test.tsx

@@ -1,237 +0,0 @@
-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 type { BoardBroadcastFn } from '../../../board-broadcast-context';
-import type { WorkspaceTaskLabel } from '../../types';
-import { useTaskRealtimeSync } from '../use-task-realtime-sync';
-
-const taskApiMocks = vi.hoisted(() => ({
-  getWorkspaceTask: vi.fn(),
-}));
-
-const boardRealtimeMocks = vi.hoisted(() => ({
-  broadcast: vi.fn(),
-  onTaskChange: undefined as
-    | ((task: Task, eventType: 'INSERT' | 'UPDATE' | 'DELETE') => void)
-    | undefined,
-  onTaskRelationsChange: undefined as ((taskIds: string[]) => void) | undefined,
-  useBoardRealtime: vi.fn(),
-}));
-
-vi.mock('@tuturuuu/internal-api/tasks', () => ({
-  getWorkspaceTask: taskApiMocks.getWorkspaceTask,
-}));
-
-vi.mock('@tuturuuu/ui/hooks/useBoardRealtime', () => ({
-  useBoardRealtime: boardRealtimeMocks.useBoardRealtime,
-}));
-
-describe('useTaskRealtimeSync', () => {
-  let queryClient: QueryClient;
-
-  const wrapper = ({ children }: { children: ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-
-  const makeProps = (
-    overrides: Partial<Parameters<typeof useTaskRealtimeSync>[0]> = {}
-  ): Parameters<typeof useTaskRealtimeSync>[0] => ({
-    wsId: 'ws-1',
-    taskWorkspaceId: undefined,
-    taskId: 'task-1',
-    boardId: 'board-1',
-    isCreateMode: false,
-    isOpen: true,
-    isPersonalWorkspace: false,
-    name: 'Initial task',
-    priority: null,
-    startDate: undefined,
-    endDate: undefined,
-    estimationPoints: null,
-    selectedListId: 'list-1',
-    pendingNameRef: { current: null },
-    setName: vi.fn(),
-    setPriority: vi.fn(),
-    setStartDate: vi.fn(),
-    setEndDate: vi.fn(),
-    setEstimationPoints: vi.fn(),
-    setSelectedListId: vi.fn(),
-    setSelectedLabels: vi.fn(),
-    setSelectedAssignees: vi.fn(),
-    setSelectedProjects: vi.fn(),
-    ...overrides,
-  });
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-    queryClient = new QueryClient({
-      defaultOptions: {
-        mutations: { retry: false },
-        queries: { retry: false },
-      },
-    });
-    boardRealtimeMocks.onTaskChange = undefined;
-    boardRealtimeMocks.onTaskRelationsChange = undefined;
-    boardRealtimeMocks.useBoardRealtime.mockImplementation(
-      (
-        _boardId: string,
-        options?: {
-          onTaskChange?: typeof boardRealtimeMocks.onTaskChange;
-          onTaskRelationsChange?: typeof boardRealtimeMocks.onTaskRelationsChange;
-        }
-      ) => {
-        boardRealtimeMocks.onTaskChange = options?.onTaskChange;
-        boardRealtimeMocks.onTaskRelationsChange =
-          options?.onTaskRelationsChange;
-        return { broadcast: boardRealtimeMocks.broadcast };
-      }
-    );
-  });
-
-  it('refetches a matching task upsert before applying open dialog state', async () => {
-    const start = '2026-05-22T01:00:00.000Z';
-    const end = '2026-05-22T02:00:00.000Z';
-    const props = makeProps();
-
-    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
-      task: {
-        id: 'task-1',
-        name: 'Server task',
-        priority: 'high',
-        start_date: start,
-        end_date: end,
-        estimation_points: 5,
-        list_id: 'list-2',
-      },
-    });
-
-    renderHook(() => useTaskRealtimeSync(props), { wrapper });
-
-    act(() => {
-      boardRealtimeMocks.onTaskChange?.(
-        {
-          id: 'task-1',
-          name: 'Untrusted broadcast task',
-          priority: 'critical',
-          start_date: '2026-05-23T01:00:00.000Z',
-          end_date: '2026-05-23T02:00:00.000Z',
-          estimation_points: 8,
-          list_id: 'list-3',
-        } as Task,
-        'UPDATE'
-      );
-    });
-
-    await waitFor(() => {
-      expect(props.setName).toHaveBeenCalledWith('Server task');
-    });
-    expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
-      'ws-1',
-      'task-1'
-    );
-    expect(props.setName).not.toHaveBeenCalledWith('Untrusted broadcast task');
-    expect(props.setPriority).toHaveBeenCalledWith('high');
-    expect(props.setStartDate).toHaveBeenCalledWith(new Date(start));
-    expect(props.setEndDate).toHaveBeenCalledWith(new Date(end));
-    expect(props.setEstimationPoints).toHaveBeenCalledWith(5);
-    expect(props.setSelectedListId).toHaveBeenCalledWith('list-2');
-  });
-
-  it('ignores task upserts for other tasks', () => {
-    const props = makeProps();
-
-    renderHook(() => useTaskRealtimeSync(props), { wrapper });
-
-    act(() => {
-      boardRealtimeMocks.onTaskChange?.(
-        { id: 'other-task', name: 'Other task' } as Task,
-        'UPDATE'
-      );
-    });
-
-    expect(props.setName).not.toHaveBeenCalled();
-    expect(props.setPriority).not.toHaveBeenCalled();
-    expect(props.setSelectedListId).not.toHaveBeenCalled();
-  });
-
-  it('does not overwrite a local pending title edit', async () => {
-    const props = makeProps({
-      pendingNameRef: { current: 'Local draft title' },
-    });
-    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
-      task: { id: 'task-1', name: 'Remote title' },
-    });
-
-    renderHook(() => useTaskRealtimeSync(props), { wrapper });
-
-    act(() => {
-      boardRealtimeMocks.onTaskChange?.(
-        { id: 'task-1', name: 'Remote title' } as Task,
-        'UPDATE'
-      );
-    });
-
-    await waitFor(() => {
-      expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
-        'ws-1',
-        'task-1'
-      );
-    });
-    expect(props.setName).not.toHaveBeenCalled();
-  });
-
-  it('refetches and applies relations when the open task changes', async () => {
-    const label: WorkspaceTaskLabel = {
-      id: 'label-1',
-      name: 'Bug',
-      color: 'red',
-      created_at: '2026-05-22T00:00:00.000Z',
-    };
-    const props = makeProps();
-
-    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
-      task: {
-        id: 'task-1',
-        labels: [label],
-        assignees: [{ id: 'user-1', display_name: 'User 1' }],
-        project_ids: ['project-2'],
-        projects: [
-          { id: 'project-1', name: 'Filtered out', status: 'active' },
-          { id: 'project-2', name: 'Included', status: 'active' },
-        ],
-      },
-    });
-
-    renderHook(() => useTaskRealtimeSync(props), { wrapper });
-
-    act(() => {
-      boardRealtimeMocks.onTaskRelationsChange?.(['other-task', 'task-1']);
-    });
-
-    await waitFor(() => {
-      expect(props.setSelectedLabels).toHaveBeenCalledWith([label]);
-    });
-    expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
-      'ws-1',
-      'task-1'
-    );
-    expect(props.setSelectedAssignees).toHaveBeenCalledWith([
-      { id: 'user-1', display_name: 'User 1' },
-    ]);
-    expect(props.setSelectedProjects).toHaveBeenCalledWith([
-      { id: 'project-2', name: 'Included', status: 'active' },
-    ]);
-  });
-
-  it('returns the dialog-local board broadcast function', () => {
-    const { result } = renderHook(() => useTaskRealtimeSync(makeProps()), {
-      wrapper,
-    });
-
-    expect((result.current as { broadcast?: BoardBroadcastFn }).broadcast).toBe(
-      boardRealtimeMocks.broadcast
-    );
-  });
-});