@micha.bigler/ui-core-micha 3.14.3 → 4.0.0

package/tests/SignUpPage.test.jsx

@@ -1,208 +0,0 @@
-// @vitest-environment jsdom
-import React from 'react';
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const authApi = vi.hoisted(() => ({
-  submitRegistrationRequest: vi.fn(),
-}));
-
-vi.mock('../src/auth/authApi', () => authApi);
-vi.mock('react-router-dom', () => ({
-  useNavigate: () => vi.fn(),
-  useLocation: () => ({ search: '' }),
-}));
-vi.mock('react-helmet', () => ({ Helmet: ({ children }) => <>{children}</> }));
-vi.mock('react-i18next', () => {
-  const t = (key, fallback) => (typeof fallback === 'string' ? fallback : key);
-  return {
-    useTranslation: () => ({
-      t,
-      // resolveErrorText (AUTH-10) reads i18n.exists/i18n.t off the object
-      // useTranslation() returns — this mock must carry both, not just `t`.
-      // No real catalogue here, so nothing "exists"; resolveErrorText falls
-      // through to the backend message or the caller's default key, exactly
-      // as it did before this mock had an i18n object at all.
-      i18n: { exists: () => false, t },
-    }),
-  };
-});
-
-import { AuthContext } from '../src/auth/AuthContext';
-import { SignUpPage } from '../src/pages/SignUpPage';
-
-function renderSignUp({ signup = true, signupModes, siteKey }) {
-  return render(
-    <AuthContext.Provider value={{ authMethods: {
-      signup,
-      signup_modes: signupModes,
-      turnstile_site_key: siteKey,
-    } }}>
-      <SignUpPage />
-    </AuthContext.Provider>,
-  );
-}
-
-describe('SignUpPage Turnstile integration', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    authApi.submitRegistrationRequest.mockResolvedValue({});
-    window.turnstile = {
-      render: vi.fn(() => 'widget-id'),
-      remove: vi.fn(),
-      reset: vi.fn(),
-    };
-  });
-
-  afterEach(() => {
-    cleanup();
-    delete window.turnstile;
-  });
-
-  it('renders only for open and email-domain signup modes when the site key is present', async () => {
-    renderSignUp({
-      signupModes: ['self_signup_open', 'self_signup_access_code', 'self_signup_email_domain'],
-      siteKey: 'site-key',
-    });
-
-    await waitFor(() => expect(screen.getByTestId('turnstile-widget')).toBeTruthy());
-    fireEvent.click(screen.getByRole('button', { name: 'self_signup_access_code' }));
-    expect(screen.queryByTestId('turnstile-widget')).toBeNull();
-
-    fireEvent.click(screen.getByRole('button', { name: 'self_signup_email_domain' }));
-    await waitFor(() => expect(screen.getByTestId('turnstile-widget')).toBeTruthy());
-  });
-
-  it('explains that signup is closed and omits the form when no signup modes are available', () => {
-    renderSignUp({ signup: false, signupModes: [] });
-
-    expect(screen.getByText('Self sign-up is currently disabled.')).toBeTruthy();
-    expect(screen.queryByRole('textbox', { name: /Auth\.EMAIL_LABEL/ })).toBeNull();
-    expect(screen.queryByRole('textbox', { name: /Auth\.ACCESS_CODE_LABEL/ })).toBeNull();
-    expect(screen.queryByRole('button', { name: 'Auth.SIGNUP_SUBMIT' })).toBeNull();
-    // A closed page must still leave a way forward, not just say why the
-    // form is missing (caught by review: the first implementation hid this
-    // too).
-    expect(screen.getByRole('button', { name: 'Auth.SIGNUP_GO_TO_LOGIN' })).toBeTruthy();
-  });
-
-  it('gates submission until verified and passes the Turnstile token to the registration API', async () => {
-    renderSignUp({ signupModes: ['self_signup_open'], siteKey: 'site-key' });
-
-    await waitFor(() => expect(window.turnstile.render).toHaveBeenCalledOnce());
-    fireEvent.change(screen.getByRole('textbox', { name: /Auth\.EMAIL_LABEL/ }), {
-      target: { value: 'ada@example.com' },
-    });
-
-    const submit = screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' });
-    expect(submit.disabled).toBe(true);
-
-    await act(async () => {
-      window.turnstile.render.mock.calls[0][1].callback('turnstile-token');
-    });
-
-    await waitFor(() => expect(submit.disabled).toBe(false));
-    fireEvent.click(submit);
-
-    await waitFor(() => expect(authApi.submitRegistrationRequest).toHaveBeenCalledWith(
-      expect.objectContaining({
-        email: 'ada@example.com',
-        mode: 'self_signup_open',
-        turnstileToken: 'turnstile-token',
-      }),
-    ));
-  });
-
-  it('resets the widget after a failed protected signup submission', async () => {
-    authApi.submitRegistrationRequest.mockRejectedValue({ code: 'Auth.INVITE_FAILED' });
-    renderSignUp({ signupModes: ['self_signup_open'], siteKey: 'site-key' });
-
-    await waitFor(() => expect(window.turnstile.render).toHaveBeenCalledOnce());
-    fireEvent.change(screen.getByRole('textbox', { name: /Auth\.EMAIL_LABEL/ }), {
-      target: { value: 'ada@example.com' },
-    });
-    await act(async () => {
-      window.turnstile.render.mock.calls[0][1].callback('turnstile-token');
-    });
-
-    fireEvent.click(screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' }));
-
-    await waitFor(() => expect(window.turnstile.reset).toHaveBeenCalledWith('widget-id'));
-    expect(screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' }).disabled).toBe(true);
-  });
-
-  it('resets the widget and gates submission when its token expires', async () => {
-    renderSignUp({ signupModes: ['self_signup_open'], siteKey: 'site-key' });
-
-    await waitFor(() => expect(window.turnstile.render).toHaveBeenCalledOnce());
-    await act(async () => {
-      window.turnstile.render.mock.calls[0][1].callback('turnstile-token');
-    });
-    await waitFor(() => expect(screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' }).disabled).toBe(false));
-
-    await act(async () => {
-      window.turnstile.render.mock.calls[0][1]['expired-callback']();
-    });
-
-    expect(window.turnstile.reset).toHaveBeenCalledWith('widget-id');
-    expect(screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' }).disabled).toBe(true);
-  });
-
-  it.each([
-    ['self_signup_access_code', 'site-key'],
-    ['self_signup_qr', 'site-key'],
-    ['self_signup_open', ''],
-  ])('does not render for %s without an eligible key/mode combination', async (mode, siteKey) => {
-    renderSignUp({ signupModes: [mode], siteKey });
-
-    await waitFor(() => expect(screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' })).toBeTruthy());
-    expect(screen.queryByTestId('turnstile-widget')).toBeNull();
-    expect(window.turnstile.render).not.toHaveBeenCalled();
-  });
-});
-
-describe('SignUpPage — success message reflects the backend response, not a hardcoded mode', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    cleanup();
-  });
-
-  async function submit(mode) {
-    renderSignUp({ signupModes: [mode] });
-    fireEvent.change(screen.getByRole('textbox', { name: /Auth\.EMAIL_LABEL/ }), {
-      target: { value: 'ada@example.com' },
-    });
-    if (mode === 'self_signup_access_code') {
-      fireEvent.change(screen.getByRole('textbox', { name: /Auth\.ACCESS_CODE_LABEL/ }), {
-        target: { value: 'some-code' },
-      });
-    }
-    fireEvent.click(screen.getByRole('button', { name: 'Auth.SIGNUP_SUBMIT' }));
-    await waitFor(() => expect(authApi.submitRegistrationRequest).toHaveBeenCalled());
-  }
-
-  it('shows the backend-provided code for open self-signup, not the access-code-specific message', async () => {
-    authApi.submitRegistrationRequest.mockResolvedValue({ code: 'Auth.INVITE_SENT', email: 'ada@example.com', mode: 'self_signup_open' });
-    await submit('self_signup_open');
-
-    await waitFor(() => expect(screen.getByText('Auth.INVITE_SENT')).toBeTruthy());
-    expect(screen.queryByText('Auth.INVITE_REQUEST_SUCCESS')).toBeNull();
-  });
-
-  it('shows the backend-provided code for access-code self-signup too', async () => {
-    authApi.submitRegistrationRequest.mockResolvedValue({ code: 'Auth.INVITE_SENT', email: 'ada@example.com', mode: 'self_signup_access_code' });
-    await submit('self_signup_access_code');
-
-    await waitFor(() => expect(screen.getByText('Auth.INVITE_SENT')).toBeTruthy());
-  });
-
-  it('falls back to Auth.INVITE_SENT if the backend response carries no code', async () => {
-    authApi.submitRegistrationRequest.mockResolvedValue({});
-    await submit('self_signup_open');
-
-    await waitFor(() => expect(screen.getByText('Auth.INVITE_SENT')).toBeTruthy());
-  });
-});

package/tests/SoftChip.test.jsx

@@ -1,105 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it } from 'vitest';
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { ThemeProvider, alpha, darken } from '@mui/material/styles';
-
-import { createAppTheme } from '../src/theme';
-import SoftChip from '../src/components/SoftChip';
-
-const theme = createAppTheme({ palette: { primary: { main: '#0F62FE' } } });
-const TONES = ['success', 'warning', 'error', 'info'];
-
-function renderChip(props) {
-  return render(<ThemeProvider theme={theme}><SoftChip {...props} /></ThemeProvider>);
-}
-
-function rgb(color) {
-  const probe = document.createElement('div');
-  probe.style.color = color;
-  document.body.appendChild(probe);
-  const resolved = window.getComputedStyle(probe).color;
-  probe.remove();
-  return resolved;
-}
-
-afterEach(() => cleanup());
-
-describe('SoftChip', () => {
-  it.each(TONES)('derives fill/border/text for tone "%s" from the theme, not a literal', (tone) => {
-    renderChip({ label: 'Provisional ranges', tone });
-
-    const chip = screen.getByText('Provisional ranges').closest('.MuiChip-root');
-    const style = window.getComputedStyle(chip);
-    const palette = theme.palette[tone];
-
-    expect(style.backgroundColor).toBe(rgb(alpha(palette.main, 0.12)));
-    expect(style.borderColor).toBe(rgb(alpha(palette.main, 0.3)));
-    expect(style.color).toBe(rgb(darken(palette.main, 0.3)));
-  });
-
-  it('differs between status and caveat in radius and typography', () => {
-    renderChip({ label: 'passed', tone: 'success', variant: 'status' });
-    const statusChip = screen.getByText('passed').closest('.MuiChip-root');
-    const statusLabel = window.getComputedStyle(screen.getByText('passed'));
-    expect(window.getComputedStyle(statusChip).borderRadius).toBe('999px');
-    // status uses the baseline's `overline` variant verbatim -- 11/600, uppercase, .4px tracking
-    expect(statusLabel.textTransform).toBe('uppercase');
-    expect(statusLabel.fontSize).toBe(theme.typography.overline.fontSize);
-    expect(statusLabel.fontWeight).toBe(String(theme.typography.overline.fontWeight));
-    expect(statusLabel.letterSpacing).toBe(theme.typography.overline.letterSpacing);
-
-    cleanup();
-
-    renderChip({ label: 'Provisional ranges', tone: 'warning', variant: 'caveat' });
-    const caveatChip = screen.getByText('Provisional ranges').closest('.MuiChip-root');
-    const caveatLabel = window.getComputedStyle(screen.getByText('Provisional ranges'));
-    expect(window.getComputedStyle(caveatChip).borderRadius).not.toBe('999px');
-    // caveat keeps its raw 12/500 -- the PRIM-1 token delta, deliberately not on a theme variant
-    expect(caveatLabel.fontSize).toBe('12px');
-    expect(caveatLabel.fontWeight).toBe('500');
-  });
-
-  it('defaults the leading element to a dot and swaps it for a passed icon', () => {
-    const { container: withDot } = renderChip({ label: 'passed', tone: 'success', variant: 'status' });
-    expect(withDot.querySelector('.MuiChip-icon')).toBeTruthy();
-
-    cleanup();
-
-    const { container: withIcon } = renderChip({
-      label: 'recurring',
-      tone: 'info',
-      variant: 'status',
-      icon: <span data-testid="custom-icon" />,
-    });
-    expect(withIcon.querySelector('[data-testid="custom-icon"]')).toBeTruthy();
-  });
-
-  it('toggles the border', () => {
-    renderChip({ label: 'failed', tone: 'error', variant: 'status', border: false });
-
-    const chip = screen.getByText('failed').closest('.MuiChip-root');
-    expect(window.getComputedStyle(chip).borderColor).toBe(rgb('transparent'));
-  });
-
-  it('renders title as a tooltip, reachable on a touch pointer with no delay', async () => {
-    renderChip({ label: 'queued', tone: 'info', variant: 'status', title: 'Waiting on the sandbox' });
-
-    expect(screen.queryByText('Waiting on the sandbox')).toBeNull();
-
-    const chip = screen.getByText('queued').closest('.MuiChip-root');
-    fireEvent.touchStart(chip);
-
-    // `enterTouchDelay={0}` is the fix for the AUTH-4 failure mode -- a tooltip a touch pointer
-    // can never trigger. waitFor's default timeout (1000ms) is generous headroom around "no
-    // delay"; a regression to the ~700ms default would still likely pass, so this is a floor, not
-    // a precise timing assertion -- the source is the actual guarantee, this proves it's wired.
-    await waitFor(() => expect(screen.getByText('Waiting on the sandbox')).toBeTruthy());
-  });
-
-  it('omits the tooltip wrapper entirely when there is no title', () => {
-    renderChip({ label: 'queued', tone: 'info', variant: 'status' });
-
-    const chip = screen.getByText('queued').closest('.MuiChip-root');
-    expect(chip.getAttribute('aria-label')).toBeNull();
-  });
-});

package/tests/StatTile.test.jsx

@@ -1,57 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it } from 'vitest';
-import { cleanup, render, screen } from '@testing-library/react';
-import { ThemeProvider } from '@mui/material/styles';
-
-import { createAppTheme } from '../src/theme';
-import StatTile from '../src/components/StatTile';
-
-const theme = createAppTheme({ palette: { primary: { main: '#0F62FE' } } });
-
-function renderTile(props) {
-  return render(<ThemeProvider theme={theme}><StatTile {...props} /></ThemeProvider>);
-}
-
-afterEach(() => cleanup());
-
-describe('StatTile', () => {
-  it('renders label, value and caption', () => {
-    renderTile({ label: 'Coverage at budget', value: '71.4 %', caption: 'of maximum realizable' });
-
-    expect(screen.getByText('Coverage at budget')).toBeTruthy();
-    expect(screen.getByText('71.4 %')).toBeTruthy();
-    expect(screen.getByText('of maximum realizable')).toBeTruthy();
-  });
-
-  it('omits the value row when value is undefined', () => {
-    renderTile({ label: 'Recovered' });
-
-    expect(screen.getByText('Recovered')).toBeTruthy();
-    expect(screen.queryByText('undefined')).toBeNull();
-  });
-
-  it('renders children', () => {
-    renderTile({ label: 'Deaths averted', value: '63.8 %', children: <span>children slot</span> });
-
-    expect(screen.getByText('children slot')).toBeTruthy();
-  });
-
-  it('applies the accent border only when accent is set', () => {
-    const { container: plain } = renderTile({ label: 'Body fat', value: '18.4 %' });
-    const plainStyle = window.getComputedStyle(plain.firstChild);
-    expect(plainStyle.borderWidth).toBe('1px');
-
-    cleanup();
-
-    const { container: accented } = renderTile({ label: 'Lean mass', value: '62.1 kg', accent: true });
-    const accentedStyle = window.getComputedStyle(accented.firstChild);
-    expect(accentedStyle.borderWidth).toBe('2px');
-  });
-
-  it('renders the value with tabular-nums', () => {
-    renderTile({ label: 'theta*', value: '0.8421' });
-
-    const value = screen.getByText('0.8421');
-    expect(window.getComputedStyle(value).fontVariantNumeric).toBe('tabular-nums');
-  });
-});

