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

package/tests/messagingThreadReceipts.test.jsx

@@ -1,178 +0,0 @@
-// @vitest-environment jsdom
-import fs from 'node:fs';
-import path from 'node:path';
-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?.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) => {
-      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')?.forEach((handler) => handler(frame)); }
-
-import { ConversationList } from '../src/messaging/ConversationList';
-import { Thread } from '../src/messaging/Thread';
-import { applyFrame, MessagingProvider } from '../src/messaging/MessagingProvider';
-
-// Server-shaped serialize_message output (django_core_micha/messaging/
-// serializers.py:80-95): reply_count/last_reply_at always present;
-// thread_last_read_at is REST-only and never on a frame — copied from the
-// real _message_response/_message_page_response wiring in views.py, not
-// hand-invented.
-function serverRoot(overrides = {}) {
-  return { id: 'root-1', conversation_id: 'conv-1', body: 'Root', sender_id: 'user-1', kind: 'chat', reply_count: 1, last_reply_at: '2026-08-01T09:00:00Z', thread_last_read_at: null, ...overrides };
-}
-function serverReply(overrides = {}) {
-  return { id: 'reply-1', conversation_id: 'conv-1', body: 'Reply', sender_id: 'user-2', kind: 'chat', reply_to_id: 'root-1', reply_count: 0, last_reply_at: null, created_at: '2026-08-01T10:00:00Z', ...overrides };
-}
-function baseApi(overrides = {}) {
-  return {
-    listConversations: vi.fn().mockResolvedValue({ results: [] }), listMessages: vi.fn().mockResolvedValue({ results: [] }),
-    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
-    markConversationRead: vi.fn().mockResolvedValue({}), markThreadRead: vi.fn(),
-    ...overrides,
-  };
-}
-
-afterEach(() => { cleanup(); realtimeSubscribers.clear(); });
-
-describe('the merge trap — thread_last_read_at must survive frames that never carry it', () => {
-  function cache() { return { conversations: {}, messages: {}, threads: {}, polls: {}, reactions: {}, receipts: {}, unread: { unread_count: 0, by_conversation: {} }, cursors: { conversations: null, messages: {}, threads: {} } }; }
-
-  it('a server-shaped message frame does not wipe a previously-fetched thread_last_read_at on an unrelated root', () => {
-    const state = { ...cache(), messages: { 'root-1': serverRoot({ thread_last_read_at: '2026-08-01T08:00:00Z' }) } };
-    // A brand-new, unrelated root message frame — server-shaped, no
-    // thread_last_read_at key, exactly as serialize_message emits it.
-    const next = applyFrame(state, { envelope: 'messaging', type: 'message', event_id: 'evt-1', conversation_id: 'conv-1', message: serverRoot({ id: 'root-2', thread_last_read_at: undefined, reply_to_id: undefined }) }, 'conv-1');
-    expect(next.messages['root-1'].thread_last_read_at).toBe('2026-08-01T08:00:00Z');
-  });
-
-  it('a server-shaped message_edited frame does not wipe the edited root\'s own thread_last_read_at', () => {
-    const state = { ...cache(), messages: { 'root-1': serverRoot({ thread_last_read_at: '2026-08-01T08:00:00Z', body: 'Before' }) } };
-    const edited = serverRoot({ body: 'After', thread_last_read_at: undefined });
-    delete edited.thread_last_read_at;
-    const next = applyFrame(state, { envelope: 'messaging', type: 'message_edited', event_id: 'evt-2', conversation_id: 'conv-1', message_id: 'root-1', message: edited }, null);
-    expect(next.messages['root-1'].thread_last_read_at).toBe('2026-08-01T08:00:00Z');
-    expect(next.messages['root-1'].body).toBe('After');
-  });
-
-  it('a reply frame bumping a cached root\'s reply_count/last_reply_at does not wipe that root\'s thread_last_read_at — the WO\'s highest-risk path', () => {
-    // The receipt is deliberately NEWER than the incoming reply, so
-    // hasUnreadReplies-style logic would already read "read" before this
-    // frame — if the bump wiped thread_last_read_at to null/undefined instead
-    // of preserving it, that derived read-state would flip, which this
-    // assertion catches directly (unlike a marker-visibility assertion,
-    // which can't distinguish "correctly still read" from "field wiped to
-    // null" — both render no marker).
-    const state = { ...cache(), messages: { 'root-1': serverRoot({ reply_count: 1, last_reply_at: '2026-08-01T08:00:00Z', thread_last_read_at: '2026-08-01T09:00:00Z' }) } };
-    const next = applyFrame(state, { envelope: 'messaging', type: 'message', event_id: 'evt-4', conversation_id: 'conv-1', message: serverReply({ id: 'reply-2', created_at: '2026-08-01T10:00:00Z' }) }, 'conv-1');
-    expect(next.messages['root-1'].reply_count).toBe(2);
-    expect(next.messages['root-1'].last_reply_at).toBe('2026-08-01T10:00:00Z');
-    expect(next.messages['root-1'].thread_last_read_at).toBe('2026-08-01T09:00:00Z');
-  });
-});
-
-describe('unread-reply marker logic', () => {
-  it('shows when last_reply_at is newer than the receipt', async () => {
-    const api = baseApi({ listMessages: vi.fn().mockResolvedValue({ results: [serverRoot({ last_reply_at: '2026-08-01T10:00:00Z', thread_last_read_at: '2026-08-01T09:00:00Z' })] }) });
-    render(<MessagingProvider api={api} activeConversationId="conv-1"><Thread conversationId="conv-1" /></MessagingProvider>);
-    await screen.findByText('Root');
-    expect(screen.getByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeTruthy();
-  });
-
-  it('hides when the receipt is equal to or newer than last_reply_at', async () => {
-    const api = baseApi({ listMessages: vi.fn().mockResolvedValue({ results: [serverRoot({ last_reply_at: '2026-08-01T09:00:00Z', thread_last_read_at: '2026-08-01T10:00:00Z' })] }) });
-    render(<MessagingProvider api={api} activeConversationId="conv-1"><Thread conversationId="conv-1" /></MessagingProvider>);
-    await screen.findByText('Root');
-    expect(screen.queryByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeNull();
-  });
-
-  it('shows when the receipt is null and reply_count > 0', async () => {
-    const api = baseApi({ listMessages: vi.fn().mockResolvedValue({ results: [serverRoot({ thread_last_read_at: null, reply_count: 2, last_reply_at: '2026-08-01T09:00:00Z' })] }) });
-    render(<MessagingProvider api={api} activeConversationId="conv-1"><Thread conversationId="conv-1" /></MessagingProvider>);
-    await screen.findByText('Root');
-    expect(screen.getByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeTruthy();
-  });
-
-  it('renders no toggle and no marker at all when reply_count is 0', async () => {
-    const api = baseApi({ listMessages: vi.fn().mockResolvedValue({ results: [serverRoot({ reply_count: 0, last_reply_at: null, thread_last_read_at: null })] }) });
-    render(<MessagingProvider api={api} activeConversationId="conv-1"><Thread conversationId="conv-1" /></MessagingProvider>);
-    await screen.findByText('Root');
-    expect(screen.queryByText(/MessagingThread\.SHOW_REPLIES/)).toBeNull();
-    expect(screen.queryByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeNull();
-  });
-});
-
-describe('opening a thread marks it read from the REST response', () => {
-  it('issues the REST read call and updates the cached receipt from last_read_at', async () => {
-    const api = baseApi({
-      listMessages: vi.fn().mockResolvedValue({ results: [serverRoot({ thread_last_read_at: null, reply_count: 1, last_reply_at: '2026-08-01T09:00:00Z' })] }),
-      listThread: vi.fn().mockResolvedValue({ results: [] }),
-      markThreadRead: vi.fn().mockResolvedValue({ last_read_at: '2026-08-01T12:00:00Z' }),
-    });
-    render(<MessagingProvider api={api} activeConversationId="conv-1"><Thread conversationId="conv-1" /></MessagingProvider>);
-    await screen.findByText('Root');
-    expect(screen.getByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeTruthy();
-    fireEvent.click(screen.getByText(/MessagingThread\.SHOW_REPLIES/));
-    await waitFor(() => expect(api.markThreadRead).toHaveBeenCalledWith('root-1', undefined));
-    await waitFor(() => expect(screen.queryByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeNull());
-  });
-});
-
-describe('live root update on an incoming reply', () => {
-  it('raises reply_count/last_reply_at on the cached root and the marker appears without a refetch when the sender is not the viewer', async () => {
-    const api = baseApi({ listMessages: vi.fn().mockResolvedValue({ results: [serverRoot({ reply_count: 1, last_reply_at: '2026-08-01T08:00:00Z', thread_last_read_at: '2026-08-01T08:30:00Z' })] }) });
-    render(<MessagingProvider api={api} activeConversationId="conv-1"><Thread conversationId="conv-1" /></MessagingProvider>);
-    await screen.findByText(/MessagingThread\.SHOW_REPLIES:1/);
-    expect(screen.queryByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeNull();
-    // A new reply from someone else — server-shaped message frame with
-    // reply_to_id naming the cached root.
-    dispatchMessagingFrame({ envelope: 'messaging', type: 'message', event_id: 'evt-3', conversation_id: 'conv-1', message: serverReply() });
-    await waitFor(() => expect(screen.getByText(/MessagingThread\.SHOW_REPLIES:2/)).toBeTruthy());
-    expect(screen.getByLabelText(/MessagingThread.UNREAD_REPLIES/)).toBeTruthy();
-  });
-});
-
-describe('managed-conversation identity (row 42)', () => {
-  it('renders two managed conversations with different external_key as distinguishable via a host resolver', async () => {
-    const api = baseApi({
-      listConversations: vi.fn().mockResolvedValue({ results: [
-        { id: 'c1', kind: 'managed', external_key: 'all' },
-        { id: 'c2', kind: 'managed', external_key: 'team' },
-      ] }),
-    });
-    render(<MessagingProvider api={api}><ConversationList resolveManagedLabel={(conversation) => conversation.external_key === 'all' ? 'Everyone' : 'My team'} /></MessagingProvider>);
-    await screen.findByText('Everyone');
-    expect(screen.getByText('My team')).toBeTruthy();
-  });
-
-  it('falls back to the existing title behavior when no resolver is supplied', async () => {
-    const api = baseApi({ listConversations: vi.fn().mockResolvedValue({ results: [{ id: 'c1', kind: 'managed', external_key: 'all', title: 'Fallback title' }] }) });
-    render(<MessagingProvider api={api}><ConversationList /></MessagingProvider>);
-    await screen.findByText('Fallback title');
-  });
-
-  it('no jg-specific vocabulary (event_all, event_team) appears anywhere in src/', () => {
-    const root = path.resolve(import.meta.dirname, '..', 'src');
-    const files = fs.readdirSync(root, { recursive: true }).filter((file) => typeof file === 'string' && /\.(jsx?|tsx?)$/.test(file));
-    const offenders = files.filter((file) => {
-      const contents = fs.readFileSync(path.join(root, file), 'utf8');
-      return /event_all|event_team/.test(contents);
-    });
-    expect(offenders).toEqual([]);
-  });
-});

package/tests/messagingThreadingQuoting.test.jsx

@@ -1,87 +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?.sender ? `${key}:${options.sender}` : key }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: () => () => {}, onReconnect: () => () => {} }) }));
-
-import { AuthContext } from '../src/auth/AuthContext';
-import { MessageBubble } from '../src/messaging/MessageBubble';
-import { applyFrame, MessagingProvider } from '../src/messaging/MessagingProvider';
-import { Thread } from '../src/messaging/Thread';
-
-function makeApi(messages = []) {
-  return {
-    listConversations: vi.fn().mockResolvedValue({ results: [{ id: 1, kind: 'group' }] }),
-    listMessages: vi.fn().mockResolvedValue({ results: messages }),
-    listThread: vi.fn().mockResolvedValue({ results: [] }),
-    getUnreadCount: vi.fn().mockResolvedValue({ unread_count: 0, by_conversation: {} }),
-    markConversationRead: vi.fn().mockResolvedValue({}),
-    markThreadRead: vi.fn().mockResolvedValue({}),
-    getReadStatus: vi.fn().mockResolvedValue({ all_read: false }),
-  };
-}
-function renderBubble(ui) {
-  return render(<MessagingProvider api={makeApi()} active={false}>{ui}</MessagingProvider>);
-}
-
-afterEach(cleanup);
-
-describe('messaging threading and quoting', () => {
-  it('groups REST-loaded server-shaped reply_to_id messages under their root', async () => {
-    const api = makeApi([
-      { id: 10, conversation_id: 1, body: 'Root', sender: { display_name: 'Ava' }, created_at: '2026-07-31T10:00:00Z' },
-      { id: 11, conversation_id: 1, body: 'Server reply', reply_to_id: 10, sender: { display_name: 'Ben' }, created_at: '2026-07-31T10:01:00Z' },
-    ]);
-    render(<MessagingProvider api={api} activeConversationId={1}><Thread conversationId={1} /></MessagingProvider>);
-    await screen.findByText('Root');
-    expect(screen.queryByText('Server reply')).toBeNull();
-    fireEvent.click(screen.getByRole('button', { name: /MessagingThread\.SHOW_REPLIES/ }));
-    expect(await screen.findByText('Server reply')).toBeTruthy();
-  });
-
-  it('groups realtime server-shaped reply_to_id messages under their root', () => {
-    const state = { conversations: {}, messages: { 10: { id: 10, conversation_id: 1, body: 'Root' } }, threads: {}, polls: {}, reactions: {}, receipts: {}, unread: { unread_count: 0, by_conversation: {} }, cursors: { conversations: null, messages: {}, threads: {} } };
-    const next = applyFrame(state, { type: 'message', conversation_id: 1, message: { id: 11, body: 'Realtime reply', reply_to_id: 10 } }, 1);
-    expect(next.messages[11].reply_to_id).toBe(10);
-    expect(Object.values(next.messages).filter((message) => !((message.reply_to_id ?? message.reply_to))).map((message) => message.id)).toEqual([10]);
-  });
-
-  it('renders a quoted sender and snippet, blanking deleted quoted content', () => {
-    const { rerender } = renderBubble(<MessageBubble message={{ id: 2, body: 'Reply' }} replyTo={{ id: 1, body: 'Quoted words', sender: { display_name: 'Ava' } }} />);
-    expect(screen.getByText('MessagingThread.REPLY_TO:Ava')).toBeTruthy();
-    expect(screen.getByText('Quoted words')).toBeTruthy();
-    rerender(<MessagingProvider api={makeApi()} active={false}><MessageBubble message={{ id: 2, body: 'Reply' }} replyTo={{ id: 1, body: 'Secret', deleted_at: '2026-07-31T10:00:00Z', sender: { display_name: 'Ava' } }} /></MessagingProvider>);
-    expect(screen.getByText('MessagingThread.DELETED')).toBeTruthy();
-    expect(screen.queryByText('Secret')).toBeNull();
-  });
-
-  it('labels an attachment-only quoted source distinctly from a deleted one', () => {
-    renderBubble(<MessageBubble message={{ id: 2, body: 'Reply' }} replyTo={{ id: 1, attachments: [{ id: 9, filename: 'photo.png' }], sender: { display_name: 'Ava' } }} />);
-    expect(screen.getByText('MessagingThread.QUOTE_ATTACHMENT')).toBeTruthy();
-    expect(screen.queryByText('MessagingThread.DELETED')).toBeNull();
-  });
-
-  it("clears the Thread's own reply-target state when the message being replied to is deleted", async () => {
-    const api = makeApi([{ id: 20, conversation_id: 1, body: 'Reply target', sender: { id: 1, display_name: 'Ava' }, created_at: '2026-07-31T10:00:00Z' }]);
-    api.deleteMessage = vi.fn().mockResolvedValue({});
-    render(<AuthContext.Provider value={{ user: { id: 1 } }}><MessagingProvider api={api} activeConversationId={1}><Thread conversationId={1} /></MessagingProvider></AuthContext.Provider>);
-    await screen.findByText('Reply target');
-    fireEvent.click(screen.getByRole('button', { name: /MessagingActions\.MENU/ }));
-    fireEvent.click(screen.getByRole('menuitem', { name: /MessagingThread\.REPLY\b/ }));
-    expect(screen.getByText(/MessagingThread\.REPLYING_TO/)).toBeTruthy();
-    fireEvent.click(screen.getByRole('button', { name: /MessagingActions\.MENU/ }));
-    fireEvent.click(screen.getByRole('menuitem', { name: /MessagingActions\.DELETE/ }));
-    fireEvent.click(screen.getByRole('button', { name: /MessagingActions\.DELETE/ }));
-    await waitFor(() => expect(api.deleteMessage).toHaveBeenCalledWith(20));
-    await waitFor(() => expect(screen.queryByText(/MessagingThread\.REPLYING_TO/)).toBeNull());
-  });
-
-  it('jumps from a quote to the original message', () => {
-    const onJumpToMessage = vi.fn();
-    renderBubble(<MessageBubble message={{ id: 2, body: 'Reply' }} replyTo={{ id: 1, body: 'Quoted words', sender: { display_name: 'Ava' } }} onJumpToMessage={onJumpToMessage} />);
-    fireEvent.click(screen.getByText('Quoted words'));
-    expect(onJumpToMessage).toHaveBeenCalledWith(1);
-  });
-});

package/tests/messagingUnreadLifecycle.test.jsx

@@ -1,78 +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) => key }) }));
-vi.mock('../src/notifications/realtime', () => ({ useRealtime: () => ({ subscribe: () => () => {}, onReconnect: () => () => {} }) }));
-
-import { ConversationList } from '../src/messaging/ConversationList';
-import { messagingReducer, MessagingProvider, useMessaging } from '../src/messaging/MessagingProvider';
-import { Thread } from '../src/messaging/Thread';
-
-function cache() { return { conversations: {}, messages: {}, threads: {}, polls: {}, reactions: {}, receipts: {}, unread: { unread_count: 0, by_conversation: {} }, cursors: { conversations: null, messages: {}, threads: {} } }; }
-function State() { const { cache: current } = useMessaging(); return <output data-testid="cache">{JSON.stringify(current)}</output>; }
-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({}), markThreadRead: vi.fn().mockResolvedValue({}),
-    ...overrides,
-  };
-}
-
-afterEach(cleanup);
-
-describe('messaging unread lifecycle', () => {
-  it('marks the selected conversation read once its thread mounts', async () => {
-    // MSG-6e made `Thread`'s mount effect the sole owner of marking a
-    // conversation read (`ConversationList`'s own onClick no longer does it,
-    // to stop the double `POST .../read/` this test used to mask) — so the
-    // realistic host wiring (onOpen mounts Thread) is what's under test here,
-    // not a click on ConversationList in isolation.
-    const api = makeApi({ listConversations: vi.fn().mockResolvedValue({ results: [{ id: 12, title: 'Support' }] }) });
-    function Surface() {
-      const [conversationId, setConversationId] = React.useState(null);
-      return <>
-        <ConversationList onOpen={(conversation) => setConversationId(conversation.id)} />
-        {conversationId != null && <Thread conversationId={conversationId} />}
-      </>;
-    }
-    render(<MessagingProvider api={api}><Surface /></MessagingProvider>);
-    fireEvent.click(await screen.findByRole('button', { name: /Support/ }));
-    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledWith(12, undefined));
-  });
-
-  it('marks a conversation read when its thread opens', async () => {
-    const api = makeApi();
-    render(<MessagingProvider api={api} active={false}><Thread conversationId={12} /></MessagingProvider>);
-    await waitFor(() => expect(api.markConversationRead).toHaveBeenCalledWith(12, undefined));
-  });
-
-  it('decrements the global unread count by the selected conversation prior count', () => {
-    const initial = { ...cache(), unread: { unread_count: 5, by_conversation: { 12: 2, 7: 3 } } };
-    const next = messagingReducer(initial, { type: 'conversationRead', conversationId: 12 });
-    expect(next.unread).toEqual({ unread_count: 3, by_conversation: { 12: 0, 7: 3 } });
-  });
-
-  it('marks a reply thread read when it expands', async () => {
-    const api = makeApi({ listMessages: vi.fn().mockResolvedValue({ results: [{ id: 40, conversation_id: 12, body: 'Root', reply_count: 1 }] }) });
-    render(<MessagingProvider api={api} activeConversationId={12}><Thread conversationId={12} /></MessagingProvider>);
-    // No thread_last_read_at in this fixture — the unread-reply marker
-    // (MSG-3d) correctly treats a null receipt with replies as unread, which
-    // changes the button's accessible name to include the marker text.
-    fireEvent.click(await screen.findByRole('button', { name: /MessagingThread\.SHOW_REPLIES/ }));
-    await waitFor(() => expect(api.markThreadRead).toHaveBeenCalledWith(40, undefined));
-  });
-
-  it('increments unread only for a new message in a non-active conversation', () => {
-    const initial = { ...cache(), unread: { unread_count: 2, by_conversation: { 7: 2 } } };
-    const incoming = { type: 'frame', activeConversationId: 7, frame: { type: 'message', conversation_id: 12, message: { id: 50, body: 'hello' } } };
-    const nonActive = messagingReducer(initial, incoming);
-    expect(nonActive.unread).toEqual({ unread_count: 3, by_conversation: { 7: 2, 12: 1 } });
-    const active = messagingReducer(nonActive, { ...incoming, frame: { type: 'message', conversation_id: 7, message: { id: 51, body: 'active' } } });
-    expect(active.unread).toEqual(nonActive.unread);
-    const optimistic = messagingReducer(initial, { type: 'messageOptimistic', message: { id: 'local-r1', conversation_id: 12, client_request_id: 'r1', status: 'pending' } });
-    const reconciled = messagingReducer(optimistic, { ...incoming, frame: { type: 'message', conversation_id: 12, message: { id: 52, client_request_id: 'r1', body: 'mine' } } });
-    expect(reconciled.unread).toEqual(initial.unread);
-  });
-});

