@micha.bigler/ui-core-micha 2.21.3 → 2.23.0

package/tests/messagingMsg6f.test.jsx

@@ -0,0 +1,155 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react';
+import { ThemeProvider, createTheme } from '@mui/material/styles';
+
+// Thread.jsx (scope C) subscribes to the messaging envelope independently of
+// MessagingProvider's own subscription -- a Set of handlers per envelope, not
+// one, so a dispatched frame reaches every current subscriber.
+let frameHandlers;
+function dispatchFrame(frame) { frameHandlers.forEach((handler) => handler(frame)); }
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options && Object.keys(options).length ? `${key}:${JSON.stringify(options)}` : key, i18n: { language: 'en' } }) }));
+vi.mock('../src/notifications/realtime', () => ({
+  useRealtime: () => ({
+    subscribe: (_envelope, handler) => { frameHandlers.add(handler); return () => frameHandlers.delete(handler); },
+    onReconnect: () => () => {},
+  }),
+}));
+
+import { AuthContext } from '../src/auth/AuthContext';
+import { MessagingProvider } from '../src/messaging/MessagingProvider';
+import { ReadTicks } from '../src/messaging/ReadTicks';
+import { Thread } from '../src/messaging/Thread';
+
+const theme = createTheme();
+function withTheme(children) { return <ThemeProvider theme={theme}>{children}</ThemeProvider>; }
+
+function makeApi(overrides = {}) {
+  return {
+    listConversations: vi.fn().mockResolvedValue({ results: [] }),
+    listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    listThread: vi.fn().mockResolvedValue({ results: [] }),
+    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+    markConversationRead: vi.fn().mockResolvedValue({}),
+    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
+    ...overrides,
+  };
+}
+
+beforeEach(() => { frameHandlers = new Set(); });
+afterEach(cleanup);
+
+describe('MSG-6f scope B: read ratio vs two-state tick', () => {
+  it('4a: a direct conversation renders a two-state tick, and the two states resolve to visibly different colours', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false }) });
+    const { rerender } = render(withTheme(
+      <MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct' }} /></MessagingProvider>
+    ));
+    const sentIcon = await screen.findByLabelText('MessagingReadTicks.SENT');
+    const sentColor = getComputedStyle(sentIcon).color;
+
+    api.getReadStatus.mockResolvedValue({ all_read: true });
+    cleanup();
+    render(withTheme(
+      <MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct' }} /></MessagingProvider>
+    ));
+    const readIcon = await screen.findByLabelText('MessagingReadTicks.ALL_READ');
+    const readColor = getComputedStyle(readIcon).color;
+
+    expect(sentColor).toBeTruthy();
+    expect(readColor).toBeTruthy();
+    expect(sentColor).not.toBe(readColor);
+  });
+
+  it('4b: a group WITH counts renders dcm\'s own read_count/recipient_count verbatim, never recomputed from recipientDetail (must fail if recomputed -- recipientDetail is not thresholded against this message\'s created_at, only dcm\'s own counts are)', async () => {
+    // Deliberately inconsistent with read_count/recipient_count: every
+    // participant has SOME last_read_at (e.g. from reading the conversation
+    // long before this message existed), which is exactly the shape that
+    // would make a naive "count non-null last_read_at" recomputation report
+    // 40/40 -- the bug caught in review. dcm's own read_count (18) is the
+    // only correct source; recipientDetail must not be trusted for the ratio.
+    const allEverRead = Array.from({ length: 40 }, (_, i) => ({ user_id: `u-${i}`, last_read_at: '2020-01-01T00:00:00Z' }));
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false, read_count: 18, recipient_count: 40, recipient_detail: allEverRead }) });
+    render(<MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'group' }} /></MessagingProvider>);
+    const ratio = await screen.findByLabelText(/READ_RATIO/);
+    expect(ratio.textContent).toBe('18/40');
+    expect(document.body.querySelector('[data-testid="DoneOutlinedIcon"]')).toBeNull();
+    expect(document.body.querySelector('[data-testid="DoneAllOutlinedIcon"]')).toBeNull();
+    expect(document.body.textContent).not.toMatch(/Zugestellt/);
+  });
+
+  it('4c: a group WITHOUT counts (an ordinary participant) renders no indicator at all', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false }) });
+    const { container } = render(<MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'group' }} /></MessagingProvider>);
+    await waitFor(() => expect(api.getReadStatus).toHaveBeenCalled());
+    expect(container.textContent).toBe('');
+    expect(container.querySelector('svg')).toBeNull();
+  });
+
+  it('5: all_read still renders the double check with its own unchanged label', async () => {
+    const api = makeApi({ getReadStatus: vi.fn().mockResolvedValue({ all_read: true }) });
+    render(<MessagingProvider api={api} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct' }} /></MessagingProvider>);
+    const icon = await screen.findByLabelText('MessagingReadTicks.ALL_READ');
+    expect(icon.getAttribute('data-testid')).toBe('DoneAllOutlinedIcon');
+  });
+});
+
+describe('MSG-6f scope C: re-mark read on a live message frame for the open conversation', () => {
+  function renderThread(api, { userId = 1 } = {}) {
+    return render(
+      <AuthContext.Provider value={{ user: { id: userId } }}>
+        <MessagingProvider api={api}><Thread conversationId="c1" /></MessagingProvider>
+      </AuthContext.Provider>
+    );
+  }
+
+  it('marks read again when a message frame arrives for the currently-open conversation', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    act(() => dispatchFrame({ type: 'message', conversation_id: 'c1', message: { id: 'm2', conversation_id: 'c1', sender: { id: 2 } } }));
+
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalled());
+    expect(api.markConversationRead.mock.calls[0][0]).toBe('c1');
+  });
+
+  it('does not re-mark for a message frame belonging to a different conversation', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    act(() => dispatchFrame({ type: 'message', conversation_id: 'other-conversation', message: { id: 'm2' } }));
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(api.markConversationRead).not.toHaveBeenCalled();
+  });
+
+  it('does not re-mark while the document is hidden', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    const visibilitySpy = vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
+    act(() => dispatchFrame({ type: 'message', conversation_id: 'c1', message: { id: 'm2' } }));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(api.markConversationRead).not.toHaveBeenCalled();
+    visibilitySpy.mockRestore();
+  });
+
+  it('does not re-mark for a non-message frame type (e.g. reaction) for the same conversation', async () => {
+    const api = makeApi();
+    renderThread(api);
+    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledTimes(1));
+    api.markConversationRead.mockClear();
+
+    act(() => dispatchFrame({ type: 'reaction', conversation_id: 'c1', message_id: 'm2' }));
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(api.markConversationRead).not.toHaveBeenCalled();
+  });
+});

