Extend test coverage for the History view (#30)

Cover the anonymous login redirect, back-button navigation, empty
histories, the absolute-date tooltip, and the revert action's input
validation and error responses.

Author: mliebischer

packages/cmsui/acceptance/tests/history.test.ts

@@ -51,6 +51,36 @@ test.describe('History route', () => {
     await expect(page.locator('tbody tr').first()).toBeVisible();
   });
 
+  test('redirects anonymous visitors to the login', async ({ page }) => {
+    // a published page: on private content the middleware already fails the
+    // anonymous content fetch (error boundary) before the loader's auth
+    // guard can redirect
+    await createContent(page, {
+      contentType: 'Document',
+      contentId: 'public-page',
+      contentTitle: 'Public Page',
+      transition: 'publish',
+    });
+    await page.context().clearCookies();
+
+    await page.goto('/@@history/public-page');
+
+    await expect(page).toHaveURL(/\/login/);
+  });
+
+  test('navigates back to the content via the toolbar back button', async ({
+    page,
+  }) => {
+    await openHistory(page);
+
+    await page.getByRole('link', { name: 'Back' }).click();
+
+    await expect(page).toHaveURL(/\/my-page$/);
+    await expect(
+      page.getByRole('heading', { name: 'My Page', exact: true }),
+    ).toBeVisible();
+  });
+
   test('asks for confirmation before reverting', async ({ page }) => {
     // two edits, so an older, revertable version exists
     await editTitle(page, 'My Page (v2)');

packages/cmsui/components/History/HistoryView.test.tsx

@@ -213,6 +213,33 @@ describe('HistoryView', () => {
     );
   });
 
+  it('shows the absolute date as tooltip on the relative time', () => {
+    render(<HistoryView content={content} history={history} />);
+
+    const times = document.querySelectorAll('time');
+    expect(times.length).toBe(history.length);
+    for (const time of times) {
+      expect(time).toHaveAttribute('dateTime');
+      // the full-date tooltip (browser locale, so only check presence)
+      expect(time.getAttribute('title')).toBeTruthy();
+    }
+  });
+
+  it('renders an empty history without errors', () => {
+    render(
+      <HistoryView content={content} history={[] as GetHistoryResponse} />,
+    );
+
+    expect(
+      screen.getByRole('heading', {
+        level: 1,
+        name: 'cmsui.history.changesTo',
+      }),
+    ).toBeInTheDocument();
+    // only the header row remains
+    expect(screen.getAllByRole('row')).toHaveLength(1);
+  });
+
   it('survives entries with an unparsable time', () => {
     render(
       <HistoryView

packages/cmsui/routes/history.test.tsx

@@ -0,0 +1,81 @@
+import { expect, describe, it, vi, afterEach } from 'vitest';
+import { RouterContextProvider } from 'react-router';
+import {
+  ploneClientContext,
+  ploneContentContext,
+} from '@plone/aurora/app/middleware.server';
+import { action } from './history';
+
+vi.mock('@plone/react-router', () => ({
+  requireAuthCookie: vi.fn().mockResolvedValue('token'),
+}));
+
+function buildArgs(body: Record<string, string>, revertMock: unknown) {
+  const context = new RouterContextProvider();
+  context.set(ploneClientContext, { revertHistory: revertMock } as never);
+  context.set(ploneContentContext, { '@id': '/my-page' } as never);
+
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(body)) {
+    formData.append(key, value);
+  }
+  const request = new Request('http://example.com/@@history/my-page', {
+    method: 'POST',
+    body: formData,
+  });
+
+  return {
+    request,
+    params: {},
+    context,
+    unstable_pattern: '/@@history/*',
+    unstable_url: new URL(request.url),
+  };
+}
+
+describe('action', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('reverts to the requested version', async () => {
+    const revertMock = vi.fn().mockResolvedValue({});
+
+    const result = await action(buildArgs({ version: '2' }, revertMock));
+
+    expect(revertMock).toHaveBeenCalledWith({
+      path: '/my-page',
+      data: { version: 2 },
+    });
+    expect(result.data).toEqual({ ok: true });
+  });
+
+  it('rejects a missing version without calling the API', async () => {
+    const revertMock = vi.fn();
+
+    const result = await action(buildArgs({}, revertMock));
+
+    expect(revertMock).not.toHaveBeenCalled();
+    expect(result.data).toEqual({ ok: false, error: 'invalidVersion' });
+    expect(result.init).toEqual({ status: 400 });
+  });
+
+  it('rejects a non-numeric version without calling the API', async () => {
+    const revertMock = vi.fn();
+
+    const result = await action(buildArgs({ version: 'abc' }, revertMock));
+
+    expect(revertMock).not.toHaveBeenCalled();
+    expect(result.data).toEqual({ ok: false, error: 'invalidVersion' });
+    expect(result.init).toEqual({ status: 400 });
+  });
+
+  it('returns the failure as data when the revert call throws', async () => {
+    const revertMock = vi.fn().mockRejectedValue(new Error('forbidden'));
+
+    const result = await action(buildArgs({ version: '1' }, revertMock));
+
+    expect(result.data).toEqual({ ok: false, error: 'revertFailed' });
+    expect(result.init).toEqual({ status: 502 });
+  });
+});