@tuturuuu/ui 0.16.0 → 0.18.0

package/src/components/ui/tu-do/shared/__tests__/task-dialog-manager.test.tsx

@@ -1,945 +0,0 @@
-import '@testing-library/jest-dom';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { act, fireEvent, render, waitFor } from '@testing-library/react';
-import type { Task } from '@tuturuuu/types/primitives/Task';
-import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
-import React from 'react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  TaskDialogProvider,
-  useTaskDialogContext,
-} from '../../providers/task-dialog-provider';
-import { RECENT_SIDEBAR_VISIT_EVENT } from '../recent-sidebar-events';
-import { TaskDialogManager } from '../task-dialog-manager';
-import { REQUEST_OPEN_TASK_EVENT } from '../task-open-events';
-
-const { mockSearchParams, taskDialogRenderStats } = vi.hoisted(() => ({
-  mockSearchParams: new URLSearchParams(),
-  taskDialogRenderStats: {
-    mounts: 0,
-    unmounts: 0,
-  },
-}));
-
-// Mock Next.js navigation (no longer needs useRouter/usePathname for URL manipulation)
-vi.mock('next/navigation', () => ({
-  useRouter: () => ({
-    push: vi.fn(),
-    replace: vi.fn(),
-    refresh: vi.fn(),
-    back: vi.fn(),
-    forward: vi.fn(),
-    prefetch: vi.fn(),
-  }),
-  usePathname: () => '/workspace-1/tasks',
-  useSearchParams: () => mockSearchParams,
-  useParams: () => ({ wsId: 'workspace-1' }),
-}));
-
-const {
-  mockGetCurrentUserProfile,
-  mockGetTaskDialogHydration,
-  mockGetUserConfig,
-  mockGetWorkspaceTask,
-  mockListWorkspaceLabels,
-  mockListWorkspaceMembers,
-  mockListWorkspaceTaskProjectsByIds,
-  mockResolveTaskProjectWorkspaceId,
-} = vi.hoisted(() => ({
-  mockGetCurrentUserProfile: vi.fn(),
-  mockGetTaskDialogHydration: vi.fn(),
-  mockGetUserConfig: vi.fn(),
-  mockGetWorkspaceTask: vi.fn(),
-  mockListWorkspaceLabels: vi.fn(),
-  mockListWorkspaceMembers: vi.fn(),
-  mockListWorkspaceTaskProjectsByIds: vi.fn(),
-  mockResolveTaskProjectWorkspaceId: vi.fn(),
-}));
-
-vi.mock('@tuturuuu/internal-api', () => ({
-  getCurrentUserProfile: mockGetCurrentUserProfile,
-}));
-
-vi.mock('@tuturuuu/internal-api/tasks', () => ({
-  getTaskDialogHydration: mockGetTaskDialogHydration,
-  getWorkspaceTask: mockGetWorkspaceTask,
-  listWorkspaceLabels: mockListWorkspaceLabels,
-  listWorkspaceTaskProjectsByIds: mockListWorkspaceTaskProjectsByIds,
-  resolveTaskProjectWorkspaceId: mockResolveTaskProjectWorkspaceId,
-}));
-
-vi.mock('@tuturuuu/internal-api/users', () => ({
-  getUserConfig: mockGetUserConfig,
-}));
-
-vi.mock('@tuturuuu/internal-api/workspaces', () => ({
-  listWorkspaceMembers: mockListWorkspaceMembers,
-}));
-
-vi.mock('@tuturuuu/supabase/next/client', () => ({
-  createClient: vi.fn(() => ({
-    auth: {
-      getSession: vi.fn().mockResolvedValue({
-        data: { session: null },
-      }),
-    },
-    from: vi.fn((table: string) => {
-      if (table === 'tasks') {
-        return {
-          select: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: {
-                  id: 'task-1',
-                  name: 'Test Task',
-                  description: '',
-                  priority: 'normal',
-                  start_date: undefined,
-                  end_date: null,
-                  estimation_points: null,
-                  list_id: 'list-1',
-                  created_at: '2024-01-01T00:00:00Z',
-                  sort_key: 1000,
-                  display_number: 1,
-                  list: {
-                    id: 'list-1',
-                    name: 'To Do',
-                    board_id: 'board-1',
-                    board: {
-                      id: 'board-1',
-                      ws_id: 'workspace-1',
-                      workspace: { personal: false },
-                    },
-                  },
-                  assignees: [],
-                  labels: [],
-                  projects: [],
-                },
-                error: null,
-              }),
-            })),
-          })),
-        };
-      }
-
-      if (table === 'task_lists') {
-        const orderChain = {
-          order: vi.fn(() => orderChain),
-        };
-
-        return {
-          select: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              eq: vi.fn(() => orderChain),
-            })),
-          })),
-        };
-      }
-
-      if (table === 'users') {
-        return {
-          select: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: null,
-                error: null,
-              }),
-            })),
-          })),
-        };
-      }
-
-      return {
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            single: vi.fn().mockResolvedValue({
-              data: null,
-              error: null,
-            }),
-          })),
-        })),
-      };
-    }),
-  })),
-}));
-
-// Mock the TaskEditDialog component since it's lazy-loaded
-vi.mock('../task-edit-dialog', () => ({
-  TaskEditDialog: ({
-    defaultPresentation,
-    isOpen,
-    isHydratingTask,
-    taskLoadError,
-    task,
-    visibleBoardId,
-    visibleTaskSnapshot,
-    onClose,
-    onNavigateToTask,
-  }: {
-    defaultPresentation?: string;
-    isOpen: boolean;
-    isHydratingTask?: boolean;
-    taskLoadError?: boolean;
-    task?: Task;
-    visibleBoardId?: string;
-    visibleTaskSnapshot?: Partial<Task>;
-    onClose: () => void;
-    onNavigateToTask?: (taskId: string) => Promise<void>;
-  }) => {
-    React.useEffect(() => {
-      taskDialogRenderStats.mounts += 1;
-
-      return () => {
-        taskDialogRenderStats.unmounts += 1;
-      };
-    }, []);
-
-    return (
-      <div
-        data-testid="task-edit-dialog"
-        data-default-presentation={defaultPresentation}
-        data-hydrating={String(!!isHydratingTask)}
-        data-load-error={String(!!taskLoadError)}
-        data-open={isOpen}
-        data-visible-board-id={visibleBoardId}
-        data-visible-list-id={visibleTaskSnapshot?.list_id}
-      >
-        {task && <div data-testid="task-name">{task.name}</div>}
-        <button
-          type="button"
-          onClick={() => void onNavigateToTask?.('task-2')}
-          data-testid="navigate-button"
-        >
-          Navigate
-        </button>
-        <button type="button" onClick={onClose} data-testid="close-button">
-          Close
-        </button>
-      </div>
-    );
-  },
-}));
-
-// Mock task data
-const mockTask: Task = {
-  id: 'task-1',
-  name: 'Test Task',
-  description: '',
-  priority: 'normal',
-  start_date: undefined,
-  end_date: null,
-  estimation_points: null,
-  list_id: 'list-1',
-  labels: [],
-  assignees: [],
-  created_at: '2024-01-01T00:00:00Z',
-  sort_key: 1000,
-  display_number: 1,
-};
-
-const mockList: TaskList = {
-  id: 'list-1',
-  name: 'To Do',
-  board_id: 'board-1',
-  position: 0,
-  status: 'not_started',
-  color: 'BLUE',
-  created_at: '2024-01-01T00:00:00Z',
-  creator_id: 'user-1',
-  archived: false,
-  deleted: false,
-};
-
-function createTestQueryClient() {
-  return new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  });
-}
-
-function createDeferred<T>() {
-  let resolve!: (value: T) => void;
-  let reject!: (reason?: unknown) => void;
-  const promise = new Promise<T>((promiseResolve, promiseReject) => {
-    resolve = promiseResolve;
-    reject = promiseReject;
-  });
-
-  return { promise, resolve, reject };
-}
-
-function Wrapper({ children }: { children: React.ReactNode }) {
-  const queryClient = createTestQueryClient();
-  return (
-    <QueryClientProvider client={queryClient}>
-      <TaskDialogProvider>{children}</TaskDialogProvider>
-    </QueryClientProvider>
-  );
-}
-
-// Spy on window.history methods for URL manipulation tests
-let pushStateSpy: ReturnType<typeof vi.spyOn>;
-let replaceStateSpy: ReturnType<typeof vi.spyOn>;
-const fetchMock = vi.fn();
-
-beforeEach(() => {
-  mockSearchParams.forEach((_, key) => {
-    mockSearchParams.delete(key);
-  });
-  taskDialogRenderStats.mounts = 0;
-  taskDialogRenderStats.unmounts = 0;
-  pushStateSpy = vi.spyOn(window.history, 'pushState');
-  replaceStateSpy = vi.spyOn(window.history, 'replaceState');
-  mockGetCurrentUserProfile.mockResolvedValue({
-    id: 'user-1',
-    display_name: 'Test User',
-    email: 'user@example.com',
-    avatar_url: null,
-  });
-  mockGetUserConfig.mockImplementation((configId: string) =>
-    Promise.resolve({
-      value:
-        configId === 'TASK_DIALOG_DEFAULT_PRESENTATION' ? 'compact' : 'false',
-    })
-  );
-  mockGetTaskDialogHydration.mockResolvedValue({
-    task: {
-      ...mockTask,
-      list: { board_id: 'board-1' },
-    },
-    availableLists: [mockList],
-    taskWsId: 'workspace-1',
-    taskWorkspacePersonal: false,
-    taskWorkspaceTier: 'PRO',
-  });
-  mockListWorkspaceLabels.mockResolvedValue({ labels: [] });
-  mockListWorkspaceMembers.mockResolvedValue({ members: [] });
-  mockGetWorkspaceTask.mockResolvedValue({
-    task: {
-      ...mockTask,
-      id: 'task-2',
-      name: 'Related Task',
-      board_id: 'board-1',
-    },
-  });
-  mockListWorkspaceTaskProjectsByIds.mockResolvedValue([]);
-  mockResolveTaskProjectWorkspaceId.mockResolvedValue('workspace-1');
-  fetchMock.mockResolvedValue({
-    ok: true,
-    json: async () => ({ value: 'false' }),
-  });
-  global.fetch = fetchMock as typeof fetch;
-  // Set a known initial pathname for tests
-  Object.defineProperty(window, 'location', {
-    value: { ...window.location, pathname: '/workspace-1/tasks' },
-    writable: true,
-  });
-});
-
-afterEach(() => {
-  pushStateSpy.mockRestore();
-  replaceStateSpy.mockRestore();
-  vi.restoreAllMocks();
-});
-
-describe('TaskDialogManager', () => {
-  it('should render nothing when dialog is not open', () => {
-    const { container } = render(
-      <Wrapper>
-        <TaskDialogManager wsId="workspace-1" />
-      </Wrapper>
-    );
-
-    expect(container.firstChild).toBeNull();
-  });
-
-  it.skip('should lazy load and render TaskEditDialog when opened', async () => {
-    const TestComponent = () => {
-      const { openTask } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        // Simulate opening the dialog after mount
-        openTask(mockTask, 'board-1', [mockList]);
-      }, [openTask]);
-
-      return <TaskDialogManager wsId="workspace-1" />;
-    };
-
-    const { queryByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    // Initially, dialog should not be rendered
-    expect(queryByTestId('task-edit-dialog')).not.toBeInTheDocument();
-
-    // Wait for the dialog to be loaded and rendered
-    await waitFor(
-      () => {
-        expect(queryByTestId('task-edit-dialog')).toBeInTheDocument();
-      },
-      { timeout: 2000 }
-    );
-  });
-
-  it('should pass correct props to TaskEditDialog', async () => {
-    const TestComponent = () => {
-      const { openTask } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(mockTask, 'board-1', [mockList]);
-      }, [openTask]);
-
-      return <TaskDialogManager wsId="workspace-1" />;
-    };
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(getByTestId('task-edit-dialog')).toBeInTheDocument();
-      expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-        'data-open',
-        'true'
-      );
-      expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-        'data-default-presentation',
-        'compact'
-      );
-      expect(getByTestId('task-name')).toHaveTextContent('Test Task');
-    });
-  });
-
-  it('should handle Suspense boundary correctly', async () => {
-    const { container } = render(
-      <Wrapper>
-        <TaskDialogManager wsId="workspace-1" />
-      </Wrapper>
-    );
-
-    // Should not crash during lazy loading
-    expect(container).toBeInTheDocument();
-  });
-
-  it('should render in create mode', async () => {
-    const TestComponent = () => {
-      const { createTask } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        createTask('board-1', 'list-1', [mockList]);
-      }, [createTask]);
-
-      return <TaskDialogManager wsId="workspace-1" />;
-    };
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(getByTestId('task-edit-dialog')).toBeInTheDocument();
-    });
-  });
-
-  it('should handle close callback', async () => {
-    const TestComponent = () => {
-      const { openTask, state } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(mockTask, 'board-1', [mockList]);
-      }, [openTask]);
-
-      return (
-        <div>
-          <TaskDialogManager wsId="workspace-1" />
-          <div data-testid="dialog-open-state">{String(state.isOpen)}</div>
-        </div>
-      );
-    };
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(getByTestId('dialog-open-state')).toHaveTextContent('true');
-    });
-
-    // Click close button
-    const closeButton = getByTestId('close-button');
-    fireEvent.click(closeButton);
-
-    await waitFor(() => {
-      expect(getByTestId('dialog-open-state')).toHaveTextContent('false');
-    });
-  });
-
-  it('should use pushState for fakeTaskUrl instead of router.push', async () => {
-    const TestComponent = () => {
-      const { openTask } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(mockTask, 'board-1', [mockList], true);
-      }, [openTask]);
-
-      return <TaskDialogManager wsId="workspace-1" />;
-    };
-
-    render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(pushStateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({ __fakeTaskUrl: true }),
-        '',
-        '/workspace-1/tasks/boards/board-1?task=task-1'
-      );
-    });
-  });
-
-  it('auto-opens the canonical task deep link from the current workspace', async () => {
-    mockSearchParams.set('task', 'task-2');
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TaskDialogManager wsId="workspace-1" />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(mockGetTaskDialogHydration).toHaveBeenCalledWith(
-        'task-2',
-        expect.any(Object),
-        expect.any(Object)
-      );
-    });
-
-    await waitFor(() => {
-      expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-        'data-open',
-        'true'
-      );
-      expect(getByTestId('task-name')).toHaveTextContent('Test Task');
-    });
-  });
-
-  it('dispatches a recent visit snapshot when an edit dialog opens', async () => {
-    const listener = vi.fn();
-    window.addEventListener(
-      RECENT_SIDEBAR_VISIT_EVENT,
-      listener as EventListener
-    );
-
-    const TestComponent = () => {
-      const { openTask } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(
-          {
-            ...mockTask,
-            list: {
-              board: { name: 'Tuverse' },
-              name: 'Backlog',
-            },
-          } as Task,
-          'board-1',
-          [mockList]
-        );
-      }, [openTask]);
-
-      return <TaskDialogManager wsId="workspace-1" />;
-    };
-
-    render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(listener).toHaveBeenCalled();
-    });
-
-    const event = listener.mock.calls.at(-1)?.[0] as CustomEvent<{
-      href: string;
-      scopeWsId: string;
-      snapshot: {
-        badges: Array<{ kind: string; value?: string }>;
-        title: string;
-      };
-    }>;
-
-    expect(event.detail).toMatchObject({
-      href: '/workspace-1/tasks/boards/board-1?task=task-1',
-      scopeWsId: 'workspace-1',
-      snapshot: {
-        badges: [
-          { kind: 'board', value: 'Tuverse' },
-          { kind: 'list', value: 'Backlog' },
-        ],
-        title: 'Test Task',
-      },
-    });
-
-    window.removeEventListener(
-      RECENT_SIDEBAR_VISIT_EVENT,
-      listener as EventListener
-    );
-  });
-
-  it('opens a task when a shared task-open event is dispatched', async () => {
-    render(
-      <Wrapper>
-        <TaskDialogManager wsId="workspace-1" />
-      </Wrapper>
-    );
-
-    act(() => {
-      window.dispatchEvent(
-        new CustomEvent(REQUEST_OPEN_TASK_EVENT, {
-          detail: { taskId: 'task-42' },
-        })
-      );
-    });
-
-    await waitFor(() => {
-      expect(
-        document.querySelector('[data-testid="task-edit-dialog"]')
-      ).toBeInTheDocument();
-      expect(
-        document.querySelector('[data-testid="task-name"]')
-      ).toHaveTextContent('Test Task');
-    });
-  });
-
-  it('renders a hydrating task dialog immediately for shared task-open events', async () => {
-    const deferred = createDeferred<{
-      task: Task & { list?: { board_id?: string | null } | null };
-      availableLists: TaskList[];
-      taskWsId: string;
-      taskWorkspacePersonal: boolean;
-      taskWorkspaceTier: 'PRO';
-    }>();
-    mockGetTaskDialogHydration.mockReturnValueOnce(deferred.promise);
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TaskDialogManager wsId="workspace-1" />
-      </Wrapper>
-    );
-
-    act(() => {
-      window.dispatchEvent(
-        new CustomEvent(REQUEST_OPEN_TASK_EVENT, {
-          detail: { taskId: 'task-42' },
-        })
-      );
-    });
-
-    expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-      'data-hydrating',
-      'true'
-    );
-
-    await act(async () => {
-      deferred.resolve({
-        task: {
-          ...mockTask,
-          id: 'task-42',
-          name: 'Hydrated Event Task',
-          list: { board_id: 'board-1' },
-        },
-        availableLists: [mockList],
-        taskWsId: 'workspace-1',
-        taskWorkspacePersonal: false,
-        taskWorkspaceTier: 'PRO',
-      });
-      await Promise.resolve();
-    });
-
-    await waitFor(() => {
-      expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-        'data-hydrating',
-        'false'
-      );
-      expect(getByTestId('task-name')).toHaveTextContent('Hydrated Event Task');
-    });
-  });
-
-  it('keeps the same dialog mounted when a source-workspace task finishes hydrating', async () => {
-    const deferred = createDeferred<{
-      task: Task & { list?: { board_id?: string | null } | null };
-      availableLists: TaskList[];
-      taskWsId: string;
-      taskWorkspacePersonal: boolean;
-      taskWorkspaceTier: 'PRO';
-    }>();
-    mockGetTaskDialogHydration.mockReturnValueOnce(deferred.promise);
-
-    const TestComponent = () => {
-      const { openTaskById } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        const visibleExternalSnapshot = {
-          ...mockTask,
-          id: 'external-task-1',
-          name: 'External snapshot',
-          list_id: 'personal-list-1',
-          personal_board_id: 'personal-board-1',
-          personal_list_id: 'personal-list-1',
-          personal_sort_key: 2000,
-          source_workspace_id: 'source-workspace-1',
-          source_board_id: 'external-board-1',
-          source_list_id: 'external-list-1',
-          source_list_name: 'External list',
-          is_personal_external: true,
-        } satisfies Task;
-
-        void openTaskById('external-task-1', {
-          initialTask: {
-            ...visibleExternalSnapshot,
-            list_id: 'external-list-1',
-          },
-          boardId: 'external-board-1',
-          availableLists: [
-            {
-              ...mockList,
-              id: 'external-list-1',
-              board_id: 'external-board-1',
-            },
-          ],
-          taskWsId: 'source-workspace-1',
-          taskWorkspacePersonal: false,
-          visibleBoardId: 'personal-board-1',
-          visibleTaskSnapshot: visibleExternalSnapshot,
-        });
-      }, [openTaskById]);
-
-      return <TaskDialogManager wsId="personal-workspace-1" />;
-    };
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-        'data-hydrating',
-        'true'
-      );
-      expect(getByTestId('task-name')).toHaveTextContent('External snapshot');
-    });
-    expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-      'data-visible-board-id',
-      'personal-board-1'
-    );
-    expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-      'data-visible-list-id',
-      'personal-list-1'
-    );
-    expect(taskDialogRenderStats).toMatchObject({
-      mounts: 1,
-      unmounts: 0,
-    });
-
-    await act(async () => {
-      deferred.resolve({
-        task: {
-          ...mockTask,
-          id: 'external-task-1',
-          name: 'Hydrated external task',
-          list: { board_id: 'external-board-1' },
-        },
-        availableLists: [
-          { ...mockList, id: 'external-list-1', board_id: 'external-board-1' },
-        ],
-        taskWsId: 'source-workspace-1',
-        taskWorkspacePersonal: false,
-        taskWorkspaceTier: 'PRO',
-      });
-      await Promise.resolve();
-    });
-
-    await waitFor(() => {
-      expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-        'data-hydrating',
-        'false'
-      );
-      expect(getByTestId('task-name')).toHaveTextContent(
-        'Hydrated external task'
-      );
-    });
-    expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-      'data-visible-board-id',
-      'personal-board-1'
-    );
-    expect(getByTestId('task-edit-dialog')).toHaveAttribute(
-      'data-visible-list-id',
-      'personal-list-1'
-    );
-    expect(taskDialogRenderStats).toMatchObject({
-      mounts: 1,
-      unmounts: 0,
-    });
-  });
-
-  it('opens a task from the canonical task query parameter', async () => {
-    mockSearchParams.set('task', 'task-42');
-
-    render(
-      <Wrapper>
-        <TaskDialogManager wsId="workspace-1" />
-      </Wrapper>
-    );
-
-    await waitFor(() => {
-      expect(mockGetTaskDialogHydration).toHaveBeenCalledWith(
-        'task-42',
-        expect.any(Object),
-        expect.any(Object)
-      );
-    });
-  });
-
-  it('opens relationship navigation targets from the current board cache before falling back to user-task lookup', async () => {
-    const queryClient = createTestQueryClient();
-
-    queryClient.setQueryData(
-      ['tasks', 'board-1'],
-      [
-        mockTask,
-        {
-          ...mockTask,
-          id: 'task-2',
-          name: 'Cached Related Task',
-        },
-      ]
-    );
-
-    const TestComponent = () => {
-      const { openTask } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(mockTask, 'board-1', [mockList]);
-      }, [openTask]);
-
-      return <TaskDialogManager wsId="workspace-1" />;
-    };
-
-    const { getByTestId } = render(
-      <QueryClientProvider client={queryClient}>
-        <TaskDialogProvider>
-          <TestComponent />
-        </TaskDialogProvider>
-      </QueryClientProvider>
-    );
-
-    await waitFor(() => {
-      expect(getByTestId('task-name')).toHaveTextContent('Test Task');
-    });
-
-    mockGetTaskDialogHydration.mockClear();
-    mockGetWorkspaceTask.mockClear();
-
-    fireEvent.click(getByTestId('navigate-button'));
-
-    await waitFor(() => {
-      expect(getByTestId('task-name')).toHaveTextContent('Cached Related Task');
-    });
-
-    expect(mockGetTaskDialogHydration).not.toHaveBeenCalled();
-  });
-
-  it('should use replaceState to revert URL when dialog closes', async () => {
-    const TestComponent = () => {
-      const { openTask, state } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(mockTask, 'board-1', [mockList], true);
-      }, [openTask]);
-
-      return (
-        <div>
-          <TaskDialogManager wsId="workspace-1" />
-          <div data-testid="dialog-open-state">{String(state.isOpen)}</div>
-        </div>
-      );
-    };
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    // Wait for dialog to open and pushState to be called
-    await waitFor(() => {
-      expect(getByTestId('dialog-open-state')).toHaveTextContent('true');
-      expect(pushStateSpy).toHaveBeenCalled();
-    });
-
-    // Close dialog
-    const closeButton = getByTestId('close-button');
-    fireEvent.click(closeButton);
-
-    await waitFor(() => {
-      expect(getByTestId('dialog-open-state')).toHaveTextContent('false');
-      // Should replaceState back to original pathname
-      expect(replaceStateSpy).toHaveBeenCalledWith(
-        null,
-        '',
-        '/workspace-1/tasks'
-      );
-    });
-  });
-
-  it('should close dialog on popstate (browser back) when fakeTaskUrl is active', async () => {
-    const TestComponent = () => {
-      const { openTask, state } = useTaskDialogContext();
-
-      React.useEffect(() => {
-        openTask(mockTask, 'board-1', [mockList], true);
-      }, [openTask]);
-
-      return (
-        <div>
-          <TaskDialogManager wsId="workspace-1" />
-          <div data-testid="dialog-open-state">{String(state.isOpen)}</div>
-        </div>
-      );
-    };
-
-    const { getByTestId } = render(
-      <Wrapper>
-        <TestComponent />
-      </Wrapper>
-    );
-
-    // Wait for dialog to open
-    await waitFor(() => {
-      expect(getByTestId('dialog-open-state')).toHaveTextContent('true');
-      expect(pushStateSpy).toHaveBeenCalled();
-    });
-
-    // Simulate browser back button
-    act(() => {
-      window.dispatchEvent(new PopStateEvent('popstate'));
-    });
-
-    await waitFor(() => {
-      expect(getByTestId('dialog-open-state')).toHaveTextContent('false');
-    });
-  });
-});