test(MapScreen): add minimal coverage for DownloadHistory and GeoJsonOverlay

Add unit tests for the two new components to satisfy the 80% global
branch coverage gate before push.

- DownloadHistory.test.tsx: error row + retry, loading skeleton, empty state,
  ready/error status labels, size formatting (8 tests).
- GeoJsonOverlay.test.tsx: dropzone render, drag-active hint, FeatureCollection /
  single Feature / bare Geometry acceptance, invalid GeoJSON / bad extension /
  unparseable JSON rejection, large-file warning, visibility toggle, remove and
  clear-all (12 tests).

Both files pass and exceed 80% lines/branch/functions/statements.

Author: github-actions[bot]

src/i18n/messages/en.json

@@ -1286,12 +1286,12 @@
   "map.overlay.title": {
     "defaultMessage": "Reference layers"
   },
-  "map.overlay.tooLarge": {
-    "defaultMessage": "“{name}” is {size}. Large files may slow down the editor."
-  },
   "map.overlay.toggle": {
     "defaultMessage": "Toggle overlay visibility"
   },
+  "map.overlay.tooLarge": {
+    "defaultMessage": "“{name}” is {size}. Large files may slow down the editor."
+  },
   "map.saved.activeError": {
     "defaultMessage": "Could not update active map. Please try again."
   },

tests/unit/screens/MapScreen/DownloadHistory.test.tsx

@@ -0,0 +1,151 @@
+import { fireEvent, screen } from '@testing-library/react';
+import { render } from '@tests/mocks/test-utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { useToast } from '@/components/ui/toast';
+import { useDownloadMap } from '@/hooks/useMaps';
+import type { SavedMap } from '@/lib/db';
+import { formatBytes } from '@/lib/map/smp-download';
+import { DownloadHistory } from '@/screens/MapScreen/DownloadHistory';
+
+type ToastReturn = ReturnType<typeof useToast>;
+type MutateOpts = {
+  onSuccess?: (d: unknown) => void;
+  onError?: (e: unknown) => void;
+};
+
+const { mutate, addToast } = vi.hoisted(() => ({
+  mutate: vi.fn<(vars: { map: SavedMap }, opts?: MutateOpts) => void>(),
+  addToast: vi.fn(),
+}));
+
+vi.mock('@/hooks/useMaps', () => ({ useDownloadMap: vi.fn() }));
+vi.mock('@/components/ui/toast', () => ({ useToast: vi.fn() }));
+
+const makeMap = (over: Partial<SavedMap> = {}): SavedMap =>
+  ({
+    id: 'm1',
+    projectLocalId: 'p1',
+    name: 'Test Map',
+    type: 'style',
+    styleUrl: 'https://example.com/style',
+    bbox: [0, 0, 0, 0],
+    minZoom: 0,
+    maxZoom: 14,
+    status: 'ready',
+    createdAt: '2024-01-01T00:00:00Z',
+    updatedAt: '2024-01-01T00:00:00Z',
+    ...over,
+  }) as SavedMap;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(useDownloadMap).mockReturnValue({
+    mutate,
+    isPending: false,
+  } as unknown as ReturnType<typeof useDownloadMap>);
+  vi.mocked(useToast).mockReturnValue({ addToast } as unknown as ToastReturn);
+});
+
+describe('DownloadHistory', () => {
+  it('renders the title and two skeletons while loading', () => {
+    render(<DownloadHistory maps={[]} isLoading />);
+    expect(screen.getByText(/download history/i)).toBeInTheDocument();
+    expect(screen.getAllByTestId('skeleton')).toHaveLength(2);
+  });
+
+  it('renders the empty message when there are no completed downloads', () => {
+    render(<DownloadHistory maps={[]} />);
+    expect(screen.getByText(/no downloads yet/i)).toBeInTheDocument();
+  });
+
+  it('renders a ready map with its size and Ready status', () => {
+    render(
+      <DownloadHistory
+        maps={[makeMap({ id: 'ready1', status: 'ready', smpSize: 1048576 })]}
+      />,
+    );
+    expect(screen.getByText('Test Map')).toBeInTheDocument();
+    const sizeText = screen.getByText(/size:/i);
+    expect(sizeText.textContent).toContain(formatBytes(1048576));
+    expect(screen.getByText(/^ready$/i)).toBeInTheDocument();
+  });
+
+  it('renders an error map with its message and a retry button', () => {
+    render(
+      <DownloadHistory
+        maps={[
+          makeMap({
+            id: 'err1',
+            status: 'error',
+            errorMessage: 'Network failure',
+          }),
+        ]}
+      />,
+    );
+    expect(screen.getByText(/failed/i)).toBeInTheDocument();
+    expect(screen.getByText('Network failure')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /retry/i })).toBeInTheDocument();
+  });
+
+  it('calls downloadMap.mutate with the map when retry is clicked', () => {
+    render(
+      <DownloadHistory
+        maps={[makeMap({ id: 'err1', status: 'error', errorMessage: 'x' })]}
+      />,
+    );
+    fireEvent.click(screen.getByRole('button', { name: /retry/i }));
+    expect(mutate).toHaveBeenCalledWith(
+      { map: expect.objectContaining({ id: 'err1' }) },
+      expect.anything(),
+    );
+  });
+
+  it('fires a success toast via onSuccess', () => {
+    mutate.mockImplementation((_vars, opts) => {
+      opts?.onSuccess?.(undefined);
+    });
+    render(
+      <DownloadHistory
+        maps={[
+          makeMap({
+            id: 'err1',
+            status: 'error',
+            errorMessage: 'x',
+            smpSize: 1048576,
+          }),
+        ]}
+      />,
+    );
+    fireEvent.click(screen.getByRole('button', { name: /retry/i }));
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({ variant: 'success' }),
+    );
+  });
+
+  it('fires an error toast via onError', () => {
+    mutate.mockImplementation((_vars, opts) => {
+      opts?.onError?.(new Error('boom'));
+    });
+    render(
+      <DownloadHistory
+        maps={[makeMap({ id: 'err1', status: 'error', errorMessage: 'x' })]}
+      />,
+    );
+    fireEvent.click(screen.getByRole('button', { name: /retry/i }));
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        variant: 'error',
+        title: expect.stringContaining('boom'),
+      }),
+    );
+  });
+
+  it('does not render a Size line for a ready map without smpSize', () => {
+    render(
+      <DownloadHistory maps={[makeMap({ id: 'ready2', status: 'ready' })]} />,
+    );
+    expect(screen.queryByText(/size:/i)).toBeNull();
+    expect(screen.getByText(/^ready$/i)).toBeInTheDocument();
+  });
+});

