feat(web): add jobs audit and settings workspaces

2026-07-17 23:08:03 +08:00
parent 5eb8680393
commit e46e81ea77
9 changed files with 1834 additions and 1 deletions
@@ -0,0 +1,157 @@
+// @vitest-environment jsdom
+import { cleanup, render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  InstanceSettingsPage,
+  sanitizeFleetSnapshot,
+  type FleetDataSource,
+  type FleetSnapshot,
+} from './instance-settings-page.js';
+
+afterEach(cleanup);
+
+function deferredSource() {
+  let resolve!: (value: FleetSnapshot) => void;
+  let reject!: (reason: unknown) => void;
+  const load = vi.fn<FleetDataSource['load']>(
+    () =>
+      new Promise((done, fail) => {
+        resolve = done;
+        reject = fail;
+      }),
+  );
+  return {
+    source: { load },
+    load,
+    resolve: (value: FleetSnapshot) => resolve(value),
+    reject: (reason: unknown) => reject(reason),
+  };
+}
+
+const snapshot: FleetSnapshot = {
+  instances: [
+    {
+      id: 'west/one',
+      name: 'West modem',
+      url: 'https://operator:secret@west.example:8443/admin?token=secret',
+      description: 'must not appear',
+      tags: ['private-tag'],
+    },
+    { id: 'offline', url: 'javascript:alert(1)' },
+  ],
+  statuses: new Map([
+    [
+      'west/one',
+      {
+        reachable: true,
+        authenticated: true,
+        latencyMs: 12,
+        summary: {
+          capabilities: ['messages', 'calls', 7],
+          freshness: 'fresh',
+          password: 'never-render',
+          credentialConfigured: true,
+          version: 'also-not-part-of-this-page',
+        },
+      },
+    ],
+    ['offline', { reachable: false }],
+  ]),
+};
+
+describe('Settings instances page', () => {
+  it('rejects identity values instead of trimming, truncating, or admitting controls', () => {
+    const longId = 'x'.repeat(257);
+    const source = (id: string, name?: string) => ({
+      instances: [{ id, url: 'https://example.test', ...(name === undefined ? {} : { name }) }],
+      statuses: new Map(),
+    });
+
+    for (const id of [' padded', 'padded ', longId, 'line\nbreak', 'null\0byte']) {
+      expect(sanitizeFleetSnapshot(source(id))).toEqual({ instances: [], statuses: new Map() });
+    }
+    expect(sanitizeFleetSnapshot(source('stable-id', `  ${'n'.repeat(300)}  `))?.instances).toEqual(
+      [{ id: 'stable-id', url: 'https://example.test', name: 'n'.repeat(256) }],
+    );
+  });
+
+  it('is explicitly unavailable without an injected fleet source', () => {
+    render(<InstanceSettingsPage />);
+    expect(screen.getByRole('heading', { name: 'Instances' })).toBeTruthy();
+    expect(screen.getByRole('status', { name: 'Instances unavailable' }).textContent).toMatch(
+      /no fleet data source/i,
+    );
+    expect(screen.getByRole('link', { name: 'Add instance' }).getAttribute('href')).toBe(
+      '/instances/new',
+    );
+  });
+
+  it('loads and renders an accessible, safe settings list using only fleet fields', async () => {
+    const pending = deferredSource();
+    render(<InstanceSettingsPage dataSource={pending.source} />);
+    expect(screen.getByRole('status', { name: 'Instances loading status' })).toBeTruthy();
+    expect(pending.load).toHaveBeenCalledWith(expect.any(AbortSignal));
+    pending.resolve(snapshot);
+
+    const list = await screen.findByRole('list', { name: 'Configured instances' });
+    const west = within(list).getByRole('listitem', { name: 'West modem' });
+    expect(within(west).getByRole('link', { name: 'West modem' }).getAttribute('href')).toBe(
+      '/settings/instances/west%2Fone',
+    );
+    const origin = within(west).getByRole('link', { name: 'Open West modem origin' });
+    expect(origin.getAttribute('href')).toBe('https://west.example:8443');
+    expect(origin.getAttribute('rel')).toBe('noopener noreferrer');
+    for (const value of ['Online', 'Authenticated', 'Fresh', 'messages, calls'])
+      expect(within(west).getByText(value)).toBeTruthy();
+
+    const offline = within(list).getByRole('listitem', { name: 'offline' });
+    expect(within(offline).getByText('Invalid origin')).toBeTruthy();
+    expect(within(offline).getByText('Offline')).toBeTruthy();
+    expect(within(offline).queryByText(/authentication|freshness|capabilities/i)).toBeNull();
+
+    expect(document.body.textContent).not.toMatch(
+      /secret|must not appear|private-tag|never-render|credentialConfigured|also-not-part/,
+    );
+  });
+
+  it('shows a fixed error, retries, and never exposes rejection details', async () => {
+    const user = userEvent.setup();
+    const load = vi
+      .fn<FleetDataSource['load']>()
+      .mockRejectedValueOnce(new Error('password=top-secret'))
+      .mockResolvedValueOnce({ instances: [], statuses: new Map() });
+    render(<InstanceSettingsPage dataSource={{ load }} />);
+    const alert = await screen.findByRole('alert');
+    expect(alert.textContent).toBe('Instances could not be loaded.Retry loading instances');
+    expect(document.body.textContent).not.toContain('top-secret');
+    await user.click(screen.getByRole('button', { name: 'Retry loading instances' }));
+    expect(await screen.findByText('No instances are configured.')).toBeTruthy();
+    expect(load).toHaveBeenCalledTimes(2);
+  });
+
+  it('aborts superseded loads and fences late results', async () => {
+    const first = deferredSource();
+    const second = deferredSource();
+    let calls = 0;
+    const load = vi.fn<FleetDataSource['load']>((signal) =>
+      (calls++ === 0 ? first : second).source.load(signal),
+    );
+    const source = { load };
+    const { rerender } = render(<InstanceSettingsPage dataSource={source} refreshSignal={0} />);
+    const oldSignal = load.mock.calls[0]?.[0];
+    rerender(<InstanceSettingsPage dataSource={source} refreshSignal={1} />);
+    expect(oldSignal?.aborted).toBe(true);
+    first.resolve({
+      instances: [{ id: 'stale', url: 'https://stale.example' }],
+      statuses: new Map(),
+    });
+    second.resolve({
+      instances: [{ id: 'current', url: 'https://current.example' }],
+      statuses: new Map(),
+    });
+    expect(await screen.findByRole('link', { name: 'current' })).toBeTruthy();
+    expect(screen.queryByRole('link', { name: 'stale' })).toBeNull();
+  });
+});