feat(mobile): KI-AGENT: Föderierte Chats und gemeinsame Sichtbarkeit ergänzen

mobile/tests/chat-conversation.test.mjs

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { test } from 'node:test';
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+import ts from 'typescript';
+import * as chatModel from '../src/lib/chat.ts';
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+const require = createRequire(import.meta.url);
+const remote = { key: 'collaboration:a', id: 'a', source: 'collaboration', name: 'A', exists: true };
+const detail = { name: 'A', canSend: true, historyFromSeq: 1, revision: 1 };
+const deferred = () => { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no; }); return { promise, resolve, reject }; };
+
+function harness(overrides = {}) {
+  const reads = [], sends = [], timers = new Map();
+  const api = {
+    detail: async () => detail, messages: async () => ({ messages: [{ id: 'first', seq: 1, body: 'Start' }] }),
+    members: async () => [{ name: 'Partner' }], reactions: async () => ({}),
+    read: async (...args) => { reads.push(args); },
+    send: async (...args) => { sends.push(args); return { id: 'sent', seq: 2, own: true }; },
+    react: async () => ({ reactions: {} }), ...overrides,
+  };
+  const output = ts.transpileModule(readFileSync(new URL('../hooks/use-chat-conversation.ts', import.meta.url), 'utf8'), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+  }).outputText;
+  const exports = {};
+  new Function('require', 'exports', 'setInterval', 'clearInterval', output)(name => {
+    if (name === '@/src/lib/chat-api') return { chatApi: api };
+    if (name === '@/src/lib/chat') return chatModel;
+    return require(name);
+  }, exports, callback => { const id = Symbol(); timers.set(id, callback); return id; }, id => timers.delete(id));
+  let latest, root;
+  function Probe(props) { latest = exports.useChatConversation(props.token || 'token', props.room, props.enabled ?? true); return null; }
+  return {
+    api, reads, sends, get state() { return latest; },
+    async render(room = remote, enabled = true, token = 'token') {
+      await act(async () => {
+        const element = React.createElement(Probe, { key: `${token}:${room.key}`, room, enabled, token });
+        if (root) root.update(element); else root = create(element);
+      });
+    },
+    async poll() { await act(async () => { for (const callback of timers.values()) callback(); }); },
+    async dispose() { await act(async () => root?.unmount()); },
+  };
+}
+
+test('Verspätete Antworten des vorherigen Raums werden nach Raumwechsel verworfen', async () => {
+  const pending = deferred();
+  const h = harness({ detail: async (_token, room) => room.id === 'a' ? pending.promise : { ...detail, name: 'B' },
+    messages: async (_token, room) => ({ messages: [{ id: room.id, seq: 1, body: room.name }] }) });
+  try {
+    await h.render();
+    await h.render({ ...remote, key: 'collaboration:b', id: 'b', name: 'B' });
+    await act(async () => pending.resolve(detail));
+    assert.equal(h.state.detail.name, 'B');
+    assert.equal(h.state.messages[0].body, 'B');
+    assert.ok(h.reads.every(([, room]) => room.id === 'b'));
+  } finally { await h.dispose(); }
+});
+test('Mandantenwechsel verwirft laufende Antworten der alten Sitzung', async () => {
+  const pending = deferred();
+  const h = harness({ messages: async token => token === 'old' ? pending.promise : { messages: [{ id: 'new', seq: 3 }] } });
+  try {
+    await h.render(remote, true, 'old');
+    await h.render(remote, true, 'new');
+    await act(async () => pending.resolve({ messages: [{ id: 'private-old', seq: 9 }] }));
+    assert.deepEqual(h.state.messages.map(message => message.id), ['new']);
+    assert.ok(h.reads.every(([token]) => token === 'new'));
+  } finally { await h.dispose(); }
+});
+test('Entzogener Zugriff entfernt Inhalt und ignoriert danach eintreffende Sendeantworten', async () => {
+  const pending = deferred(); let forbidden = false;
+  const h = harness({ detail: async () => { if (forbidden) throw Object.assign(new Error('Zugriff entzogen'), { status: 403 }); return detail; }, send: () => pending.promise });
+  try {
+    await h.render();
+    let send;
+    await act(async () => { send = h.state.send('Hallo', null, 'stable'); });
+    forbidden = true; await h.poll();
+    assert.equal(h.state.detail, null);
+    assert.deepEqual(h.state.messages, []); assert.deepEqual(h.state.members, []);
+    await act(async () => pending.resolve({ id: 'late', seq: 7 }));
+    assert.equal(await send, true); // The old draft can be cleared, but no content reappears.
+    assert.deepEqual(h.state.messages, []);
+    assert.equal(await h.state.send('Nicht erlaubt', null, 'blocked'), false);
+  } finally { await h.dispose(); }
+});
+test('Neue Leserechte und Historiengrenzen werden während des Pollings übernommen', async () => {
+  let revision = 1;
+  const h = harness({ detail: async () => ({ ...detail, revision, canSend: revision === 1, historyFromSeq: revision === 1 ? 1 : 5 }),
+    messages: async () => ({ messages: revision === 1 ? [{ id: 'old', seq: 1 }, { id: 'allowed', seq: 5 }, { id: 'queued', seq: null, pending: true }] : [] }) });
+  try {
+    await h.render(); revision = 2; await h.poll();
+    assert.deepEqual(h.state.messages.map(message => message.id), ['allowed']);
+    assert.equal(h.state.detail.canSend, false);
+    assert.equal(await h.state.send('Gesperrt', null, 'no-send'), false);
+    assert.equal(h.sends.length, 0);
+  } finally { await h.dispose(); }
+});
+test('Doppelklick sendet nur einmal; fehlgeschlagene Nachrichten können mit derselben ID wiederholt werden', async () => {
+  const pending = deferred(), ids = []; let attempt = 0;
+  const h = harness({ send: (_token, _room, _text, _image, clientId) => { ids.push(clientId); return ++attempt === 1 ? pending.promise : Promise.resolve({ id: 'sent', seq: 2 }); } });
+  try {
+    await h.render(); let first, second;
+    await act(async () => { first = h.state.send('Hallo', null, 'same-id'); second = h.state.send('Hallo', null, 'same-id'); });
+    assert.equal(await second, false); assert.equal(ids.length, 1);
+    await act(async () => pending.reject(new Error('Netzwerkfehler')));
+    assert.equal(await first, false);
+    await act(async () => assert.equal(await h.state.send('Hallo', null, 'same-id'), true));
+    assert.deepEqual(ids, ['same-id', 'same-id']);
+  } finally { await h.dispose(); }
+});
+test('Im Hintergrund werden keine Nachrichten abgefragt oder als gelesen markiert', async () => {
+  const h = harness();
+  try {
+    await h.render(remote, false); await h.poll(); assert.equal(h.reads.length, 0);
+    await h.render(remote, true); assert.equal(h.reads.length, 1);
+    await h.render(remote, false); await h.poll(); assert.equal(h.reads.length, 1);
+  } finally { await h.dispose(); }
+});