package/tests/messagingMsg6g.test.jsx

@@ -0,0 +1,166 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { afterEach, 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 && Object.keys(options).length ? `${key}:${JSON.stringify(options)}` : key }) }));
+
+const realtimeSubscribers = new Map();
+vi.mock('../src/notifications/realtime', () => ({
+  useRealtime: () => ({
+    subscribe: (envelope, handler) => { realtimeSubscribers.set(envelope, handler); return () => realtimeSubscribers.delete(envelope); },
+    onReconnect: () => () => {},
+  }),
+}));
+function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.(frame); }
+
+import { PollCard } from '../src/messaging/PollCard';
+import { MessagingProvider, useMessaging } from '../src/messaging/MessagingProvider';
+
+function baseApi(overrides = {}) {
+  return {
+    listConversations: vi.fn().mockResolvedValue({ results: [] }), listMessages: vi.fn().mockResolvedValue({ results: [] }),
+    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
+    votePoll: vi.fn(), closePoll: vi.fn(),
+    ...overrides,
+  };
+}
+function serverPoll(overrides = {}) {
+  return {
+    id: 'poll-1', question: 'Q', allow_multiple: false, closed_at: null, created_by_id: 'user-9',
+    options: [
+      { id: 'opt-a', text: 'A', order: 0, vote_count: 0, voters: [] },
+      { id: 'opt-b', text: 'B', order: 1, vote_count: 0, voters: [] },
+    ],
+    ...overrides,
+  };
+}
+function ConnectedPollCard({ messageId }) {
+  const { cache } = useMessaging();
+  return <PollCard message={cache.messages[messageId]} />;
+}
+function CachePollState({ messageId }) {
+  const { cache } = useMessaging();
+  return <output data-testid="cache-poll">{JSON.stringify(cache.messages[messageId]?.poll)}</output>;
+}
+
+afterEach(() => { cleanup(); realtimeSubscribers.clear(); });
+
+describe('MSG-6g: tap-to-vote poll UI with result bars', () => {
+  it('1. single-choice: tapping an option votes without further interaction; tapping a second option moves the vote', async () => {
+    const api = baseApi();
+    api.votePoll.mockResolvedValueOnce({ poll: { ...serverPoll(), voted_option_ids: ['opt-a'], options: [{ id: 'opt-a', text: 'A', order: 0, vote_count: 1, voters: ['me'] }, { id: 'opt-b', text: 'B', order: 1, vote_count: 0, voters: [] }] } });
+    api.votePoll.mockResolvedValueOnce({ poll: { ...serverPoll(), voted_option_ids: ['opt-b'], options: [{ id: 'opt-a', text: 'A', order: 0, vote_count: 0, voters: [] }, { id: 'opt-b', text: 'B', order: 1, vote_count: 1, voters: ['me'] }] } });
+    render(<MessagingProvider api={api} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll() }} /></MessagingProvider>);
+    const radios = screen.getAllByRole('radio');
+
+    fireEvent.click(radios[0]);
+    await waitFor(() => expect(api.votePoll).toHaveBeenCalledWith('poll-1', ['opt-a']));
+    expect(radios[0].checked).toBe(true);
+
+    fireEvent.click(radios[1]);
+    await waitFor(() => expect(api.votePoll).toHaveBeenCalledWith('poll-1', ['opt-b']));
+    await waitFor(() => expect(radios[1].checked).toBe(true));
+    expect(radios[0].checked).toBe(false);
+  });
+
+  it('2. multi-select: tapping toggles one option on and off, and each tap sends the complete option-id set', async () => {
+    const api = baseApi();
+    api.votePoll.mockResolvedValue({ poll: serverPoll({ allow_multiple: true }) });
+    render(<MessagingProvider api={api} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll({ allow_multiple: true }) }} /></MessagingProvider>);
+    const checkboxes = screen.getAllByRole('checkbox');
+
+    fireEvent.click(checkboxes[0]);
+    await waitFor(() => expect(api.votePoll).toHaveBeenCalledWith('poll-1', ['opt-a']));
+    fireEvent.click(checkboxes[1]);
+    await waitFor(() => expect(api.votePoll).toHaveBeenCalledWith('poll-1', ['opt-a', 'opt-b']));
+    fireEvent.click(checkboxes[0]);
+    await waitFor(() => expect(api.votePoll).toHaveBeenCalledWith('poll-1', ['opt-b']));
+    expect(api.votePoll).toHaveBeenCalledTimes(3);
+  });
+
+  it('3. a rejected vote reverts the optimistic state and surfaces an error -- the reverted value, not merely an error message', async () => {
+    const api = baseApi();
+    api.votePoll.mockRejectedValue({ response: { data: { detail: 'Voting disabled' } } });
+    render(<MessagingProvider api={api} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll() }} /></MessagingProvider>);
+    const radios = screen.getAllByRole('radio');
+
+    fireEvent.click(radios[0]);
+    // Optimistic: briefly checked before the rejection resolves.
+    await waitFor(() => expect(radios[0].checked).toBe(true));
+    await screen.findByRole('alert');
+    await waitFor(() => expect(radios[0].checked).toBe(false));
+    expect(radios[1].checked).toBe(false);
+  });
+
+  it('4. bars render proportionally, including the zero-vote case, with no NaN and no division error', () => {
+    render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll() }} /></MessagingProvider>);
+    // vote_count 0/0 for both options -> 0%, never NaN%.
+    const results = screen.getAllByText(/MessagingPoll\.OPTION_RESULT/);
+    expect(results).toHaveLength(2);
+    results.forEach((node) => {
+      expect(node.textContent).toMatch(/"count":0/);
+      expect(node.textContent).toMatch(/"percent":0/);
+      expect(node.textContent).not.toMatch(/NaN/);
+    });
+  });
+
+  it('5. the viewer\'s own selection survives a poll_updated frame that does not carry voted_option_ids (merge-trap guard)', async () => {
+    const api = baseApi();
+    render(<MessagingProvider api={api} active={false}><ConnectedPollCard messageId="msg-1" /></MessagingProvider>);
+    dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'seed', conversation_id: 'conv-1', message: { id: 'msg-1', conversation_id: 'conv-1', kind: 'poll', poll: serverPoll({ voted_option_ids: ['opt-a'], options: [{ id: 'opt-a', text: 'A', order: 0, vote_count: 1, voters: ['me'] }, { id: 'opt-b', text: 'B', order: 1, vote_count: 0, voters: [] }] }) } });
+    await waitFor(() => expect(screen.getAllByRole('radio')[0].checked).toBe(true));
+
+    // A poll_updated frame never carries voted_option_ids (dcm's serialize_poll
+    // is viewer-independent) -- must not wipe the REST-known selection.
+    dispatchMessagingFrame({
+      envelope: 'messaging', type: 'poll_updated', event_id: 'evt-1', conversation_id: 'conv-1', message_id: 'msg-1', poll_id: 'poll-1',
+      poll: serverPoll({ options: [{ id: 'opt-a', text: 'A', order: 0, vote_count: 2, voters: ['me', 'other'] }, { id: 'opt-b', text: 'B', order: 1, vote_count: 0, voters: [] }] }),
+    });
+    await waitFor(() => expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":2/)).toBeTruthy());
+    expect(screen.getAllByRole('radio')[0].checked).toBe(true);
+  });
+
+  it('6. a closed poll is non-interactive: tapping an option does nothing and issues no request', () => {
+    const api = baseApi();
+    render(<MessagingProvider api={api} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll({ closed_at: '2026-08-01T00:00:00Z' }) }} /></MessagingProvider>);
+    const radios = screen.getAllByRole('radio');
+    fireEvent.click(radios[0]);
+    expect(api.votePoll).not.toHaveBeenCalled();
+    expect(radios[0].checked).toBe(false);
+  });
+
+  it('a rapid switch (A then B, before the first vote confirms) projects counts from the freshest cache state, not a stale prop (regression)', async () => {
+    // MessagingProvider.castPollVote must build its optimistic count delta from
+    // `previousPoll` (freshly read from the shared cache at call time), never
+    // from the caller-supplied `poll` argument. PollCard is deliberately given
+    // a STATIC message prop here (never re-rendered with a fresh one between
+    // taps, exactly like PollCard's own documented "dumb, prop-driven"
+    // contract, and exactly how a host that doesn't re-connect it to live
+    // cache updates would behave) -- a separate, genuinely cache-connected
+    // reader (CachePollState) is what must show the correct number. Starting
+    // counts are non-zero so a wrong baseline isn't masked by the
+    // Math.max(0, ...) clamp.
+    const api = baseApi();
+    api.votePoll.mockReturnValue(new Promise(() => {})); // never resolves -- isolate the optimistic phase
+    const seedPoll = serverPoll({
+      voted_option_ids: [],
+      options: [
+        { id: 'opt-a', text: 'A', order: 0, vote_count: 5, voters: ['u1', 'u2', 'u3', 'u4', 'u5'] },
+        { id: 'opt-b', text: 'B', order: 1, vote_count: 2, voters: ['u6', 'u7'] },
+      ],
+    });
+    render(<MessagingProvider api={api} active={false}><PollCard message={{ id: 'msg-1', poll: seedPoll }} /><CachePollState messageId="msg-1" /></MessagingProvider>);
+    const radios = screen.getAllByRole('radio');
+
+    fireEvent.click(radios[0]); // vote A: 5 -> 6
+    await waitFor(() => expect(JSON.parse(screen.getByTestId('cache-poll').textContent).options.find((option) => option.id === 'opt-a').vote_count).toBe(6));
+
+    fireEvent.click(radios[1]); // switch to B: A must go 6 -> 5 in the shared cache (a stale-prop baseline of 5 would wrongly compute 4)
+    await waitFor(() => {
+      const poll = JSON.parse(screen.getByTestId('cache-poll').textContent);
+      expect(poll.options.find((option) => option.id === 'opt-a').vote_count).toBe(5);
+      expect(poll.options.find((option) => option.id === 'opt-b').vote_count).toBe(3);
+    });
+  });
+});