tests/unit/screens/MapScreen/GeoJsonOverlay.test.tsx

@@ -0,0 +1,189 @@
+import { fireEvent, screen, waitFor } from '@testing-library/react';
+import { render } from '@tests/mocks/test-utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { GeoJsonOverlay } from '@/screens/MapScreen/GeoJsonOverlay';
+
+const { uuid } = vi.hoisted(() => {
+  let n = 0;
+  return { uuid: () => `uuid-${n++}` };
+});
+vi.mock('@/lib/uuid', () => ({ uuid }));
+
+const dropGeoJson = (zone: HTMLElement, files: File[]) => {
+  fireEvent.drop(zone, {
+    dataTransfer: { files, items: [], types: ['Files'] },
+  });
+};
+
+const makeFile = (name: string, content: string, size?: number): File => {
+  const f = new File([content], name, { type: 'application/json' });
+  if (size !== undefined) Object.defineProperty(f, 'size', { value: size });
+  return f;
+};
+
+const featureCollection = JSON.stringify({
+  type: 'FeatureCollection',
+  features: [
+    {
+      type: 'Feature',
+      geometry: { type: 'Point', coordinates: [0, 0] },
+      properties: {},
+    },
+  ],
+});
+const feature = JSON.stringify({
+  type: 'Feature',
+  geometry: { type: 'Point', coordinates: [1, 1] },
+  properties: {},
+});
+const bareGeometry = JSON.stringify({ type: 'Point', coordinates: [2, 2] });
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('GeoJsonOverlay', () => {
+  it('renders the dropzone with the correct label and no panel initially', () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    expect(screen.getByTestId('geojson-dropzone')).toHaveAttribute(
+      'aria-label',
+      expect.stringMatching(/drop a \.geojson/i),
+    );
+    expect(screen.queryByTestId('geojson-overlay-panel')).toBeNull();
+  });
+
+  it('shows the active drop hint on drag enter and hides it on drag leave', () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    const zone = screen.getByTestId('geojson-dropzone');
+    fireEvent.dragEnter(zone);
+    expect(
+      screen.getByText(/drop the file to add the overlay/i),
+    ).toBeInTheDocument();
+    expect(zone.className).toContain('border-dashed');
+    fireEvent.dragLeave(zone);
+    expect(screen.queryByText(/drop the file to add the overlay/i)).toBeNull();
+  });
+
+  it('adds an overlay from a valid FeatureCollection file', async () => {
+    const onOverlaysChange = vi.fn();
+    render(<GeoJsonOverlay onOverlaysChange={onOverlaysChange} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('layer.geojson', featureCollection),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByTestId('geojson-overlay-row')).toBeInTheDocument();
+    });
+    expect(onOverlaysChange).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'layer.geojson' }),
+      ]),
+    );
+  });
+
+  it('adds an overlay from a single Feature file', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('feat.geojson', feature),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByTestId('geojson-overlay-row')).toBeInTheDocument();
+    });
+  });
+
+  it('adds an overlay from a bare Geometry object', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('geom.geojson', bareGeometry),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByTestId('geojson-overlay-row')).toBeInTheDocument();
+    });
+  });
+
+  it('rejects an invalid GeoJSON object with an alert and no overlay', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('bad.geojson', JSON.stringify({ foo: 'bar' })),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByRole('alert')).toHaveTextContent(/not valid geojson/i);
+    });
+    expect(screen.queryByTestId('geojson-overlay-row')).toBeNull();
+  });
+
+  it('rejects a non-geojson filename extension', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('layer.txt', featureCollection),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByRole('alert')).toHaveTextContent(/not valid geojson/i);
+    });
+    expect(screen.queryByTestId('geojson-overlay-row')).toBeNull();
+  });
+
+  it('rejects unparseable JSON content', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('broken.geojson', 'not json'),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByRole('alert')).toHaveTextContent(/not valid geojson/i);
+    });
+    expect(screen.queryByTestId('geojson-overlay-row')).toBeNull();
+  });
+
+  it('warns when a large file is dropped', async () => {
+    const big = makeFile('big.geojson', featureCollection, 6 * 1024 * 1024);
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [big]);
+    await waitFor(() => {
+      expect(screen.getByText(/large files may slow/i)).toBeInTheDocument();
+    });
+  });
+
+  it('toggles an overlay visibility', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('layer.geojson', featureCollection),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByTestId('geojson-overlay-row')).toBeInTheDocument();
+    });
+    const toggle = screen.getByLabelText(/toggle overlay visibility/i);
+    expect(toggle).toHaveAttribute('aria-pressed', 'true');
+    fireEvent.click(toggle);
+    expect(screen.getByLabelText(/toggle overlay visibility/i)).toHaveAttribute(
+      'aria-pressed',
+      'false',
+    );
+  });
+
+  it('removes an overlay', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    dropGeoJson(screen.getByTestId('geojson-dropzone'), [
+      makeFile('layer.geojson', featureCollection),
+    ]);
+    await waitFor(() => {
+      expect(screen.getByTestId('geojson-overlay-row')).toBeInTheDocument();
+    });
+    fireEvent.click(screen.getByLabelText(/remove overlay/i));
+    expect(screen.queryByTestId('geojson-overlay-row')).toBeNull();
+  });
+
+  it('clears all overlays', async () => {
+    render(<GeoJsonOverlay onOverlaysChange={vi.fn()} />);
+    const zone = screen.getByTestId('geojson-dropzone');
+    dropGeoJson(zone, [makeFile('a.geojson', featureCollection)]);
+    dropGeoJson(zone, [makeFile('b.geojson', feature)]);
+    await waitFor(() => {
+      expect(screen.getAllByTestId('geojson-overlay-row')).toHaveLength(2);
+    });
+    fireEvent.click(screen.getByText(/clear all overlays/i));
+    await waitFor(() => {
+      expect(screen.queryByTestId('geojson-overlay-panel')).toBeNull();
+    });
+    expect(screen.queryByTestId('geojson-overlay-row')).toBeNull();
+  });
+});