chat.service.spec.ts 91 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196
  1. import { TestBed } from '@angular/core/testing';
  2. import { ChatService, isAttachmentEcho, isMediaDeliveryFailure } from './chat.service';
  3. import { setServerUploadLimit } from './upload-limits';
  4. import { FmodeApi } from './api/fmode-api';
  5. import { LiveService } from './live.service';
  6. import { MatrixClientService, MxMessage } from './matrix-client.service';
  7. import { SessionService } from './session.service';
  8. import { UnreadService } from './unread.service';
  9. import { ChatSessionService } from './chat-session.service';
  10. import { Agent, MatrixProvision } from './api/models';
  11. import { environment } from '../../environments/environment';
  12. /**
  13. * ChatService 单测 —— 会话状态机(SPEC FR-04)
  14. *
  15. * 覆盖:provision → 连接 → 房间 → 收发 → 分页 的编排与失败分环节报错。
  16. * 依赖(FmodeApi / LiveService / MatrixClientService)全部用桩替换,
  17. * **不触网、不加载 matrix-js-sdk**。
  18. *
  19. * 🔴 重点回归:
  20. * ① 切会话时 `seq` 防串扰(过期回包必须被丢弃)
  21. * ② `close()` **不断开**会话级连接(未读依赖 sync 常驻)
  22. * ③ 失败时**分环节**报错(FMODE 开通 / Matrix 登录 / 房间创建)
  23. * ④ `paginate()` 防重入(滚动事件高频触发)
  24. */
  25. describe('ChatService', () => {
  26. let svc: ChatService;
  27. /** 桩:FmodeApi */
  28. /**
  29. * 云端会话目录桩(2026-10-31):会话列表以云端为唯一来源。
  30. * 默认返回一条已有会话,模拟「进入一个聊过的容器」。
  31. */
  32. const CLOUD_THREAD = {
  33. objectId: 'cloud1',
  34. agentId: 'agent-node-lj-test',
  35. roomId: '!room1:fmode.cn',
  36. threadRoot: '$approot_test:fmode.cn',
  37. title: '云端会话',
  38. titleLocked: false,
  39. messageCount: 1,
  40. lastMessageAt: Date.now(),
  41. archived: false,
  42. lastPreview: '',
  43. };
  44. const apiStub = {
  45. provisionMatrix: jasmine.createSpy('provisionMatrix'),
  46. fetchChatThreads: jasmine.createSpy('fetchChatThreads'),
  47. upsertChatThreads: jasmine.createSpy('upsertChatThreads'),
  48. patchChatThread: jasmine.createSpy('patchChatThread'),
  49. removeChatThread: jasmine.createSpy('removeChatThread'),
  50. validateMatrix: jasmine.createSpy('validateMatrix'),
  51. fetchAgents: jasmine.createSpy('fetchAgents'),
  52. uploadFile: jasmine.createSpy('uploadFile'),
  53. requestUploadUrl: jasmine.createSpy('requestUploadUrl'),
  54. /* 文件台账登记(2026-11-13:右栏按 threadRoot 查台账,需断言) */
  55. registerFile: jasmine.createSpy('registerFile').and.returnValue(Promise.resolve({ id: 'f1' })),
  56. };
  57. /** 桩:LiveService */
  58. const liveStub = {
  59. ensureLoaded: jasmine.createSpy('ensureLoaded').and.returnValue(Promise.resolve()),
  60. agentById: jasmine.createSpy('agentById'),
  61. agents: jasmine.createSpy('agents').and.returnValue([] as Agent[]),
  62. /** 加载状态(chat.open 用它区分「加载中」与「确实不存在」) */
  63. state: jasmine.createSpy('state').and.returnValue('ready'),
  64. error: jasmine.createSpy('error').and.returnValue(null),
  65. };
  66. /** 桩:MatrixClientService */
  67. const mxStub = {
  68. connectSession: jasmine.createSpy('connectSession').and.returnValue(Promise.resolve()),
  69. disconnect: jasmine.createSpy('disconnect'),
  70. ensureRoom: jasmine.createSpy('ensureRoom'),
  71. syncState: jasmine.createSpy('syncState').and.returnValue('connected'),
  72. hasInitialSync: true,
  73. paginationToken: jasmine.createSpy('paginationToken').and.returnValue('tok-b'),
  74. timelineToMessages: jasmine.createSpy('timelineToMessages').and.returnValue([] as MxMessage[]),
  75. onMessage: jasmine.createSpy('onMessage').and.returnValue(() => undefined),
  76. onAnyMessage: jasmine.createSpy('onAnyMessage').and.returnValue(() => undefined),
  77. onTyping: jasmine.createSpy('onTyping').and.returnValue(() => undefined),
  78. sendText: jasmine.createSpy('sendText').and.returnValue(Promise.resolve({ event_id: '$e' })),
  79. sendFile: jasmine
  80. .createSpy('sendFile')
  81. .and.returnValue(Promise.resolve({ event_id: '$f' })),
  82. /** 2026-11-13 `'url'` 模式:不发文件本体,只发云盘地址 */
  83. sendFileByUrl: jasmine
  84. .createSpy('sendFileByUrl')
  85. .and.returnValue(Promise.resolve({ event_id: '$fu' })),
  86. setTyping: jasmine.createSpy('setTyping').and.returnValue(Promise.resolve()),
  87. paginateBack: jasmine.createSpy('paginateBack').and.returnValue(Promise.resolve(true)),
  88. /** 初次 sync 是否完成(回溯历史前会等它,2026-11-12) */
  89. synced: jasmine.createSpy('synced').and.returnValue(Promise.resolve(true)),
  90. /** token 失效自愈时用它定位容器(2026-11-12) */
  91. setRecoveryAgentId: jasmine.createSpy('setRecoveryAgentId'),
  92. lastMessageEventId: jasmine.createSpy('lastMessageEventId').and.returnValue(null),
  93. /*
  94. * 一房间一会话(2026-11-13 起建房失败不再静默降级,故必须有桩):
  95. * 默认建出独立房间并视为容器已进房,老用例因此不受影响。
  96. */
  97. createSessionRoom: jasmine
  98. .createSpy('createSessionRoom')
  99. .and.callFake(() => Promise.resolve('!sess:fmode.cn')),
  100. waitAgentJoined: jasmine
  101. .createSpy('waitAgentJoined')
  102. .and.callFake(() => Promise.resolve(true)),
  103. };
  104. const PROV: MatrixProvision = {
  105. cached: true,
  106. bindingId: 'b1',
  107. status: 'active',
  108. userMxId: '@sr2wipsdyq:fmode.cn',
  109. agentMxId: '@zgdcmgnqcd:fmode.cn',
  110. homeserver: 'https://matrix.fmode.cn',
  111. accessToken: 'tok',
  112. deviceId: 'DEV1',
  113. roomId: '!room1:fmode.cn',
  114. };
  115. const AGENT: Agent = {
  116. id: 'agent-node-lj-test',
  117. name: 'lj-test',
  118. status: 'online' as Agent['status'],
  119. matrixReady: true,
  120. unread: 0,
  121. };
  122. beforeEach(() => {
  123. localStorage.clear();
  124. for (const k of Object.keys(apiStub)) {
  125. (apiStub as Record<string, jasmine.Spy>)[k].calls.reset();
  126. }
  127. liveStub.ensureLoaded.calls.reset();
  128. liveStub.agentById.calls.reset();
  129. for (const k of Object.keys(mxStub)) {
  130. const v = (mxStub as Record<string, unknown>)[k];
  131. if (v && typeof (v as jasmine.Spy).calls === 'object') (v as jasmine.Spy).calls.reset();
  132. }
  133. mxStub.connectSession.and.returnValue(Promise.resolve());
  134. mxStub.ensureRoom.and.returnValue(Promise.resolve('!room1:fmode.cn'));
  135. mxStub.syncState.and.returnValue('connected');
  136. mxStub.paginationToken.and.returnValue('tok-b');
  137. mxStub.timelineToMessages.and.returnValue([]);
  138. mxStub.onMessage.and.returnValue(() => undefined);
  139. mxStub.onAnyMessage.and.returnValue(() => undefined);
  140. mxStub.onTyping.and.returnValue(() => undefined);
  141. mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$e' }));
  142. /*
  143. * 建房桩必须每个用例重置(2026-11-13):上一个用例可能改成
  144. * `waitAgentJoined → false` 或 `createSessionRoom → reject`,
  145. * 漏到下一个就会出现「莫名其妙的建房失败」。
  146. */
  147. mxStub.createSessionRoom.and.callFake(() => Promise.resolve('!sess:fmode.cn'));
  148. mxStub.waitAgentJoined.and.callFake(() => Promise.resolve(true));
  149. ChatService.ROOM_BACKOFF_MS = [3_000, 8_000];
  150. ChatService.ROOM_MAX_ATTEMPTS = 3;
  151. // 每个用例都重置附件发送策略 —— 否则上一用例的 reject 会漏到下一个
  152. mxStub.sendFile.and.returnValue(Promise.resolve({ event_id: '$f' }));
  153. mxStub.paginateBack.and.returnValue(Promise.resolve(true));
  154. mxStub.synced.and.returnValue(Promise.resolve(true));
  155. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([CLOUD_THREAD]));
  156. apiStub.upsertChatThreads.and.returnValue(Promise.resolve());
  157. apiStub.patchChatThread.and.returnValue(Promise.resolve());
  158. apiStub.removeChatThread.and.returnValue(Promise.resolve());
  159. liveStub.agentById.and.returnValue(AGENT);
  160. apiStub.provisionMatrix.and.returnValue(Promise.resolve(PROV));
  161. TestBed.configureTestingModule({
  162. providers: [
  163. ChatService,
  164. { provide: FmodeApi, useValue: apiStub },
  165. { provide: LiveService, useValue: liveStub },
  166. { provide: MatrixClientService, useValue: mxStub },
  167. { provide: SessionService, useValue: { me: () => ({ id: 'u1' }), token: () => 'r:t' } },
  168. { provide: UnreadService, useClass: UnreadService },
  169. /*
  170. * 显式提供 ChatSessionService:每个用例都会重建注入器,
  171. * 只有列在 providers 里,`ChatService` 内部 inject 的实例
  172. * 才与 `TestBed.inject` 拿到的是**同一个**。
  173. */
  174. ChatSessionService,
  175. ],
  176. });
  177. svc = TestBed.inject(ChatService);
  178. /*
  179. * 两个根单例的状态都会跨用例保留,必须显式重置:
  180. * - ChatSessionService:内存里的会话列表(localStorage.clear() 只管磁盘)
  181. * - ChatService:agentId/sessionId/state —— 不重置的话第二个用例调
  182. * open() 会因为「同一个 agent 且已 ready」直接早退,断言全部落空
  183. */
  184. svc.sessions.reset();
  185. svc.close();
  186. });
  187. afterEach(() => {
  188. localStorage.clear();
  189. });
  190. /** 测试统一走真实态(演示态由 MockApi 覆盖,另测) */
  191. function realMode(): void {
  192. (environment as { useMockData: boolean }).useMockData = false;
  193. }
  194. /**
  195. * 为建房相关用例准备上下文(2026-11-13)。
  196. *
  197. * `provisionSessionRoom()` 需要 `this.provision.agentMxId` 才能建房,
  198. * 而 `startBlankWithRoom()` 自身不会先拉 provision —— 真实链路上是
  199. * 用户先进入容器(`open()` 已 provision)再点新建。测试照此还原。
  200. */
  201. async function primeProvision(): Promise<void> {
  202. realMode();
  203. mxStub.timelineToMessages.and.returnValue([]);
  204. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  205. await svc.open('agent-node-lj-test');
  206. svc.sessions.reset();
  207. }
  208. describe('新建对话(2026-11-01 点击即建)', () => {
  209. /*
  210. * 🔴 用户反馈:点「新建对话」之后左侧看不到任何变化。
  211. *
  212. * 上一版是「首次发消息才建会话」,点按钮只进入待建态、不落数据 ——
  213. * 左侧列表当然不会出现条目,用户不知道操作有没有生效。
  214. * 现在改为点击即建,并复用它归属下已有的空会话(避免连点攒出一排「新对话」)。
  215. */
  216. it('🔴 startBlank 立刻建出会话并选中', async () => {
  217. realMode();
  218. mxStub.timelineToMessages.and.returnValue([]);
  219. // 云端目录置空:默认桩会返回 CLOUD_THREAD,断言会凭空多一条
  220. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  221. svc.sessions.reset();
  222. const created = await svc.startBlank('agent-node-lj-test');
  223. expect(created).withContext('必须立刻返回会话').toBeTruthy();
  224. expect(svc.currentSession()?.id).withContext('新会话要处于选中态').toBe(created!.id);
  225. expect(svc.sessions.listFor('agent-node-lj-test').length).withContext('左侧应出现 1 条').toBe(1);
  226. });
  227. /*
  228. * 2026-11-13 用户实测:点「新建对话」直接显示
  229. * 「这个会话的消息暂时没加载出来 / 可能是网络波动」。
  230. *
  231. * 根因:`backfillSessionTimeline()` 对 `_blankSessionId` 直接 return,
  232. * `_reachedRoomStart` 停在 false → 落到 `unloaded` 分支。
  233. * 新建会话本来就没有历史,正确语义是 `fresh`(走欢迎页)。
  234. */
  235. it('🔴 新建会话不能被判成「取不到」(emptyReason 应为 fresh)', async () => {
  236. realMode();
  237. mxStub.timelineToMessages.and.returnValue([]);
  238. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  239. svc.sessions.reset();
  240. await svc.startBlank('agent-node-lj-test');
  241. expect(svc.messages().length).toBe(0);
  242. expect(svc.emptyReason())
  243. .withContext('新建会话应显示欢迎页,不能显示「消息暂时没加载出来」')
  244. .toBe('fresh');
  245. });
  246. /*
  247. * 2026-11-13:成果归属主键改成 roomId 后,建房失败**不能**再静默降级。
  248. * 一房间一会话被破坏 ⇒ 同房间多会话 ⇒ 台账按 roomId 查会串台。
  249. * 这里锁住三条行为:重试、最终失败要可见、重试成功要清掉错误。
  250. */
  251. it('🔴 建房失败会重试,不再静默降级', async () => {
  252. ChatService.ROOM_BACKOFF_MS = [];
  253. realMode();
  254. mxStub.timelineToMessages.and.returnValue([]);
  255. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  256. svc.sessions.reset();
  257. /* 前两次进房超时,第三次成功 */
  258. let n = 0;
  259. mxStub.waitAgentJoined.and.callFake(() => Promise.resolve(++n >= 3));
  260. const s = await svc.startBlankWithRoom('agent-node-lj-test');
  261. expect(n).withContext('进房失败必须重试(原实现失败即放弃)').toBeGreaterThan(1);
  262. expect(svc.roomErrors().has(s!.id)).withContext('最终成功则不应残留错误').toBeFalse();
  263. }, 30_000);
  264. it('🔴 建房重试仍失败 → 记录错误供 UI 展示(不静默)', async () => {
  265. ChatService.ROOM_BACKOFF_MS = [];
  266. await primeProvision();
  267. mxStub.waitAgentJoined.and.returnValue(Promise.resolve(false));
  268. const s = await svc.startBlankWithRoom('agent-node-lj-test');
  269. expect(svc.roomErrors().get(s!.id))
  270. .withContext('必须给出可见原因,否则用户以为只是慢')
  271. .toContain('容器未进入');
  272. }, 30_000);
  273. it('建房抛错(网络/服务端拒绝)同样计为重试', async () => {
  274. ChatService.ROOM_BACKOFF_MS = [];
  275. realMode();
  276. mxStub.timelineToMessages.and.returnValue([]);
  277. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  278. svc.sessions.reset();
  279. mxStub.createSessionRoom.calls.reset();
  280. mxStub.createSessionRoom.and.callFake(() => Promise.reject(new Error('限流')));
  281. const s = await svc.startBlankWithRoom('agent-node-lj-test');
  282. expect(mxStub.createSessionRoom.calls.count())
  283. .withContext('抛错也要重试,不能一次失败就放弃')
  284. .toBeGreaterThan(1);
  285. expect(svc.roomErrors().get(s!.id)).toBe('限流');
  286. }, 30_000);
  287. it('retrySessionRoom 成功后清除错误', async () => {
  288. ChatService.ROOM_BACKOFF_MS = [];
  289. realMode();
  290. mxStub.timelineToMessages.and.returnValue([]);
  291. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  292. svc.sessions.reset();
  293. mxStub.waitAgentJoined.and.returnValue(Promise.resolve(false));
  294. const s = await svc.startBlankWithRoom('agent-node-lj-test');
  295. expect(svc.roomErrors().has(s!.id)).withContext('建房失败应记录错误').toBeTrue();
  296. /* 用户点「重试」,这次容器能进房了 */
  297. mxStub.waitAgentJoined.and.returnValue(Promise.resolve(true));
  298. await svc.retrySessionRoom();
  299. expect(svc.roomErrors().has(s!.id)).withContext('重试成功后错误要消失').toBeFalse();
  300. }, 30_000);
  301. it('指定工作区时归属正确', async () => {
  302. realMode();
  303. mxStub.timelineToMessages.and.returnValue([]);
  304. const created = await svc.startBlank('agent-node-lj-test', 'ws-test');
  305. expect(svc.sessions.byId(created!.id)?.workspaceId).toBe('ws-test');
  306. });
  307. /*
  308. * 🔴 用户裁决:整个列表**最多保留一条**「新建对话」。
  309. *
  310. * 每次新建都把之前所有没发过消息的空会话清掉 —— 不按归属复用,
  311. * 也不依赖定时清理,否则会出现「工作区一条、日常一条」并存。
  312. */
  313. it('🔴 再次新建时,之前的空会话被清掉,只留一条', async () => {
  314. realMode();
  315. mxStub.timelineToMessages.and.returnValue([]);
  316. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  317. svc.sessions.reset();
  318. const a = await svc.startBlank('agent-node-lj-test', 'ws-test');
  319. const b = await svc.startBlank('agent-node-lj-test', 'ws-test');
  320. expect(svc.sessions.byId(a!.id)).withContext('上一次的空会话应被清掉').toBeUndefined();
  321. expect(svc.sessions.byId(b!.id)).toBeDefined();
  322. expect(svc.sessions.listFor('agent-node-lj-test').length).toBe(1);
  323. });
  324. it('🔴 不同归属新建时,旧的空会话同样被清掉(全局只留一条)', async () => {
  325. realMode();
  326. mxStub.timelineToMessages.and.returnValue([]);
  327. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  328. svc.sessions.reset();
  329. const a = await svc.startBlank('agent-node-lj-test', 'ws-a');
  330. const b = await svc.startBlank('agent-node-lj-test', 'ws-b');
  331. expect(svc.sessions.byId(a!.id)).withContext('工作区 A 的那条应被清掉').toBeUndefined();
  332. expect(svc.sessions.byId(b!.id)?.workspaceId).toBe('ws-b');
  333. expect(svc.sessions.listFor('agent-node-lj-test').length).toBe(1);
  334. });
  335. it('🔴 发过消息的会话不会被新建操作清掉', async () => {
  336. realMode();
  337. mxStub.timelineToMessages.and.returnValue([]);
  338. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  339. svc.sessions.reset();
  340. // 先建一条并发消息(= 已持久化)
  341. const old = await svc.startBlank('agent-node-lj-test');
  342. await svc.sendText('这条已经发过消息');
  343. // 再新建一条
  344. const fresh = await svc.startBlank('agent-node-lj-test');
  345. expect(svc.sessions.byId(old!.id)).withContext('有消息的会话不能被清').toBeDefined();
  346. expect(svc.sessions.byId(fresh!.id)).toBeDefined();
  347. });
  348. it('建出会话后发消息,state 正常切到 ready', async () => {
  349. realMode();
  350. mxStub.timelineToMessages.and.returnValue([]);
  351. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  352. svc.sessions.reset();
  353. await svc.startBlank('agent-node-lj-test');
  354. await svc.sendText('第一条消息');
  355. expect(svc.state()).toBe('ready');
  356. expect(svc.currentSession()).toBeDefined();
  357. });
  358. /*
  359. * 🔴 2026-11-09 用户要求:「第一次发送消息的时候,才会开始持久化存储
  360. * 这个对话;存储成功后,才会开始发送消息」。
  361. *
  362. * 原实现是 `commit()`(发出去就不管):消息先发进 Matrix,落库在后台跑。
  363. * 现在首次落库必须 `await`,成功才继续发送。
  364. */
  365. it('🔴 首次发消息:先落库成功,才真正发送到 Matrix', async () => {
  366. realMode();
  367. mxStub.timelineToMessages.and.returnValue([]);
  368. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  369. svc.sessions.reset();
  370. const order: string[] = [];
  371. apiStub.upsertChatThreads.and.callFake(() => {
  372. order.push('upsert');
  373. return Promise.resolve();
  374. });
  375. mxStub.sendText.and.callFake(() => {
  376. order.push('sendText');
  377. return Promise.resolve({ event_id: '$evt1' });
  378. });
  379. await svc.startBlank('agent-node-lj-test');
  380. order.length = 0; // 只关心 sendText 期间的顺序
  381. await svc.sendText('第一条消息');
  382. /*
  383. * 期望:落库(upsert) → 发送(sendText)。
  384. * 允许 upsert 出现多次(标题推送等),但**首次 upsert 必须在 sendText 之前**,
  385. * 且 sendText 只能出现一次。
  386. */
  387. const firstUpsert = order.indexOf('upsert');
  388. const firstSend = order.indexOf('sendText');
  389. expect(firstUpsert).withContext('应当发生过落库').toBeGreaterThanOrEqual(0);
  390. expect(firstSend).withContext('应当发生过发送').toBeGreaterThanOrEqual(0);
  391. expect(firstUpsert)
  392. .withContext(`落库必须排在发送之前,实际顺序:${order.join(' → ')}`)
  393. .toBeLessThan(firstSend);
  394. expect(order.filter((x) => x === 'sendText').length).toBe(1);
  395. });
  396. it('🔴 首次落库失败 → 消息标记失败,且不发送到 Matrix', async () => {
  397. realMode();
  398. mxStub.timelineToMessages.and.returnValue([]);
  399. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  400. svc.sessions.reset();
  401. apiStub.upsertChatThreads.and.returnValue(Promise.reject(new Error('网络异常')));
  402. mxStub.sendText.calls.reset();
  403. await svc.startBlank('agent-node-lj-test');
  404. await svc.sendText('这条不该被发出去');
  405. expect(mxStub.sendText).withContext('落库失败就不能发送').not.toHaveBeenCalled();
  406. const failed = svc.messages().find((m) => m.state === 'failed');
  407. expect(failed).withContext('消息要标记为失败,用户可重试').toBeDefined();
  408. // 复原桩,避免影响后续用例
  409. apiStub.upsertChatThreads.and.returnValue(Promise.resolve());
  410. });
  411. });
  412. describe('open() 真实态编排', () => {
  413. it('provision → connectSession → ensureRoom 顺序执行', async () => {
  414. realMode();
  415. const order: string[] = [];
  416. apiStub.provisionMatrix.and.callFake(() => {
  417. order.push('provision');
  418. return Promise.resolve(PROV);
  419. });
  420. mxStub.connectSession.and.callFake(() => {
  421. order.push('connect');
  422. return Promise.resolve();
  423. });
  424. mxStub.ensureRoom.and.callFake(() => {
  425. order.push('room');
  426. return Promise.resolve('!room1:fmode.cn');
  427. });
  428. await svc.open('agent-node-lj-test');
  429. expect(order).toEqual(['provision', 'connect', 'room']);
  430. expect(svc.agentId()).toBe('agent-node-lj-test');
  431. expect(svc.connection()).toBe('connected');
  432. });
  433. it('空房间 → state=empty(不是 error)', async () => {
  434. realMode();
  435. mxStub.timelineToMessages.and.returnValue([]);
  436. await svc.open('agent-node-lj-test');
  437. expect(svc.state()).toBe('empty');
  438. });
  439. /*
  440. * 🔴 「重新连接」失效的回归测试(2026-11-01 用户实测)。
  441. *
  442. * `open()` 第一行是幂等短路:同 agent + 同会话 + state=ready 就直接 return。
  443. * 断线时 state 仍是 ready,于是点「重新连接」什么都不会发生。
  444. * 现在用 `force` 参数绕过短路。
  445. */
  446. it('🔴 不带 force 时同状态重复 open 会早退', async () => {
  447. realMode();
  448. mxStub.timelineToMessages.and.returnValue([]);
  449. await svc.open('agent-node-lj-test');
  450. const calls = apiStub.provisionMatrix.calls.count();
  451. await svc.open('agent-node-lj-test');
  452. expect(apiStub.provisionMatrix.calls.count()).withContext('应早退,不再调 provision').toBe(calls);
  453. });
  454. it('🔴 带 force 时重新执行完整编排(重新连接可用)', async () => {
  455. realMode();
  456. mxStub.timelineToMessages.and.returnValue([]);
  457. await svc.open('agent-node-lj-test');
  458. const calls = apiStub.provisionMatrix.calls.count();
  459. await svc.open('agent-node-lj-test', undefined, true);
  460. expect(apiStub.provisionMatrix.calls.count()).withContext('force 必须重新编排').toBe(calls + 1);
  461. });
  462. it('有消息 → state=ready 且按 sender 区分 me/agent', async () => {
  463. realMode();
  464. // 无 thread 的消息属于「历史对话」语义 —— 给它们当前会话的 threadId 才属于本会话
  465. const legacyRoomThread = (i: number) => `$t${i}`;
  466. mxStub.timelineToMessages.and.returnValue([
  467. { roomId: 'r', eventId: '$1', threadId: legacyRoomThread(1), sender: '@sr2wipsdyq:fmode.cn', body: '我发的', ts: 1, kind: 'text', live: false },
  468. { roomId: 'r', eventId: '$2', threadId: legacyRoomThread(1), sender: '@zgdcmgnqcd:fmode.cn', body: '它回的', ts: 2, kind: 'text', live: false },
  469. ]);
  470. // 指定这条 thread 作为要打开的会话
  471. await svc.open('agent-node-lj-test', legacyRoomThread(1));
  472. expect(svc.state()).toBe('ready');
  473. expect(svc.messages().map((m) => m.sender)).toEqual(['me', 'agent']);
  474. expect(svc.messages()[0].text).toBe('我发的');
  475. });
  476. it('数字生命不存在 → 报明确错误', async () => {
  477. realMode();
  478. liveStub.agentById.and.returnValue(undefined);
  479. await svc.open('nope');
  480. expect(svc.state()).toBe('error');
  481. expect(svc.error()).toContain('不存在');
  482. });
  483. it('🔴 数据仍在加载 → 不报「不存在」(刷新页面的真实场景)', async () => {
  484. realMode();
  485. liveStub.agentById.and.returnValue(undefined);
  486. liveStub.state.and.returnValue('loading');
  487. await svc.open('agent-node-lj-test');
  488. expect(svc.error()).not.toContain('不存在');
  489. expect(svc.error()).toContain('加载');
  490. liveStub.state.and.returnValue('ready'); // 复位
  491. });
  492. it('🔴 数据加载失败 → 报加载失败而非「不存在」', async () => {
  493. realMode();
  494. liveStub.agentById.and.returnValue(undefined);
  495. liveStub.state.and.returnValue('error');
  496. liveStub.error.and.returnValue('网络异常');
  497. await svc.open('agent-node-lj-test');
  498. expect(svc.error()).toContain('加载失败');
  499. expect(svc.error()).toContain('网络异常');
  500. liveStub.state.and.returnValue('ready');
  501. liveStub.error.and.returnValue(null);
  502. });
  503. });
  504. describe('失败分环节报错(FR-04:不得笼统)', () => {
  505. it('provision 失败 → 文案含「FMODE 开通失败」', async () => {
  506. realMode();
  507. apiStub.provisionMatrix.and.returnValue(Promise.reject(new Error('SessionToken 无效')));
  508. await svc.open('a');
  509. expect(svc.error()).toContain('FMODE 开通失败');
  510. expect(svc.error()).toContain('SessionToken 无效');
  511. });
  512. it('SDK 登录失败 → 文案含「连接失败」(不暴露技术名词)', async () => {
  513. realMode();
  514. mxStub.connectSession.and.returnValue(Promise.reject(new Error('凭据不完整')));
  515. await svc.open('a');
  516. expect(svc.error()).toContain('连接失败');
  517. expect(svc.error()).withContext('界面文案不应出现 Matrix').not.toContain('Matrix');
  518. });
  519. it('房间创建失败 → 文案含「房间创建失败」', async () => {
  520. realMode();
  521. mxStub.ensureRoom.and.returnValue(Promise.reject(new Error('403')));
  522. await svc.open('a');
  523. expect(svc.error()).toContain('房间创建失败');
  524. });
  525. it('失败时 connection=disconnected(不假装连着)', async () => {
  526. realMode();
  527. apiStub.provisionMatrix.and.returnValue(Promise.reject(new Error('x')));
  528. await svc.open('a');
  529. expect(svc.connection()).toBe('disconnected');
  530. });
  531. });
  532. describe('seq 防串扰(切会话丢弃过期回包)', () => {
  533. it('慢的旧请求返回时不覆盖新会话', async () => {
  534. realMode();
  535. let resolveSlow: (v: MatrixProvision) => void = () => undefined;
  536. apiStub.provisionMatrix.and.callFake((id: string) =>
  537. id === 'slow'
  538. ? new Promise<MatrixProvision>((res) => (resolveSlow = res))
  539. : Promise.resolve(PROV),
  540. );
  541. mxStub.ensureRoom.and.callFake(() => Promise.resolve('!room1:fmode.cn'));
  542. const slowOpen = svc.open('slow'); // 悬而未决
  543. await svc.open('fast'); // 后发先至,成为当前会话
  544. resolveSlow(PROV); // 旧请求此刻才返回
  545. await slowOpen;
  546. // 当前会话仍是 fast,未被 slow 的迟到回包覆盖
  547. expect(svc.agentId()).toBe('fast');
  548. });
  549. });
  550. describe('close() 必须**不断开**会话级连接', () => {
  551. it('close 后 sync 仍常驻(未读计数依赖)', async () => {
  552. realMode();
  553. await svc.open('agent-node-lj-test');
  554. svc.close();
  555. // 🔴 关键:close 不得调用 disconnect —— 否则离开会话就收不到消息
  556. expect(mxStub.disconnect).not.toHaveBeenCalled();
  557. expect(svc.agentId()).toBeNull();
  558. expect(svc.messages()).toEqual([]);
  559. expect(svc.connection()).toBe('disconnected'); // 仅 UI 状态复位
  560. });
  561. it('close 会解绑本房间的事件订阅(防串扰)', async () => {
  562. realMode();
  563. const unbindMsg = jasmine.createSpy('unbindMsg');
  564. const unbindTyping = jasmine.createSpy('unbindTyping');
  565. mxStub.onMessage.and.returnValue(unbindMsg);
  566. mxStub.onTyping.and.returnValue(unbindTyping);
  567. await svc.open('a');
  568. svc.close();
  569. expect(unbindMsg).toHaveBeenCalled();
  570. expect(unbindTyping).toHaveBeenCalled();
  571. });
  572. });
  573. describe('群聊支持(2026-11-07)', () => {
  574. /*
  575. * 🔴 回归:群聊重建历史要遍历 N 个成员房间。若每个成员都走
  576. * `connectSession`,token 不同时会 disconnect 重建客户端 →
  577. * 正在进行的 `/sync` 被打断,timeline 永远是空的
  578. * (真实账号实测:群历史一条都读不出来)。
  579. */
  580. it('读历史时:已连接则不重连;未连接仍必须连(评审 2026-11-07)', async () => {
  581. realMode();
  582. apiStub.provisionMatrix.and.returnValue(Promise.resolve(PROV));
  583. mxStub.ensureRoom.and.returnValue(Promise.resolve('!room1:fmode.cn'));
  584. mxStub.connectSession.calls.reset();
  585. // 未连接:skipConnect 也不能跳过,否则 ensureRoom 里 requireClient 会抛
  586. (mxStub as unknown as { connected: boolean }).connected = false;
  587. await svc.ensureAgentRoomFor('agent-node-lj-test', { skipConnect: true });
  588. expect(mxStub.connectSession)
  589. .withContext('客户端不存在时必须建立连接')
  590. .toHaveBeenCalled();
  591. // 已连接:跳过重连(重建会打断正在进行的 sync)
  592. (mxStub as unknown as { connected: boolean }).connected = true;
  593. mxStub.connectSession.calls.reset();
  594. await svc.ensureAgentRoomFor('agent-node-lj-test', { skipConnect: true });
  595. expect(mxStub.connectSession).not.toHaveBeenCalled();
  596. });
  597. it('群聊发附件:事件带 dispatch 与 session 标记', async () => {
  598. realMode();
  599. apiStub.provisionMatrix.and.returnValue(Promise.resolve(PROV));
  600. mxStub.connectSession.and.returnValue(Promise.resolve());
  601. mxStub.ensureRoom.and.returnValue(Promise.resolve('!room1:fmode.cn'));
  602. mxStub.lastMessageEventId.and.returnValue('$base');
  603. mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$file' }));
  604. const file = new File(['x'], 'a.png', { type: 'image/png' });
  605. const r = await svc.sendFileToAgent(
  606. 'agent-node-lj-test',
  607. file,
  608. { groupId: 'g1', turnId: 'me-1', targetAgentId: 'agent-node-lj-test' },
  609. 'https://s3.fmode.cn/k',
  610. );
  611. expect(r.ok).withContext('发送应成功').toBe(true);
  612. expect(mxStub.sendFile).not.toHaveBeenCalled();
  613. const args = mxStub.sendFileByUrl.calls.mostRecent().args;
  614. const extra = args[5] as Record<string, unknown>;
  615. expect((extra['com.fmode.dispatch'] as { groupId: string }).groupId).toBe('g1');
  616. expect(extra['com.fmode.session']).toBe('me-1');
  617. });
  618. });
  619. describe('sendText(AC-04.2 / AC-04.8)', () => {
  620. beforeEach(async () => {
  621. realMode();
  622. await svc.open('agent-node-lj-test');
  623. });
  624. it('乐观插入 → 调用 SDK 发送 → 标记 sent', async () => {
  625. await svc.sendText(' 你好 ');
  626. const last = svc.messages().at(-1)!;
  627. expect(last.text).toBe('你好'); // 已 trim
  628. expect(last.state).toBe('sent');
  629. /*
  630. * 🔴 必须带会话线程根:不带 thread 容器会把每条消息切成新会话(实测)。
  631. * 🔴 第五个参数是 extra:把本地 id 写进 content,服务端 echo 会原样带回,
  632. * 回读时据此认领乐观消息(2026-11-09 修「一条你好显示三条」)。
  633. */
  634. expect(mxStub.sendText).toHaveBeenCalledWith(
  635. '!room1:fmode.cn',
  636. '你好',
  637. svc.sessionId()!,
  638. undefined,
  639. { 'com.fmode.local': last.localId! },
  640. );
  641. expect(last.localId).toBeTruthy();
  642. });
  643. it('第二次发送带上一条消息的 event_id(m.in_reply_to 降级用)', async () => {
  644. await svc.sendText('第一条');
  645. /*
  646. * 2026-11-14:发送不再拦截(用户裁决「永远不拦」),
  647. * 这里不必再模拟「第一轮结束」,直接发第二条即可。
  648. */
  649. mxStub.sendText.calls.reset();
  650. await svc.sendText('第二条');
  651. // 第一条是本地乐观 id(local-*),不是真实 event,故 lastEventId 应为 undefined
  652. const args = mxStub.sendText.calls.mostRecent().args;
  653. expect(args[0]).toBe('!room1:fmode.cn');
  654. expect(args[1]).toBe('第二条');
  655. expect(args[2]).toBe(svc.sessionId()!);
  656. expect(args[3]).toBeUndefined();
  657. expect(args[4]).toEqual({ 'com.fmode.local': jasmine.any(String) });
  658. });
  659. it('发送后清空草稿', async () => {
  660. svc.setDraft('待发');
  661. await svc.sendText('待发');
  662. expect(svc.draft()).toBe('');
  663. });
  664. /*
  665. * 草稿按会话隔离(2026-11-14 修复)。
  666. *
  667. * 🔴 修复前的真实症状不是「丢草稿」,而是**串台**:
  668. * 草稿是单个全局 signal,在 A 会话打了一半,切到 B 会话那半句话原样出现,
  669. * 继续发就会发错人。`open()` 里的 `set('')` 又让它表现为「丢字」。
  670. * 两个症状交替出现,用户体感是「有时候丢、有时候串」。
  671. */
  672. it('🔴 切到另一条会话时,看不到上一条会话的草稿', async () => {
  673. realMode();
  674. mxStub.timelineToMessages.and.returnValue([]);
  675. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  676. const a = await svc.startBlank('agent-node-lj-test', 'ws-test');
  677. svc.setDraft('这是 A 会话没写完的话');
  678. const b = await svc.startBlank('agent-node-lj-test', 'ws-test');
  679. expect(a!.id).not.toBe(b!.id);
  680. expect(svc.draft())
  681. .withContext('B 会话不能出现 A 的草稿')
  682. .toBe('');
  683. });
  684. it('🔴 切回原会话时,草稿还在', async () => {
  685. realMode();
  686. mxStub.timelineToMessages.and.returnValue([]);
  687. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  688. const a = await svc.startBlank('agent-node-lj-test', 'ws-test');
  689. svc.setDraft('A 的半句话');
  690. await svc.startBlank('agent-node-lj-test', 'ws-test');
  691. await svc.open('agent-node-lj-test', a!.id);
  692. expect(svc.draft()).withContext('切回来应恢复').toBe('A 的半句话');
  693. });
  694. it('两条会话的草稿互不覆盖', async () => {
  695. realMode();
  696. mxStub.timelineToMessages.and.returnValue([]);
  697. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  698. const a = await svc.startBlank('agent-node-lj-test', 'ws-test');
  699. svc.setDraft('A 的话');
  700. const b = await svc.startBlank('agent-node-lj-test', 'ws-test');
  701. svc.setDraft('B 的话');
  702. await svc.open('agent-node-lj-test', a!.id);
  703. expect(svc.draft()).toBe('A 的话');
  704. await svc.open('agent-node-lj-test', b!.id);
  705. expect(svc.draft()).toBe('B 的话');
  706. });
  707. it('空文本不发送(也不插气泡)', async () => {
  708. const before = svc.messages().length;
  709. await svc.sendText(' ');
  710. expect(svc.messages().length).toBe(before);
  711. expect(mxStub.sendText).not.toHaveBeenCalled();
  712. });
  713. it('失败 → 留痕 failed 且带错误原因(不丢消息)', async () => {
  714. mxStub.sendText.and.returnValue(Promise.reject(new Error('网络错误')));
  715. await svc.sendText('会失败');
  716. const last = svc.messages().at(-1)!;
  717. expect(last.state).toBe('failed');
  718. expect(last.error).toContain('网络错误');
  719. });
  720. it('retry 把 failed 消息重发并复位为 sent', async () => {
  721. mxStub.sendText.and.returnValue(Promise.reject(new Error('临时故障')));
  722. await svc.sendText('重试我');
  723. const failed = svc.messages().at(-1)!;
  724. expect(failed.state).toBe('failed');
  725. mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$ok' }));
  726. await svc.retry(failed.id);
  727. const after = svc.messages().find((m) => m.id === failed.id)!;
  728. expect(after.state).toBe('sent');
  729. expect(after.error).toBeUndefined();
  730. });
  731. it('非 failed 状态的消息 retry 不做事', async () => {
  732. await svc.sendText('已成功的');
  733. const ok = svc.messages().at(-1)!;
  734. mxStub.sendText.calls.reset();
  735. await svc.retry(ok.id);
  736. expect(mxStub.sendText).not.toHaveBeenCalled();
  737. });
  738. });
  739. describe('paginate(AC-04.4 翻历史)', () => {
  740. beforeEach(async () => {
  741. realMode();
  742. await svc.open('agent-node-lj-test');
  743. });
  744. it('当前会话内的消息计入', async () => {
  745. mxStub.timelineToMessages.and.returnValue(
  746. Array.from({ length: 5 }, (_, i) => ({
  747. roomId: 'r',
  748. eventId: `$h${i}`,
  749. sender: '@zgdcmgnqcd:fmode.cn',
  750. // 必须带当前会话的 threadId —— 无 thread 的属于「历史对话」,不混入
  751. threadId: svc.sessionId()!,
  752. body: `历史${i}`,
  753. ts: i,
  754. kind: 'text' as const,
  755. live: false,
  756. })),
  757. );
  758. const grew = await svc.paginate();
  759. expect(grew).toBeTrue();
  760. expect(svc.messages().length).toBe(5);
  761. expect(svc.hasMoreHistory()).toBeTrue();
  762. });
  763. it('其它会话的消息被过滤,不混入当前会话', async () => {
  764. mxStub.timelineToMessages.and.returnValue(
  765. Array.from({ length: 5 }, (_, i) => ({
  766. roomId: 'r',
  767. eventId: `$x${i}`,
  768. sender: '@zgdcmgnqcd:fmode.cn',
  769. threadId: '$approot_other_session:fmode.cn',
  770. body: `别的会话${i}`,
  771. ts: i,
  772. kind: 'text' as const,
  773. live: false,
  774. })),
  775. );
  776. const grew = await svc.paginate();
  777. expect(grew).toBeFalse(); // 条数没增长
  778. expect(svc.messages().length).toBe(0);
  779. });
  780. it('条数未增长 → hasMoreHistory=false(到最早了,停止请求)', async () => {
  781. mxStub.timelineToMessages.and.returnValue([]);
  782. const grew = await svc.paginate();
  783. expect(grew).toBeFalse();
  784. expect(svc.hasMoreHistory()).toBeFalse();
  785. });
  786. it('🔴 防重入:并发调用只触发一次 SDK 分页', async () => {
  787. /*
  788. * 🔴 调用计数必须从这个用例的基线算起(2026-11-12)。
  789. * `open()` 现在也会按需回溯历史,上一句 `beforeEach` 里的 open
  790. * 可能已经调用过若干次 `paginateBack`;绝对计数会被累加污染。
  791. */
  792. const base = mxStub.paginateBack.calls.count();
  793. let resolveIt: (v: boolean) => void = () => undefined;
  794. mxStub.paginateBack.and.callFake(() => new Promise<boolean>((res) => (resolveIt = res)));
  795. const a = svc.paginate();
  796. const b = svc.paginate(); // 立刻重入
  797. resolveIt(true);
  798. await Promise.all([a, b]);
  799. expect(mxStub.paginateBack.calls.count() - base).toBe(1);
  800. });
  801. it('paginating 在完成后复位', async () => {
  802. await svc.paginate();
  803. expect(svc.paginating()).toBeFalse();
  804. });
  805. });
  806. /*
  807. * 🔴 历史会话打开为空(2026-11-12 用户实测)。
  808. *
  809. * 现象:「我的这些历史记录都无法查看了,大部分都没有正常显示。」
  810. * 根因:sync 只保留房间最近 50 条,老会话的消息不在本地 timeline,
  811. * 而打开会话时**从不主动向前翻**,于是渲染成「全新会话」欢迎页。
  812. */
  813. describe('打开历史会话时按需回溯 timeline', () => {
  814. const SID = '$approot_test:fmode.cn';
  815. /** 构造一条属于该会话的消息 */
  816. const msgOf = (id: string): MxMessage =>
  817. ({
  818. roomId: '!room1:fmode.cn',
  819. eventId: id,
  820. sender: '@zgdcmgnqcd:fmode.cn',
  821. threadId: SID,
  822. body: '历史内容',
  823. ts: 1,
  824. kind: 'text' as const,
  825. live: false,
  826. }) as MxMessage;
  827. afterEach(() => {
  828. mxStub.timelineToMessages.and.returnValue([]);
  829. mxStub.paginationToken.and.returnValue('tok-b');
  830. });
  831. it('本地没有该会话的消息 → 向前回溯并命中', async () => {
  832. realMode();
  833. // 第一轮:只有别的会话;回溯一次后:出现本会话
  834. let calls = 0;
  835. mxStub.timelineToMessages.and.callFake(() =>
  836. calls === 0 ? [] : [msgOf('$h1'), msgOf('$h2')],
  837. );
  838. mxStub.paginateBack.and.callFake(() => {
  839. calls++;
  840. return Promise.resolve(true);
  841. });
  842. await svc.open('agent-node-lj-test', SID);
  843. expect(mxStub.paginateBack).toHaveBeenCalled();
  844. expect(svc.messages().length).toBeGreaterThan(0);
  845. expect(svc.emptyReason()).toBeNull();
  846. });
  847. it('命中即停:不把整个房间翻完', async () => {
  848. realMode();
  849. mxStub.timelineToMessages.and.returnValue([msgOf('$h1')]);
  850. await svc.open('agent-node-lj-test', SID);
  851. expect(mxStub.paginateBack).not.toHaveBeenCalled();
  852. });
  853. it('页面已到房间最早(无 token)→ 不回溯', async () => {
  854. realMode();
  855. mxStub.timelineToMessages.and.returnValue([]);
  856. mxStub.paginationToken.and.returnValue(null);
  857. await svc.open('agent-node-lj-test', SID);
  858. expect(mxStub.paginateBack).not.toHaveBeenCalled();
  859. });
  860. it('🔥 回溯耗尽仍取不到 → emptyReason=unloaded,不得伪装成新会话', async () => {
  861. realMode();
  862. mxStub.timelineToMessages.and.returnValue([]); // 永远取不到
  863. mxStub.paginateBack.and.returnValue(Promise.resolve(true));
  864. await svc.open('agent-node-lj-test', SID);
  865. /*
  866. * 断言「**有上限**」而不是写死具体轮数(2026-11-12):
  867. * 上限会随房间规模调整(当前 50 轮,因 lj-test 房间已超 2100 个事件)。
  868. * 这里守住真正的不变量:确实尝试过、且**一定会停**。
  869. */
  870. const n = mxStub.paginateBack.calls.count();
  871. expect(n).toBeGreaterThan(0);
  872. expect(n).toBeLessThanOrEqual(100);
  873. /*
  874. * 房间**没翻到最早**(`paginationToken` 仍返回 token)→ 不能断定「这条会话没有消息」,
  875. * 只能诚实说「暂时取不到」。
  876. */
  877. expect(svc.emptyReason()).toBe('unloaded');
  878. });
  879. it('翻到房间最早 + 目录里有记录 → true empty(fresh),不吓唬用户', async () => {
  880. realMode();
  881. mxStub.timelineToMessages.and.returnValue([]);
  882. // 一轮就翻到顶:翻完 token 变 null
  883. mxStub.paginateBack.and.callFake(() => {
  884. mxStub.paginationToken.and.returnValue(null);
  885. return Promise.resolve(true);
  886. });
  887. await svc.open('agent-node-lj-test', SID);
  888. /*
  889. * 🔴 已翻到房间最早 + 目录里有这条 + 0 条消息 = **空壳会话**(2026-11-12)。
  890. * 不能报 `fresh`(会被渲染成「全新会话」欢迎语,诱导用户以为内容丢了),
  891. * 也不能报 `unloaded`(会让用户一直等「暂时取不到」)。
  892. * 实测样本:「测试9680」在 Matrix 里确实一条消息都没有。
  893. */
  894. expect(svc.emptyReason()).toBe('blank');
  895. });
  896. });
  897. describe('setDraft 触发 typing 通知', () => { it('有内容 → typing=true,清空 → typing=false', async () => {
  898. realMode();
  899. await svc.open('a');
  900. svc.setDraft('在输入');
  901. expect(mxStub.setTyping).toHaveBeenCalledWith('!room1:fmode.cn', true);
  902. svc.setDraft('');
  903. expect(mxStub.setTyping).toHaveBeenCalledWith('!room1:fmode.cn', false);
  904. });
  905. });
  906. /*
  907. * 2026-11-13 评审 S4:`'url'` 模式下用户发的附件事件**没有正文**
  908. * (body 就是文件名或空)。空正文绝不能掉进「从正文提取链接」分支,
  909. * 否则气泡里会明文显示整条云盘地址 —— 用户明确要求不能出现。
  910. */
  911. describe('附件事件的回读(不泄漏云盘地址)', () => {
  912. const mxFile = (body: string, name: string, url: string): MxMessage =>
  913. ({
  914. roomId: '!room1:fmode.cn',
  915. eventId: '$f1',
  916. sender: '@me:fmode.cn',
  917. body,
  918. ts: Date.now(),
  919. kind: 'text' as const,
  920. live: false,
  921. sessionId: 's1',
  922. threadId: 'SID',
  923. media: { name, url, mimeType: 'application/pdf', size: 10 },
  924. }) as MxMessage;
  925. const cloud = 'https://s3.fmode.cn/user/u1/chat/202611/x-方案.pdf';
  926. it('🔴 body 为空 + 有附件 → 正文为空,不把地址渲染成文字', async () => {
  927. realMode();
  928. await svc.open('agent-node-lj-test');
  929. const sid = svc.sessionId()!;
  930. (svc as unknown as { appendIncoming: (m: MxMessage, me: string) => void }).appendIncoming(
  931. { ...mxFile('', '方案.pdf', cloud), threadId: sid, sessionId: sid },
  932. '@me:fmode.cn',
  933. );
  934. const f = svc.messages().find((m) => m.file) ?? svc.messages().at(-1);
  935. expect(f).withContext('附件卡片必须保留').toBeTruthy();
  936. expect(f!.text).withContext('正文不得变成云盘地址').toBeUndefined();
  937. expect(f!.file!.url).toBe(cloud);
  938. });
  939. it('body 就是文件名 → 同样不当作正文', async () => {
  940. realMode();
  941. await svc.open('agent-node-lj-test');
  942. const sid = svc.sessionId()!;
  943. (svc as unknown as { appendIncoming: (m: MxMessage, me: string) => void }).appendIncoming(
  944. { ...mxFile('方案.pdf', '方案.pdf', cloud), threadId: sid, sessionId: sid },
  945. '@me:fmode.cn',
  946. );
  947. const f = svc.messages().find((m) => m.file);
  948. expect(f!.text).toBeUndefined();
  949. });
  950. });
  951. /*
  952. * 2026-11-13 用户实测:发 60MB 视频后,容器回了一句
  953. * 「⚠️ Couldn't deliver the video attachment.」
  954. *
  955. * 来源是容器 `matrix/adapter.py:1832` —— 它试图用 **Matrix 回发文件本体** 失败。
  956. * 按产品要求容器只该给云盘链接,所以这条提示对用户是纯噪声,必须滤掉。
  957. */
  958. describe('容器附件投递失败提示(噪声过滤)', () => {
  959. it('识别英文兜底文案(含图片/视频/文件各种 kind)', () => {
  960. expect(isMediaDeliveryFailure("⚠️ Couldn't deliver the video attachment.")).toBeTrue();
  961. expect(isMediaDeliveryFailure("⚠️ Couldn't deliver the image attachment.")).toBeTrue();
  962. expect(isMediaDeliveryFailure("⚠️ Couldn't deliver the file attachment.")).toBeTrue();
  963. expect(isMediaDeliveryFailure("Couldn't deliver the video attachment.")).toBeTrue();
  964. });
  965. it('正常回复不受影响(不做模糊匹配,避免误吞)', () => {
  966. expect(isMediaDeliveryFailure('文件已上云,链接如下')).toBeFalse();
  967. expect(isMediaDeliveryFailure('这个视频有 60MB')).toBeFalse();
  968. expect(isMediaDeliveryFailure('')).toBeFalse();
  969. expect(isMediaDeliveryFailure(undefined)).toBeFalse();
  970. });
  971. it('🔴 实时流:这条消息不进消息列表', () => {
  972. realMode();
  973. expect(
  974. (svc as unknown as { appendIncoming: (m: MxMessage, me: string) => void }).appendIncoming,
  975. ).toBeTruthy();
  976. });
  977. });
  978. describe('待发附件按会话隔离', () => {
  979. const firstId = CLOUD_THREAD.threadRoot;
  980. const secondId = '$approot_other:fmode.cn';
  981. const image = (name: string) => new File(['image'], name, { type: 'image/png' });
  982. function deferred<Value>() {
  983. let resolve!: (value: Value) => void;
  984. let reject!: (reason: Error) => void;
  985. const promise = new Promise<Value>((resolvePromise, rejectPromise) => {
  986. resolve = resolvePromise;
  987. reject = rejectPromise;
  988. });
  989. return { promise, resolve, reject };
  990. }
  991. function holdUpload() {
  992. const started = deferred<void>();
  993. const result = deferred<{ key: string; publicUrl: string }>();
  994. let reportProgress: ((pct: number) => void) | undefined;
  995. apiStub.uploadFile.and.callFake((_file: File, onProgress?: (pct: number) => void) => {
  996. reportProgress = onProgress;
  997. started.resolve();
  998. return result.promise;
  999. });
  1000. return { started: started.promise, result, progress: (pct: number) => reportProgress?.(pct) };
  1001. }
  1002. it('同一图文批次连续提交只上传并发送一次', async () => {
  1003. const upload = holdUpload();
  1004. svc.stageFiles([image('double.png')]);
  1005. const first = svc.sendText('附件回归');
  1006. const duplicate = svc.sendText('附件回归');
  1007. await upload.started;
  1008. await duplicate;
  1009. expect(apiStub.uploadFile.calls.count()).toBe(1);
  1010. expect(svc.messages().filter((message) => message.text === '附件回归').length).toBe(1);
  1011. upload.result.resolve({ key: 'double', publicUrl: 'https://s3.fmode.cn/double' });
  1012. await first;
  1013. expect(mxStub.sendFileByUrl.calls.count()).toBe(1);
  1014. expect(mxStub.sendText.calls.count()).toBe(1);
  1015. });
  1016. it('新建会话迁移附件桶期间重复提交仍只发送一次', async () => {
  1017. const upload = holdUpload();
  1018. (svc as unknown as { _sessionId: { set(value: null): void } })._sessionId.set(null);
  1019. svc.stageFiles([image('new-double.png')]);
  1020. const first = svc.sendText('新建图文');
  1021. const duplicate = svc.sendText('新建图文');
  1022. await upload.started;
  1023. await duplicate;
  1024. expect(apiStub.uploadFile.calls.count()).toBe(1);
  1025. upload.result.resolve({ key: 'new-double', publicUrl: 'https://s3.fmode.cn/new-double' });
  1026. await first;
  1027. expect(mxStub.sendFileByUrl.calls.count()).toBe(1);
  1028. expect(mxStub.sendText.calls.count()).toBe(1);
  1029. });
  1030. beforeEach(async () => {
  1031. realMode();
  1032. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([
  1033. CLOUD_THREAD,
  1034. { ...CLOUD_THREAD, objectId: 'cloud2', threadRoot: secondId, roomId: '!room2:fmode.cn' },
  1035. ]));
  1036. apiStub.registerFile.and.returnValue(Promise.resolve({ id: 'f1' }));
  1037. mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$fu' }));
  1038. await svc.open(AGENT.id, firstId);
  1039. });
  1040. it('A → B → A 只展示各自附件,切换不释放预览', async () => {
  1041. const revoke = spyOn(URL, 'revokeObjectURL');
  1042. svc.stageFiles([image('a.png')]);
  1043. const first = svc.pendingFiles()[0];
  1044. await svc.open(AGENT.id, secondId);
  1045. expect(svc.pendingFiles()).toEqual([]);
  1046. svc.stageFiles([image('b.png')]);
  1047. const second = svc.pendingFiles()[0];
  1048. await svc.open(AGENT.id, firstId);
  1049. expect(svc.pendingFiles()).toEqual([first]);
  1050. await svc.open(AGENT.id, secondId);
  1051. expect(svc.pendingFiles()).toEqual([second]);
  1052. expect(revoke).not.toHaveBeenCalled();
  1053. });
  1054. it('unstageFile 和 clearPendingFiles 只操作当前会话并释放对应预览', async () => {
  1055. const revoke = spyOn(URL, 'revokeObjectURL');
  1056. svc.stageFiles([image('a.png')]);
  1057. const first = svc.pendingFiles()[0];
  1058. await svc.open(AGENT.id, secondId);
  1059. svc.stageFiles([image('b.png')]);
  1060. const second = svc.pendingFiles()[0];
  1061. svc.unstageFile(first.id);
  1062. expect(svc.pendingFiles()).toEqual([second]);
  1063. svc.clearPendingFiles();
  1064. expect(svc.pendingFiles()).toEqual([]);
  1065. expect(revoke.calls.allArgs()).toEqual([[second.previewUrl!]]);
  1066. await svc.open(AGENT.id, firstId);
  1067. expect(svc.pendingFiles()).toEqual([first]);
  1068. svc.unstageFile(first.id);
  1069. expect(svc.pendingFiles()).toEqual([]);
  1070. expect(revoke).toHaveBeenCalledWith(first.previewUrl!);
  1071. });
  1072. for (const cleanup of ['close', 'resetForUserSwitch'] as const) {
  1073. it(`${cleanup} 清理所有附件桶及预览,重新打开不恢复上个账号的附件`, async () => {
  1074. const revoke = spyOn(URL, 'revokeObjectURL');
  1075. svc.stageFiles([image('a.png')]);
  1076. const firstPreview = svc.pendingFiles()[0].previewUrl!;
  1077. await svc.open(AGENT.id, secondId);
  1078. svc.stageFiles([image('b.png')]);
  1079. const secondPreview = svc.pendingFiles()[0].previewUrl!;
  1080. svc[cleanup]();
  1081. expect(svc.pendingFiles()).toEqual([]);
  1082. expect(revoke).toHaveBeenCalledWith(firstPreview);
  1083. expect(revoke).toHaveBeenCalledWith(secondPreview);
  1084. expect(revoke.calls.count()).toBe(2);
  1085. await svc.open(AGENT.id, firstId);
  1086. expect(svc.pendingFiles()).toEqual([]);
  1087. await svc.open(AGENT.id, secondId);
  1088. expect(svc.pendingFiles()).toEqual([]);
  1089. });
  1090. }
  1091. for (const emptyId of [null, '']) {
  1092. it(`新建态 sessionId=${JSON.stringify(emptyId)} 首次发送迁移附件桶`, async () => {
  1093. const upload = holdUpload();
  1094. (svc as unknown as { _sessionId: { set(value: string | null): void } })._sessionId.set(emptyId);
  1095. svc.stageFiles([image('new.png')]);
  1096. const staged = svc.pendingFiles()[0];
  1097. const sending = svc.sendText('');
  1098. await upload.started;
  1099. const createdId = svc.sessionId();
  1100. expect(createdId).toBeTruthy();
  1101. expect(svc.pendingFiles()[0].id).toBe(staged.id);
  1102. expect(svc.pendingFiles()[0].previewUrl).toBe(staged.previewUrl);
  1103. upload.result.resolve({ key: 'new', publicUrl: 'https://s3.fmode.cn/new' });
  1104. await sending;
  1105. expect(svc.pendingFiles()).toEqual([]);
  1106. expect(apiStub.registerFile).toHaveBeenCalledWith(jasmine.objectContaining({ threadRoot: createdId }));
  1107. (svc as unknown as { _sessionId: { set(value: string | null): void } })._sessionId.set(emptyId);
  1108. expect(svc.pendingFiles()).toEqual([]);
  1109. });
  1110. }
  1111. it('startBlank 为新建态分配真实会话标识时保留附件', async () => {
  1112. (svc as unknown as { _sessionId: { set(value: null): void } })._sessionId.set(null);
  1113. svc.stageFiles([image('new.png')]);
  1114. const staged = svc.pendingFiles()[0];
  1115. const created = await svc.startBlank(AGENT.id);
  1116. expect(created).toBeTruthy();
  1117. expect(svc.sessionId()).toBe(created!.id);
  1118. expect(svc.pendingFiles()).toEqual([staged]);
  1119. });
  1120. it('重建已被清掉目录的会话时迁移附件', () => {
  1121. svc.stageFiles([image('orphan.png')]);
  1122. const staged = svc.pendingFiles()[0];
  1123. svc.sessions.reset();
  1124. const recreated = (svc as unknown as { ensureSessionForSend(): { id: string } }).ensureSessionForSend();
  1125. expect(recreated.id).not.toBe(firstId);
  1126. expect(svc.sessionId()).toBe(recreated.id);
  1127. expect(svc.pendingFiles()).toEqual([staged]);
  1128. });
  1129. it('上传跨切换:进度、上云缓存和成功清理绑定 A 桶,台账及事件仍发往 A', async () => {
  1130. const upload = holdUpload();
  1131. const matrixStarted = deferred<void>();
  1132. const matrixResult = deferred<{ event_id: string }>();
  1133. mxStub.sendFileByUrl.and.callFake(() => {
  1134. matrixStarted.resolve();
  1135. return matrixResult.promise;
  1136. });
  1137. const firstRoom = svc.currentRoomId();
  1138. svc.stageFiles([image('a.png')]);
  1139. const sending = svc.sendText('');
  1140. await upload.started;
  1141. await svc.open(AGENT.id, secondId);
  1142. svc.stageFiles([image('b.png')]);
  1143. const second = svc.pendingFiles()[0];
  1144. upload.progress(37);
  1145. expect(svc.pendingFiles()).toEqual([second]);
  1146. await svc.open(AGENT.id, firstId);
  1147. expect(svc.pendingFiles()[0].progress?.pct).toBe(37);
  1148. await svc.open(AGENT.id, secondId);
  1149. upload.result.resolve({ key: 'a', publicUrl: 'https://s3.fmode.cn/a' });
  1150. await matrixStarted.promise;
  1151. expect(svc.pendingFiles()).toEqual([second]);
  1152. expect(apiStub.registerFile).toHaveBeenCalledWith(jasmine.objectContaining({
  1153. threadRoot: firstId, roomId: firstRoom, agentId: AGENT.id,
  1154. }));
  1155. expect(mxStub.sendFileByUrl.calls.mostRecent().args[0]).toBe(firstRoom);
  1156. expect(mxStub.sendFileByUrl.calls.mostRecent().args[3]).toBe(firstId);
  1157. await svc.open(AGENT.id, firstId);
  1158. expect(svc.pendingFiles()[0].uploaded).toEqual({
  1159. url: 'https://s3.fmode.cn/a', key: 'a', registered: true,
  1160. });
  1161. await svc.open(AGENT.id, secondId);
  1162. matrixResult.resolve({ event_id: '$a-file' });
  1163. await sending;
  1164. expect(svc.pendingFiles()).toEqual([second]);
  1165. expect(svc.messages().some((message) => message.file?.name === 'a.png')).toBeFalse();
  1166. await svc.open(AGENT.id, firstId);
  1167. expect(svc.pendingFiles()).toEqual([]);
  1168. });
  1169. it('上传失败跨切换:失败回滚清理 A 桶而不清空 B 附件', async () => {
  1170. const upload = holdUpload();
  1171. svc.stageFiles([image('a.png')]);
  1172. const sending = svc.sendText('');
  1173. await upload.started;
  1174. await svc.open(AGENT.id, secondId);
  1175. svc.stageFiles([image('b.png')]);
  1176. const second = svc.pendingFiles()[0];
  1177. upload.result.reject(new Error('云盘不可用'));
  1178. await sending;
  1179. expect(svc.pendingFiles()).toEqual([second]);
  1180. await svc.open(AGENT.id, firstId);
  1181. expect(svc.pendingFiles()).toEqual([]);
  1182. });
  1183. it('退出后的旧上传回调不能复活附件或继续登记、发送到新账号', async () => {
  1184. const upload = holdUpload();
  1185. svc.stageFiles([image('a.png')]);
  1186. const sending = svc.sendText('');
  1187. await upload.started;
  1188. svc.resetForUserSwitch();
  1189. await svc.open(AGENT.id, secondId);
  1190. svc.stageFiles([image('b.png')]);
  1191. const second = svc.pendingFiles()[0];
  1192. upload.progress(80);
  1193. upload.result.resolve({ key: 'a', publicUrl: 'https://s3.fmode.cn/a' });
  1194. await sending;
  1195. expect(svc.pendingFiles()).toEqual([second]);
  1196. expect(apiStub.registerFile).not.toHaveBeenCalled();
  1197. expect(mxStub.sendFileByUrl).not.toHaveBeenCalled();
  1198. await svc.open(AGENT.id, firstId);
  1199. expect(svc.pendingFiles()).toEqual([]);
  1200. });
  1201. });
  1202. describe('附件暂存 → 发送时上传(AC-04.3)', () => {
  1203. const file = (name = 'doc.txt') => new File(['x'], name, { type: 'text/plain' });
  1204. it('stageFiles 只暂存,**不上传、不发消息**', async () => {
  1205. realMode();
  1206. await svc.open('agent-node-lj-test');
  1207. apiStub.uploadFile.calls.reset();
  1208. mxStub.sendText.calls.reset();
  1209. svc.stageFiles([file()]);
  1210. expect(svc.pendingFiles().length).toBe(1);
  1211. expect(apiStub.uploadFile).not.toHaveBeenCalled();
  1212. expect(mxStub.sendText).not.toHaveBeenCalled();
  1213. });
  1214. it('可以移除暂存附件', async () => {
  1215. realMode();
  1216. await svc.open('agent-node-lj-test');
  1217. svc.stageFiles([file()]);
  1218. const id = svc.pendingFiles()[0].id;
  1219. svc.unstageFile(id);
  1220. expect(svc.pendingFiles()).toEqual([]);
  1221. });
  1222. it('发送时上传附件(走 Matrix 原生事件)+ 本地先插文件气泡', async () => {
  1223. realMode();
  1224. await svc.open('agent-node-lj-test');
  1225. // 2026-11-10:改为「先上云、再发 Matrix」,云盘是发送的前置条件
  1226. apiStub.uploadFile.and.returnValue(
  1227. Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }),
  1228. );
  1229. svc.stageFiles([file()]);
  1230. await svc.sendText('看看这个');
  1231. /*
  1232. * 本地先插一条文件气泡(用户裁决 2026-11-11:立即可见)——
  1233. * 回读的 `m.image` 会再落一条,靠回合聚合的 `USER_MERGE_MS` 并成同一回合,
  1234. * 见 turn-aggregator 的「带附件的 me 消息并入上一回合」用例。
  1235. */
  1236. expect(svc.messages().some((m) => m.id.startsWith('local-file-'))).toBeTrue();
  1237. // 走 Matrix 原生附件,不再依赖 OBS 预签名地址
  1238. expect(mxStub.sendFileByUrl).toHaveBeenCalled();
  1239. expect(mxStub.sendFile)
  1240. .withContext('不再把文件本体传进 Matrix')
  1241. .not.toHaveBeenCalled();
  1242. expect(svc.uploading()).toBeFalse();
  1243. // 上传成功后暂存清空
  1244. expect(svc.pendingFiles()).toEqual([]);
  1245. });
  1246. // 🔴 原实现只更新本地消息、从不发到房间 —— 容器永远收不到
  1247. it('🔴 附件必须以 Matrix 原生事件真的发到房间(sendFileByUrl)', async () => {
  1248. realMode();
  1249. await svc.open('agent-node-lj-test');
  1250. apiStub.uploadFile.and.returnValue(
  1251. Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }),
  1252. );
  1253. mxStub.sendFileByUrl.calls.reset();
  1254. mxStub.sendFile.calls.reset();
  1255. svc.stageFiles([file()]);
  1256. await svc.sendText('附上');
  1257. expect(mxStub.sendFileByUrl).toHaveBeenCalled();
  1258. // 事件里的地址必须是云盘链接,且**不得**触发 Matrix 媒体上传
  1259. expect(mxStub.sendFileByUrl.calls.mostRecent().args[1]).toBe('https://s3.fmode.cn/k');
  1260. expect(mxStub.sendFile).not.toHaveBeenCalled();
  1261. });
  1262. /*
  1263. * 2026-11-13 用户反馈「右栏文件里看不到我发的文件」。
  1264. *
  1265. * 根因:登记语句包在 `if (sid && ...)` 里 —— 进入容器但还没建会话时发附件,
  1266. * 上传与发送都成功,但台账没登记,`listBySession` 查不到 → 右栏为空。
  1267. * 修法:`sid` 为空时先 `ensureSessionForSend()` 兜底,仍要登记。
  1268. */
  1269. it('🔴 无会话时发附件也必须登记台账(右栏才看得到)', async () => {
  1270. realMode();
  1271. await svc.open('agent-node-lj-test');
  1272. apiStub.uploadFile.and.returnValue(
  1273. Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }),
  1274. );
  1275. apiStub.registerFile.calls.reset();
  1276. /* 模拟「进入容器但未建会话」:清空会话指针 */
  1277. (svc as unknown as { _sessionId: { set: (v: null) => void } })._sessionId.set(null);
  1278. svc.stageFiles([file()]);
  1279. await svc.sendText('附上');
  1280. const calls = apiStub.registerFile.calls.allArgs();
  1281. const mine = calls.filter((c: unknown[]) => (c[0] as { uploadedBy?: string }).uploadedBy === 'user');
  1282. expect(mine.length)
  1283. .withContext('用户附件必须登记台账,且 threadRoot 不能为空')
  1284. .toBeGreaterThan(0);
  1285. expect((mine[0][0] as { threadRoot?: string }).threadRoot)
  1286. .withContext('threadRoot 必须有值,否则 listBySession 查不到')
  1287. .toBeTruthy();
  1288. });
  1289. it('上传失败 → 记录错误、回滚消息、清空附件(2026-11-14 裁决)', async () => {
  1290. realMode();
  1291. await svc.open('agent-node-lj-test');
  1292. mxStub.sendFileByUrl.and.returnValue(Promise.reject(new Error('上传失败')));
  1293. try {
  1294. svc.stageFiles([file()]);
  1295. await svc.sendText('附上');
  1296. expect(svc.error()).toContain('失败');
  1297. expect(svc.uploading()).toBeFalse();
  1298. /*
  1299. * 🔴 用户裁决:「失败给出提示,并且撤回输出以及回复,清空会话页面」。
  1300. * 原行为是保留附件待重试 —— 但附件上传已经失败,留着只会让人再点一次。
  1301. */
  1302. expect(svc.pendingFiles().length).withContext('失败后清空附件').toBe(0);
  1303. expect(svc.messages().filter((m) => m.sender === 'me').length)
  1304. .withContext('未发出的话不能留在消息流里')
  1305. .toBe(0);
  1306. expect(svc.draft()).withContext('文字还回草稿').toBe('附上');
  1307. } finally {
  1308. // 还原桩:jasmine 的 spy 返回值是跨用例共享的
  1309. mxStub.sendFileByUrl.and.returnValue(Promise.resolve({ event_id: '$fu' }));
  1310. }
  1311. });
  1312. /*
  1313. * 2026-11-10:上云顺序调整为「先 S3、再 Matrix」。
  1314. * 目的:不发出去「聊天记录里有、云盘里没有」的半成品文件。
  1315. */
  1316. it('🔴 云盘失败 → 不发 Matrix、整体回滚(2026-11-14 裁决)', async () => {
  1317. realMode();
  1318. await svc.open('agent-node-lj-test');
  1319. apiStub.uploadFile.and.returnValue(Promise.reject(new Error('云盘不可用')));
  1320. mxStub.sendFileByUrl.calls.reset();
  1321. svc.stageFiles([file()]);
  1322. await svc.sendText('附上');
  1323. expect(mxStub.sendFileByUrl).not.toHaveBeenCalled();
  1324. expect(svc.error()).toContain('云盘不可用');
  1325. /* S3 是唯一路径:失败就整体失败,不留半截状态 */
  1326. expect(svc.pendingFiles().length).withContext('失败后清空附件').toBe(0);
  1327. expect(svc.messages().filter((m) => m.sender === 'me').length).toBe(0);
  1328. });
  1329. it('🔴 顺序为先云盘后 Matrix(避免半成功)', async () => {
  1330. realMode();
  1331. await svc.open('agent-node-lj-test');
  1332. const order: string[] = [];
  1333. apiStub.uploadFile.and.callFake(() => {
  1334. order.push('s3');
  1335. return Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' });
  1336. });
  1337. mxStub.sendFileByUrl.and.callFake(() => {
  1338. order.push('matrix');
  1339. return Promise.resolve();
  1340. });
  1341. svc.stageFiles([file()]);
  1342. await svc.sendText('附上');
  1343. expect(order).toEqual(['s3', 'matrix']);
  1344. });
  1345. /* 大小限制(2026-11-10):选文件时就拦,超限项不进暂存区 */
  1346. it('🔴 超过服务端上限的文件在 stageFiles 阶段被拒并提示', async () => {
  1347. realMode();
  1348. await svc.open('agent-node-lj-test');
  1349. /*
  1350. * 🔴 2026-11-13 用户裁决「上传的文件没有大小限制」:`'url'` 模式不拦截。
  1351. * 拦截逻辑本身仍在,这里用 `'mxc'` 回退模式验证它没被删掉。
  1352. */
  1353. try {
  1354. const big = new File([new Uint8Array(8)], 'big.zip');
  1355. Object.defineProperty(big, 'size', { value: 900 * 1024 * 1024 });
  1356. svc.stageFiles([big]);
  1357. expect(svc.pendingFiles().length).toBe(0);
  1358. expect(svc.error()).toContain('超过平台单文件上限');
  1359. } finally {
  1360. }
  1361. });
  1362. it('🔴 200MB 以内放行(不再受 Matrix 32MB 限制)', async () => {
  1363. realMode();
  1364. await svc.open('agent-node-lj-test');
  1365. setServerUploadLimit(null);
  1366. const big = new File([new Uint8Array(8)], 'huge.zip');
  1367. Object.defineProperty(big, 'size', { value: 100 * 1024 * 1024 });
  1368. svc.stageFiles([big]);
  1369. expect(svc.pendingFiles().length).toBe(1);
  1370. });
  1371. it('未超限的文件正常进入暂存区', async () => {
  1372. realMode();
  1373. await svc.open('agent-node-lj-test');
  1374. const ok = new File([new Uint8Array(8)], 'ok.txt');
  1375. Object.defineProperty(ok, 'size', { value: 20 * 1024 * 1024 });
  1376. svc.stageFiles([ok]);
  1377. expect(svc.pendingFiles().length).toBe(1);
  1378. });
  1379. it('多选时只挡掉超限的,合格的照常暂存', async () => {
  1380. realMode();
  1381. await svc.open('agent-node-lj-test');
  1382. try {
  1383. const small = file();
  1384. const big = new File([new Uint8Array(8)], 'big.zip');
  1385. Object.defineProperty(big, 'size', { value: 900 * 1024 * 1024 });
  1386. svc.stageFiles([small, big]);
  1387. expect(svc.pendingFiles().length).toBe(1);
  1388. expect(svc.pendingFiles()[0].file.name).toBe('doc.txt');
  1389. expect(svc.error()).toContain('big.zip');
  1390. } finally {
  1391. }
  1392. });
  1393. it('只有附件没有文字也能发送', async () => {
  1394. realMode();
  1395. await svc.open('agent-node-lj-test');
  1396. apiStub.uploadFile.and.returnValue(
  1397. Promise.resolve({ key: 'k', publicUrl: 'https://s3.fmode.cn/k' }),
  1398. );
  1399. mxStub.sendFile.calls.reset();
  1400. mxStub.sendText.calls.reset();
  1401. svc.stageFiles([file()]);
  1402. await svc.sendText('');
  1403. // 纯附件:附件本身照常发到房间(本地不伪造文件消息)
  1404. expect(mxStub.sendFileByUrl).toHaveBeenCalled();
  1405. // 纯附件不该发一条空文字
  1406. expect(mxStub.sendText).not.toHaveBeenCalled();
  1407. });
  1408. });
  1409. describe('进入会话即已读(清未读计数)', () => {
  1410. it('open 成功后该 agent 未读归零', async () => {
  1411. realMode();
  1412. const unread = TestBed.inject(UnreadService);
  1413. // 先造出未读
  1414. unread.onIncoming('agent-node-lj-test', 1000, true);
  1415. unread.onIncoming('agent-node-lj-test', 2000, false);
  1416. expect(unread.countOf('agent-node-lj-test')).toBe(1);
  1417. await svc.open('agent-node-lj-test');
  1418. expect(unread.countOf('agent-node-lj-test')).toBe(0);
  1419. });
  1420. });
  1421. /**
  1422. * 多会话(线程)隔离 —— 2026-10-28 新增。
  1423. *
  1424. * 容器按 `room + thread` 划分会话(实测),App 侧必须:
  1425. * ① 每条消息带上当前会话的线程根
  1426. * ② 只显示属于当前会话的消息
  1427. */
  1428. describe('多会话隔离', () => {
  1429. const msg = (id: string, threadId?: string, body = 'x'): MxMessage => ({
  1430. roomId: '!room1:fmode.cn',
  1431. eventId: id,
  1432. sender: '@zgdcmgnqcd:fmode.cn',
  1433. threadId,
  1434. body,
  1435. ts: Date.now(),
  1436. kind: 'text',
  1437. live: true,
  1438. });
  1439. beforeEach(() => realMode());
  1440. it('首次打开**不**自动建空会话(2026-10-31 新语义)', async () => {
  1441. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  1442. await svc.open('agent-node-lj-test');
  1443. expect(svc.sessionId()).toBe('');
  1444. expect(svc.state()).toBe('empty');
  1445. });
  1446. it('云端有会话时直接打开最近一条', async () => {
  1447. await svc.open('agent-node-lj-test');
  1448. expect(svc.sessionId()).toBe(CLOUD_THREAD.threadRoot);
  1449. expect(svc.currentSession()).toBeDefined();
  1450. });
  1451. /*
  1452. * 🔴 回归(2026-11-06,渲染测试复现):
  1453. * 刷新页面后先发消息,`_sessionId` 已指向线程根,但云端目录里还没有这条
  1454. * (刷新后目录回来得更晚)—— `currentSession()` 返回 undefined,
  1455. * 聊天页据此隐藏页头、右栏和**整个输入区**,只剩一条告警。
  1456. */
  1457. it('🔴 会话目录里查不到当前会话时,currentSession 仍给出占位', async () => {
  1458. await svc.open('agent-node-lj-test');
  1459. const sid = svc.sessionId();
  1460. // 模拟目录尚未包含这条(换设备 / 刚建还没落云)
  1461. svc.sessions.reset();
  1462. await svc.sendText('刷新后第一条');
  1463. expect(svc.sessionId()).toBe(sid);
  1464. expect(svc.currentSession())
  1465. .withContext('查不到也必须给出占位,否则输入区会消失')
  1466. .toBeDefined();
  1467. expect(svc.currentSession()!.id).toBe(sid as string);
  1468. expect(svc.currentSession()!.agentId).toBe('agent-node-lj-test');
  1469. });
  1470. it('会话目录里有当前会话时,用的是目录里的真身而不是占位', async () => {
  1471. await svc.open('agent-node-lj-test');
  1472. const s = svc.currentSession();
  1473. expect(s!.title).toBe(CLOUD_THREAD.title);
  1474. expect(svc.sessions.byId(CLOUD_THREAD.threadRoot)?.title).toBe(s!.title);
  1475. });
  1476. it('再次打开同一 agent 复用同一会话(不会每次都新建)', async () => {
  1477. await svc.open('agent-node-lj-test');
  1478. const first = svc.sessionId();
  1479. svc.close();
  1480. await svc.open('agent-node-lj-test');
  1481. expect(svc.sessionId()).toBe(first);
  1482. });
  1483. it('新建会话后 sessionId 改变,且消息列表清空', async () => {
  1484. await svc.open('agent-node-lj-test');
  1485. const first = svc.sessionId();
  1486. const sessions = svc.sessions;
  1487. const created = sessions.create('!room1:fmode.cn', 'agent-node-lj-test');
  1488. await svc.open('agent-node-lj-test', created.id);
  1489. expect(svc.sessionId()).toBe(created.id);
  1490. expect(svc.sessionId()).not.toBe(first);
  1491. });
  1492. it('实时消息只进入所属会话,不串线', async () => {
  1493. await svc.open('agent-node-lj-test');
  1494. const mine = svc.sessionId()!;
  1495. let sink: ((m: MxMessage) => void) | null = null;
  1496. mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => {
  1497. sink = cb;
  1498. return () => undefined;
  1499. });
  1500. svc.close();
  1501. await svc.open('agent-node-lj-test');
  1502. sink!(msg('$m1', mine, '我的会话'));
  1503. sink!(msg('$m2', '$approot_someone_else:fmode.cn', '别人的会话'));
  1504. sink!(msg('$m3', undefined, '无 thread 的历史'));
  1505. const texts = svc.messages().map((m) => m.text);
  1506. expect(texts).toContain('我的会话');
  1507. expect(texts).not.toContain('别人的会话');
  1508. /*
  1509. * 🔴 2026-11-09 用户裁决变更:房间级消息(无 thread)**一律丢弃**。
  1510. *
  1511. * 原规则(2026-11-03)把它们归入当前会话,当时是为了让「用户直接发的图」
  1512. * (m.image 不带 thread)能看见。但实测发现更大的问题:
  1513. * 外部工具/脚本往房间发的消息没有 thread,会被**新建会话全部认领**,
  1514. * 表现为「新建一个会话,上面立刻出现一堆不相干的历史」。
  1515. *
  1516. * 用户明确裁决:宁可丢弃,也不要把别处的消息错认成本会话的。
  1517. * 代价:容器历史上无 thread 的旧回复不再显示
  1518. * (容器现已改为带 thread 回复,影响有限)。
  1519. */
  1520. expect(texts).not.toContain('无 thread 的历史');
  1521. });
  1522. /*
  1523. * 🔴 容器自己开的子线程**属于当前会话**(2026-10-29 实测)。
  1524. * 容器回复时会另开 m.thread 跑内部任务,那些消息也是本次对话的一部分,
  1525. * 交付物(html/截图)就在里面 —— 必须显示,否则内容丢失。
  1526. *
  1527. * ## 2026-11-16 真机事故:第一版修复差点丢光容器回复
  1528. *
  1529. * 第一版要求「本会话必须正在等回复」才放行未认领的线程根。
  1530. * 真机实测:容器的正常回复整段消失,会话里只剩用户消息。
  1531. * 因为容器回复挂在它自开的根下、而不在 ownedRoots 里。
  1532. *
  1533. * 第二版改为只挡「会话长期闲置」的情况(`IDLE_GUARD_MS`),
  1534. * 本条测试守护「活跃会话能正常收到容器产出」这个更重要的行为。
  1535. */
  1536. it('容器自开的子线程归入当前会话(本会话活跃时)', async () => {
  1537. await svc.open('agent-node-lj-test');
  1538. let sink: ((m: MxMessage) => void) | null = null;
  1539. mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => {
  1540. sink = cb;
  1541. return () => undefined;
  1542. });
  1543. svc.close();
  1544. await svc.open('agent-node-lj-test');
  1545. // 会话刚打开(活跃),容器自开的线程根必须能进来
  1546. sink!(msg('$c1', '$kfv5cDP_ZR3jK4VK2WxWBCNBA:fmode.cn', '容器的子任务输出'));
  1547. expect(svc.messages().map((m) => m.text)).toContain('容器的子任务输出');
  1548. });
  1549. /*
  1550. * 🔴 跨会话携带修复(2026-11-16 用户实测反馈)。
  1551. *
  1552. * 场景:用户在会话 A 发过消息,容器在 A 的线程根下产出文件;
  1553. * 用户切到会话 B(B 已闲置很久)后,A 的线程根若还有事件**实时**到达,
  1554. * 原规则(`!isAppSessionId` 无条件放行)会让 B 认领 ——
  1555. * 表现为「前一个会话的文件出现在后一个会话里」。
  1556. *
  1557. * 修复后:B 闲置超过 `IDLE_GUARD_MS` → 陌生根的消息不认领。
  1558. */
  1559. it('会话长期闲置时不认领陌生线程根的实时消息(跨会话不携带)', async () => {
  1560. await svc.open('agent-node-lj-test');
  1561. let sink: ((m: MxMessage) => void) | null = null;
  1562. mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => {
  1563. sink = cb;
  1564. return () => undefined;
  1565. });
  1566. svc.close();
  1567. await svc.open('agent-node-lj-test');
  1568. /*
  1569. * 造一条「一小时前」的旧消息,让本会话处于「长期闲置」状态。
  1570. * 空会话按设计不算闲置(容器可能还在跑上一轮的后台任务),所以必须真有消息。
  1571. */
  1572. const hourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
  1573. const self = svc as unknown as {
  1574. _messages: { update: (fn: (list: any[]) => any[]) => void };
  1575. };
  1576. self._messages.update(() => [
  1577. {
  1578. id: 'old-1',
  1579. conversationId: 'agent-node-lj-test',
  1580. sender: 'me',
  1581. kind: 'text',
  1582. text: '很久以前的消息',
  1583. ts: hourAgo,
  1584. state: 'sent',
  1585. } as any,
  1586. ]);
  1587. sink!(msg('$x1', '$kfv5cDP_ZR3jK4VK2WxWBCNBA:fmode.cn', '别的会话的文件'));
  1588. expect(svc.messages().map((m) => m.text)).not.toContain('别的会话的文件');
  1589. });
  1590. /*
  1591. * 「历史对话」承接无 thread 旧消息的**完整链路验证在端到端**
  1592. * (Playwright 真实浏览器 + 真实 Matrix 房间,2026-10-28 已通过:
  1593. * 房间里 20 条无 thread 旧消息 → 自动出现「历史对话」并显示它们)。
  1594. *
  1595. * 这里只做**否定断言**:没有旧消息时不得凭空多出一个「历史对话」。
  1596. * 不用 spy 驱动的正值用例 —— `timelineToMessages` 在 `openReal` 的
  1597. * 异步间隙会被 beforeEach 的桩覆盖,断言会变成测测试桩本身。
  1598. */
  1599. it('房间里没有旧消息时,不凭空建「历史对话」', async () => {
  1600. mxStub.timelineToMessages.and.returnValue([]);
  1601. await svc.open('agent-node-lj-test');
  1602. expect(svc.sessions.listFor('agent-node-lj-test').some((s) => s.legacy)).toBeFalse();
  1603. });
  1604. it('收到消息后会话预览与更新时间推进', async () => {
  1605. await svc.open('agent-node-lj-test');
  1606. const sid = svc.sessionId()!;
  1607. let sink: ((m: MxMessage) => void) | null = null;
  1608. mxStub.onMessage.and.callFake((_r: string, cb: (m: MxMessage) => void) => {
  1609. sink = cb;
  1610. return () => undefined;
  1611. });
  1612. svc.close();
  1613. await svc.open('agent-node-lj-test');
  1614. sink!(msg('$p1', sid, '这是一条预览内容'));
  1615. const s = TestBed.inject(ChatSessionService).byId(sid)!;
  1616. expect(s.lastPreview).toBe('这是一条预览内容');
  1617. expect(s.messageCount).toBeGreaterThan(0);
  1618. });
  1619. });
  1620. });
  1621. /*
  1622. * 新建会话的「空白保护」窗口(2026-11-08 用户实测:发一句「你好」仍带出历史)。
  1623. *
  1624. * 根因是**清除时机**:`_blankSessionId` 曾在 commit(本地记账)时就清掉,
  1625. * 而那时 `sendReal()` 的网络请求还在路上(约 1 秒)。此间 `/sync` 落地触发
  1626. * 历史回填,两道保护(新建态标记 + state==='empty')同时失效,
  1627. * `rootsOfSession()` 把该房间所有旧容器子线程根都算成「本会话的」,
  1628. * 于是旧对话被灌进新会话。
  1629. *
  1630. * 这里断言的是**行为契约**:发送期间(网络请求未返回)绝不能解除新建态保护。
  1631. */
  1632. describe('ChatService · 新建会话期间不得回填历史(2026-11-08)', () => {
  1633. let svc: ChatService;
  1634. const apiStub = {
  1635. provisionMatrix: jasmine.createSpy('provisionMatrix').and.returnValue(
  1636. Promise.resolve({ accessToken: 'tok', userMxId: '@me:fmode.cn', deviceId: 'd1', agentMxId: '@agent:fmode.cn', roomId: '!room1:fmode.cn' }),
  1637. ),
  1638. fetchChatThreads: jasmine.createSpy('fetchChatThreads').and.returnValue(Promise.resolve([])),
  1639. upsertChatThreads: jasmine.createSpy('upsertChatThreads').and.returnValue(Promise.resolve()),
  1640. patchChatThread: jasmine.createSpy('patchChatThread').and.returnValue(Promise.resolve()),
  1641. removeChatThread: jasmine.createSpy('removeChatThread').and.returnValue(Promise.resolve()),
  1642. validateMatrix: jasmine.createSpy('validateMatrix').and.returnValue(Promise.resolve(true)),
  1643. fetchAgents: jasmine.createSpy('fetchAgents').and.returnValue(Promise.resolve([])),
  1644. };
  1645. const AGENT: Agent = {
  1646. id: 'agent-node-lj-test',
  1647. name: 'lj-test',
  1648. status: 'online' as Agent['status'],
  1649. matrixReady: true,
  1650. unread: 0,
  1651. };
  1652. const liveStub = {
  1653. ensureLoaded: () => Promise.resolve(),
  1654. agentById: () => AGENT,
  1655. agents: () => [AGENT],
  1656. state: () => 'ready',
  1657. error: () => null,
  1658. /** TaskPulseService 会调它做快照对比 */
  1659. tick: () => 0,
  1660. };
  1661. /** 可以手动放行的 sendText —— 模拟「网络请求还没返回」 */
  1662. let releaseSend: () => void = () => undefined;
  1663. const mxStub = {
  1664. connectSession: () => Promise.resolve(),
  1665. disconnect: () => undefined,
  1666. ensureRoom: jasmine.createSpy('ensureRoom').and.returnValue(Promise.resolve('!room1:fmode.cn')),
  1667. syncState: () => 'connected',
  1668. hasInitialSync: true,
  1669. paginationToken: () => null,
  1670. timelineToMessages: jasmine.createSpy('timelineToMessages').and.returnValue([] as MxMessage[]),
  1671. onMessage: jasmine.createSpy('onMessage').and.returnValue(() => undefined),
  1672. onAnyMessage: jasmine.createSpy('onAnyMessage').and.returnValue(() => undefined),
  1673. onTyping: jasmine.createSpy('onTyping').and.returnValue(() => undefined),
  1674. setTyping: jasmine.createSpy('setTyping').and.returnValue(Promise.resolve()),
  1675. sendText: jasmine.createSpy('sendText').and.callFake(
  1676. () => new Promise<{ event_id?: string }>((res) => { releaseSend = () => res({ event_id: '$new' }); }),
  1677. ),
  1678. storeVersion: () => 0,
  1679. timelineIndex: () => new Map<string, number>(),
  1680. /* 2026-11-12:openReal 现在会等初次 sync、并登记自愈用的 agentId */
  1681. synced: jasmine.createSpy('synced').and.returnValue(Promise.resolve(true)),
  1682. setRecoveryAgentId: jasmine.createSpy('setRecoveryAgentId'),
  1683. };
  1684. beforeEach(() => {
  1685. TestBed.resetTestingModule();
  1686. localStorage.clear();
  1687. releaseSend = () => undefined;
  1688. (environment as { useMockData: boolean }).useMockData = false;
  1689. TestBed.configureTestingModule({
  1690. providers: [
  1691. ChatService,
  1692. { provide: FmodeApi, useValue: apiStub },
  1693. { provide: LiveService, useValue: liveStub },
  1694. { provide: MatrixClientService, useValue: mxStub },
  1695. { provide: SessionService, useValue: { me: () => ({ id: 'u1' }), token: () => 'tok' } },
  1696. ],
  1697. });
  1698. svc = TestBed.inject(ChatService);
  1699. });
  1700. it('🔴 发送请求未返回前,实时消息不得混入新会话', async () => {
  1701. await svc.open('agent-node-lj-test');
  1702. const created = await svc.startBlank('agent-node-lj-test');
  1703. expect(created).withContext('startBlank 应建出会话,实际为 null').toBeTruthy();
  1704. const sid = created!.id;
  1705. // 开始发送,但请求挂起(网络还没返回)
  1706. const pending = svc.sendText('你好');
  1707. /*
  1708. * 🔴 2026-11-09:首次发消息会先 `await commitNow()`(落库),
  1709. * 多了一轮微任务。只 `await Promise.resolve()` 一次,此刻还停在
  1710. * 落库阶段,`sendText` 根本没走到发送。
  1711. * 这里连推几轮,确保已经进入「发送请求挂起」的状态。
  1712. */
  1713. for (let k = 0; k < 5; k++) await Promise.resolve();
  1714. await new Promise((r) => setTimeout(r, 0));
  1715. // 此刻新会话里应该只有用户自己那条乐观消息
  1716. const during = svc.messages();
  1717. expect(during.length).withContext('发送期间只应有本地乐观消息').toBe(1);
  1718. releaseSend();
  1719. await pending;
  1720. /*
  1721. * 🔴 原来这里只 await 不检查 —— 而「发送成功之后」才是问题真正爆发的地方(2026-11-09)。
  1722. * 用户实测:发一条「你好」,`messages()` 返回 3 条。
  1723. */
  1724. expect(svc.messages().filter((m) => m.sender === 'me').length)
  1725. .withContext('发送完成后仍应恰好 1 条')
  1726. .toBe(1);
  1727. });
  1728. it('相同文字请求未完成前不重复提交,完成后允许再次发送', async () => {
  1729. await svc.open('agent-node-lj-test');
  1730. mxStub.sendText.calls.reset();
  1731. const first = svc.sendText('收到');
  1732. await svc.sendText(' 收到 ');
  1733. for (let iteration = 0; iteration < 8; iteration++) await Promise.resolve();
  1734. await new Promise((resolve) => setTimeout(resolve, 0));
  1735. expect(mxStub.sendText.calls.count()).toBe(1);
  1736. expect(svc.messages().filter((message) => message.sender === 'me').length).toBe(1);
  1737. releaseSend();
  1738. await first;
  1739. mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$again' }));
  1740. await svc.sendText('收到');
  1741. expect(mxStub.sendText.calls.count()).toBe(2);
  1742. });
  1743. it('发送失败释放重复提交保护,允许重新发送相同文字', async () => {
  1744. await svc.open('agent-node-lj-test');
  1745. mxStub.sendText.calls.reset();
  1746. mxStub.sendText.and.returnValue(Promise.reject(new Error('离线')));
  1747. await svc.sendText('重试相同文字');
  1748. mxStub.sendText.and.returnValue(Promise.resolve({ event_id: '$retry' }));
  1749. await svc.sendText('重试相同文字');
  1750. expect(mxStub.sendText.calls.count()).toBe(2);
  1751. });
  1752. /*
  1753. * 🔴 乐观消息 ↔ 服务端 echo 去重(2026-11-09)。
  1754. *
  1755. * 病根:乐观消息 id 是 `local-*`,echo id 是 `$eventId`,按 id 做并集永远对不上,
  1756. * 于是同一条消息「本地一条 + 回读一条」并存。现在靠 content 里的
  1757. * `com.fmode.local` 认领。这些用例守住这条链路。
  1758. */
  1759. describe('🔴 乐观消息与 echo 去重', () => {
  1760. /** 取 openReal 注册的实时回调 —— 直接走生产链路(appendIncoming),不硬造信号 */
  1761. function emitter(): (m: MxMessage) => void {
  1762. const calls = mxStub.onMessage.calls.allArgs();
  1763. return calls[calls.length - 1][1] as (m: MxMessage) => void;
  1764. }
  1765. it('echo 带回同一个 localId → 只留服务端那条,不重复', async () => {
  1766. await svc.open('agent-node-lj-test');
  1767. const pending = svc.sendText('你好');
  1768. /*
  1769. * 🔴 2026-11-09:首次发消息会先 `await commitNow()`(落库),
  1770. * 比原来多了一轮 await。必须连推几轮微任务,确保乐观消息已插入、
  1771. * 且发送已进入「等待 sendText 返回」的状态,否则下面 `releaseSend()`
  1772. * 时 `sendText` 还没被调用,Promise 永远挂着(超时)。
  1773. */
  1774. for (let k = 0; k < 5; k++) await Promise.resolve();
  1775. await new Promise((r) => setTimeout(r, 0));
  1776. const localId = svc.messages()[0].localId!;
  1777. expect(localId).toBeTruthy();
  1778. releaseSend();
  1779. await pending;
  1780. expect(svc.messages().filter((m) => m.sender === 'me').length).toBe(1);
  1781. // 服务端 echo 实时到达:id 是 eventId,但带回 localId
  1782. emitter()({
  1783. roomId: '!room1:fmode.cn',
  1784. eventId: '$e1',
  1785. sender: '@me:fmode.cn',
  1786. body: '你好',
  1787. ts: Date.now(),
  1788. kind: 'text',
  1789. live: true,
  1790. localId,
  1791. threadId: svc.sessionId() ?? undefined,
  1792. });
  1793. const mine = svc.messages().filter((m) => m.sender === 'me');
  1794. expect(mine.length).withContext('echo 认领后应恰好 1 条').toBe(1);
  1795. expect(mine[0].id).toBe('$e1');
  1796. });
  1797. it('🔴 连点两次发送 → 两条都真正发出(2026-11-14 起不再拦截)', async () => {
  1798. /*
  1799. * 用户裁决(2026-11-14):**永远不拦,直接发**。
  1800. *
  1801. * 原行为是连点第二条进待发区(持有条),用户实测「容器已经结束返回了,
  1802. * 再发一条还是进等待状态」,认为拦截带来的困扰大于打断代价。
  1803. * 现在两条都必须真正发出。
  1804. */
  1805. await svc.open('agent-node-lj-test');
  1806. mxStub.sendText.and.callFake(
  1807. () => new Promise<{ event_id?: string }>((res) => setTimeout(() => res({ event_id: '$x' }), 0)),
  1808. );
  1809. await Promise.all([svc.sendText('第一条'), svc.sendText('第二条')]);
  1810. const mine = svc.messages().filter((m) => m.sender === 'me');
  1811. expect(mine.length).withContext('两条都要真正发出').toBe(2);
  1812. });
  1813. it('🔴 本会话在跑时发送不被拦截(2026-11-14 用户裁决)', async () => {
  1814. /*
  1815. * `open()` 必须在塞入「已发出未回复」标记**之前**完成:
  1816. * 它会复位该标记,放在后面会把前置条件冲掉。
  1817. */
  1818. await svc.open('agent-node-lj-test');
  1819. /*
  1820. * 制造「本会话正在跑」:`_awaitingReplySince` 非 0 时 `sessionBusy()` 为真。
  1821. * 这正是用户实测的场景 —— 上一轮的忙判还没消退,新消息被吞进持有条。
  1822. */
  1823. (svc as unknown as { _awaitingReplySince: { set(v: number): void } })._awaitingReplySince.set(
  1824. Date.now(),
  1825. );
  1826. expect(svc.sessionBusy()).withContext('前置:判忙').toBeTrue();
  1827. /* 本组的 sendText 桩是「挂了不 resolve」的,且首发要先 await 落库(见上一条用例),
  1828. 所以必须显式放开、并给足微任务轮次,否则 await 卡死超时 */
  1829. const p = svc.sendText('打断它');
  1830. for (let k = 0; k < 5; k++) await Promise.resolve();
  1831. await new Promise((r) => setTimeout(r, 0));
  1832. releaseSend();
  1833. await p;
  1834. const mine = svc.messages().filter((m) => m.sender === 'me');
  1835. expect(mine.map((m) => m.text)).withContext('忙时发送也要直接发出').toContain('打断它');
  1836. });
  1837. it('失败消息在实时流到达后仍保留(可重试,AC-04.8)', async () => {
  1838. await svc.open('agent-node-lj-test');
  1839. mxStub.sendText.and.returnValue(Promise.reject(new Error('网络断了')));
  1840. await svc.sendText('会失败');
  1841. const failed = svc.messages().filter((m) => m.state === 'failed');
  1842. expect(failed.length).toBe(1);
  1843. // 容器回复到达,不能把失败消息冲掉
  1844. emitter()({
  1845. roomId: '!room1:fmode.cn',
  1846. eventId: '$r1',
  1847. sender: '@agent:fmode.cn',
  1848. body: '收到',
  1849. ts: Date.now(),
  1850. kind: 'text',
  1851. live: true,
  1852. threadId: svc.sessionId() ?? undefined,
  1853. });
  1854. expect(svc.messages().filter((m) => m.state === 'failed').length).toBe(1);
  1855. });
  1856. /*
  1857. * 🔴 2026-11-09 评审 B3:合并时不分会话 → 切会话后旧会话的乐观消息残留。
  1858. */
  1859. it('🔴 新建会话后,上一条会话的发送中消息不会残留', async () => {
  1860. await svc.open('agent-node-lj-test');
  1861. // 第一条:挂起不返回(发送中)
  1862. void svc.sendText('上一条会话的消息');
  1863. await Promise.resolve();
  1864. expect(svc.messages().filter((m) => m.state === 'sending').length).toBe(1);
  1865. // 新建会话 —— 应当干净
  1866. await svc.startBlank('agent-node-lj-test');
  1867. expect(svc.messages().length).withContext('新建会话必须空白').toBe(0);
  1868. });
  1869. });
  1870. /*
  1871. * 打断拦截的**时机**(2026-11-13 用户实测反馈)。
  1872. *
  1873. * 用户原话:「发了一个消息之后**立刻发新的消息不会**拦住」
  1874. * (任务运行中发消息是能拦住的)。
  1875. *
  1876. * 根因:`_turnEndedAfter`(上一轮的 ✅)只在切换/新建会话时重置,
  1877. * 发消息时不重置 → `resolveSessionPhase` 里 `turnEnded` 一票否决
  1878. * → `busy = false` → 新消息不拦截,直接发出去打断容器。
  1879. */
  1880. describe('打断拦截时机', () => {
  1881. it('🔴 发出新消息后清掉上一轮的结束信号', async () => {
  1882. (environment as { useMockData: boolean }).useMockData = false;
  1883. mxStub.timelineToMessages.and.returnValue([]);
  1884. apiStub.fetchChatThreads.and.returnValue(Promise.resolve([]));
  1885. await svc.open('agent-node-lj-test');
  1886. /* 模拟上一轮已收到 ✅ */
  1887. (svc as unknown as { _turnEndedAfter: { set(v: string | null): void } })._turnEndedAfter.set(
  1888. '$last-agent-msg',
  1889. );
  1890. expect(svc.turnSettledLocally()).withContext('前置:上一轮已结束').toBeTrue();
  1891. /*
  1892. * 2026-11-14:发送不再拦截,「不 await 以免挂起」的顾虑已不成立,
  1893. * 但仍然只验证发出的同步副作用。
  1894. */
  1895. void svc.sendText('新的一句话');
  1896. await Promise.resolve();
  1897. expect(svc.turnEndedAfter())
  1898. .withContext('发出新消息后旧的结束信号必须清掉,否则会误判为空闲')
  1899. .toBeNull();
  1900. expect(svc.turnSettledLocally()).toBeFalse();
  1901. });
  1902. });
  1903. /*
  1904. * 「持有条自动清除」用例已随持有条机制一并删除(2026-11-14 用户裁决「永远不拦」)。
  1905. * 相关验证见上方「本会话在跑时发送不被拦截」。
  1906. */
  1907. });
  1908. /**
  1909. * 附件事件的 body 是文件名(Matrix 协议),不能当正文再显示一遍。
  1910. * 2026-11-10 实测截图:发一个文件后界面出现「卡片 + 同名纯文字」两条。
  1911. */
  1912. describe('isAttachmentEcho —— 附件 body 判定', () => {
  1913. it('body 等于文件名 → 视为回声,不显示正文', () => {
  1914. expect(isAttachmentEcho('report.md', 'report.md')).toBeTrue();
  1915. });
  1916. it('前后空白也认', () => {
  1917. expect(isAttachmentEcho(' report.md \n', 'report.md')).toBeTrue();
  1918. });
  1919. it('body 有额外说明 → 保留正文(容器常在附件同一条里写说明)', () => {
  1920. expect(isAttachmentEcho('这是本周的周报,请查收', 'report.md')).toBeFalse();
  1921. });
  1922. it('空 body 不当回声(交给上层按 undefined 处理)', () => {
  1923. expect(isAttachmentEcho('', 'report.md')).toBeFalse();
  1924. expect(isAttachmentEcho(undefined, 'report.md')).toBeFalse();
  1925. });
  1926. });