package/tests/notificationsApi.test.js

@@ -1,41 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const client = vi.hoisted(() => ({
-  delete: vi.fn(),
-  get: vi.fn(),
-  patch: vi.fn(),
-  post: vi.fn(),
-}));
-
-vi.mock('../src/auth/apiClient', () => ({ default: client }));
-
-import { removePushSubscription, savePushSubscription } from '../src/notifications/api';
-
-describe('notifications API', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('saves a push subscription with its user agent', async () => {
-    client.post.mockResolvedValue({ data: { id: 1 } });
-    const subscription = { endpoint: 'https://fcm.googleapis.com/fcm/send/example' };
-
-    await savePushSubscription(subscription, 'Example Browser');
-
-    expect(client.post).toHaveBeenCalledWith(
-      '/api/notifications/preferences/push-subscription/',
-      { subscription, ua: 'Example Browser' },
-    );
-  });
-
-  it('removes a push subscription by endpoint using an axios delete body', async () => {
-    client.delete.mockResolvedValue({ data: null });
-
-    await removePushSubscription({ endpoint: 'https://updates.push.services.mozilla.com/example' });
-
-    expect(client.delete).toHaveBeenCalledWith(
-      '/api/notifications/preferences/push-subscription/',
-      { data: { endpoint: 'https://updates.push.services.mozilla.com/example' } },
-    );
-  });
-});

