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

package/tests/messagingMessageActions.test.jsx

@@ -1,163 +0,0 @@
-// @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?.message ? `${key}:${options.message}` : key }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: () => () => {}, onReconnect: () => () => {} }) }));
-
-import { AuthContext } from '../src/auth/AuthContext';
-import { Composer } from '../src/messaging/Composer';
-import { MessageBubble } from '../src/messaging/MessageBubble';
-import { MessagingProvider } from '../src/messaging/MessagingProvider';
-
-function makeApi() {
-  return {
-    patchMessage: vi.fn().mockImplementation(async (id, patch) => ({ id, ...patch, edited_at: '2026-07-31T10:01:00Z' })),
-    deleteMessage: vi.fn().mockImplementation(async (id) => ({ id, deleted_at: '2026-07-31T10:01:00Z' })),
-  };
-}
-function renderBubble(message, { userId = 1, canModerateMessages = false, api = makeApi(), onReply } = {}) {
-  const result = render(<AuthContext.Provider value={{ user: { id: userId } }}><MessagingProvider api={api} active={false}><MessageBubble message={message} canModerateMessages={canModerateMessages} onReply={onReply} /></MessagingProvider></AuthContext.Provider>);
-  return { ...result, api };
-}
-function openActions() { fireEvent.click(screen.getByRole('button', { name: 'MessagingActions.MENU' })); }
-
-afterEach(cleanup);
-
-describe('message actions', () => {
-  it('offers Reply, React and Copy for incoming messages, adding Edit and Delete only for authors or moderators', () => {
-    const mine = { id: 1, body: 'Mine', sender: { id: 1 } };
-    const theirs = { id: 2, body: 'Theirs', sender: { id: 2 } };
-    const { unmount } = renderBubble(mine);
-    expect(screen.getByRole('button', { name: 'MessagingActions.MENU' })).toBeTruthy();
-    openActions();
-    ['MessagingThread.REPLY', 'MessagingReactions.ADD', 'MessagingActions.EDIT', 'MessagingActions.DELETE', 'MessagingActions.COPY'].forEach((name) => expect(screen.getByRole('menuitem', { name })).toBeTruthy());
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingReactions.ADD' }));
-    expect(screen.getByLabelText('MessagingReactions.LABEL')).toBeTruthy();
-    expect(screen.getByText('👍')).toBeTruthy();
-    unmount();
-    renderBubble(theirs);
-    expect(screen.getByRole('button', { name: 'MessagingActions.MENU' })).toBeTruthy();
-    openActions();
-    ['MessagingThread.REPLY', 'MessagingReactions.ADD', 'MessagingActions.COPY'].forEach((name) => expect(screen.getByRole('menuitem', { name })).toBeTruthy());
-    expect(screen.queryByRole('menuitem', { name: 'MessagingActions.EDIT' })).toBeNull();
-    expect(screen.queryByRole('menuitem', { name: 'MessagingActions.DELETE' })).toBeNull();
-    cleanup();
-    renderBubble(theirs, { canModerateMessages: true });
-    expect(screen.getByRole('button', { name: 'MessagingActions.MENU' })).toBeTruthy();
-    cleanup();
-    renderBubble({ ...mine, deleted_at: '2026-07-31T10:00:00Z' });
-    expect(screen.queryByRole('button', { name: 'MessagingActions.MENU' })).toBeNull();
-    cleanup();
-    renderBubble({ ...mine, kind: 'poll' });
-    expect(screen.getByRole('button', { name: 'MessagingActions.MENU' })).toBeTruthy();
-  });
-
-  it('opens the affordance from a tap and lets a keyboard user reveal and operate it', () => {
-    const onReply = vi.fn();
-    const { container } = renderBubble({ id: 3, body: 'Touch me', sender: { id: 2 } }, { onReply });
-    const bubble = container.querySelector('[data-message-id="3"] .MuiPaper-root');
-    fireEvent.click(bubble);
-    expect(bubble.getAttribute('data-actions-visible')).toBe('true');
-    const actions = screen.getByRole('button', { name: 'MessagingActions.MENU' });
-    fireEvent.focus(actions);
-    fireEvent.click(actions);
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingThread.REPLY' }));
-    expect(onReply).toHaveBeenCalledWith(expect.objectContaining({ id: 3 }));
-  });
-
-  it('dismisses the tap-revealed affordance again on an outside interaction, but not on a reaction-picker click inside the same bubble', () => {
-    const { container } = renderBubble({ id: 3, body: 'Touch me', sender: { id: 2 }, reactions: [{ emoji: '👍', count: 1, reacted: false }] });
-    const bubble = container.querySelector('[data-message-id="3"] .MuiPaper-root');
-    fireEvent.click(bubble);
-    expect(bubble.getAttribute('data-actions-visible')).toBe('true');
-    // A pointerdown inside the same message's own reaction row (a sibling of
-    // the Paper, still within the article) must not count as "outside" —
-    // otherwise every reaction click would prematurely hide the affordance.
-    fireEvent.pointerDown(screen.getByText('👍 1'));
-    expect(bubble.getAttribute('data-actions-visible')).toBe('true');
-    // A pointerdown genuinely outside the message dismisses it — this is the
-    // U1 fix: without it, the affordance stayed pinned visible forever after
-    // any click that bubbled up to the bubble (Part A's "no visible
-    // affordance at rest" requirement).
-    fireEvent.pointerDown(document.body);
-    expect(bubble.getAttribute('data-actions-visible')).toBeNull();
-  });
-
-  it('keeps each message bubble\'s tap-reveal state independent — revealing one does not dismiss another', () => {
-    const api = makeApi();
-    const { container } = render(
-      <AuthContext.Provider value={{ user: { id: 1 } }}>
-        <MessagingProvider api={api} active={false}>
-          <MessageBubble message={{ id: 10, body: 'First', sender: { id: 2 } }} />
-          <MessageBubble message={{ id: 11, body: 'Second', sender: { id: 2 } }} />
-        </MessagingProvider>
-      </AuthContext.Provider>
-    );
-    const bubbleA = container.querySelector('[data-message-id="10"] .MuiPaper-root');
-    const bubbleB = container.querySelector('[data-message-id="11"] .MuiPaper-root');
-    fireEvent.pointerDown(bubbleA);
-    fireEvent.click(bubbleA);
-    expect(bubbleA.getAttribute('data-actions-visible')).toBe('true');
-    expect(bubbleB.getAttribute('data-actions-visible')).toBeNull();
-    // Tapping bubble B is, from bubble A's perspective, an outside
-    // interaction — A dismisses, B reveals; the two must never share state.
-    // (A real tap fires pointerdown before click; fireEvent.click alone
-    // wouldn't exercise the pointerdown-driven dismiss listener.)
-    fireEvent.pointerDown(bubbleB);
-    fireEvent.click(bubbleB);
-    expect(bubbleA.getAttribute('data-actions-visible')).toBeNull();
-    expect(bubbleB.getAttribute('data-actions-visible')).toBe('true');
-  });
-
-  it('edits an author message through the API and auto-cancels when deleted elsewhere', async () => {
-    const api = makeApi();
-    const message = { id: 4, body: 'Before', sender: { id: 1 } };
-    const { rerender } = renderBubble(message, { api });
-    openActions();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingActions.EDIT' }));
-    const field = screen.getByRole('textbox', { name: 'MessagingActions.EDIT' });
-    fireEvent.change(field, { target: { value: 'After' } });
-    fireEvent.click(screen.getByRole('button', { name: 'MessagingActions.SAVE' }));
-    await waitFor(() => expect(api.patchMessage).toHaveBeenCalledWith(4, { body: 'After' }));
-    openActions();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingActions.EDIT' }));
-    expect(screen.getByRole('textbox', { name: 'MessagingActions.EDIT' })).toBeTruthy();
-    rerender(<AuthContext.Provider value={{ user: { id: 1 } }}><MessagingProvider api={api} active={false}><MessageBubble message={{ ...message, deleted_at: '2026-07-31T10:02:00Z' }} /></MessagingProvider></AuthContext.Provider>);
-    await waitFor(() => expect(screen.queryByRole('textbox', { name: 'MessagingActions.EDIT' })).toBeNull());
-  });
-
-  it('requires confirmation before author or moderator deletion reaches the API', async () => {
-    const api = makeApi();
-    const { rerender } = renderBubble({ id: 5, body: 'Delete me', sender: { id: 1 } }, { api });
-    openActions();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingActions.DELETE' }));
-    expect(api.deleteMessage).not.toHaveBeenCalled();
-    fireEvent.click(screen.getByRole('button', { name: 'MessagingActions.DELETE' }));
-    await waitFor(() => expect(api.deleteMessage).toHaveBeenCalledWith(5));
-    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
-    const moderatorApi = makeApi();
-    rerender(<AuthContext.Provider value={{ user: { id: 1 } }}><MessagingProvider api={moderatorApi} active={false}><MessageBubble message={{ id: 6, body: 'Moderator delete', sender: { id: 2 } }} canModerateMessages /></MessagingProvider></AuthContext.Provider>);
-    openActions();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingActions.DELETE' }));
-    fireEvent.click(screen.getByRole('button', { name: 'MessagingActions.DELETE' }));
-    await waitFor(() => expect(moderatorApi.deleteMessage).toHaveBeenCalledWith(6));
-  });
-
-  it('clears a deleted reply target and copies the exact message body', async () => {
-    const onReplyTargetChange = vi.fn();
-    const replyTarget = { id: 7, body: 'Reply source', sender: { display_name: 'Ava' } };
-    const { rerender } = render(<MessagingProvider api={makeApi()} active={false}><Composer conversationId={1} replyTarget={replyTarget} onReplyTargetChange={onReplyTargetChange} /></MessagingProvider>);
-    onReplyTargetChange.mockClear();
-    rerender(<MessagingProvider api={makeApi()} active={false}><Composer conversationId={1} replyTarget={{ ...replyTarget, deleted_at: '2026-07-31T10:00:00Z' }} onReplyTargetChange={onReplyTargetChange} /></MessagingProvider>);
-    await waitFor(() => expect(onReplyTargetChange).toHaveBeenCalledWith(null));
-
-    const writeText = vi.fn().mockResolvedValue(undefined);
-    Object.defineProperty(navigator, 'clipboard', { configurable: true, value: { writeText } });
-    renderBubble({ id: 8, body: 'Copy exactly this', sender: { id: 1 } });
-    openActions();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'MessagingActions.COPY' }));
-    await waitFor(() => expect(writeText).toHaveBeenCalledWith('Copy exactly this'));
-  });
-});

