github-issue-tower-defence-management 2.7.0 → 2.9.0

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

@@ -0,0 +1,51 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { useConsoleFeaturesConfig } from './useConsoleFeaturesConfig';
+
+describe('useConsoleFeaturesConfig', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns airplaneMode false while loading (initial state)', () => {
+    global.fetch = jest.fn().mockReturnValue(new Promise(() => {}));
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+
+  it('returns airplaneMode true when /api/features responds { airplaneMode: true }', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ airplaneMode: true }),
+    });
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(result.current.airplaneMode).toBe(true));
+  });
+
+  it('returns airplaneMode false when /api/features responds { airplaneMode: false }', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ airplaneMode: false }),
+    });
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(global.fetch).toHaveBeenCalled());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+
+  it('returns airplaneMode false on fetch failure', async () => {
+    global.fetch = jest.fn().mockRejectedValue(new Error('network error'));
+    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(consoleSpy).toHaveBeenCalled());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+
+  it('returns airplaneMode false when response is not ok', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      json: async () => ({ airplaneMode: true }),
+    });
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(global.fetch).toHaveBeenCalled());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+});

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

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+
+export type ConsoleFeaturesConfig = {
+  airplaneMode: boolean;
+};
+
+const FEATURES_PATH = '/api/features';
+
+export const useConsoleFeaturesConfig = (): ConsoleFeaturesConfig => {
+  const [config, setConfig] = useState<ConsoleFeaturesConfig>({
+    airplaneMode: false,
+  });
+
+  useEffect(() => {
+    fetch(FEATURES_PATH)
+      .then(async (response) => {
+        if (!response.ok) {
+          return;
+        }
+        const data: unknown = await response.json();
+        if (
+          data !== null &&
+          typeof data === 'object' &&
+          !Array.isArray(data) &&
+          'airplaneMode' in data &&
+          typeof (data as { airplaneMode: unknown }).airplaneMode === 'boolean'
+        ) {
+          setConfig({
+            airplaneMode: (data as { airplaneMode: boolean }).airplaneMode,
+          });
+        }
+      })
+      .catch((err: unknown) => {
+        console.warn('Failed to fetch /api/features', err);
+      });
+  }, []);
+
+  return config;
+};

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

@@ -1,4 +1,5 @@
 import { act, renderHook, waitFor } from '@testing-library/react';
+import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
 import { CONSOLE_TABS } from '../logic/types';
 import {
   CONSOLE_TAB_REFRESH_INTERVAL_MS,
@@ -257,4 +258,218 @@ describe('useConsoleTabData', () => {
     expect(result.current.error).toBe('No project specified in the URL path.');
     expect(fetchMock).not.toHaveBeenCalled();
   });
+
+  it('renders board items from airplane snapshot without fetching when network rejects', async () => {
+    const fetchMock = jest.fn().mockRejectedValue(new Error('network down'));
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const airplaneSnapshot: AirplaneSnapshot = {
+      capturedAt: '2026-08-01T10:00:00Z',
+      failures: [],
+      items: {},
+      tabs: {
+        acme: {
+          prs: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+            items: [
+              {
+                number: 1,
+                title: 'Offline PR',
+                url: 'https://github.com/o/r/pull/1',
+                repo: 'o/r',
+                nameWithOwner: 'o/r',
+                projectItemId: 'PVTI_1',
+                itemId: 'PVTI_1',
+                isPr: true,
+                story: 'regular',
+                status: 'Awaiting Quality Check',
+                nextActionDate: null,
+                nextActionHour: null,
+                dependedIssueUrls: [],
+                labels: [],
+                createdAt: '2026-08-01T00:00:00Z',
+                relatedOpenPullRequestUrls: [],
+                agent: null,
+              },
+            ],
+          },
+          'workflow-blocker': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'failed-preparation': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-human': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-agent': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          stories: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+        },
+      },
+    };
+
+    const { result } = renderHook(() =>
+      useConsoleTabData('acme', airplaneSnapshot),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(result.current.error).toBeNull();
+    expect(result.current.snapshots.prs?.items).toHaveLength(1);
+    expect(result.current.snapshots.prs?.items[0].title).toBe('Offline PR');
+    expect(result.current.snapshots.prs?.generatedAt).toBe(
+      '2026-08-01T10:00:00Z',
+    );
+  });
+
+  it('stops the 60-second periodic refresh while an airplane snapshot is in use', async () => {
+    jest.useFakeTimers();
+    const fetchMock = jest.fn().mockRejectedValue(new Error('network down'));
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const airplaneSnapshot: AirplaneSnapshot = {
+      capturedAt: '2026-08-01T10:00:00Z',
+      failures: [],
+      items: {},
+      tabs: {
+        acme: {
+          prs: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'workflow-blocker': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'failed-preparation': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-human': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-agent': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          stories: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+        },
+      },
+    };
+
+    const { result } = renderHook(() =>
+      useConsoleTabData('acme', airplaneSnapshot),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(CONSOLE_TAB_REFRESH_INTERVAL_MS * 3);
+    });
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    jest.useRealTimers();
+  });
 });

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

@@ -1,4 +1,5 @@
 import { useEffect, useState } from 'react';
+import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
 import type {
   ConsoleFieldOption,
   ConsoleListItem,
@@ -205,6 +206,7 @@ const fetchSnapshots = async (
 
 export const useConsoleTabData = (
   pjcode: string | null,
+  airplaneSnapshot: AirplaneSnapshot | null = null,
 ): ConsoleTabDataState => {
   const [snapshots, setSnapshots] =
     useState<Record<ConsoleTabName, ConsoleTabSnapshot | null>>(emptySnapshots);
@@ -212,6 +214,23 @@ export const useConsoleTabData = (
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
+    if (airplaneSnapshot !== null && pjcode !== null) {
+      const pjTabs = airplaneSnapshot.tabs[pjcode];
+      if (pjTabs !== undefined) {
+        const next = emptySnapshots();
+        for (const tab of CONSOLE_TABS) {
+          const stored = pjTabs[tab.name];
+          if (stored !== undefined) {
+            next[tab.name] = stored;
+          }
+        }
+        setSnapshots(next);
+        setIsLoading(false);
+        setError(null);
+        return;
+      }
+    }
+
     let cancelled = false;
     setIsLoading(true);
     setError(null);
@@ -251,7 +270,7 @@ export const useConsoleTabData = (
       cancelled = true;
       clearInterval(timer);
     };
-  }, [pjcode]);
+  }, [pjcode, airplaneSnapshot]);
 
   return { snapshots, isLoading, error };
 };