import { TestBed } from '@angular/core/testing'; import { ChatService, isAttachmentEcho, isMediaDeliveryFailure } from './chat.service'; import { setServerUploadLimit } from './upload-limits'; import { FmodeApi } from './api/fmode-api'; import { LiveService } from './live.service'; import { MatrixClientService, MxMessage } from './matrix-client.service'; import { SessionService } from './session.service'; import { UnreadService } from './unread.service'; import { ChatSessionService } from './chat-session.service'; import { Agent, MatrixProvision } from './api/models'; import { environment } from '../../environments/environment'; /** * ChatService 单测 —— 会话状态机(SPEC FR-04) * * 覆盖:provision → 连接 → 房间 → 收发 → 分页 的编排与失败分环节报错。 * 依赖(FmodeApi / LiveService / MatrixClientService)全部用桩替换, * **不触网、不加载 matrix-js-sdk**。 * * 🔴 重点回归: * ① 切会话时 `seq` 防串扰(过期回包必须被丢弃) * ② `close()` **不断开**会话级连接(未读依赖 sync 常驻) * ③ 失败时**分环节**报错(FMODE 开通 / Matrix 登录 / 房间创建) * ④ `paginate()` 防重入(滚动事件高频触发) */ describe('ChatService', () => { let svc: ChatService; /** 桩:FmodeApi */ /** * 云端会话目录桩(2026-10-31):会话列表以云端为唯一来源。 * 默认返回一条已有会话,模拟「进入一个聊过的容器」。 */ const CLOUD_THREAD = { objectId: 'cloud1', agentId: 'agent-node-lj-test', roomId: '!room1:fmode.cn', threadRoot: '$approot_test:fmode.cn', title: '云端会话', titleLocked: false, messageCount: 1, lastMessageAt: Date.now(), archived: false, lastPreview: '', }; const apiStub = { provisionMatrix: jasmine.createSpy('provisionMatrix'), fetchChatThreads: jasmine.createSpy('fetchChatThreads'), upsertChatThreads: jasmine.createSpy('upsertChatThreads'), patchChatThread: jasmine.createSpy('patchChatThread'), removeChatThread: jasmine.createSpy('removeChatThread'), validateMatrix: jasmine.createSpy('validateMatrix'), fetchAgents: jasmine.createSpy('fetchAgents'), uploadFile: jasmine.createSpy('uploadFile'), requestUploadUrl: jasmine.createSpy('requestUploadUrl'), /* 文件台账登记(2026-11-13:右栏按 threadRoot 查台账,需断言) */ registerFile: jasmine.createSpy('registerFile').and.returnValue(Promise.resolve({ id: 'f1' })), }; /** 桩:LiveService */ const liveStub = { ensureLoaded: jasmine.createSpy('ensureLoaded').and.returnValue(Promise.resolve()), agentById: jasmine.createSpy('agentById'), agents: jasmine.createSpy('agents').and.returnValue([] as Agent[]), /** 加载状态(chat.open 用它区分「加载中」与「确实不存在」) */ state: jasmine.createSpy('state').and.returnValue('ready'), error: jasmine.createSpy('error').and.returnValue(null), }; /** 桩:MatrixClientService */ const mxStub = { connectSession: jasmine.createSpy('connectSession').and.returnValue(Promise.resolve()), disconnect: jasmine.createSpy('disconnect'), ensureRoom: jasmine.createSpy('ensureRoom'), syncState: jasmine.createSpy('syncState').and.returnValue('connected'), hasInitialSync: true, paginationToken: jasmine.createSpy('paginationToken').and.returnValue('tok-b'), timelineToMessages: jasmine.createSpy('timelineToMessages').and.returnValue([] as MxMessage[]), onMessage: jasmine.createSpy('onMessage').and.returnValue(() => undefined), onAnyMessage: jasmine.createSpy('onAnyMessage').and.returnValue(() => undefined), onTyping: jasmine.createSpy('onTyping').and.returnValue(() => undefined), sendText: jasmine.createSpy('sendText').and.returnValue(Promise.resolve({ event_id: '$e' })), sendFile: jasmine .createSpy('sendFile') .and.returnValue(Promise.resolve({ event_id: '$f' })), /** 2026-11-13 `'url'` 模式:不发文件本体,只发云盘地址 */ sendFileByUrl: jasmine .createSpy('sendFileByUrl') .and.returnValue(Promise.resolve({ event_id: '$fu' })), setTyping: jasmine.createSpy('setTyping').and.returnValue(Promise.resolve()), paginateBack: jasmine.createSpy('paginateBack').and.returnValue(Promise.resolve(true)), /** 初次 sync 是否完成(回溯历史前会等它,2026-11-12) */ synced: jasmine.createSpy('synced').and.returnValue(Promise.resolve(true)), /** token 失效自愈时用它定位容器(2026-11-12) */ setRecoveryAgentId: jasmine.createSpy('setRecoveryAgentId'), lastMessageEventId: jasmine.createSpy('lastMessageEventId').and.returnValue(null), /* * 一房间一会话(2026-11-13 起建房失败不再静默降级,故必须有桩): * 默认建出独立房间并视为容器已进房,老用例因此不受影响。 */ createSessionRoom: jasmine .createSpy('createSessionRoom') .and.callFake(() => Promise.resolve('!sess:fmode.cn')), waitAgentJoined: jasmine .createSpy('waitAgentJoined') .and.callFake(() => Promise.resolve(true)), }; const PROV: MatrixProvision = { cached: true, bindingId: 'b1', status: 'active', userMxId: '@sr2wipsdyq:fmode.cn', agentMxId: '@zgdcmgnqcd:fmode.cn', homeserver: 'https://matrix.fmode.cn', accessToken: 'tok', deviceId: 'DEV1', roomId: '!room1:fmode.cn', }; const AGENT: Agent = { id: 'agent-node-lj-test', name: 'lj-test', status: 'online' as Agent['status'], matrixReady: true, unread: 0, }; beforeEach(() => { localStorage.clear(); for (const k of Object.keys(apiStub)) { (apiStub as Record)[k].calls.reset(); } liveStub.ensureLoaded.calls.reset(); liveStub.agentById.calls.reset(); for (const k of Object.keys(mxStub)) { const v = (mxStub as Record)[k]; if (v && typeof (v as jasmine.Spy).calls === 'object') (v as jasmine.Spy).calls.reset(); } mxStub.connectSession.and.returnValue(Promise.resolve()); mxStub.ensureRoom.and.returnValue(Promise.resolve('!room1:fmode.cn')); mxStub.syncState.and.returnValue('connected'); mxStub.paginationToken.and.returnValue('tok-b'); mxStub.timelineToMessages.and.returnValue([]); mxStub.onMessage.and.returnValue(() => undefined); mxStub.onAnyMessage.and.returnValue(() => undefined); mxStub.onTyping.and.returnValue(() => undefined); mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$e' })); /* * 建房桩必须每个用例重置(2026-11-13):上一个用例可能改成 * `waitAgentJoined → false` 或 `createSessionRoom → reject`, * 漏到下一个就会出现「莫名其妙的建房失败」。 */ mxStub.createSessionRoom.and.callFake(() => Promise.resolve('!sess:fmode.cn')); mxStub.waitAgentJoined.and.callFake(() => Promise.resolve(true)); ChatService.ROOM_BACKOFF_MS = [3_000, 8_000]; ChatService.ROOM_MAX_ATTEMPTS = 3; // 每个用例都重置附件发送策略 —— 否则上一用例的 reject 会漏到下一个 mxStub.sendFile.and.returnValue(Promise.resolve({ event_id: '$f' })); mxStub.paginateBack.and.returnValue(Promise.resolve(true)); mxStub.synced.and.returnValue(Promise.resolve(true)); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([CLOUD_THREAD])); apiStub.upsertChatThreads.and.returnValue(Promise.resolve()); apiStub.patchChatThread.and.returnValue(Promise.resolve()); apiStub.removeChatThread.and.returnValue(Promise.resolve()); liveStub.agentById.and.returnValue(AGENT); apiStub.provisionMatrix.and.returnValue(Promise.resolve(PROV)); TestBed.configureTestingModule({ providers: [ ChatService, { provide: FmodeApi, useValue: apiStub }, { provide: LiveService, useValue: liveStub }, { provide: MatrixClientService, useValue: mxStub }, { provide: SessionService, useValue: { me: () => ({ id: 'u1' }), token: () => 'r:t' } }, { provide: UnreadService, useClass: UnreadService }, /* * 显式提供 ChatSessionService:每个用例都会重建注入器, * 只有列在 providers 里,`ChatService` 内部 inject 的实例 * 才与 `TestBed.inject` 拿到的是**同一个**。 */ ChatSessionService, ], }); svc = TestBed.inject(ChatService); /* * 两个根单例的状态都会跨用例保留,必须显式重置: * - ChatSessionService:内存里的会话列表(localStorage.clear() 只管磁盘) * - ChatService:agentId/sessionId/state —— 不重置的话第二个用例调 * open() 会因为「同一个 agent 且已 ready」直接早退,断言全部落空 */ svc.sessions.reset(); svc.close(); }); afterEach(() => { localStorage.clear(); }); /** 测试统一走真实态(演示态由 MockApi 覆盖,另测) */ function realMode(): void { (environment as { useMockData: boolean }).useMockData = false; } /** * 为建房相关用例准备上下文(2026-11-13)。 * * `provisionSessionRoom()` 需要 `this.provision.agentMxId` 才能建房, * 而 `startBlankWithRoom()` 自身不会先拉 provision —— 真实链路上是 * 用户先进入容器(`open()` 已 provision)再点新建。测试照此还原。 */ async function primeProvision(): Promise { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); await svc.open('agent-node-lj-test'); svc.sessions.reset(); } describe('新建对话(2026-11-01 点击即建)', () => { /* * 🔴 用户反馈:点「新建对话」之后左侧看不到任何变化。 * * 上一版是「首次发消息才建会话」,点按钮只进入待建态、不落数据 —— * 左侧列表当然不会出现条目,用户不知道操作有没有生效。 * 现在改为点击即建,并复用它归属下已有的空会话(避免连点攒出一排「新对话」)。 */ it('🔴 startBlank 立刻建出会话并选中', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); // 云端目录置空:默认桩会返回 CLOUD_THREAD,断言会凭空多一条 apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); const created = await svc.startBlank('agent-node-lj-test'); expect(created).withContext('必须立刻返回会话').toBeTruthy(); expect(svc.currentSession()?.id).withContext('新会话要处于选中态').toBe(created!.id); expect(svc.sessions.listFor('agent-node-lj-test').length).withContext('左侧应出现 1 条').toBe(1); }); /* * 2026-11-13 用户实测:点「新建对话」直接显示 * 「这个会话的消息暂时没加载出来 / 可能是网络波动」。 * * 根因:`backfillSessionTimeline()` 对 `_blankSessionId` 直接 return, * `_reachedRoomStart` 停在 false → 落到 `unloaded` 分支。 * 新建会话本来就没有历史,正确语义是 `fresh`(走欢迎页)。 */ it('🔴 新建会话不能被判成「取不到」(emptyReason 应为 fresh)', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); await svc.startBlank('agent-node-lj-test'); expect(svc.messages().length).toBe(0); expect(svc.emptyReason()) .withContext('新建会话应显示欢迎页,不能显示「消息暂时没加载出来」') .toBe('fresh'); }); /* * 2026-11-13:成果归属主键改成 roomId 后,建房失败**不能**再静默降级。 * 一房间一会话被破坏 ⇒ 同房间多会话 ⇒ 台账按 roomId 查会串台。 * 这里锁住三条行为:重试、最终失败要可见、重试成功要清掉错误。 */ it('🔴 建房失败会重试,不再静默降级', async () => { ChatService.ROOM_BACKOFF_MS = []; realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); /* 前两次进房超时,第三次成功 */ let n = 0; mxStub.waitAgentJoined.and.callFake(() => Promise.resolve(++n >= 3)); const s = await svc.startBlankWithRoom('agent-node-lj-test'); expect(n).withContext('进房失败必须重试(原实现失败即放弃)').toBeGreaterThan(1); expect(svc.roomErrors().has(s!.id)).withContext('最终成功则不应残留错误').toBeFalse(); }, 30_000); it('🔴 建房重试仍失败 → 记录错误供 UI 展示(不静默)', async () => { ChatService.ROOM_BACKOFF_MS = []; await primeProvision(); mxStub.waitAgentJoined.and.returnValue(Promise.resolve(false)); const s = await svc.startBlankWithRoom('agent-node-lj-test'); expect(svc.roomErrors().get(s!.id)) .withContext('必须给出可见原因,否则用户以为只是慢') .toContain('容器未进入'); }, 30_000); it('建房抛错(网络/服务端拒绝)同样计为重试', async () => { ChatService.ROOM_BACKOFF_MS = []; realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); mxStub.createSessionRoom.calls.reset(); mxStub.createSessionRoom.and.callFake(() => Promise.reject(new Error('限流'))); const s = await svc.startBlankWithRoom('agent-node-lj-test'); expect(mxStub.createSessionRoom.calls.count()) .withContext('抛错也要重试,不能一次失败就放弃') .toBeGreaterThan(1); expect(svc.roomErrors().get(s!.id)).toBe('限流'); }, 30_000); it('retrySessionRoom 成功后清除错误', async () => { ChatService.ROOM_BACKOFF_MS = []; realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); mxStub.waitAgentJoined.and.returnValue(Promise.resolve(false)); const s = await svc.startBlankWithRoom('agent-node-lj-test'); expect(svc.roomErrors().has(s!.id)).withContext('建房失败应记录错误').toBeTrue(); /* 用户点「重试」,这次容器能进房了 */ mxStub.waitAgentJoined.and.returnValue(Promise.resolve(true)); await svc.retrySessionRoom(); expect(svc.roomErrors().has(s!.id)).withContext('重试成功后错误要消失').toBeFalse(); }, 30_000); it('指定工作区时归属正确', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); const created = await svc.startBlank('agent-node-lj-test', 'ws-test'); expect(svc.sessions.byId(created!.id)?.workspaceId).toBe('ws-test'); }); /* * 🔴 用户裁决:整个列表**最多保留一条**「新建对话」。 * * 每次新建都把之前所有没发过消息的空会话清掉 —— 不按归属复用, * 也不依赖定时清理,否则会出现「工作区一条、日常一条」并存。 */ it('🔴 再次新建时,之前的空会话被清掉,只留一条', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); const a = await svc.startBlank('agent-node-lj-test', 'ws-test'); const b = await svc.startBlank('agent-node-lj-test', 'ws-test'); expect(svc.sessions.byId(a!.id)).withContext('上一次的空会话应被清掉').toBeUndefined(); expect(svc.sessions.byId(b!.id)).toBeDefined(); expect(svc.sessions.listFor('agent-node-lj-test').length).toBe(1); }); it('🔴 不同归属新建时,旧的空会话同样被清掉(全局只留一条)', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); const a = await svc.startBlank('agent-node-lj-test', 'ws-a'); const b = await svc.startBlank('agent-node-lj-test', 'ws-b'); expect(svc.sessions.byId(a!.id)).withContext('工作区 A 的那条应被清掉').toBeUndefined(); expect(svc.sessions.byId(b!.id)?.workspaceId).toBe('ws-b'); expect(svc.sessions.listFor('agent-node-lj-test').length).toBe(1); }); it('🔴 发过消息的会话不会被新建操作清掉', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); // 先建一条并发消息(= 已持久化) const old = await svc.startBlank('agent-node-lj-test'); await svc.sendText('这条已经发过消息'); // 再新建一条 const fresh = await svc.startBlank('agent-node-lj-test'); expect(svc.sessions.byId(old!.id)).withContext('有消息的会话不能被清').toBeDefined(); expect(svc.sessions.byId(fresh!.id)).toBeDefined(); }); it('建出会话后发消息,state 正常切到 ready', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); await svc.startBlank('agent-node-lj-test'); await svc.sendText('第一条消息'); expect(svc.state()).toBe('ready'); expect(svc.currentSession()).toBeDefined(); }); /* * 🔴 2026-11-09 用户要求:「第一次发送消息的时候,才会开始持久化存储 * 这个对话;存储成功后,才会开始发送消息」。 * * 原实现是 `commit()`(发出去就不管):消息先发进 Matrix,落库在后台跑。 * 现在首次落库必须 `await`,成功才继续发送。 */ it('🔴 首次发消息:先落库成功,才真正发送到 Matrix', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); const order: string[] = []; apiStub.upsertChatThreads.and.callFake(() => { order.push('upsert'); return Promise.resolve(); }); mxStub.sendText.and.callFake(() => { order.push('sendText'); return Promise.resolve({ event_id: '$evt1' }); }); await svc.startBlank('agent-node-lj-test'); order.length = 0; // 只关心 sendText 期间的顺序 await svc.sendText('第一条消息'); /* * 期望:落库(upsert) → 发送(sendText)。 * 允许 upsert 出现多次(标题推送等),但**首次 upsert 必须在 sendText 之前**, * 且 sendText 只能出现一次。 */ const firstUpsert = order.indexOf('upsert'); const firstSend = order.indexOf('sendText'); expect(firstUpsert).withContext('应当发生过落库').toBeGreaterThanOrEqual(0); expect(firstSend).withContext('应当发生过发送').toBeGreaterThanOrEqual(0); expect(firstUpsert) .withContext(`落库必须排在发送之前,实际顺序:${order.join(' → ')}`) .toBeLessThan(firstSend); expect(order.filter((x) => x === 'sendText').length).toBe(1); }); it('🔴 首次落库失败 → 消息标记失败,且不发送到 Matrix', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); svc.sessions.reset(); apiStub.upsertChatThreads.and.returnValue(Promise.reject(new Error('网络异常'))); mxStub.sendText.calls.reset(); await svc.startBlank('agent-node-lj-test'); await svc.sendText('这条不该被发出去'); expect(mxStub.sendText).withContext('落库失败就不能发送').not.toHaveBeenCalled(); const failed = svc.messages().find((m) => m.state === 'failed'); expect(failed).withContext('消息要标记为失败,用户可重试').toBeDefined(); // 复原桩,避免影响后续用例 apiStub.upsertChatThreads.and.returnValue(Promise.resolve()); }); }); describe('open() 真实态编排', () => { it('provision → connectSession → ensureRoom 顺序执行', async () => { realMode(); const order: string[] = []; apiStub.provisionMatrix.and.callFake(() => { order.push('provision'); return Promise.resolve(PROV); }); mxStub.connectSession.and.callFake(() => { order.push('connect'); return Promise.resolve(); }); mxStub.ensureRoom.and.callFake(() => { order.push('room'); return Promise.resolve('!room1:fmode.cn'); }); await svc.open('agent-node-lj-test'); expect(order).toEqual(['provision', 'connect', 'room']); expect(svc.agentId()).toBe('agent-node-lj-test'); expect(svc.connection()).toBe('connected'); }); it('空房间 → state=empty(不是 error)', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); await svc.open('agent-node-lj-test'); expect(svc.state()).toBe('empty'); }); /* * 🔴 「重新连接」失效的回归测试(2026-11-01 用户实测)。 * * `open()` 第一行是幂等短路:同 agent + 同会话 + state=ready 就直接 return。 * 断线时 state 仍是 ready,于是点「重新连接」什么都不会发生。 * 现在用 `force` 参数绕过短路。 */ it('🔴 不带 force 时同状态重复 open 会早退', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); await svc.open('agent-node-lj-test'); const calls = apiStub.provisionMatrix.calls.count(); await svc.open('agent-node-lj-test'); expect(apiStub.provisionMatrix.calls.count()).withContext('应早退,不再调 provision').toBe(calls); }); it('🔴 带 force 时重新执行完整编排(重新连接可用)', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); await svc.open('agent-node-lj-test'); const calls = apiStub.provisionMatrix.calls.count(); await svc.open('agent-node-lj-test', undefined, true); expect(apiStub.provisionMatrix.calls.count()).withContext('force 必须重新编排').toBe(calls + 1); }); it('有消息 → state=ready 且按 sender 区分 me/agent', async () => { realMode(); // 无 thread 的消息属于「历史对话」语义 —— 给它们当前会话的 threadId 才属于本会话 const legacyRoomThread = (i: number) => `$t${i}`; mxStub.timelineToMessages.and.returnValue([ { roomId: 'r', eventId: '$1', threadId: legacyRoomThread(1), sender: '@sr2wipsdyq:fmode.cn', body: '我发的', ts: 1, kind: 'text', live: false }, { roomId: 'r', eventId: '$2', threadId: legacyRoomThread(1), sender: '@zgdcmgnqcd:fmode.cn', body: '它回的', ts: 2, kind: 'text', live: false }, ]); // 指定这条 thread 作为要打开的会话 await svc.open('agent-node-lj-test', legacyRoomThread(1)); expect(svc.state()).toBe('ready'); expect(svc.messages().map((m) => m.sender)).toEqual(['me', 'agent']); expect(svc.messages()[0].text).toBe('我发的'); }); it('数字生命不存在 → 报明确错误', async () => { realMode(); liveStub.agentById.and.returnValue(undefined); await svc.open('nope'); expect(svc.state()).toBe('error'); expect(svc.error()).toContain('不存在'); }); it('🔴 数据仍在加载 → 不报「不存在」(刷新页面的真实场景)', async () => { realMode(); liveStub.agentById.and.returnValue(undefined); liveStub.state.and.returnValue('loading'); await svc.open('agent-node-lj-test'); expect(svc.error()).not.toContain('不存在'); expect(svc.error()).toContain('加载'); liveStub.state.and.returnValue('ready'); // 复位 }); it('🔴 数据加载失败 → 报加载失败而非「不存在」', async () => { realMode(); liveStub.agentById.and.returnValue(undefined); liveStub.state.and.returnValue('error'); liveStub.error.and.returnValue('网络异常'); await svc.open('agent-node-lj-test'); expect(svc.error()).toContain('加载失败'); expect(svc.error()).toContain('网络异常'); liveStub.state.and.returnValue('ready'); liveStub.error.and.returnValue(null); }); }); describe('失败分环节报错(FR-04:不得笼统)', () => { it('provision 失败 → 文案含「FMODE 开通失败」', async () => { realMode(); apiStub.provisionMatrix.and.returnValue(Promise.reject(new Error('SessionToken 无效'))); await svc.open('a'); expect(svc.error()).toContain('FMODE 开通失败'); expect(svc.error()).toContain('SessionToken 无效'); }); it('SDK 登录失败 → 文案含「连接失败」(不暴露技术名词)', async () => { realMode(); mxStub.connectSession.and.returnValue(Promise.reject(new Error('凭据不完整'))); await svc.open('a'); expect(svc.error()).toContain('连接失败'); expect(svc.error()).withContext('界面文案不应出现 Matrix').not.toContain('Matrix'); }); it('房间创建失败 → 文案含「房间创建失败」', async () => { realMode(); mxStub.ensureRoom.and.returnValue(Promise.reject(new Error('403'))); await svc.open('a'); expect(svc.error()).toContain('房间创建失败'); }); it('失败时 connection=disconnected(不假装连着)', async () => { realMode(); apiStub.provisionMatrix.and.returnValue(Promise.reject(new Error('x'))); await svc.open('a'); expect(svc.connection()).toBe('disconnected'); }); }); describe('seq 防串扰(切会话丢弃过期回包)', () => { it('慢的旧请求返回时不覆盖新会话', async () => { realMode(); let resolveSlow: (v: MatrixProvision) => void = () => undefined; apiStub.provisionMatrix.and.callFake((id: string) => id === 'slow' ? new Promise((res) => (resolveSlow = res)) : Promise.resolve(PROV), ); mxStub.ensureRoom.and.callFake(() => Promise.resolve('!room1:fmode.cn')); const slowOpen = svc.open('slow'); // 悬而未决 await svc.open('fast'); // 后发先至,成为当前会话 resolveSlow(PROV); // 旧请求此刻才返回 await slowOpen; // 当前会话仍是 fast,未被 slow 的迟到回包覆盖 expect(svc.agentId()).toBe('fast'); }); }); describe('close() 必须**不断开**会话级连接', () => { it('close 后 sync 仍常驻(未读计数依赖)', async () => { realMode(); await svc.open('agent-node-lj-test'); svc.close(); // 🔴 关键:close 不得调用 disconnect —— 否则离开会话就收不到消息 expect(mxStub.disconnect).not.toHaveBeenCalled(); expect(svc.agentId()).toBeNull(); expect(svc.messages()).toEqual([]); expect(svc.connection()).toBe('disconnected'); // 仅 UI 状态复位 }); it('close 会解绑本房间的事件订阅(防串扰)', async () => { realMode(); const unbindMsg = jasmine.createSpy('unbindMsg'); const unbindTyping = jasmine.createSpy('unbindTyping'); mxStub.onMessage.and.returnValue(unbindMsg); mxStub.onTyping.and.returnValue(unbindTyping); await svc.open('a'); svc.close(); expect(unbindMsg).toHaveBeenCalled(); expect(unbindTyping).toHaveBeenCalled(); }); }); describe('群聊支持(2026-11-07)', () => { /* * 🔴 回归:群聊重建历史要遍历 N 个成员房间。若每个成员都走 * `connectSession`,token 不同时会 disconnect 重建客户端 → * 正在进行的 `/sync` 被打断,timeline 永远是空的 * (真实账号实测:群历史一条都读不出来)。 */ it('读历史时:已连接则不重连;未连接仍必须连(评审 2026-11-07)', async () => { realMode(); apiStub.provisionMatrix.and.returnValue(Promise.resolve(PROV)); mxStub.ensureRoom.and.returnValue(Promise.resolve('!room1:fmode.cn')); mxStub.connectSession.calls.reset(); // 未连接:skipConnect 也不能跳过,否则 ensureRoom 里 requireClient 会抛 (mxStub as unknown as { connected: boolean }).connected = false; await svc.ensureAgentRoomFor('agent-node-lj-test', { skipConnect: true }); expect(mxStub.connectSession) .withContext('客户端不存在时必须建立连接') .toHaveBeenCalled(); // 已连接:跳过重连(重建会打断正在进行的 sync) (mxStub as unknown as { connected: boolean }).connected = true; mxStub.connectSession.calls.reset(); await svc.ensureAgentRoomFor('agent-node-lj-test', { skipConnect: true }); expect(mxStub.connectSession).not.toHaveBeenCalled(); }); it('群聊发附件:事件带 dispatch 与 session 标记', async () => { realMode(); apiStub.provisionMatrix.and.returnValue(Promise.resolve(PROV)); mxStub.connectSession.and.returnValue(Promise.resolve()); mxStub.ensureRoom.and.returnValue(Promise.resolve('!room1:fmode.cn')); mxStub.lastMessageEventId.and.returnValue('$base'); mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$file' })); const file = new File(['x'], 'a.png', { type: 'image/png' }); const r = await svc.sendFileToAgent( 'agent-node-lj-test', file, { groupId: 'g1', turnId: 'me-1', targetAgentId: 'agent-node-lj-test' }, 'https://s3.fmode.cn/k', ); expect(r.ok).withContext('发送应成功').toBe(true); expect(mxStub.sendFile).not.toHaveBeenCalled(); const args = mxStub.sendFileByUrl.calls.mostRecent().args; const extra = args[5] as Record; expect((extra['com.fmode.dispatch'] as { groupId: string }).groupId).toBe('g1'); expect(extra['com.fmode.session']).toBe('me-1'); }); }); describe('sendText(AC-04.2 / AC-04.8)', () => { beforeEach(async () => { realMode(); await svc.open('agent-node-lj-test'); }); it('乐观插入 → 调用 SDK 发送 → 标记 sent', async () => { await svc.sendText(' 你好 '); const last = svc.messages().at(-1)!; expect(last.text).toBe('你好'); // 已 trim expect(last.state).toBe('sent'); /* * 🔴 必须带会话线程根:不带 thread 容器会把每条消息切成新会话(实测)。 * 🔴 第五个参数是 extra:把本地 id 写进 content,服务端 echo 会原样带回, * 回读时据此认领乐观消息(2026-11-09 修「一条你好显示三条」)。 */ expect(mxStub.sendText).toHaveBeenCalledWith( '!room1:fmode.cn', '你好', svc.sessionId()!, undefined, { 'com.fmode.local': last.localId! }, ); expect(last.localId).toBeTruthy(); }); it('第二次发送带上一条消息的 event_id(m.in_reply_to 降级用)', async () => { await svc.sendText('第一条'); /* * 2026-11-14:发送不再拦截(用户裁决「永远不拦」), * 这里不必再模拟「第一轮结束」,直接发第二条即可。 */ mxStub.sendText.calls.reset(); await svc.sendText('第二条'); // 第一条是本地乐观 id(local-*),不是真实 event,故 lastEventId 应为 undefined const args = mxStub.sendText.calls.mostRecent().args; expect(args[0]).toBe('!room1:fmode.cn'); expect(args[1]).toBe('第二条'); expect(args[2]).toBe(svc.sessionId()!); expect(args[3]).toBeUndefined(); expect(args[4]).toEqual({ 'com.fmode.local': jasmine.any(String) }); }); it('发送后清空草稿', async () => { svc.setDraft('待发'); await svc.sendText('待发'); expect(svc.draft()).toBe(''); }); /* * 草稿按会话隔离(2026-11-14 修复)。 * * 🔴 修复前的真实症状不是「丢草稿」,而是**串台**: * 草稿是单个全局 signal,在 A 会话打了一半,切到 B 会话那半句话原样出现, * 继续发就会发错人。`open()` 里的 `set('')` 又让它表现为「丢字」。 * 两个症状交替出现,用户体感是「有时候丢、有时候串」。 */ it('🔴 切到另一条会话时,看不到上一条会话的草稿', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); const a = await svc.startBlank('agent-node-lj-test', 'ws-test'); svc.setDraft('这是 A 会话没写完的话'); const b = await svc.startBlank('agent-node-lj-test', 'ws-test'); expect(a!.id).not.toBe(b!.id); expect(svc.draft()) .withContext('B 会话不能出现 A 的草稿') .toBe(''); }); it('🔴 切回原会话时,草稿还在', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); const a = await svc.startBlank('agent-node-lj-test', 'ws-test'); svc.setDraft('A 的半句话'); await svc.startBlank('agent-node-lj-test', 'ws-test'); await svc.open('agent-node-lj-test', a!.id); expect(svc.draft()).withContext('切回来应恢复').toBe('A 的半句话'); }); it('两条会话的草稿互不覆盖', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); const a = await svc.startBlank('agent-node-lj-test', 'ws-test'); svc.setDraft('A 的话'); const b = await svc.startBlank('agent-node-lj-test', 'ws-test'); svc.setDraft('B 的话'); await svc.open('agent-node-lj-test', a!.id); expect(svc.draft()).toBe('A 的话'); await svc.open('agent-node-lj-test', b!.id); expect(svc.draft()).toBe('B 的话'); }); it('空文本不发送(也不插气泡)', async () => { const before = svc.messages().length; await svc.sendText(' '); expect(svc.messages().length).toBe(before); expect(mxStub.sendText).not.toHaveBeenCalled(); }); it('失败 → 留痕 failed 且带错误原因(不丢消息)', async () => { mxStub.sendText.and.returnValue(Promise.reject(new Error('网络错误'))); await svc.sendText('会失败'); const last = svc.messages().at(-1)!; expect(last.state).toBe('failed'); expect(last.error).toContain('网络错误'); }); it('retry 把 failed 消息重发并复位为 sent', async () => { mxStub.sendText.and.returnValue(Promise.reject(new Error('临时故障'))); await svc.sendText('重试我'); const failed = svc.messages().at(-1)!; expect(failed.state).toBe('failed'); mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$ok' })); await svc.retry(failed.id); const after = svc.messages().find((m) => m.id === failed.id)!; expect(after.state).toBe('sent'); expect(after.error).toBeUndefined(); }); it('非 failed 状态的消息 retry 不做事', async () => { await svc.sendText('已成功的'); const ok = svc.messages().at(-1)!; mxStub.sendText.calls.reset(); await svc.retry(ok.id); expect(mxStub.sendText).not.toHaveBeenCalled(); }); }); describe('paginate(AC-04.4 翻历史)', () => { beforeEach(async () => { realMode(); await svc.open('agent-node-lj-test'); }); it('当前会话内的消息计入', async () => { mxStub.timelineToMessages.and.returnValue( Array.from({ length: 5 }, (_, i) => ({ roomId: 'r', eventId: `$h${i}`, sender: '@zgdcmgnqcd:fmode.cn', // 必须带当前会话的 threadId —— 无 thread 的属于「历史对话」,不混入 threadId: svc.sessionId()!, body: `历史${i}`, ts: i, kind: 'text' as const, live: false, })), ); const grew = await svc.paginate(); expect(grew).toBeTrue(); expect(svc.messages().length).toBe(5); expect(svc.hasMoreHistory()).toBeTrue(); }); it('其它会话的消息被过滤,不混入当前会话', async () => { mxStub.timelineToMessages.and.returnValue( Array.from({ length: 5 }, (_, i) => ({ roomId: 'r', eventId: `$x${i}`, sender: '@zgdcmgnqcd:fmode.cn', threadId: '$approot_other_session:fmode.cn', body: `别的会话${i}`, ts: i, kind: 'text' as const, live: false, })), ); const grew = await svc.paginate(); expect(grew).toBeFalse(); // 条数没增长 expect(svc.messages().length).toBe(0); }); it('条数未增长 → hasMoreHistory=false(到最早了,停止请求)', async () => { mxStub.timelineToMessages.and.returnValue([]); const grew = await svc.paginate(); expect(grew).toBeFalse(); expect(svc.hasMoreHistory()).toBeFalse(); }); it('🔴 防重入:并发调用只触发一次 SDK 分页', async () => { /* * 🔴 调用计数必须从这个用例的基线算起(2026-11-12)。 * `open()` 现在也会按需回溯历史,上一句 `beforeEach` 里的 open * 可能已经调用过若干次 `paginateBack`;绝对计数会被累加污染。 */ const base = mxStub.paginateBack.calls.count(); let resolveIt: (v: boolean) => void = () => undefined; mxStub.paginateBack.and.callFake(() => new Promise((res) => (resolveIt = res))); const a = svc.paginate(); const b = svc.paginate(); // 立刻重入 resolveIt(true); await Promise.all([a, b]); expect(mxStub.paginateBack.calls.count() - base).toBe(1); }); it('paginating 在完成后复位', async () => { await svc.paginate(); expect(svc.paginating()).toBeFalse(); }); }); /* * 🔴 历史会话打开为空(2026-11-12 用户实测)。 * * 现象:「我的这些历史记录都无法查看了,大部分都没有正常显示。」 * 根因:sync 只保留房间最近 50 条,老会话的消息不在本地 timeline, * 而打开会话时**从不主动向前翻**,于是渲染成「全新会话」欢迎页。 */ describe('打开历史会话时按需回溯 timeline', () => { const SID = '$approot_test:fmode.cn'; /** 构造一条属于该会话的消息 */ const msgOf = (id: string): MxMessage => ({ roomId: '!room1:fmode.cn', eventId: id, sender: '@zgdcmgnqcd:fmode.cn', threadId: SID, body: '历史内容', ts: 1, kind: 'text' as const, live: false, }) as MxMessage; afterEach(() => { mxStub.timelineToMessages.and.returnValue([]); mxStub.paginationToken.and.returnValue('tok-b'); }); it('本地没有该会话的消息 → 向前回溯并命中', async () => { realMode(); // 第一轮:只有别的会话;回溯一次后:出现本会话 let calls = 0; mxStub.timelineToMessages.and.callFake(() => calls === 0 ? [] : [msgOf('$h1'), msgOf('$h2')], ); mxStub.paginateBack.and.callFake(() => { calls++; return Promise.resolve(true); }); await svc.open('agent-node-lj-test', SID); expect(mxStub.paginateBack).toHaveBeenCalled(); expect(svc.messages().length).toBeGreaterThan(0); expect(svc.emptyReason()).toBeNull(); }); it('命中即停:不把整个房间翻完', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([msgOf('$h1')]); await svc.open('agent-node-lj-test', SID); expect(mxStub.paginateBack).not.toHaveBeenCalled(); }); it('页面已到房间最早(无 token)→ 不回溯', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); mxStub.paginationToken.and.returnValue(null); await svc.open('agent-node-lj-test', SID); expect(mxStub.paginateBack).not.toHaveBeenCalled(); }); it('🔥 回溯耗尽仍取不到 → emptyReason=unloaded,不得伪装成新会话', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); // 永远取不到 mxStub.paginateBack.and.returnValue(Promise.resolve(true)); await svc.open('agent-node-lj-test', SID); /* * 断言「**有上限**」而不是写死具体轮数(2026-11-12): * 上限会随房间规模调整(当前 50 轮,因 lj-test 房间已超 2100 个事件)。 * 这里守住真正的不变量:确实尝试过、且**一定会停**。 */ const n = mxStub.paginateBack.calls.count(); expect(n).toBeGreaterThan(0); expect(n).toBeLessThanOrEqual(100); /* * 房间**没翻到最早**(`paginationToken` 仍返回 token)→ 不能断定「这条会话没有消息」, * 只能诚实说「暂时取不到」。 */ expect(svc.emptyReason()).toBe('unloaded'); }); it('翻到房间最早 + 目录里有记录 → true empty(fresh),不吓唬用户', async () => { realMode(); mxStub.timelineToMessages.and.returnValue([]); // 一轮就翻到顶:翻完 token 变 null mxStub.paginateBack.and.callFake(() => { mxStub.paginationToken.and.returnValue(null); return Promise.resolve(true); }); await svc.open('agent-node-lj-test', SID); /* * 🔴 已翻到房间最早 + 目录里有这条 + 0 条消息 = **空壳会话**(2026-11-12)。 * 不能报 `fresh`(会被渲染成「全新会话」欢迎语,诱导用户以为内容丢了), * 也不能报 `unloaded`(会让用户一直等「暂时取不到」)。 * 实测样本:「测试9680」在 Matrix 里确实一条消息都没有。 */ expect(svc.emptyReason()).toBe('blank'); }); }); describe('setDraft 触发 typing 通知', () => { it('有内容 → typing=true,清空 → typing=false', async () => { realMode(); await svc.open('a'); svc.setDraft('在输入'); expect(mxStub.setTyping).toHaveBeenCalledWith('!room1:fmode.cn', true); svc.setDraft(''); expect(mxStub.setTyping).toHaveBeenCalledWith('!room1:fmode.cn', false); }); }); /* * 2026-11-13 评审 S4:`'url'` 模式下用户发的附件事件**没有正文** * (body 就是文件名或空)。空正文绝不能掉进「从正文提取链接」分支, * 否则气泡里会明文显示整条云盘地址 —— 用户明确要求不能出现。 */ describe('附件事件的回读(不泄漏云盘地址)', () => { const mxFile = (body: string, name: string, url: string): MxMessage => ({ roomId: '!room1:fmode.cn', eventId: '$f1', sender: '@me:fmode.cn', body, ts: Date.now(), kind: 'text' as const, live: false, sessionId: 's1', threadId: 'SID', media: { name, url, mimeType: 'application/pdf', size: 10 }, }) as MxMessage; const cloud = 'https://s3.fmode.cn/user/u1/chat/202611/x-方案.pdf'; it('🔴 body 为空 + 有附件 → 正文为空,不把地址渲染成文字', async () => { realMode(); await svc.open('agent-node-lj-test'); const sid = svc.sessionId()!; (svc as unknown as { appendIncoming: (m: MxMessage, me: string) => void }).appendIncoming( { ...mxFile('', '方案.pdf', cloud), threadId: sid, sessionId: sid }, '@me:fmode.cn', ); const f = svc.messages().find((m) => m.file) ?? svc.messages().at(-1); expect(f).withContext('附件卡片必须保留').toBeTruthy(); expect(f!.text).withContext('正文不得变成云盘地址').toBeUndefined(); expect(f!.file!.url).toBe(cloud); }); it('body 就是文件名 → 同样不当作正文', async () => { realMode(); await svc.open('agent-node-lj-test'); const sid = svc.sessionId()!; (svc as unknown as { appendIncoming: (m: MxMessage, me: string) => void }).appendIncoming( { ...mxFile('方案.pdf', '方案.pdf', cloud), threadId: sid, sessionId: sid }, '@me:fmode.cn', ); const f = svc.messages().find((m) => m.file); expect(f!.text).toBeUndefined(); }); }); /* * 2026-11-13 用户实测:发 60MB 视频后,容器回了一句 * 「⚠️ Couldn't deliver the video attachment.」 * * 来源是容器 `matrix/adapter.py:1832` —— 它试图用 **Matrix 回发文件本体** 失败。 * 按产品要求容器只该给云盘链接,所以这条提示对用户是纯噪声,必须滤掉。 */ describe('容器附件投递失败提示(噪声过滤)', () => { it('识别英文兜底文案(含图片/视频/文件各种 kind)', () => { expect(isMediaDeliveryFailure("⚠️ Couldn't deliver the video attachment.")).toBeTrue(); expect(isMediaDeliveryFailure("⚠️ Couldn't deliver the image attachment.")).toBeTrue(); expect(isMediaDeliveryFailure("⚠️ Couldn't deliver the file attachment.")).toBeTrue(); expect(isMediaDeliveryFailure("Couldn't deliver the video attachment.")).toBeTrue(); }); it('正常回复不受影响(不做模糊匹配,避免误吞)', () => { expect(isMediaDeliveryFailure('文件已上云,链接如下')).toBeFalse(); expect(isMediaDeliveryFailure('这个视频有 60MB')).toBeFalse(); expect(isMediaDeliveryFailure('')).toBeFalse(); expect(isMediaDeliveryFailure(undefined)).toBeFalse(); }); it('🔴 实时流:这条消息不进消息列表', () => { realMode(); expect( (svc as unknown as { appendIncoming: (m: MxMessage, me: string) => void }).appendIncoming, ).toBeTruthy(); }); }); describe('待发附件按会话隔离', () => { const firstId = CLOUD_THREAD.threadRoot; const secondId = '$approot_other:fmode.cn'; const image = (name: string) => new File(['image'], name, { type: 'image/png' }); function deferred() { let resolve!: (value: Value) => void; let reject!: (reason: Error) => void; const promise = new Promise((resolvePromise, rejectPromise) => { resolve = resolvePromise; reject = rejectPromise; }); return { promise, resolve, reject }; } function holdUpload() { const started = deferred(); const result = deferred<{ key: string; publicUrl: string }>(); let reportProgress: ((pct: number) => void) | undefined; apiStub.uploadFile.and.callFake((_file: File, onProgress?: (pct: number) => void) => { reportProgress = onProgress; started.resolve(); return result.promise; }); return { started: started.promise, result, progress: (pct: number) => reportProgress?.(pct) }; } it('同一图文批次连续提交只上传并发送一次', async () => { const upload = holdUpload(); svc.stageFiles([image('double.png')]); const first = svc.sendText('附件回归'); const duplicate = svc.sendText('附件回归'); await upload.started; await duplicate; expect(apiStub.uploadFile.calls.count()).toBe(1); expect(svc.messages().filter((message) => message.text === '附件回归').length).toBe(1); upload.result.resolve({ key: 'double', publicUrl: 'https://s3.fmode.cn/double' }); await first; expect(mxStub.sendFileByUrl.calls.count()).toBe(1); expect(mxStub.sendText.calls.count()).toBe(1); }); it('新建会话迁移附件桶期间重复提交仍只发送一次', async () => { const upload = holdUpload(); (svc as unknown as { _sessionId: { set(value: null): void } })._sessionId.set(null); svc.stageFiles([image('new-double.png')]); const first = svc.sendText('新建图文'); const duplicate = svc.sendText('新建图文'); await upload.started; await duplicate; expect(apiStub.uploadFile.calls.count()).toBe(1); upload.result.resolve({ key: 'new-double', publicUrl: 'https://s3.fmode.cn/new-double' }); await first; expect(mxStub.sendFileByUrl.calls.count()).toBe(1); expect(mxStub.sendText.calls.count()).toBe(1); }); beforeEach(async () => { realMode(); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([ CLOUD_THREAD, { ...CLOUD_THREAD, objectId: 'cloud2', threadRoot: secondId, roomId: '!room2:fmode.cn' }, ])); apiStub.registerFile.and.returnValue(Promise.resolve({ id: 'f1' })); mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$fu' })); await svc.open(AGENT.id, firstId); }); it('A → B → A 只展示各自附件,切换不释放预览', async () => { const revoke = spyOn(URL, 'revokeObjectURL'); svc.stageFiles([image('a.png')]); const first = svc.pendingFiles()[0]; await svc.open(AGENT.id, secondId); expect(svc.pendingFiles()).toEqual([]); svc.stageFiles([image('b.png')]); const second = svc.pendingFiles()[0]; await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()).toEqual([first]); await svc.open(AGENT.id, secondId); expect(svc.pendingFiles()).toEqual([second]); expect(revoke).not.toHaveBeenCalled(); }); it('unstageFile 和 clearPendingFiles 只操作当前会话并释放对应预览', async () => { const revoke = spyOn(URL, 'revokeObjectURL'); svc.stageFiles([image('a.png')]); const first = svc.pendingFiles()[0]; await svc.open(AGENT.id, secondId); svc.stageFiles([image('b.png')]); const second = svc.pendingFiles()[0]; svc.unstageFile(first.id); expect(svc.pendingFiles()).toEqual([second]); svc.clearPendingFiles(); expect(svc.pendingFiles()).toEqual([]); expect(revoke.calls.allArgs()).toEqual([[second.previewUrl!]]); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()).toEqual([first]); svc.unstageFile(first.id); expect(svc.pendingFiles()).toEqual([]); expect(revoke).toHaveBeenCalledWith(first.previewUrl!); }); for (const cleanup of ['close', 'resetForUserSwitch'] as const) { it(`${cleanup} 清理所有附件桶及预览,重新打开不恢复上个账号的附件`, async () => { const revoke = spyOn(URL, 'revokeObjectURL'); svc.stageFiles([image('a.png')]); const firstPreview = svc.pendingFiles()[0].previewUrl!; await svc.open(AGENT.id, secondId); svc.stageFiles([image('b.png')]); const secondPreview = svc.pendingFiles()[0].previewUrl!; svc[cleanup](); expect(svc.pendingFiles()).toEqual([]); expect(revoke).toHaveBeenCalledWith(firstPreview); expect(revoke).toHaveBeenCalledWith(secondPreview); expect(revoke.calls.count()).toBe(2); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()).toEqual([]); await svc.open(AGENT.id, secondId); expect(svc.pendingFiles()).toEqual([]); }); } for (const emptyId of [null, '']) { it(`新建态 sessionId=${JSON.stringify(emptyId)} 首次发送迁移附件桶`, async () => { const upload = holdUpload(); (svc as unknown as { _sessionId: { set(value: string | null): void } })._sessionId.set(emptyId); svc.stageFiles([image('new.png')]); const staged = svc.pendingFiles()[0]; const sending = svc.sendText(''); await upload.started; const createdId = svc.sessionId(); expect(createdId).toBeTruthy(); expect(svc.pendingFiles()[0].id).toBe(staged.id); expect(svc.pendingFiles()[0].previewUrl).toBe(staged.previewUrl); upload.result.resolve({ key: 'new', publicUrl: 'https://s3.fmode.cn/new' }); await sending; expect(svc.pendingFiles()).toEqual([]); expect(apiStub.registerFile).toHaveBeenCalledWith(jasmine.objectContaining({ threadRoot: createdId })); (svc as unknown as { _sessionId: { set(value: string | null): void } })._sessionId.set(emptyId); expect(svc.pendingFiles()).toEqual([]); }); } it('startBlank 为新建态分配真实会话标识时保留附件', async () => { (svc as unknown as { _sessionId: { set(value: null): void } })._sessionId.set(null); svc.stageFiles([image('new.png')]); const staged = svc.pendingFiles()[0]; const created = await svc.startBlank(AGENT.id); expect(created).toBeTruthy(); expect(svc.sessionId()).toBe(created!.id); expect(svc.pendingFiles()).toEqual([staged]); }); it('重建已被清掉目录的会话时迁移附件', () => { svc.stageFiles([image('orphan.png')]); const staged = svc.pendingFiles()[0]; svc.sessions.reset(); const recreated = (svc as unknown as { ensureSessionForSend(): { id: string } }).ensureSessionForSend(); expect(recreated.id).not.toBe(firstId); expect(svc.sessionId()).toBe(recreated.id); expect(svc.pendingFiles()).toEqual([staged]); }); it('上传跨切换:进度、上云缓存和成功清理绑定 A 桶,台账及事件仍发往 A', async () => { const upload = holdUpload(); const matrixStarted = deferred(); const matrixResult = deferred<{ event_id: string }>(); mxStub.sendFileByUrl.and.callFake(() => { matrixStarted.resolve(); return matrixResult.promise; }); const firstRoom = svc.currentRoomId(); svc.stageFiles([image('a.png')]); const sending = svc.sendText(''); await upload.started; await svc.open(AGENT.id, secondId); svc.stageFiles([image('b.png')]); const second = svc.pendingFiles()[0]; upload.progress(37); expect(svc.pendingFiles()).toEqual([second]); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()[0].progress?.pct).toBe(37); await svc.open(AGENT.id, secondId); upload.result.resolve({ key: 'a', publicUrl: 'https://s3.fmode.cn/a' }); await matrixStarted.promise; expect(svc.pendingFiles()).toEqual([second]); expect(apiStub.registerFile).toHaveBeenCalledWith(jasmine.objectContaining({ threadRoot: firstId, roomId: firstRoom, agentId: AGENT.id, })); expect(mxStub.sendFileByUrl.calls.mostRecent().args[0]).toBe(firstRoom); expect(mxStub.sendFileByUrl.calls.mostRecent().args[3]).toBe(firstId); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()[0].uploaded).toEqual({ url: 'https://s3.fmode.cn/a', key: 'a', registered: true, }); await svc.open(AGENT.id, secondId); matrixResult.resolve({ event_id: '$a-file' }); await sending; expect(svc.pendingFiles()).toEqual([second]); expect(svc.messages().some((message) => message.file?.name === 'a.png')).toBeFalse(); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()).toEqual([]); }); it('上传失败跨切换:失败回滚清理 A 桶而不清空 B 附件', async () => { const upload = holdUpload(); svc.stageFiles([image('a.png')]); const sending = svc.sendText(''); await upload.started; await svc.open(AGENT.id, secondId); svc.stageFiles([image('b.png')]); const second = svc.pendingFiles()[0]; upload.result.reject(new Error('云盘不可用')); await sending; expect(svc.pendingFiles()).toEqual([second]); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()).toEqual([]); }); it('退出后的旧上传回调不能复活附件或继续登记、发送到新账号', async () => { const upload = holdUpload(); svc.stageFiles([image('a.png')]); const sending = svc.sendText(''); await upload.started; svc.resetForUserSwitch(); await svc.open(AGENT.id, secondId); svc.stageFiles([image('b.png')]); const second = svc.pendingFiles()[0]; upload.progress(80); upload.result.resolve({ key: 'a', publicUrl: 'https://s3.fmode.cn/a' }); await sending; expect(svc.pendingFiles()).toEqual([second]); expect(apiStub.registerFile).not.toHaveBeenCalled(); expect(mxStub.sendFileByUrl).not.toHaveBeenCalled(); await svc.open(AGENT.id, firstId); expect(svc.pendingFiles()).toEqual([]); }); }); describe('附件暂存 → 发送时上传(AC-04.3)', () => { const file = (name = 'doc.txt') => new File(['x'], name, { type: 'text/plain' }); it('stageFiles 只暂存,**不上传、不发消息**', async () => { realMode(); await svc.open('agent-node-lj-test'); apiStub.uploadFile.calls.reset(); mxStub.sendText.calls.reset(); svc.stageFiles([file()]); expect(svc.pendingFiles().length).toBe(1); expect(apiStub.uploadFile).not.toHaveBeenCalled(); expect(mxStub.sendText).not.toHaveBeenCalled(); }); it('可以移除暂存附件', async () => { realMode(); await svc.open('agent-node-lj-test'); svc.stageFiles([file()]); const id = svc.pendingFiles()[0].id; svc.unstageFile(id); expect(svc.pendingFiles()).toEqual([]); }); it('发送时上传附件(走 Matrix 原生事件)+ 本地先插文件气泡', async () => { realMode(); await svc.open('agent-node-lj-test'); // 2026-11-10:改为「先上云、再发 Matrix」,云盘是发送的前置条件 apiStub.uploadFile.and.returnValue( Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }), ); svc.stageFiles([file()]); await svc.sendText('看看这个'); /* * 本地先插一条文件气泡(用户裁决 2026-11-11:立即可见)—— * 回读的 `m.image` 会再落一条,靠回合聚合的 `USER_MERGE_MS` 并成同一回合, * 见 turn-aggregator 的「带附件的 me 消息并入上一回合」用例。 */ expect(svc.messages().some((m) => m.id.startsWith('local-file-'))).toBeTrue(); // 走 Matrix 原生附件,不再依赖 OBS 预签名地址 expect(mxStub.sendFileByUrl).toHaveBeenCalled(); expect(mxStub.sendFile) .withContext('不再把文件本体传进 Matrix') .not.toHaveBeenCalled(); expect(svc.uploading()).toBeFalse(); // 上传成功后暂存清空 expect(svc.pendingFiles()).toEqual([]); }); // 🔴 原实现只更新本地消息、从不发到房间 —— 容器永远收不到 it('🔴 附件必须以 Matrix 原生事件真的发到房间(sendFileByUrl)', async () => { realMode(); await svc.open('agent-node-lj-test'); apiStub.uploadFile.and.returnValue( Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }), ); mxStub.sendFileByUrl.calls.reset(); mxStub.sendFile.calls.reset(); svc.stageFiles([file()]); await svc.sendText('附上'); expect(mxStub.sendFileByUrl).toHaveBeenCalled(); // 事件里的地址必须是云盘链接,且**不得**触发 Matrix 媒体上传 expect(mxStub.sendFileByUrl.calls.mostRecent().args[1]).toBe('https://s3.fmode.cn/k'); expect(mxStub.sendFile).not.toHaveBeenCalled(); }); /* * 2026-11-13 用户反馈「右栏文件里看不到我发的文件」。 * * 根因:登记语句包在 `if (sid && ...)` 里 —— 进入容器但还没建会话时发附件, * 上传与发送都成功,但台账没登记,`listBySession` 查不到 → 右栏为空。 * 修法:`sid` 为空时先 `ensureSessionForSend()` 兜底,仍要登记。 */ it('🔴 无会话时发附件也必须登记台账(右栏才看得到)', async () => { realMode(); await svc.open('agent-node-lj-test'); apiStub.uploadFile.and.returnValue( Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }), ); apiStub.registerFile.calls.reset(); /* 模拟「进入容器但未建会话」:清空会话指针 */ (svc as unknown as { _sessionId: { set: (v: null) => void } })._sessionId.set(null); svc.stageFiles([file()]); await svc.sendText('附上'); const calls = apiStub.registerFile.calls.allArgs(); const mine = calls.filter((c: unknown[]) => (c[0] as { uploadedBy?: string }).uploadedBy === 'user'); expect(mine.length) .withContext('用户附件必须登记台账,且 threadRoot 不能为空') .toBeGreaterThan(0); expect((mine[0][0] as { threadRoot?: string }).threadRoot) .withContext('threadRoot 必须有值,否则 listBySession 查不到') .toBeTruthy(); }); it('上传失败 → 记录错误、回滚消息、清空附件(2026-11-14 裁决)', async () => { realMode(); await svc.open('agent-node-lj-test'); mxStub.sendFileByUrl.and.returnValue(Promise.reject(new Error('上传失败'))); try { svc.stageFiles([file()]); await svc.sendText('附上'); expect(svc.error()).toContain('失败'); expect(svc.uploading()).toBeFalse(); /* * 🔴 用户裁决:「失败给出提示,并且撤回输出以及回复,清空会话页面」。 * 原行为是保留附件待重试 —— 但附件上传已经失败,留着只会让人再点一次。 */ expect(svc.pendingFiles().length).withContext('失败后清空附件').toBe(0); expect(svc.messages().filter((m) => m.sender === 'me').length) .withContext('未发出的话不能留在消息流里') .toBe(0); expect(svc.draft()).withContext('文字还回草稿').toBe('附上'); } finally { // 还原桩:jasmine 的 spy 返回值是跨用例共享的 mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$fu' })); } }); /* * 2026-11-10:上云顺序调整为「先 S3、再 Matrix」。 * 目的:不发出去「聊天记录里有、云盘里没有」的半成品文件。 */ it('🔴 云盘失败 → 不发 Matrix、整体回滚(2026-11-14 裁决)', async () => { realMode(); await svc.open('agent-node-lj-test'); apiStub.uploadFile.and.returnValue(Promise.reject(new Error('云盘不可用'))); mxStub.sendFileByUrl.calls.reset(); svc.stageFiles([file()]); await svc.sendText('附上'); expect(mxStub.sendFileByUrl).not.toHaveBeenCalled(); expect(svc.error()).toContain('云盘不可用'); /* S3 是唯一路径:失败就整体失败,不留半截状态 */ expect(svc.pendingFiles().length).withContext('失败后清空附件').toBe(0); expect(svc.messages().filter((m) => m.sender === 'me').length).toBe(0); }); it('🔴 顺序为先云盘后 Matrix(避免半成功)', async () => { realMode(); await svc.open('agent-node-lj-test'); const order: string[] = []; apiStub.uploadFile.and.callFake(() => { order.push('s3'); return Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }); }); mxStub.sendFileByUrl.and.callFake(() => { order.push('matrix'); return Promise.resolve(); }); svc.stageFiles([file()]); await svc.sendText('附上'); expect(order).toEqual(['s3', 'matrix']); }); /* 大小限制(2026-11-10):选文件时就拦,超限项不进暂存区 */ it('🔴 超过服务端上限的文件在 stageFiles 阶段被拒并提示', async () => { realMode(); await svc.open('agent-node-lj-test'); /* * 🔴 2026-11-13 用户裁决「上传的文件没有大小限制」:`'url'` 模式不拦截。 * 拦截逻辑本身仍在,这里用 `'mxc'` 回退模式验证它没被删掉。 */ try { const big = new File([new Uint8Array(8)], 'big.zip'); Object.defineProperty(big, 'size', { value: 900 * 1024 * 1024 }); svc.stageFiles([big]); expect(svc.pendingFiles().length).toBe(0); expect(svc.error()).toContain('超过平台单文件上限'); } finally { } }); it('🔴 200MB 以内放行(不再受 Matrix 32MB 限制)', async () => { realMode(); await svc.open('agent-node-lj-test'); setServerUploadLimit(null); const big = new File([new Uint8Array(8)], 'huge.zip'); Object.defineProperty(big, 'size', { value: 100 * 1024 * 1024 }); svc.stageFiles([big]); expect(svc.pendingFiles().length).toBe(1); }); it('未超限的文件正常进入暂存区', async () => { realMode(); await svc.open('agent-node-lj-test'); const ok = new File([new Uint8Array(8)], 'ok.txt'); Object.defineProperty(ok, 'size', { value: 20 * 1024 * 1024 }); svc.stageFiles([ok]); expect(svc.pendingFiles().length).toBe(1); }); it('多选时只挡掉超限的,合格的照常暂存', async () => { realMode(); await svc.open('agent-node-lj-test'); try { const small = file(); const big = new File([new Uint8Array(8)], 'big.zip'); Object.defineProperty(big, 'size', { value: 900 * 1024 * 1024 }); svc.stageFiles([small, big]); expect(svc.pendingFiles().length).toBe(1); expect(svc.pendingFiles()[0].file.name).toBe('doc.txt'); expect(svc.error()).toContain('big.zip'); } finally { } }); it('只有附件没有文字也能发送', async () => { realMode(); await svc.open('agent-node-lj-test'); apiStub.uploadFile.and.returnValue( Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }), ); mxStub.sendFile.calls.reset(); mxStub.sendText.calls.reset(); svc.stageFiles([file()]); await svc.sendText(''); // 纯附件:附件本身照常发到房间(本地不伪造文件消息) expect(mxStub.sendFileByUrl).toHaveBeenCalled(); // 纯附件不该发一条空文字 expect(mxStub.sendText).not.toHaveBeenCalled(); }); }); describe('进入会话即已读(清未读计数)', () => { it('open 成功后该 agent 未读归零', async () => { realMode(); const unread = TestBed.inject(UnreadService); // 先造出未读 unread.onIncoming('agent-node-lj-test', 1000, true); unread.onIncoming('agent-node-lj-test', 2000, false); expect(unread.countOf('agent-node-lj-test')).toBe(1); await svc.open('agent-node-lj-test'); expect(unread.countOf('agent-node-lj-test')).toBe(0); }); }); /** * 多会话(线程)隔离 —— 2026-10-28 新增。 * * 容器按 `room + thread` 划分会话(实测),App 侧必须: * ① 每条消息带上当前会话的线程根 * ② 只显示属于当前会话的消息 */ describe('多会话隔离', () => { const msg = (id: string, threadId?: string, body = 'x'): MxMessage => ({ roomId: '!room1:fmode.cn', eventId: id, sender: '@zgdcmgnqcd:fmode.cn', threadId, body, ts: Date.now(), kind: 'text', live: true, }); beforeEach(() => realMode()); it('首次打开**不**自动建空会话(2026-10-31 新语义)', async () => { apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); await svc.open('agent-node-lj-test'); expect(svc.sessionId()).toBe(''); expect(svc.state()).toBe('empty'); }); it('云端有会话时直接打开最近一条', async () => { await svc.open('agent-node-lj-test'); expect(svc.sessionId()).toBe(CLOUD_THREAD.threadRoot); expect(svc.currentSession()).toBeDefined(); }); /* * 🔴 回归(2026-11-06,渲染测试复现): * 刷新页面后先发消息,`_sessionId` 已指向线程根,但云端目录里还没有这条 * (刷新后目录回来得更晚)—— `currentSession()` 返回 undefined, * 聊天页据此隐藏页头、右栏和**整个输入区**,只剩一条告警。 */ it('🔴 会话目录里查不到当前会话时,currentSession 仍给出占位', async () => { await svc.open('agent-node-lj-test'); const sid = svc.sessionId(); // 模拟目录尚未包含这条(换设备 / 刚建还没落云) svc.sessions.reset(); await svc.sendText('刷新后第一条'); expect(svc.sessionId()).toBe(sid); expect(svc.currentSession()) .withContext('查不到也必须给出占位,否则输入区会消失') .toBeDefined(); expect(svc.currentSession()!.id).toBe(sid as string); expect(svc.currentSession()!.agentId).toBe('agent-node-lj-test'); }); it('会话目录里有当前会话时,用的是目录里的真身而不是占位', async () => { await svc.open('agent-node-lj-test'); const s = svc.currentSession(); expect(s!.title).toBe(CLOUD_THREAD.title); expect(svc.sessions.byId(CLOUD_THREAD.threadRoot)?.title).toBe(s!.title); }); it('再次打开同一 agent 复用同一会话(不会每次都新建)', async () => { await svc.open('agent-node-lj-test'); const first = svc.sessionId(); svc.close(); await svc.open('agent-node-lj-test'); expect(svc.sessionId()).toBe(first); }); it('新建会话后 sessionId 改变,且消息列表清空', async () => { await svc.open('agent-node-lj-test'); const first = svc.sessionId(); const sessions = svc.sessions; const created = sessions.create('!room1:fmode.cn', 'agent-node-lj-test'); await svc.open('agent-node-lj-test', created.id); expect(svc.sessionId()).toBe(created.id); expect(svc.sessionId()).not.toBe(first); }); it('实时消息只进入所属会话,不串线', async () => { await svc.open('agent-node-lj-test'); const mine = svc.sessionId()!; let sink: ((m: MxMessage) => void) | null = null; mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => { sink = cb; return () => undefined; }); svc.close(); await svc.open('agent-node-lj-test'); sink!(msg('$m1', mine, '我的会话')); sink!(msg('$m2', '$approot_someone_else:fmode.cn', '别人的会话')); sink!(msg('$m3', undefined, '无 thread 的历史')); const texts = svc.messages().map((m) => m.text); expect(texts).toContain('我的会话'); expect(texts).not.toContain('别人的会话'); /* * 🔴 2026-11-09 用户裁决变更:房间级消息(无 thread)**一律丢弃**。 * * 原规则(2026-11-03)把它们归入当前会话,当时是为了让「用户直接发的图」 * (m.image 不带 thread)能看见。但实测发现更大的问题: * 外部工具/脚本往房间发的消息没有 thread,会被**新建会话全部认领**, * 表现为「新建一个会话,上面立刻出现一堆不相干的历史」。 * * 用户明确裁决:宁可丢弃,也不要把别处的消息错认成本会话的。 * 代价:容器历史上无 thread 的旧回复不再显示 * (容器现已改为带 thread 回复,影响有限)。 */ expect(texts).not.toContain('无 thread 的历史'); }); /* * 🔴 容器自己开的子线程**属于当前会话**(2026-10-29 实测)。 * 容器回复时会另开 m.thread 跑内部任务,那些消息也是本次对话的一部分, * 交付物(html/截图)就在里面 —— 必须显示,否则内容丢失。 * * ## 2026-11-16 真机事故:第一版修复差点丢光容器回复 * * 第一版要求「本会话必须正在等回复」才放行未认领的线程根。 * 真机实测:容器的正常回复整段消失,会话里只剩用户消息。 * 因为容器回复挂在它自开的根下、而不在 ownedRoots 里。 * * 第二版改为只挡「会话长期闲置」的情况(`IDLE_GUARD_MS`), * 本条测试守护「活跃会话能正常收到容器产出」这个更重要的行为。 */ it('容器自开的子线程归入当前会话(本会话活跃时)', async () => { await svc.open('agent-node-lj-test'); let sink: ((m: MxMessage) => void) | null = null; mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => { sink = cb; return () => undefined; }); svc.close(); await svc.open('agent-node-lj-test'); // 会话刚打开(活跃),容器自开的线程根必须能进来 sink!(msg('$c1', '$kfv5cDP_ZR3jK4VK2WxWBCNBA:fmode.cn', '容器的子任务输出')); expect(svc.messages().map((m) => m.text)).toContain('容器的子任务输出'); }); /* * 🔴 跨会话携带修复(2026-11-16 用户实测反馈)。 * * 场景:用户在会话 A 发过消息,容器在 A 的线程根下产出文件; * 用户切到会话 B(B 已闲置很久)后,A 的线程根若还有事件**实时**到达, * 原规则(`!isAppSessionId` 无条件放行)会让 B 认领 —— * 表现为「前一个会话的文件出现在后一个会话里」。 * * 修复后:B 闲置超过 `IDLE_GUARD_MS` → 陌生根的消息不认领。 */ it('会话长期闲置时不认领陌生线程根的实时消息(跨会话不携带)', async () => { await svc.open('agent-node-lj-test'); let sink: ((m: MxMessage) => void) | null = null; mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => { sink = cb; return () => undefined; }); svc.close(); await svc.open('agent-node-lj-test'); /* * 造一条「一小时前」的旧消息,让本会话处于「长期闲置」状态。 * 空会话按设计不算闲置(容器可能还在跑上一轮的后台任务),所以必须真有消息。 */ const hourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString(); const self = svc as unknown as { _messages: { update: (fn: (list: any[]) => any[]) => void }; }; self._messages.update(() => [ { id: 'old-1', conversationId: 'agent-node-lj-test', sender: 'me', kind: 'text', text: '很久以前的消息', ts: hourAgo, state: 'sent', } as any, ]); sink!(msg('$x1', '$kfv5cDP_ZR3jK4VK2WxWBCNBA:fmode.cn', '别的会话的文件')); expect(svc.messages().map((m) => m.text)).not.toContain('别的会话的文件'); }); /* * 「历史对话」承接无 thread 旧消息的**完整链路验证在端到端** * (Playwright 真实浏览器 + 真实 Matrix 房间,2026-10-28 已通过: * 房间里 20 条无 thread 旧消息 → 自动出现「历史对话」并显示它们)。 * * 这里只做**否定断言**:没有旧消息时不得凭空多出一个「历史对话」。 * 不用 spy 驱动的正值用例 —— `timelineToMessages` 在 `openReal` 的 * 异步间隙会被 beforeEach 的桩覆盖,断言会变成测测试桩本身。 */ it('房间里没有旧消息时,不凭空建「历史对话」', async () => { mxStub.timelineToMessages.and.returnValue([]); await svc.open('agent-node-lj-test'); expect(svc.sessions.listFor('agent-node-lj-test').some((s) => s.legacy)).toBeFalse(); }); it('收到消息后会话预览与更新时间推进', async () => { await svc.open('agent-node-lj-test'); const sid = svc.sessionId()!; let sink: ((m: MxMessage) => void) | null = null; mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => { sink = cb; return () => undefined; }); svc.close(); await svc.open('agent-node-lj-test'); sink!(msg('$p1', sid, '这是一条预览内容')); const s = TestBed.inject(ChatSessionService).byId(sid)!; expect(s.lastPreview).toBe('这是一条预览内容'); expect(s.messageCount).toBeGreaterThan(0); }); }); }); /* * 新建会话的「空白保护」窗口(2026-11-08 用户实测:发一句「你好」仍带出历史)。 * * 根因是**清除时机**:`_blankSessionId` 曾在 commit(本地记账)时就清掉, * 而那时 `sendReal()` 的网络请求还在路上(约 1 秒)。此间 `/sync` 落地触发 * 历史回填,两道保护(新建态标记 + state==='empty')同时失效, * `rootsOfSession()` 把该房间所有旧容器子线程根都算成「本会话的」, * 于是旧对话被灌进新会话。 * * 这里断言的是**行为契约**:发送期间(网络请求未返回)绝不能解除新建态保护。 */ describe('ChatService · 新建会话期间不得回填历史(2026-11-08)', () => { let svc: ChatService; const apiStub = { provisionMatrix: jasmine.createSpy('provisionMatrix').and.returnValue( Promise.resolve({ accessToken: 'tok', userMxId: '@me:fmode.cn', deviceId: 'd1', agentMxId: '@agent:fmode.cn', roomId: '!room1:fmode.cn' }), ), fetchChatThreads: jasmine.createSpy('fetchChatThreads').and.returnValue(Promise.resolve([])), upsertChatThreads: jasmine.createSpy('upsertChatThreads').and.returnValue(Promise.resolve()), patchChatThread: jasmine.createSpy('patchChatThread').and.returnValue(Promise.resolve()), removeChatThread: jasmine.createSpy('removeChatThread').and.returnValue(Promise.resolve()), validateMatrix: jasmine.createSpy('validateMatrix').and.returnValue(Promise.resolve(true)), fetchAgents: jasmine.createSpy('fetchAgents').and.returnValue(Promise.resolve([])), }; const AGENT: Agent = { id: 'agent-node-lj-test', name: 'lj-test', status: 'online' as Agent['status'], matrixReady: true, unread: 0, }; const liveStub = { ensureLoaded: () => Promise.resolve(), agentById: () => AGENT, agents: () => [AGENT], state: () => 'ready', error: () => null, /** TaskPulseService 会调它做快照对比 */ tick: () => 0, }; /** 可以手动放行的 sendText —— 模拟「网络请求还没返回」 */ let releaseSend: () => void = () => undefined; const mxStub = { connectSession: () => Promise.resolve(), disconnect: () => undefined, ensureRoom: jasmine.createSpy('ensureRoom').and.returnValue(Promise.resolve('!room1:fmode.cn')), syncState: () => 'connected', hasInitialSync: true, paginationToken: () => null, timelineToMessages: jasmine.createSpy('timelineToMessages').and.returnValue([] as MxMessage[]), onMessage: jasmine.createSpy('onMessage').and.returnValue(() => undefined), onAnyMessage: jasmine.createSpy('onAnyMessage').and.returnValue(() => undefined), onTyping: jasmine.createSpy('onTyping').and.returnValue(() => undefined), setTyping: jasmine.createSpy('setTyping').and.returnValue(Promise.resolve()), sendText: jasmine.createSpy('sendText').and.callFake( () => new Promise<{ event_id?: string }>((res) => { releaseSend = () => res({ event_id: '$new' }); }), ), storeVersion: () => 0, timelineIndex: () => new Map(), /* 2026-11-12:openReal 现在会等初次 sync、并登记自愈用的 agentId */ synced: jasmine.createSpy('synced').and.returnValue(Promise.resolve(true)), setRecoveryAgentId: jasmine.createSpy('setRecoveryAgentId'), }; beforeEach(() => { TestBed.resetTestingModule(); localStorage.clear(); releaseSend = () => undefined; (environment as { useMockData: boolean }).useMockData = false; TestBed.configureTestingModule({ providers: [ ChatService, { provide: FmodeApi, useValue: apiStub }, { provide: LiveService, useValue: liveStub }, { provide: MatrixClientService, useValue: mxStub }, { provide: SessionService, useValue: { me: () => ({ id: 'u1' }), token: () => 'tok' } }, ], }); svc = TestBed.inject(ChatService); }); it('🔴 发送请求未返回前,实时消息不得混入新会话', async () => { await svc.open('agent-node-lj-test'); const created = await svc.startBlank('agent-node-lj-test'); expect(created).withContext('startBlank 应建出会话,实际为 null').toBeTruthy(); const sid = created!.id; // 开始发送,但请求挂起(网络还没返回) const pending = svc.sendText('你好'); /* * 🔴 2026-11-09:首次发消息会先 `await commitNow()`(落库), * 多了一轮微任务。只 `await Promise.resolve()` 一次,此刻还停在 * 落库阶段,`sendText` 根本没走到发送。 * 这里连推几轮,确保已经进入「发送请求挂起」的状态。 */ for (let k = 0; k < 5; k++) await Promise.resolve(); await new Promise((r) => setTimeout(r, 0)); // 此刻新会话里应该只有用户自己那条乐观消息 const during = svc.messages(); expect(during.length).withContext('发送期间只应有本地乐观消息').toBe(1); releaseSend(); await pending; /* * 🔴 原来这里只 await 不检查 —— 而「发送成功之后」才是问题真正爆发的地方(2026-11-09)。 * 用户实测:发一条「你好」,`messages()` 返回 3 条。 */ expect(svc.messages().filter((m) => m.sender === 'me').length) .withContext('发送完成后仍应恰好 1 条') .toBe(1); }); it('相同文字请求未完成前不重复提交,完成后允许再次发送', async () => { await svc.open('agent-node-lj-test'); mxStub.sendText.calls.reset(); const first = svc.sendText('收到'); await svc.sendText(' 收到 '); for (let iteration = 0; iteration < 8; iteration++) await Promise.resolve(); await new Promise((resolve) => setTimeout(resolve, 0)); expect(mxStub.sendText.calls.count()).toBe(1); expect(svc.messages().filter((message) => message.sender === 'me').length).toBe(1); releaseSend(); await first; mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$again' })); await svc.sendText('收到'); expect(mxStub.sendText.calls.count()).toBe(2); }); it('发送失败释放重复提交保护,允许重新发送相同文字', async () => { await svc.open('agent-node-lj-test'); mxStub.sendText.calls.reset(); mxStub.sendText.and.returnValue(Promise.reject(new Error('离线'))); await svc.sendText('重试相同文字'); mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$retry' })); await svc.sendText('重试相同文字'); expect(mxStub.sendText.calls.count()).toBe(2); }); /* * 🔴 乐观消息 ↔ 服务端 echo 去重(2026-11-09)。 * * 病根:乐观消息 id 是 `local-*`,echo id 是 `$eventId`,按 id 做并集永远对不上, * 于是同一条消息「本地一条 + 回读一条」并存。现在靠 content 里的 * `com.fmode.local` 认领。这些用例守住这条链路。 */ describe('🔴 乐观消息与 echo 去重', () => { /** 取 openReal 注册的实时回调 —— 直接走生产链路(appendIncoming),不硬造信号 */ function emitter(): (m: MxMessage) => void { const calls = mxStub.onMessage.calls.allArgs(); return calls[calls.length - 1][1] as (m: MxMessage) => void; } it('echo 带回同一个 localId → 只留服务端那条,不重复', async () => { await svc.open('agent-node-lj-test'); const pending = svc.sendText('你好'); /* * 🔴 2026-11-09:首次发消息会先 `await commitNow()`(落库), * 比原来多了一轮 await。必须连推几轮微任务,确保乐观消息已插入、 * 且发送已进入「等待 sendText 返回」的状态,否则下面 `releaseSend()` * 时 `sendText` 还没被调用,Promise 永远挂着(超时)。 */ for (let k = 0; k < 5; k++) await Promise.resolve(); await new Promise((r) => setTimeout(r, 0)); const localId = svc.messages()[0].localId!; expect(localId).toBeTruthy(); releaseSend(); await pending; expect(svc.messages().filter((m) => m.sender === 'me').length).toBe(1); // 服务端 echo 实时到达:id 是 eventId,但带回 localId emitter()({ roomId: '!room1:fmode.cn', eventId: '$e1', sender: '@me:fmode.cn', body: '你好', ts: Date.now(), kind: 'text', live: true, localId, threadId: svc.sessionId() ?? undefined, }); const mine = svc.messages().filter((m) => m.sender === 'me'); expect(mine.length).withContext('echo 认领后应恰好 1 条').toBe(1); expect(mine[0].id).toBe('$e1'); }); it('🔴 连点两次发送 → 两条都真正发出(2026-11-14 起不再拦截)', async () => { /* * 用户裁决(2026-11-14):**永远不拦,直接发**。 * * 原行为是连点第二条进待发区(持有条),用户实测「容器已经结束返回了, * 再发一条还是进等待状态」,认为拦截带来的困扰大于打断代价。 * 现在两条都必须真正发出。 */ await svc.open('agent-node-lj-test'); mxStub.sendText.and.callFake( () => new Promise<{ event_id?: string }>((res) => setTimeout(() => res({ event_id: '$x' }), 0)), ); await Promise.all([svc.sendText('第一条'), svc.sendText('第二条')]); const mine = svc.messages().filter((m) => m.sender === 'me'); expect(mine.length).withContext('两条都要真正发出').toBe(2); }); it('🔴 本会话在跑时发送不被拦截(2026-11-14 用户裁决)', async () => { /* * `open()` 必须在塞入「已发出未回复」标记**之前**完成: * 它会复位该标记,放在后面会把前置条件冲掉。 */ await svc.open('agent-node-lj-test'); /* * 制造「本会话正在跑」:`_awaitingReplySince` 非 0 时 `sessionBusy()` 为真。 * 这正是用户实测的场景 —— 上一轮的忙判还没消退,新消息被吞进持有条。 */ (svc as unknown as { _awaitingReplySince: { set(v: number): void } })._awaitingReplySince.set( Date.now(), ); expect(svc.sessionBusy()).withContext('前置:判忙').toBeTrue(); /* 本组的 sendText 桩是「挂了不 resolve」的,且首发要先 await 落库(见上一条用例), 所以必须显式放开、并给足微任务轮次,否则 await 卡死超时 */ const p = svc.sendText('打断它'); for (let k = 0; k < 5; k++) await Promise.resolve(); await new Promise((r) => setTimeout(r, 0)); releaseSend(); await p; const mine = svc.messages().filter((m) => m.sender === 'me'); expect(mine.map((m) => m.text)).withContext('忙时发送也要直接发出').toContain('打断它'); }); it('失败消息在实时流到达后仍保留(可重试,AC-04.8)', async () => { await svc.open('agent-node-lj-test'); mxStub.sendText.and.returnValue(Promise.reject(new Error('网络断了'))); await svc.sendText('会失败'); const failed = svc.messages().filter((m) => m.state === 'failed'); expect(failed.length).toBe(1); // 容器回复到达,不能把失败消息冲掉 emitter()({ roomId: '!room1:fmode.cn', eventId: '$r1', sender: '@agent:fmode.cn', body: '收到', ts: Date.now(), kind: 'text', live: true, threadId: svc.sessionId() ?? undefined, }); expect(svc.messages().filter((m) => m.state === 'failed').length).toBe(1); }); /* * 🔴 2026-11-09 评审 B3:合并时不分会话 → 切会话后旧会话的乐观消息残留。 */ it('🔴 新建会话后,上一条会话的发送中消息不会残留', async () => { await svc.open('agent-node-lj-test'); // 第一条:挂起不返回(发送中) void svc.sendText('上一条会话的消息'); await Promise.resolve(); expect(svc.messages().filter((m) => m.state === 'sending').length).toBe(1); // 新建会话 —— 应当干净 await svc.startBlank('agent-node-lj-test'); expect(svc.messages().length).withContext('新建会话必须空白').toBe(0); }); }); /* * 打断拦截的**时机**(2026-11-13 用户实测反馈)。 * * 用户原话:「发了一个消息之后**立刻发新的消息不会**拦住」 * (任务运行中发消息是能拦住的)。 * * 根因:`_turnEndedAfter`(上一轮的 ✅)只在切换/新建会话时重置, * 发消息时不重置 → `resolveSessionPhase` 里 `turnEnded` 一票否决 * → `busy = false` → 新消息不拦截,直接发出去打断容器。 */ describe('打断拦截时机', () => { it('🔴 发出新消息后清掉上一轮的结束信号', async () => { (environment as { useMockData: boolean }).useMockData = false; mxStub.timelineToMessages.and.returnValue([]); apiStub.fetchChatThreads.and.returnValue(Promise.resolve([])); await svc.open('agent-node-lj-test'); /* 模拟上一轮已收到 ✅ */ (svc as unknown as { _turnEndedAfter: { set(v: string | null): void } })._turnEndedAfter.set( '$last-agent-msg', ); expect(svc.turnSettledLocally()).withContext('前置:上一轮已结束').toBeTrue(); /* * 2026-11-14:发送不再拦截,「不 await 以免挂起」的顾虑已不成立, * 但仍然只验证发出的同步副作用。 */ void svc.sendText('新的一句话'); await Promise.resolve(); expect(svc.turnEndedAfter()) .withContext('发出新消息后旧的结束信号必须清掉,否则会误判为空闲') .toBeNull(); expect(svc.turnSettledLocally()).toBeFalse(); }); }); /* * 「持有条自动清除」用例已随持有条机制一并删除(2026-11-14 用户裁决「永远不拦」)。 * 相关验证见上方「本会话在跑时发送不被拦截」。 */ }); /** * 附件事件的 body 是文件名(Matrix 协议),不能当正文再显示一遍。 * 2026-11-10 实测截图:发一个文件后界面出现「卡片 + 同名纯文字」两条。 */ describe('isAttachmentEcho —— 附件 body 判定', () => { it('body 等于文件名 → 视为回声,不显示正文', () => { expect(isAttachmentEcho('report.md', 'report.md')).toBeTrue(); }); it('前后空白也认', () => { expect(isAttachmentEcho(' report.md \n', 'report.md')).toBeTrue(); }); it('body 有额外说明 → 保留正文(容器常在附件同一条里写说明)', () => { expect(isAttachmentEcho('这是本周的周报,请查收', 'report.md')).toBeFalse(); }); it('空 body 不当回声(交给上层按 undefined 处理)', () => { expect(isAttachmentEcho('', 'report.md')).toBeFalse(); expect(isAttachmentEcho(undefined, 'report.md')).toBeFalse(); }); });