package/tests/messagingMsg6.test.jsx

@@ -1,105 +0,0 @@
-// @vitest-environment jsdom
-import React from 'react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-
-// Thread.jsx (MSG-6f scope C) now subscribes to the messaging envelope
-// independently of MessagingProvider's own subscription -- a Set of handlers,
-// not a single captured variable, so frameHandler(...) still reaches every
-// current subscriber, matching the real registry's multi-handler support.
-let frameHandlers;
-function frameHandler(frame) { frameHandlers.forEach((handler) => handler(frame)); }
-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, options) => options?.count != null ? `${key}:${options.count}` : key, i18n: { language: 'de-DE' } }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: (_envelope, handler) => { frameHandlers.add(handler); return () => frameHandlers.delete(handler); }, onReconnect: () => () => {} }) }));
-
-import { MessageBubble } from '../src/messaging/MessageBubble';
-import { ConversationList } from '../src/messaging/ConversationList';
-import { applyFrame, MessagingProvider, useMessaging } from '../src/messaging/MessagingProvider';
-import { ReadTicks } from '../src/messaging/ReadTicks';
-import { Thread } from '../src/messaging/Thread';
-import { messagingTranslations } from '../src/i18n/messagingTranslations';
-import { AuthContext } from '../src/auth/AuthContext';
-
-const api = (overrides = {}) => ({ listConversations: vi.fn().mockResolvedValue({ results: [{ id: 'c1', kind: 'group' }] }), listMessages: vi.fn().mockResolvedValue({ results: [] }), listThread: vi.fn().mockResolvedValue({ results: [] }), getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }), getReadStatus: vi.fn().mockResolvedValue({ all_read: false, read_count: 0, recipient_count: 1, recipient_detail: [{ user_id: 'u2', display_name: 'Ava' }] }), markConversationRead: vi.fn().mockResolvedValue({}), ...overrides });
-const state = () => ({ conversations: {}, messages: {}, threads: {}, polls: {}, reactions: {}, receipts: {}, unread: { unread_count: 0, by_conversation: {} }, cursors: { conversations: null, messages: {}, threads: {} } });
-beforeEach(() => { frameHandlers = new Set(); });
-afterEach(cleanup);
-
-function PollHarness() { const { createConversationPoll, cache } = useMessaging(); return <><button onClick={() => createConversationPoll('c1', { question: 'Q' })}>create</button><output>{JSON.stringify(cache.messages)}</output></>; }
-
-describe('MSG-6 messaging regressions', () => {
-  it('uses the server message_id, never the poll id, for a newly-created poll cache row', async () => {
-    const client = api({ createPoll: vi.fn().mockResolvedValue({ id: 'poll-9', message_id: 'message-9', question: 'Q', options: [] }) });
-    render(<MessagingProvider api={client} active={false}><PollHarness /></MessagingProvider>);
-    await act(async () => screen.getByText('create').click());
-    const messages = JSON.parse(screen.getByText((_, node) => node.tagName === 'OUTPUT').textContent);
-    expect(Object.keys(messages)).toEqual(['message-9']);
-    expect(messages['message-9'].created_at).toBeTruthy();
-    expect(messages['poll-9']).toBeUndefined();
-  });
-
-  it('renders time-only metadata in the active locale and one separator per changed root day', async () => {
-    const time = vi.spyOn(Date.prototype, 'toLocaleTimeString'); time.mockReturnValue('10:41');
-    render(<MessageBubble message={{ id: 1, body: 'Hi', created_at: '2026-08-03T10:41:00Z' }} />);
-    expect(await screen.findByText('10:41')).toBeTruthy();
-    expect(time).toHaveBeenCalledWith('de-DE', { hour: '2-digit', minute: '2-digit' });
-    time.mockRestore();
-    const client = api({ listMessages: vi.fn().mockResolvedValue({ results: [{ id: 1, conversation_id: 'c1', body: 'one', created_at: '2026-08-01T10:00:00Z' }, { id: 2, conversation_id: 'c1', body: 'two', created_at: '2026-08-01T11:00:00Z' }, { id: 3, conversation_id: 'c1', body: 'three', created_at: '2026-08-02T10:00:00Z' }] }) });
-    render(<MessagingProvider api={client}><Thread conversationId="c1" /></MessagingProvider>);
-    await screen.findByText('three');
-    expect(screen.getAllByTestId('day-separator')).toHaveLength(1);
-  });
-
-  it('applies read frames to cache (for the per-person popover) but the group read ratio stays dcm\'s own numbers, not recomputed', async () => {
-    const client = api();
-    render(<MessagingProvider api={client} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'group' }} /></MessagingProvider>);
-    const tick = await screen.findByLabelText('MessagingReadTicks.READ_RATIO');
-    expect(tick.textContent).toBe('0/1');
-    act(() => frameHandler({ type: 'read_state', conversation_id: 'c1', user_id: 'u2', last_read_at: '2026-08-03T10:00:00Z' }));
-    // Deliberate, documented trade-off (see ReadTicks.jsx): the numeric ratio
-    // is dcm's own read_count/recipient_count verbatim, never recomputed from
-    // recipientDetail -- recipientDetail has no way to threshold against
-    // this specific message's created_at, only dcm's own aggregate does.
-    // So a read_state frame updates the *popover's* per-person list (proven
-    // by the receipts assertion below) but the ratio digits only change on
-    // the next read-status fetch, same as before this frame arrived.
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    expect(screen.getByLabelText('MessagingReadTicks.READ_RATIO').textContent).toBe('0/1');
-    expect(client.getReadStatus).toHaveBeenCalledTimes(1);
-    const next = applyFrame(state(), { type: 'thread_read_state', root_id: 'root-1', user_id: 'u2', last_read_at: '2026-08-03T10:00:00Z' });
-    expect(next.receipts['thread:root-1:u2'].last_read_at).toBe('2026-08-03T10:00:00Z');
-  });
-
-  it('updates direct-conversation ReadTicks from a read frame without another REST call', async () => {
-    const client = api({ getReadStatus: vi.fn().mockResolvedValue({ all_read: false }) });
-    render(<MessagingProvider api={client} active={false}><ReadTicks messageId="m1" conversation={{ id: 'c1', kind: 'direct', other_user_id: 'u2' }} /></MessagingProvider>);
-    await screen.findByLabelText('MessagingReadTicks.SENT');
-    act(() => frameHandler({ type: 'read_state', conversation_id: 'c1', user_id: 'u2', last_read_at: '2026-08-03T10:00:00Z' }));
-    await screen.findByLabelText('MessagingReadTicks.ALL_READ');
-    expect(client.getReadStatus).toHaveBeenCalledTimes(1);
-  });
-
-  it('keeps Thread as the sole read-mark owner for direct mounts and list opens', async () => {
-    const client = api({ listMessages: vi.fn().mockResolvedValue({ results: [] }) });
-    function Surface() { const [conversationId, setConversationId] = React.useState(null); return <MessagingProvider api={client}><ConversationList onOpen={(conversation) => setConversationId(conversation.id)} />{conversationId && <Thread conversationId={conversationId} />}</MessagingProvider>; }
-    render(<Surface />);
-    await screen.findByText('MessagingList.UNTITLED');
-    fireEvent.click(screen.getByText('MessagingList.UNTITLED'));
-    await waitFor(() => expect(client.markConversationRead).toHaveBeenCalledTimes(1));
-    client.markConversationRead.mockClear();
-    render(<MessagingProvider api={client} active={false}><Thread conversationId="c1" /></MessagingProvider>);
-    await waitFor(() => expect(client.markConversationRead).toHaveBeenCalledTimes(1));
-  });
-
-  it('updates the rendered thread unread state from a thread_read_state frame', async () => {
-    const client = api({ listMessages: vi.fn().mockResolvedValue({ results: [{ id: 'root-1', conversation_id: 'c1', body: 'Root', sender: { id: 'u1' }, reply_count: 1, last_reply_at: '2026-08-03T10:00:00Z', thread_last_read_at: null }] }) });
-    render(<AuthContext.Provider value={{ user: { id: 'u2' } }}><MessagingProvider api={client}><Thread conversationId="c1" /></MessagingProvider></AuthContext.Provider>);
-    await screen.findByLabelText(/MessagingThread.UNREAD_REPLIES/);
-    act(() => frameHandler({ type: 'thread_read_state', root_id: 'root-1', user_id: 'u2', last_read_at: '2026-08-03T11:00:00Z' }));
-    await waitFor(() => expect(screen.queryByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeNull());
-  });
-
-  it('defines singular reply labels for de, en, fr, and sw', () => {
-    expect(messagingTranslations['MessagingThread.SHOW_REPLIES_one']).toEqual({ de: '{{count}} Antwort anzeigen', en: 'Show {{count}} reply', fr: 'Afficher {{count}} réponse', sw: 'Onyesha jibu {{count}}' });
-  });
-});

package/tests/messagingMsg6f.test.jsx

@@ -1,155 +0,0 @@
-// @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

@@ -1,166 +0,0 @@
-// @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);
-    });
-  });
-});