package/tests/messagingPollRendering.test.jsx

@@ -3,7 +3,7 @@ import React from 'react';
 import { afterEach, 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?.message ? `${key}:${options.message}` : key }) }));
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options && Object.keys(options).length ? `${key}:${JSON.stringify(options)}` : key }) }));
 
 const realtimeSubscribers = new Map();
 vi.mock('../src/notifications/realtime', () => ({
@@ -55,20 +55,29 @@ function ConnectedPollCard({ messageId }) {
 afterEach(() => { cleanup(); realtimeSubscribers.clear(); });
 
 describe('poll rendering against the real server contract', () => {
-  it('renders question, options, vote counts and per-option voters from a server-shaped payload', () => {
+  it('renders question, options and proportional vote counts from a server-shaped payload', () => {
+    // totalVotes = 2 + 1 = 3 -> Library 67%, Cafe 33%.
     render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll: serverPoll() }} /></MessagingProvider>);
     expect(screen.getByText('Where should we meet?')).toBeTruthy();
-    expect(screen.getByText(/Library \(2\)/)).toBeTruthy();
-    expect(screen.getByText(/Cafe \(1\)/)).toBeTruthy();
+    expect(screen.getByText('Library')).toBeTruthy();
+    expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":2.*"percent":67/)).toBeTruthy();
+    expect(screen.getByText('Cafe')).toBeTruthy();
+    expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":1.*"percent":33/)).toBeTruthy();
   });
 
   it('derives selection from voted_option_ids (REST-only) and marks the viewer\'s own vote', () => {
+    // Single-choice (allow_multiple: false) renders radios, not checkboxes --
+    // native radio semantics match the WO's "tapping a different option moves
+    // the vote, tapping the same one is a no-op" design directly.
     const poll = serverPoll({ voted_option_ids: ['opt-a'] });
     render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll }} /></MessagingProvider>);
-    const checkboxes = screen.getAllByRole('checkbox');
-    expect(checkboxes[0].checked).toBe(true);
-    expect(checkboxes[1].checked).toBe(false);
-    expect(screen.getByText(/Library.*MessagingPoll\.YOU_VOTED/)).toBeTruthy();
+    const radios = screen.getAllByRole('radio');
+    expect(radios[0].checked).toBe(true);
+    expect(radios[1].checked).toBe(false);
+    // Count/percent and the viewer's own vote both live in the accessible
+    // name, not conveyed by the bar's width alone (WO accessibility risk).
+    expect(radios[0].getAttribute('aria-label')).toMatch(/Library.*MessagingPoll\.OPTION_RESULT.*MessagingPoll\.YOU_VOTED/);
+    expect(radios[1].getAttribute('aria-label')).not.toMatch(/YOU_VOTED/);
   });
 
   it('does not clear or invert the viewer\'s own vote when a poll_updated frame carries no voted_option_ids', async () => {
@@ -80,7 +89,7 @@ describe('poll rendering against the real server contract', () => {
     // own castPollVote reconciliation would leave it — not a static prop the
     // component can never observe a later frame update against.
     dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'seed', conversation_id: 'conv-1', message: { id: 'msg-1', conversation_id: 'conv-1', kind: 'poll', poll: votedPoll } });
-    await waitFor(() => expect(screen.getAllByRole('checkbox')[0].checked).toBe(true));
+    await waitFor(() => expect(screen.getAllByRole('radio')[0].checked).toBe(true));
     // The real poll_updated frame shape: payload.poll is a bare serialize_poll
     // result (verified against services.py's _poll_updated_payload) — never
     // carries voted_option_ids. A vote_count bump from another viewer must
@@ -89,10 +98,10 @@ describe('poll rendering against the real server contract', () => {
       envelope: 'messaging', type: 'poll_updated', event_id: 'evt-1', conversation_id: 'conv-1', message_id: 'msg-1', poll_id: 'poll-1',
       poll: { ...serverPoll(), options: [{ id: 'opt-a', text: 'Library', order: 0, vote_count: 3, voters: ['user-1', 'user-2', 'user-4'] }, { id: 'opt-b', text: 'Cafe', order: 1, vote_count: 1, voters: ['user-3'] }] },
     });
-    await waitFor(() => expect(screen.getByText(/Library \(3\)/)).toBeTruthy());
+    await waitFor(() => expect(screen.getByText(/MessagingPoll\.OPTION_RESULT.*"count":3/)).toBeTruthy());
     // The frame carries no voted_option_ids at all — the viewer's REST-known
     // vote must be carried forward, not wiped, by this update.
-    expect(screen.getAllByRole('checkbox')[0].checked).toBe(true);
+    expect(screen.getAllByRole('radio')[0].checked).toBe(true);
   });
 
   it('grants close only to the poll creator (created_by_id) or a host override, never a guess from an object shape', () => {
@@ -105,11 +114,12 @@ describe('poll rendering against the real server contract', () => {
     expect(screen.getByRole('button', { name: 'MessagingPoll.CLOSE' })).toBeTruthy();
   });
 
-  it('disables voting once the poll is closed', () => {
+  it('disables voting once the poll is closed and shows a closed indicator, not merely a missing button', () => {
+    // With no separate submit button (MSG-6g), "closed" can no longer be
+    // inferred from its absence -- must be an explicit, visible indicator.
     const poll = serverPoll({ closed_at: '2026-07-31T10:00:00Z' });
     render(<MessagingProvider api={baseApi()} active={false}><PollCard message={{ id: 'msg-1', poll }} /></MessagingProvider>);
-    screen.getAllByRole('checkbox').forEach((checkbox) => expect(checkbox.disabled).toBe(true));
-    expect(screen.getByRole('button', { name: 'MessagingPoll.VOTE' }).disabled).toBe(true);
+    screen.getAllByRole('radio').forEach((radio) => expect(radio.disabled).toBe(true));
     expect(screen.getByText('MessagingPoll.CLOSED')).toBeTruthy();
   });
 });

package/tests/messagingThreadReceipts.test.jsx

@@ -7,14 +7,22 @@ import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/re
 
 vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.count !== undefined ? `${key}:${options.count}` : key, i18n: { language: 'en' } }) }));
 