package/tests/Thread.test.jsx

@@ -1,151 +0,0 @@
-// @vitest-environment jsdom
-import React from 'react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-
-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.count != null ? `${key}:${options.count}` : key }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: () => () => {}, onReconnect: () => () => {} }) }));
-
-import { AuthContext } from '../src/auth/AuthContext';
-import { MessageBubble } from '../src/messaging/MessageBubble';
-import { MessagingProvider } from '../src/messaging/MessagingProvider';
-import { ReadTicks } from '../src/messaging/ReadTicks';
-import { Thread } from '../src/messaging/Thread';
-
-function makeApi() {
-  return {
-    listConversations: vi.fn().mockResolvedValue({ results: [{ id: 1, kind: 'group' }] }),
-    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
-    listMessages: vi.fn().mockResolvedValue({ results: [{ id: 2, conversation_id: 1, body: 'Visible message', created_at: '2026-07-31T10:00:00Z' }], next_cursor: 'signed-opaque-cursor' }),
-    listThread: vi.fn().mockResolvedValue({ results: [] }),
-    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
-  };
-}
-// No `activeConversationId` on the provider: this matches how jg-ferien
-// actually mounts it (the provider sits above the page that tracks which
-// conversation is open, with no way to keep that prop in sync) — `Thread`'s
-// own conversationId-driven fetch is the one exercised here, not the
-// provider's separate activeConversationId-driven mount fetch (that path has
-// its own dedicated coverage in MessagingProvider.test.jsx).
-function renderThread(api, { userId = 9 } = {}) {
-  return render(
-    <AuthContext.Provider value={{ user: { id: userId } }}>
-      <MessagingProvider api={api}><Thread conversationId={1} /></MessagingProvider>
-    </AuthContext.Provider>,
-  );
-}
-
-describe('messaging Thread surfaces', () => {
-  let api;
-  beforeEach(() => { api = makeApi(); });
-  afterEach(cleanup);
-
-  it('uses the opaque message cursor and shows a rejected older page as an error', async () => {
-    api.listMessages.mockResolvedValueOnce({ results: [{ id: 2, conversation_id: 1, body: 'Visible message' }], next_cursor: 'signed-opaque-cursor' }).mockRejectedValueOnce(new Error('bad cursor'));
-    renderThread(api);
-    await screen.findByText('Visible message');
-    fireEvent.click(screen.getByRole('button', { name: 'MessagingThread.LOAD_OLDER' }));
-    await screen.findByRole('alert');
-    expect(api.listMessages).toHaveBeenLastCalledWith(1, { cursor: 'signed-opaque-cursor' });
-    expect(screen.getByText('Visible message')).toBeTruthy();
-  });
-
-  it('renders deleted content as a redacted placeholder', () => {
-    render(<MessageBubble message={{ id: 4, body: 'Stale secret', deleted_at: '2026-07-31T10:00:00Z' }} />);
-    expect(screen.getByText('MessagingThread.DELETED')).toBeTruthy();
-    expect(screen.queryByText('Stale secret')).toBeNull();
-  });
-
-  it('renders the two-state direct tick and never exposes supplied recipient details for a direct conversation', async () => {
-    api.getReadStatus.mockResolvedValue({ all_read: false, recipient_detail: [{ display_name: 'Private recipient' }] });
-    render(<MessagingProvider api={api} active={false}><ReadTicks messageId={2} conversation={{ id: 1, kind: 'direct' }} /></MessagingProvider>);
-    await screen.findByLabelText('MessagingReadTicks.SENT');
-    expect(screen.queryByText('Private recipient')).toBeNull();
-  });
-
-  it('renders supplied recipient detail for a non-direct conversation with counts (the permitted case)', async () => {
-    api.getReadStatus.mockResolvedValue({ all_read: false, read_count: 1, recipient_count: 2, recipient_detail: [{ display_name: 'Visible recipient' }] });
-    render(<MessagingProvider api={api} active={false}><ReadTicks messageId={2} conversation={{ id: 1, kind: 'group' }} /></MessagingProvider>);
-    const tick = await screen.findByLabelText('MessagingReadTicks.READ_RATIO');
-    fireEvent.click(tick);
-    await screen.findByText('Visible recipient');
-  });
-
-  it('only mounts ReadTicks (and its REST call) for the current user\'s own messages, not every message in the timeline', async () => {
-    api.listMessages.mockResolvedValue({
-      results: [
-        { id: 2, conversation_id: 1, body: 'Mine', created_at: '2026-07-31T10:00:00Z', sender: { id: 9 } },
-        { id: 3, conversation_id: 1, body: 'Theirs', created_at: '2026-07-31T10:01:00Z', sender: { id: 42 } },
-      ],
-      next_cursor: null,
-    });
-    renderThread(api, { userId: 9 });
-    await screen.findByText('Mine');
-    await screen.findByText('Theirs');
-    await waitFor(() => expect(api.getReadStatus).toHaveBeenCalledTimes(1));
-    expect(api.getReadStatus).toHaveBeenCalledWith(2);
-  });
-
-  it('does not mount ReadTicks (or fire a REST call) for a still-pending optimistic own message', async () => {
-    api.listMessages.mockResolvedValue({
-      results: [{ id: 'local-r9', conversation_id: 1, body: 'Sending...', created_at: '2026-07-31T10:00:00Z', sender: { id: 9 }, status: 'pending', client_request_id: 'r9' }],
-      next_cursor: null,
-    });
-    renderThread(api, { userId: 9 });
-    await screen.findByText('Sending...');
-    expect(api.getReadStatus).not.toHaveBeenCalled();
-  });
-
-  it('mounts Thread and ReadTicks independently', async () => {
-    renderThread(api);
-    await screen.findByLabelText('MessagingThread.TIMELINE');
-    cleanup();
-    api.getReadStatus.mockResolvedValue({ all_read: false, read_count: 0, recipient_count: 3 });
-    render(<MessagingProvider api={api} active={false}><ReadTicks messageId={2} conversation={{ id: 1, kind: 'group' }} /></MessagingProvider>);
-    await waitFor(() => expect(screen.getByLabelText('MessagingReadTicks.READ_RATIO')).toBeTruthy());
-  });
-
-  it('fetches and shows a conversation\'s historical messages on open, with no realtime frame or optimistic send involved', async () => {
-    // The bug this pins: nothing else in Thread/MessagingProvider ever calls
-    // listMessages for the conversation actually opened when the host (like
-    // jg-ferien) never wires `activeConversationId` into the provider itself
-    // — cache.messages was otherwise only ever populated by a live frame or
-    // this browser's own optimistic send, so any conversation whose only
-    // messages predate the current session rendered as permanently empty
-    // despite the conversation list correctly showing a last-message preview.
-    renderThread(api);
-    expect(await screen.findByText('Visible message')).toBeTruthy();
-    expect(screen.queryByText('MessagingThread.EMPTY')).toBeNull();
-    expect(api.listMessages).toHaveBeenCalledWith(1);
-  });
-
-  it('does not flash the empty state while the initial fetch is still pending', async () => {
-    let resolveMessages;
-    api.listMessages.mockReturnValueOnce(new Promise((resolve) => { resolveMessages = resolve; }));
-    renderThread(api);
-    expect(screen.queryByText('MessagingThread.EMPTY')).toBeNull();
-    resolveMessages({ results: [{ id: 2, conversation_id: 1, body: 'Visible message' }], next_cursor: null });
-    await screen.findByText('Visible message');
-  });
-
-  it('does not cover already-cached messages with the initial-load spinner while a redundant re-fetch is in flight', async () => {
-    function Switcher({ conversationId }) {
-      return <AuthContext.Provider value={{ user: { id: 9 } }}><MessagingProvider api={api}><Thread conversationId={conversationId} /></MessagingProvider></AuthContext.Provider>;
-    }
-    // First open (conversation 1): messages load and cache normally.
-    const { rerender } = render(<Switcher conversationId={1} />);
-    await screen.findByText('Visible message');
-    // Switch away, then back to conversation 1 — the effect re-fires (a real
-    // "close and reopen" or focus-regain), triggering a redundant re-fetch
-    // against a cache that already has this conversation's messages. Make
-    // that second fetch (the one for the switch BACK to 1) hang so the
-    // assertion below is meaningful.
-    rerender(<Switcher conversationId={2} />);
-    let resolveSecondFetch;
-    api.listMessages.mockImplementationOnce(() => new Promise((resolve) => { resolveSecondFetch = resolve; }));
-    rerender(<Switcher conversationId={1} />);
-    expect(screen.getByText('Visible message')).toBeTruthy();
-    resolveSecondFetch({ results: [{ id: 2, conversation_id: 1, body: 'Visible message' }], next_cursor: null });
-    await waitFor(() => expect(screen.getByText('Visible message')).toBeTruthy());
-  });
-});