github-issue-tower-defence-management 1.90.0 → 1.91.1

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleOperationMenu.test.tsx

@@ -0,0 +1,85 @@
+import { render } from '@testing-library/react';
+import type { ConsoleOperationHandlers } from '../../logic/operations';
+import {
+  consoleListItemsFixture,
+  consoleStatusOptionsFixture,
+  consoleStoryOptionsFixture,
+} from '../../testing/fixtures';
+import { ConsoleOperationMenu } from './ConsoleOperationMenu';
+
+const handlers: ConsoleOperationHandlers = {
+  onReview: jest.fn(),
+  onSetNextActionDate: jest.fn(),
+  onSetStory: jest.fn(),
+  onSetStatus: jest.fn(),
+  onSetInTmuxByHuman: jest.fn(),
+  onClose: jest.fn(),
+};
+
+const prItem = consoleListItemsFixture[0];
+const issueItem = consoleListItemsFixture[2];
+
+describe('ConsoleOperationMenu', () => {
+  it('shows the review group for a PR and hides story and close groups outside triage', () => {
+    const { getByText, queryByText } = render(
+      <ConsoleOperationMenu
+        tab="prs"
+        item={prItem}
+        hasPullRequest
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        handlers={handlers}
+      />,
+    );
+    expect(getByText('Approve')).toBeInTheDocument();
+    expect(getByText('+1 day')).toBeInTheDocument();
+    expect(getByText('Awaiting Workspace')).toBeInTheDocument();
+    expect(queryByText('Close')).toBeNull();
+    expect(queryByText('TDPM Console port')).toBeNull();
+  });
+
+  it('shows the story group on the triage tab and the close group for an issue', () => {
+    const { getByText } = render(
+      <ConsoleOperationMenu
+        tab="triage"
+        item={issueItem}
+        hasPullRequest={false}
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        handlers={handlers}
+      />,
+    );
+    expect(getByText('Move to Okinawa')).toBeInTheDocument();
+    expect(getByText('Close')).toBeInTheDocument();
+    expect(getByText('Close as not planned')).toBeInTheDocument();
+  });
+
+  it('shows +1 week and skip on the todo-by-human tab', () => {
+    const { getByText } = render(
+      <ConsoleOperationMenu
+        tab="todo-by-human"
+        item={issueItem}
+        hasPullRequest={false}
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        handlers={handlers}
+      />,
+    );
+    expect(getByText('+1 week and skip')).toBeInTheDocument();
+  });
+
+  it('hides the review group when there is no pull request', () => {
+    const { queryByText } = render(
+      <ConsoleOperationMenu
+        tab="unread"
+        item={issueItem}
+        hasPullRequest={false}
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        handlers={handlers}
+      />,
+    );
+    expect(queryByText('Approve')).toBeNull();
+    expect(queryByText('Close')).not.toBeNull();
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleOperationMenu.tsx

@@ -0,0 +1,58 @@
+import {
+  type ConsoleOperationHandlers,
+  isTodoByHumanTab,
+} from '../../logic/operations';
+import type {
+  ConsoleFieldOption,
+  ConsoleListItem,
+  ConsoleTabName,
+} from '../../logic/types';
+import { ConsoleCloseActions } from './ConsoleCloseActions';
+import { ConsoleNextActionDateActions } from './ConsoleNextActionDateActions';
+import { ConsolePullRequestReviewActions } from './ConsolePullRequestReviewActions';
+import { ConsoleStatusActions } from './ConsoleStatusActions';
+import { ConsoleStoryActions } from './ConsoleStoryActions';
+
+export type ConsoleOperationBarProps = {
+  tab: ConsoleTabName;
+  item: ConsoleListItem;
+  hasPullRequest: boolean;
+  statusOptions: ConsoleFieldOption[];
+  storyOptions: ConsoleFieldOption[];
+  handlers: ConsoleOperationHandlers;
+};
+
+export const ConsoleOperationMenu = ({
+  tab,
+  item,
+  hasPullRequest,
+  statusOptions,
+  storyOptions,
+  handlers,
+}: ConsoleOperationBarProps) => {
+  const showStory = tab === 'triage';
+  const showClose = !item.isPr;
+  return (
+    <div className="console-operation-bar">
+      {hasPullRequest && (
+        <ConsolePullRequestReviewActions onReview={handlers.onReview} />
+      )}
+      <ConsoleNextActionDateActions
+        isTodoByHuman={isTodoByHumanTab(tab)}
+        onSetNextActionDate={handlers.onSetNextActionDate}
+      />
+      {showStory && (
+        <ConsoleStoryActions
+          storyOptions={storyOptions}
+          onSetStory={handlers.onSetStory}
+        />
+      )}
+      <ConsoleStatusActions
+        statusOptions={statusOptions}
+        onSetStatus={handlers.onSetStatus}
+        onSetInTmuxByHuman={handlers.onSetInTmuxByHuman}
+      />
+      {showClose && <ConsoleCloseActions onClose={handlers.onClose} />}
+    </div>
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsolePullRequestReviewActions.stories.tsx

@@ -0,0 +1,14 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { ConsolePullRequestReviewActions } from './ConsolePullRequestReviewActions';
+
+const meta: Meta<typeof ConsolePullRequestReviewActions> = {
+  title: 'Console/ConsolePullRequestReviewActions',
+  component: ConsolePullRequestReviewActions,
+  args: { onReview: () => {} },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsolePullRequestReviewActions>;
+
+export const Default: Story = {};

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsolePullRequestReviewActions.test.tsx

@@ -0,0 +1,33 @@
+import { fireEvent, render } from '@testing-library/react';
+import { ConsolePullRequestReviewActions } from './ConsolePullRequestReviewActions';
+
+describe('ConsolePullRequestReviewActions', () => {
+  it('renders the four buttons left to right', () => {
+    const { getAllByRole } = render(
+      <ConsolePullRequestReviewActions onReview={() => {}} />,
+    );
+    expect(getAllByRole('button').map((button) => button.textContent)).toEqual([
+      'Unnecessary',
+      'Totally wrong',
+      'Reject',
+      'Approve',
+    ]);
+  });
+
+  it('reports each review action', () => {
+    const onReview = jest.fn();
+    const { getByText } = render(
+      <ConsolePullRequestReviewActions onReview={onReview} />,
+    );
+    fireEvent.click(getByText('Unnecessary'));
+    fireEvent.click(getByText('Totally wrong'));
+    fireEvent.click(getByText('Reject'));
+    fireEvent.click(getByText('Approve'));
+    expect(onReview.mock.calls.map((call) => call[0])).toEqual([
+      'unnecessary',
+      'totally_wrong',
+      'request_changes',
+      'approve',
+    ]);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsolePullRequestReviewActions.tsx

@@ -0,0 +1,34 @@
+import type { ConsoleReviewAction } from '../../logic/operations';
+
+export type ConsolePullRequestReviewGroupProps = {
+  onReview: (action: ConsoleReviewAction) => void;
+};
+
+const REVIEW_BUTTONS: {
+  action: ConsoleReviewAction;
+  label: string;
+  color: string;
+}[] = [
+  { action: 'unnecessary', label: 'Unnecessary', color: '#8b949e' },
+  { action: 'totally_wrong', label: 'Totally wrong', color: '#f85149' },
+  { action: 'request_changes', label: 'Reject', color: '#d29922' },
+  { action: 'approve', label: 'Approve', color: '#3fb950' },
+];
+
+export const ConsolePullRequestReviewActions = ({
+  onReview,
+}: ConsolePullRequestReviewGroupProps) => (
+  <div className="console-op-group">
+    {REVIEW_BUTTONS.map((button) => (
+      <button
+        key={button.action}
+        type="button"
+        className="console-op-button"
+        style={{ color: button.color, borderColor: button.color }}
+        onClick={() => onReview(button.action)}
+      >
+        {button.label}
+      </button>
+    ))}
+  </div>
+);

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleStatusActions.stories.tsx

@@ -0,0 +1,17 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { consoleStatusOptionsFixture } from '../../testing/fixtures';
+import { ConsoleStatusActions } from './ConsoleStatusActions';
+
+const meta: Meta<typeof ConsoleStatusActions> = {
+  title: 'Console/ConsoleStatusActions',
+  component: ConsoleStatusActions,
+  args: { onSetStatus: () => {}, onSetInTmuxByHuman: () => {} },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleStatusActions>;
+
+export const AllStatusOptions: Story = {
+  args: { statusOptions: consoleStatusOptionsFixture },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleStatusActions.test.tsx

@@ -0,0 +1,49 @@
+import { fireEvent, render } from '@testing-library/react';
+import { consoleStatusOptionsFixture } from '../../testing/fixtures';
+import { ConsoleStatusActions } from './ConsoleStatusActions';
+
+describe('ConsoleStatusActions', () => {
+  it('renders only the four routed status buttons that exist in the data', () => {
+    const { getByText, queryByText } = render(
+      <ConsoleStatusActions
+        statusOptions={consoleStatusOptionsFixture}
+        onSetStatus={() => {}}
+        onSetInTmuxByHuman={() => {}}
+      />,
+    );
+    expect(getByText('In Tmux by agent')).toBeInTheDocument();
+    expect(getByText('In Tmux by human')).toBeInTheDocument();
+    expect(getByText('Todo by human')).toBeInTheDocument();
+    expect(getByText('Awaiting Workspace')).toBeInTheDocument();
+    expect(queryByText('Preparation')).toBeNull();
+  });
+
+  it('routes In Tmux by human to the intmux handler and others to the status handler', () => {
+    const onSetStatus = jest.fn();
+    const onSetInTmuxByHuman = jest.fn();
+    const { getByText } = render(
+      <ConsoleStatusActions
+        statusOptions={consoleStatusOptionsFixture}
+        onSetStatus={onSetStatus}
+        onSetInTmuxByHuman={onSetInTmuxByHuman}
+      />,
+    );
+    fireEvent.click(getByText('In Tmux by human'));
+    fireEvent.click(getByText('In Tmux by agent'));
+    expect(onSetInTmuxByHuman).toHaveBeenCalledTimes(1);
+    expect(onSetInTmuxByHuman.mock.calls[0][0].name).toBe('In Tmux by human');
+    expect(onSetStatus).toHaveBeenCalledTimes(1);
+    expect(onSetStatus.mock.calls[0][0].name).toBe('In Tmux by agent');
+  });
+
+  it('renders nothing when no routed option exists', () => {
+    const { container } = render(
+      <ConsoleStatusActions
+        statusOptions={[{ id: 'x', name: 'Preparation', color: 'YELLOW' }]}
+        onSetStatus={() => {}}
+        onSetInTmuxByHuman={() => {}}
+      />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleStatusActions.tsx

@@ -0,0 +1,66 @@
+import { colorFromEnum } from '../../logic/colors';
+import {
+  IN_TMUX_BY_HUMAN_NAME,
+  STATUS_BUTTON_NAMES,
+} from '../../logic/operations';
+import type { ConsoleFieldOption } from '../../logic/types';
+
+export type ConsoleStatusButtonGroupProps = {
+  statusOptions: ConsoleFieldOption[];
+  onSetStatus: (option: ConsoleFieldOption) => void;
+  onSetInTmuxByHuman: (option: ConsoleFieldOption) => void;
+};
+
+const findStatusOption = (
+  statusOptions: ConsoleFieldOption[],
+  name: string,
+): ConsoleFieldOption | null => {
+  const lower = name.toLowerCase();
+  return (
+    statusOptions.find((option) => option.name.toLowerCase() === lower) ?? null
+  );
+};
+
+export const ConsoleStatusActions = ({
+  statusOptions,
+  onSetStatus,
+  onSetInTmuxByHuman,
+}: ConsoleStatusButtonGroupProps) => {
+  const buttons = STATUS_BUTTON_NAMES.map((name) => ({
+    name,
+    option: findStatusOption(statusOptions, name),
+  })).filter(
+    (entry): entry is { name: string; option: ConsoleFieldOption } =>
+      entry.option !== null,
+  );
+
+  if (buttons.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className="console-op-group">
+      {buttons.map(({ name, option }) => {
+        const palette = colorFromEnum(option.color);
+        const isInTmuxByHuman = name === IN_TMUX_BY_HUMAN_NAME;
+        return (
+          <button
+            key={option.id}
+            type="button"
+            className="console-op-button"
+            style={{
+              color: palette.fg,
+              borderColor: palette.border,
+              backgroundColor: palette.bg,
+            }}
+            onClick={() =>
+              isInTmuxByHuman ? onSetInTmuxByHuman(option) : onSetStatus(option)
+            }
+          >
+            {option.name}
+          </button>
+        );
+      })}
+    </div>
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleStoryActions.stories.tsx

@@ -0,0 +1,17 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { consoleStoryOptionsFixture } from '../../testing/fixtures';
+import { ConsoleStoryActions } from './ConsoleStoryActions';
+
+const meta: Meta<typeof ConsoleStoryActions> = {
+  title: 'Console/ConsoleStoryActions',
+  component: ConsoleStoryActions,
+  args: { onSetStory: () => {} },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleStoryActions>;
+
+export const AssignableStories: Story = {
+  args: { storyOptions: consoleStoryOptionsFixture },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleStoryActions.test.tsx

@@ -0,0 +1,39 @@
+import { fireEvent, render } from '@testing-library/react';
+import { ConsoleStoryActions } from './ConsoleStoryActions';
+
+const options = [
+  { id: '1', name: 'TDPM Console port', color: 'BLUE' as const },
+  {
+    id: '2',
+    name: "regular / NO STORY; DON'T WORK ON THIS",
+    color: 'RED' as const,
+  },
+  { id: '3', name: 'Move to Okinawa', color: 'PURPLE' as const },
+];
+
+describe('ConsoleStoryActions', () => {
+  it('excludes no-story options', () => {
+    const { getByText, queryByText } = render(
+      <ConsoleStoryActions storyOptions={options} onSetStory={() => {}} />,
+    );
+    expect(getByText('TDPM Console port')).toBeInTheDocument();
+    expect(getByText('Move to Okinawa')).toBeInTheDocument();
+    expect(queryByText(/NO STORY/)).toBeNull();
+  });
+
+  it('reports the selected story option', () => {
+    const onSetStory = jest.fn();
+    const { getByText } = render(
+      <ConsoleStoryActions storyOptions={options} onSetStory={onSetStory} />,
+    );
+    fireEvent.click(getByText('Move to Okinawa'));
+    expect(onSetStory).toHaveBeenCalledWith(options[2]);
+  });
+
+  it('renders nothing when only no-story options exist', () => {
+    const { container } = render(
+      <ConsoleStoryActions storyOptions={[options[1]]} onSetStory={() => {}} />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleStoryActions.tsx

@@ -0,0 +1,42 @@
+import { colorFromEnum } from '../../logic/colors';
+import type { ConsoleFieldOption } from '../../logic/types';
+
+export type ConsoleStoryButtonGroupProps = {
+  storyOptions: ConsoleFieldOption[];
+  onSetStory: (option: ConsoleFieldOption) => void;
+};
+
+const isNoStoryOption = (option: ConsoleFieldOption): boolean =>
+  option.name.toLowerCase().includes('no story');
+
+export const ConsoleStoryActions = ({
+  storyOptions,
+  onSetStory,
+}: ConsoleStoryButtonGroupProps) => {
+  const assignable = storyOptions.filter((option) => !isNoStoryOption(option));
+  if (assignable.length === 0) {
+    return null;
+  }
+  return (
+    <div className="console-op-group console-op-group-stories">
+      {assignable.map((option) => {
+        const palette = colorFromEnum(option.color);
+        return (
+          <button
+            key={option.id}
+            type="button"
+            className="console-op-button"
+            style={{
+              color: palette.fg,
+              borderColor: palette.border,
+              backgroundColor: palette.bg,
+            }}
+            onClick={() => onSetStory(option)}
+          >
+            {option.name}
+          </button>
+        );
+      })}
+    </div>
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleCaches.test.ts

@@ -0,0 +1,22 @@
+import { renderHook } from '@testing-library/react';
+import { useConsoleCaches } from './useConsoleCaches';
+
+describe('useConsoleCaches', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    window.history.replaceState({}, '', '/?k=token');
+  });
+
+  it('exposes one cache per resource and a stable identity across renders', () => {
+    const { result, rerender } = renderHook(() => useConsoleCaches());
+    const first = result.current;
+    expect(first.body).toBeDefined();
+    expect(first.comments).toBeDefined();
+    expect(first.files).toBeDefined();
+    expect(first.commits).toBeDefined();
+    expect(first.relatedPrs).toBeDefined();
+    expect(first.state).toBeDefined();
+    rerender();
+    expect(result.current).toBe(first);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleCaches.ts

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+import {
+  type ConsoleApiClient,
+  createConsoleApiClient,
+} from '../lib/consoleApi';
+import { ResourceCache } from '../lib/resourceCache';
+import type {
+  ConsoleChangedFile,
+  ConsoleComment,
+  ConsoleCommit,
+  ConsoleIssueState,
+  ConsoleRelatedPullRequest,
+} from '../logic/types';
+import { useConsoleToken } from './useConsoleToken';
+
+export type ConsoleCaches = {
+  body: ResourceCache<string>;
+  comments: ResourceCache<ConsoleComment[]>;
+  files: ResourceCache<ConsoleChangedFile[]>;
+  commits: ResourceCache<ConsoleCommit[]>;
+  relatedPrs: ResourceCache<ConsoleRelatedPullRequest[]>;
+  state: ResourceCache<ConsoleIssueState>;
+  client: ConsoleApiClient;
+};
+
+export const useConsoleCaches = (): ConsoleCaches => {
+  const { appendToken } = useConsoleToken();
+  return useMemo(() => {
+    const client = createConsoleApiClient(appendToken);
+    return {
+      client,
+      body: new ResourceCache<string>(client.fetchItemBody),
+      comments: new ResourceCache<ConsoleComment[]>(client.fetchComments),
+      files: new ResourceCache<ConsoleChangedFile[]>(client.fetchPrFiles),
+      commits: new ResourceCache<ConsoleCommit[]>(client.fetchPrCommits),
+      relatedPrs: new ResourceCache<ConsoleRelatedPullRequest[]>(
+        client.fetchRelatedPrs,
+      ),
+      state: new ResourceCache<ConsoleIssueState>(client.fetchIssueState),
+    };
+  }, [appendToken]);
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleItemDetailData.test.ts

@@ -0,0 +1,126 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { ResourceCache } from '../lib/resourceCache';
+import type {
+  ConsoleChangedFile,
+  ConsoleComment,
+  ConsoleCommit,
+  ConsoleIssueState,
+  ConsoleListItem,
+  ConsoleRelatedPullRequest,
+} from '../logic/types';
+import type { ConsoleCaches } from './useConsoleCaches';
+import { useConsoleItemDetailData } from './useConsoleItemDetailData';
+
+const prItem: ConsoleListItem = {
+  number: 1,
+  title: 'PR',
+  url: 'https://github.com/o/r/pull/1',
+  repo: 'o/r',
+  nameWithOwner: 'o/r',
+  projectItemId: 'PVTI_1',
+  itemId: 'PVTI_1',
+  isPr: true,
+  story: 'Story',
+  labels: [],
+  createdAt: '2026-06-10T00:00:00.000Z',
+};
+
+const issueItem: ConsoleListItem = {
+  ...prItem,
+  isPr: false,
+  url: 'https://github.com/o/r/issues/2',
+  number: 2,
+};
+
+const buildCaches = (related: ConsoleRelatedPullRequest[]): ConsoleCaches => {
+  const client = {
+    fetchItemBody: async () => 'body',
+    fetchComments: async (): Promise<ConsoleComment[]> => [],
+    fetchPrFiles: async (): Promise<ConsoleChangedFile[]> => [
+      {
+        path: 'a.ts',
+        additions: 1,
+        deletions: 0,
+        status: 'added',
+        patch: null,
+      },
+    ],
+    fetchPrCommits: async (): Promise<ConsoleCommit[]> => [
+      {
+        sha: 'abc',
+        message: 'm',
+        author: 'a',
+        authoredAt: '2026-06-10T00:00:00.000Z',
+      },
+    ],
+    fetchRelatedPrs: async (): Promise<ConsoleRelatedPullRequest[]> => related,
+    fetchIssueState: async (): Promise<ConsoleIssueState> => ({
+      state: 'open',
+      merged: false,
+      isPullRequest: true,
+    }),
+  };
+  return {
+    client,
+    body: new ResourceCache(client.fetchItemBody),
+    comments: new ResourceCache(client.fetchComments),
+    files: new ResourceCache(client.fetchPrFiles),
+    commits: new ResourceCache(client.fetchPrCommits),
+    relatedPrs: new ResourceCache(client.fetchRelatedPrs),
+    state: new ResourceCache(client.fetchIssueState),
+  };
+};
+
+describe('useConsoleItemDetailData', () => {
+  it('loads body, files and commits for a PR item', async () => {
+    const caches = buildCaches([]);
+    const { result } = renderHook(() =>
+      useConsoleItemDetailData(caches, prItem),
+    );
+    await waitFor(() => {
+      expect(result.current.body).toBe('body');
+      expect(result.current.files.length).toBe(1);
+      expect(result.current.commits.length).toBe(1);
+    });
+  });
+
+  it('loads related pull request views for an issue item', async () => {
+    const related: ConsoleRelatedPullRequest[] = [
+      {
+        url: 'https://github.com/o/r/pull/9',
+        branchName: 'feat',
+        createdAt: '2026-06-10T00:00:00.000Z',
+        isDraft: false,
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+        summary: {
+          title: 'Linked PR',
+          body: 'body',
+          additions: 5,
+          deletions: 1,
+          changedFiles: 2,
+        },
+      },
+    ];
+    const caches = buildCaches(related);
+    const { result } = renderHook(() =>
+      useConsoleItemDetailData(caches, issueItem),
+    );
+    await waitFor(() => {
+      expect(result.current.relatedPullRequests.length).toBe(1);
+      expect(result.current.relatedPullRequests[0].filesAreLoading).toBe(false);
+    });
+    expect(result.current.relatedPullRequests[0].files.length).toBe(1);
+  });
+
+  it('returns defaults when no item is selected', () => {
+    const caches = buildCaches([]);
+    const { result } = renderHook(() => useConsoleItemDetailData(caches, null));
+    expect(result.current.body).toBe('');
+    expect(result.current.relatedPullRequests).toEqual([]);
+  });
+});