+// Thread.jsx (MSG-6f scope C) now subscribes to the messaging envelope
+// independently of MessagingProvider's own subscription -- a Set of handlers
+// per envelope, not one handler per envelope, so a dispatched frame still
+// reaches every current subscriber, matching the real registry's multi-handler support.
 const realtimeSubscribers = new Map();
 vi.mock('../src/notifications/realtime', () => ({
   useRealtime: () => ({
-    subscribe: (envelope, handler) => { realtimeSubscribers.set(envelope, handler); return () => realtimeSubscribers.delete(envelope); },
+    subscribe: (envelope, handler) => {
+      if (!realtimeSubscribers.has(envelope)) realtimeSubscribers.set(envelope, new Set());
+      realtimeSubscribers.get(envelope).add(handler);
+      return () => realtimeSubscribers.get(envelope)?.delete(handler);
+    },
     onReconnect: () => () => {},
   }),
 }));
-function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.(frame); }
+function dispatchMessagingFrame(frame) { realtimeSubscribers.get('messaging')?.forEach((handler) => handler(frame)); }
 
 import { ConversationList } from '../src/messaging/ConversationList';
 import { Thread } from '../src/messaging/Thread';

package/tests/messagingThreadingQuoting.test.jsx

@@ -19,7 +19,7 @@ function makeApi(messages = []) {
     getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
     markConversationRead: vi.fn().mockResolvedValue({}),
     markThreadRead: vi.fn().mockResolvedValue({}),
-    getReadStatus: vi.fn().mockResolvedValue({ all_read: false, delivered_count: 0 }),
+    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
   };
 }
 function renderBubble(ui) {