package/tests/notificationsExports.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  NotificationSettings,
-  PopupSurface,
-  getNotificationPreferences,
-  getVapidPublicKey,
-  listPushSubscriptions,
-  notificationsTranslations,
-  patchNotificationPreferences,
-  removePushSubscription,
-  savePushSubscription,
-  urlBase64ToUint8Array,
-} from '../src/index';
-
-describe('notification barrel exports', () => {
-  it('preserves legacy notification exports and translations', () => {
-    [
-      NotificationSettings,
-      getNotificationPreferences,
-      patchNotificationPreferences,
-      getVapidPublicKey,
-      listPushSubscriptions,
-      savePushSubscription,
-      removePushSubscription,
-      urlBase64ToUint8Array,
-      notificationsTranslations,
-    ].forEach((value) => expect(value).toBeDefined());
-  });
-
-  it('additively exports the NOTIF-12 popup surface', () => {
-    expect(PopupSurface).toBeDefined();
-  });
-});

package/tests/onboardingDescriptors.test.js

@@ -1,132 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { UNIVERSAL_STEP_DESCRIPTORS } from '../src/onboarding/OnboardingProvider';
-import { selectActiveSteps } from '../src/onboarding/stepSelection';
-
-const cookieConsentDescriptor = UNIVERSAL_STEP_DESCRIPTORS.find((step) => step.id === 'cookie_consent');
-const browserPushDescriptor = UNIVERSAL_STEP_DESCRIPTORS.find((step) => step.id === 'browser_push');
-const pwaInstallDescriptor = UNIVERSAL_STEP_DESCRIPTORS.find((step) => step.id === 'pwa_install');
-
-describe('cookie_consent descriptor condition', () => {
-  it('is active when the user has not accepted the privacy statement, regardless of cookies', () => {
-    expect(cookieConsentDescriptor.condition({
-      user: { accepted_privacy_statement: false, accepted_convenience_cookies: false },
-    })).toBe(true);
-    expect(cookieConsentDescriptor.condition({
-      user: { accepted_privacy_statement: false, accepted_convenience_cookies: true },
-    })).toBe(true);
-  });
-
-  it('is inactive once the privacy statement is accepted, even if cookies were declined', () => {
-    expect(cookieConsentDescriptor.condition({
-      user: { accepted_privacy_statement: true, accepted_convenience_cookies: false },
-    })).toBe(false);
-  });
-
-  it('is inactive with no user', () => {
-    expect(cookieConsentDescriptor.condition({ user: null })).toBe(false);
-  });
-});
-
-describe('browser_push descriptor condition', () => {
-  it('is active by default only when neither supported channel is configured', () => {
-    expect(browserPushDescriptor.condition({
-      pushState: { supported: true, subscribed: false },
-      emailOptedIn: false,
-    })).toBe(true);
-    expect(browserPushDescriptor.condition({
-      pushState: { supported: true, subscribed: false },
-      emailOptedIn: true,
-    })).toBe(false);
-    expect(browserPushDescriptor.condition({
-      pushState: { supported: true, subscribed: true },
-      emailOptedIn: false,
-    })).toBe(false);
-  });
-
-  it('keeps the legacy condition when configured for all-channels', () => {
-    expect(browserPushDescriptor.condition({
-      browserPush: { nagUntil: 'all-channels' },
-      pushState: { supported: true, subscribed: false },
-      emailOptedIn: true,
-    })).toBe(true);
-    expect(browserPushDescriptor.condition({
-      browserPush: { nagUntil: 'all-channels' },
-      pushState: { supported: true, subscribed: true },
-      emailOptedIn: false,
-    })).toBe(true);
-  });
-
-  it('is active when push is unsupported and email notifications are not enabled', () => {
-    expect(browserPushDescriptor.condition({
-      pushState: { supported: false, subscribed: false },
-      emailOptedIn: false,
-    })).toBe(true);
-  });
-
-  it('is inactive when push is unsupported with email notifications enabled or both channels are enabled', () => {
-    expect(browserPushDescriptor.condition({
-      pushState: { supported: false, subscribed: false },
-      emailOptedIn: true,
-    })).toBe(false);
-    expect(browserPushDescriptor.condition({
-      pushState: { supported: true, subscribed: true },
-      emailOptedIn: true,
-    })).toBe(false);
-  });
-
-  it('is excluded after persistent dismissal', () => {
-    const activeSteps = selectActiveSteps(
-      [browserPushDescriptor],
-      { browser_push: true },
-      { pushState: { supported: true, subscribed: false }, emailOptedIn: false },
-      new Set(['browser_push']),
-    );
-
-    expect(activeSteps).toEqual([]);
-  });
-});
-
-describe('pwa_install descriptor condition', () => {
-  it('is inactive when the app has not opted in, even if the device could install', () => {
-    expect(pwaInstallDescriptor.condition({
-      pwaInstallEnabled: false,
-      pwaInstall: { deferredPrompt: {}, isStandalone: false, isIos: false },
-    })).toBe(false);
-  });
-
-  it('is active when opted in and Android/Chrome captured a deferred install prompt', () => {
-    expect(pwaInstallDescriptor.condition({
-      pwaInstallEnabled: true,
-      pwaInstall: { deferredPrompt: {}, isStandalone: false, isIos: false },
-    })).toBe(true);
-  });
-
-  it('is active when opted in on iOS (no deferred prompt exists there, only the hint)', () => {
-    expect(pwaInstallDescriptor.condition({
-      pwaInstallEnabled: true,
-      pwaInstall: { deferredPrompt: null, isStandalone: false, isIos: true },
-    })).toBe(true);
-  });
-
-  it('is inactive when opted in but neither a deferred prompt nor iOS applies', () => {
-    expect(pwaInstallDescriptor.condition({
-      pwaInstallEnabled: true,
-      pwaInstall: { deferredPrompt: null, isStandalone: false, isIos: false },
-    })).toBe(false);
-  });
-
-  it('is inactive once already running standalone, regardless of opt-in or device capability', () => {
-    expect(pwaInstallDescriptor.condition({
-      pwaInstallEnabled: true,
-      pwaInstall: { deferredPrompt: {}, isStandalone: true, isIos: false },
-    })).toBe(false);
-    expect(pwaInstallDescriptor.condition({
-      pwaInstallEnabled: true,
-      pwaInstall: { deferredPrompt: null, isStandalone: true, isIos: true },
-    })).toBe(false);
-  });
-
-  it('is inactive with no pwaInstall context at all', () => {
-    expect(pwaInstallDescriptor.condition({ pwaInstallEnabled: true })).toBe(false);
-  });
-});