instance-manager.test.js 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248
  1. import test from 'node:test';
  2. import assert from 'node:assert/strict';
  3. import { mkdtemp, mkdir, writeFile, readFile, rm, readdir } from 'node:fs/promises';
  4. import { tmpdir } from 'node:os';
  5. import { resolve, join, sep } from 'node:path';
  6. import { createStore } from '../src/store.js';
  7. import { createInstanceManager, capturedAccounts } from '../src/instance-manager.js';
  8. import { createNetworkService } from '../src/network-service.js';
  9. import { createNetworkSynchronizer } from '../src/network-sync.js';
  10. import { createNetworkHistory } from '../src/network-history.js';
  11. import { classifyPresenceCapture, createNetworkPresence } from '../src/network-presence.js';
  12. const tenant = '11111111-1111-1111-1111-111111111111';
  13. const alice = '22222222-2222-2222-2222-222222222222', bob = '33333333-3333-3333-3333-333333333333';
  14. const app = '44444444-4444-4444-4444-444444444444';
  15. const tick = () => new Promise(done => setImmediate(done));
  16. const scope = (person = alice, tid = tenant) => ({ source: 'web-api', accountId: `web-api:${tid}:${person}` });
  17. const token = (person = alice, tid = tenant) => 'Bearer fixture.' + Buffer.from(JSON.stringify({ tid, oid: person,
  18. appid: app, aud: 'https://graph.microsoft.com', scp: 'Presence.Read Presence.ReadWrite', exp: 2200000000 })).toString('base64url') + '.fictional-signature';
  19. const url = chat => `https://teams.cloud.microsoft/api/chatsvc/apac/v1/users/ME/conversations/${encodeURIComponent(chat)}/messages?pageSize=200`;
  20. const payload = (chat = '19:fictional-chat', ids = ['fixture-message']) => ({ messages: ids.map(id => ({ id, conversationid: chat, conversationLink: url(chat).split('/messages')[0],
  21. type: 'Message', messagetype: 'RichText/Html', content: '<p>Fictional message</p>', version: '1788850000000',
  22. originalarrivaltime: '2026-09-08T01:00:00Z', imdisplayname: 'Fictional author' })),
  23. _metadata: { lastCompleteSegmentStartTime: 0, lastCompleteSegmentEndTime: 1788850000000 } });
  24. const messageEntry = (person = alice, tid = tenant, chat = '19:fictional-chat') => ({ request: { method: 'GET', url: url(chat),
  25. headers: [{ name: 'Authorization', value: token(person, tid) }] }, response: { status: 200, content: { mimeType: 'application/json', text: JSON.stringify(payload(chat)) } } });
  26. const har = (...entries) => ({ log: { version: '1.2', entries } });
  27. const session = (person = alice) => har(messageEntry(person));
  28. function presenceEntries(person = alice) {
  29. const headers = [{ name: 'Authorization', value: token(person) }];
  30. return [
  31. { request: { method: 'GET', url: 'https://graph.microsoft.com/v1.0/me/presence', headers },
  32. response: { status: 200, content: { mimeType: 'application/json', text: JSON.stringify({ id: person, availability: 'Available', activity: 'Available' }) } } },
  33. { request: { method: 'POST', url: `https://graph.microsoft.com/v1.0/users/${person}/presence/setPresence`, headers,
  34. postData: { mimeType: 'application/json', text: JSON.stringify({ sessionId: app, availability: 'Available', activity: 'Available', expirationDuration: 'PT5M' }) } },
  35. response: { status: 200, content: { text: '' } } }
  36. ];
  37. }
  38. const record = (person = alice, text = 'Fictional message') => ({ ...scope(person), kind: 'message', externalId: 'same-message-id',
  39. parentId: 'same-chat-id', title: 'Fixture', text, occurredAt: '2026-09-08T01:00:00Z', raw: {} });
  40. async function fixture(t, options = {}) {
  41. const directory = await mkdtemp(join(tmpdir(), 'teams-instance-manager-test-'));
  42. const store = createStore(':memory:'), sessions = new Map(), candidates = new Map(), logins = new Map(), services = new Map();
  43. const timers = [], calls = [], seenStores = new Map(), presenceCalls = [];
  44. const idAt = dataDir => resolve(dataDir) === resolve(directory) ? 'default' : dataDir.split(/[\\/]/).at(-1);
  45. const loginFactory = ({ dataDir, validateSession }) => {
  46. const id = idAt(dataDir); let state = 'idle';
  47. const login = { dataDir, validateSession, status: () => ({ state }),
  48. start: async () => { state = 'waiting'; calls.push(`login:${id}`); return login.status(); },
  49. finish: async () => {
  50. const input = candidates.get(id); await validateSession(input);
  51. await mkdir(dataDir, { recursive: true }); await writeFile(join(dataDir, 'network-session.har'), JSON.stringify(input));
  52. sessions.set(id, input); state = 'complete'; return { ok: true };
  53. }, stop: async () => { state = 'cancelled'; calls.push(`cancel:${id}`); return login.status(); } };
  54. logins.set(id, login); return login;
  55. };
  56. const serviceOptions = {
  57. schedule: (fn, ms) => { const timer = { fn, ms }; timers.push(timer); return timer; }, unschedule: timer => { timer.cancelled = true; },
  58. syncFactory: ({ har: input, store: scoped }) => {
  59. const account = capturedAccounts(input)[0]; seenStores.set(account.accountId, scoped);
  60. return { runOnce: async () => { calls.push(`sync:${account.accountId}`);
  61. scoped.setState('web-api:cursor:shared-test-key', { accountId: account.accountId });
  62. scoped.upsertRecord({ ...record(), ...account }); return { ok: true, authRequired: false, noUsableRequests: false }; } };
  63. },
  64. historyFactory: () => ({ refreshChats: () => {}, runOnce: async () => ({ ok: true, coverage: { conversations: 1 } }) }),
  65. presenceFactory: () => { let running = false; return { status: () => ({ running, state: running ? 'running' : 'disabled' }),
  66. start: async () => { running = true; presenceCalls.push('start'); }, stop: async () => { running = false; presenceCalls.push('stop'); },
  67. shutdown: async () => { running = false; presenceCalls.push('shutdown'); } }; },
  68. ...options.serviceOptions
  69. };
  70. const manager = createInstanceManager({ store, config: { dataDir: directory, pollIntervalMs: 30000,
  71. historyRequestMinDelayMs: 0, historyRequestMaxDelayMs: 0, ...options.config }, loginFactory, serviceOptions,
  72. serviceFactory: input => { const service = createNetworkService(input); services.set(idAt(input.config.dataDir), { input, service }); return service; },
  73. ...(options.diskSessions ? {} : { readSession: async ({ id }) => { if (!sessions.has(id)) throw new Error('No fictional session'); return sessions.get(id); } }) });
  74. t.after(async () => {
  75. await manager.shutdown(); store.close();
  76. const target = resolve(directory), allowed = resolve(tmpdir()) + sep;
  77. assert.ok(target.startsWith(allowed) && target.slice(allowed.length).startsWith('teams-instance-manager-test-'));
  78. await rm(target, { recursive: true, force: true });
  79. });
  80. return { directory, store, manager, sessions, candidates, logins, services, timers, calls, seenStores, presenceCalls,
  81. saveSession: async (id, input) => { const path = join(id === 'default' ? directory : join(directory, 'instances', id), 'network-session.har');
  82. await mkdir(resolve(path, '..'), { recursive: true }); await writeFile(path, JSON.stringify(input)); sessions.set(id, input); return path; },
  83. saveCapture: async (name, input) => { await mkdir(join(directory, 'captures'), { recursive: true }); await writeFile(join(directory, 'captures', name), JSON.stringify(input)); } };
  84. }
  85. test('creating instances is inert and two login flows use distinct instance directories', async t => {
  86. const f = await fixture(t), first = f.manager.create({ name: 'First' }), second = f.manager.create({ name: 'Second' });
  87. assert.notEqual(first.id, second.id); assert.equal(first.keepOnline, false); assert.equal(first.runtime.running, false);
  88. assert.equal(first.runtime.sessionAvailable, false); assert.deepEqual(first.accounts, []); assert.deepEqual(f.calls, []);
  89. await Promise.all([f.manager.beginLogin(first.id), f.manager.beginLogin(second.id)]);
  90. assert.notEqual(f.logins.get(first.id).dataDir, f.logins.get(second.id).dataDir);
  91. assert.equal(f.logins.get(first.id).dataDir, join(f.directory, 'instances', first.id));
  92. assert.equal(f.manager.status(first.id).login.state, 'waiting');
  93. await f.manager.cancelLogin(first.id);
  94. assert.equal(f.manager.status(first.id).login.state, 'cancelled'); assert.equal(f.manager.status(second.id).login.state, 'waiting');
  95. assert.ok(f.manager.listInstances().every(value => value.runtime && value.id && typeof value.keepOnline === 'boolean'));
  96. });
  97. test('two accounts collect concurrently with separate state and stopping one preserves the other worker', async t => {
  98. const f = await fixture(t), second = f.manager.create({ name: 'Second' });
  99. f.sessions.set('default', session(alice)); f.sessions.set(second.id, session(bob));
  100. await Promise.all([f.manager.start(), f.manager.start(second.id)]); await tick();
  101. assert.equal(f.manager.status().running, true); assert.equal(f.manager.status(second.id).running, true);
  102. assert.deepEqual(f.store.getState('web-api:cursor:shared-test-key'), { accountId: scope(alice).accountId });
  103. assert.deepEqual(f.store.getState(`instance:${second.id}:web-api:cursor:shared-test-key`), { accountId: scope(bob).accountId });
  104. const ownStore = f.seenStores.get(scope(alice).accountId);
  105. assert.throws(() => ownStore.upsertRecord(record(bob)), /不属于/);
  106. assert.throws(() => ownStore.getRecordByIdentity(record(bob)), /不属于/);
  107. assert.equal(ownStore.listRecords({}).total, 1);
  108. await f.manager.update(second.id, { keepOnline: true });
  109. assert.equal(f.manager.status(second.id).presence.running, true);
  110. await f.manager.stop();
  111. assert.equal(f.manager.status().running, false); assert.equal(f.manager.status(second.id).running, true);
  112. assert.equal(f.manager.status(second.id).presence.running, true);
  113. const before = f.calls.filter(value => value === `sync:${scope(bob).accountId}`).length;
  114. for (const timer of [...f.timers]) if (!timer.cancelled) { await timer.fn(); await tick(); }
  115. assert.equal(f.calls.filter(value => value === `sync:${scope(bob).accountId}`).length, before + 1);
  116. assert.equal(f.store.getState('web-api:service').enabled, false);
  117. assert.equal(f.store.getState(`instance:${second.id}:web-api:service`).enabled, true);
  118. });
  119. test('default resumes legacy state without rewriting its history checkpoint while new instances remain disabled', async t => {
  120. let seen;
  121. const checkpoint = { adapterVersion: 4, status: 'complete', pages: 7, records: 81 };
  122. const f = await fixture(t, { serviceOptions: { historyFactory: ({ store }) => { seen = store.getState('web-api:history:legacy'); return { runOnce: async () => ({ ok: true }) }; } } });
  123. f.sessions.set('default', session()); f.store.setState('web-api:history:legacy', checkpoint); f.store.setState('web-api:service', { enabled: true });
  124. const other = f.manager.create({ name: 'Not started' }); await f.manager.resume(); await tick();
  125. assert.deepEqual(seen, checkpoint); assert.deepEqual(f.store.getState('web-api:history:legacy'), checkpoint);
  126. assert.equal(f.manager.status().running, true); assert.equal(f.manager.status(other.id).running, false);
  127. assert.equal(f.services.get('default').input.config.dataDir, f.directory);
  128. assert.equal(f.store.getState(`instance:${other.id}:web-api:service`), null);
  129. });
  130. test('only the default instance can use an external legacy HAR fallback', async t => {
  131. const f = await fixture(t, { diskSessions: true });
  132. const external = join(f.directory, 'legacy-external.har'); await writeFile(external, JSON.stringify(session()));
  133. // The configuration object passed to the real service remains local to this fixture.
  134. f.manager.status(); f.services.get('default').input.config.networkHarPath = external;
  135. const other = f.manager.create({ name: 'No fallback' });
  136. assert.equal(f.services.get(other.id).input.allowExternalSessionPath, false);
  137. assert.equal(f.services.get(other.id).input.config.networkHarPath, '');
  138. await f.manager.start(); await f.manager.start(other.id); await tick();
  139. assert.equal(f.manager.status().running, true); assert.equal(f.manager.status(other.id).running, false);
  140. assert.equal(f.manager.status(other.id).sessionAvailable, false); assert.deepEqual(f.store.getInstance(other.id).accounts, []);
  141. });
  142. test('duplicate account login and changing a bound account fail before replacing any session', async t => {
  143. const f = await fixture(t), second = f.manager.create({ name: 'Second' });
  144. f.candidates.set('default', session(alice)); await f.manager.beginLogin(); await f.manager.finishLogin(); await tick();
  145. const path = join(f.directory, 'network-session.har'), before = await readFile(path, 'utf8');
  146. f.candidates.set(second.id, session(alice)); await f.manager.beginLogin(second.id);
  147. await assert.rejects(f.manager.finishLogin(second.id), error => error.code === 'instance_account_conflict');
  148. assert.deepEqual(f.store.getInstance(second.id).accounts, []); assert.equal(f.manager.status(second.id).sessionAvailable, false);
  149. f.candidates.set('default', session(bob)); await f.manager.beginLogin();
  150. await assert.rejects(f.manager.finishLogin(), error => error.code === 'instance_identity_mismatch');
  151. assert.equal(await readFile(path, 'utf8'), before); assert.equal(f.manager.status().running, true);
  152. assert.deepEqual(f.store.getInstance('default').accounts, [scope(alice)]);
  153. assert.doesNotMatch(JSON.stringify(f.manager.listInstances()), /fictional-signature|Fictional message|Authorization/);
  154. });
  155. test('bindings come from captured requests, allow a previously captured tenant subset, and reject opaque identities', async t => {
  156. const f = await fixture(t), otherTenant = '55555555-5555-5555-5555-555555555555';
  157. f.store.upsertRecord(record(bob));
  158. const validate = f.logins.get('default') || (f.manager.status(), f.logins.get('default'));
  159. validate.validateSession(har(messageEntry(alice), messageEntry(alice, otherTenant)));
  160. assert.equal(f.store.getInstance('default').accounts.length, 2);
  161. assert.ok(f.store.getInstance('default').accounts.every(value => value.accountId !== scope(bob).accountId));
  162. assert.doesNotThrow(() => validate.validateSession(har(messageEntry(alice, otherTenant))));
  163. assert.throws(() => validate.validateSession(session(bob)), error => error.code === 'instance_identity_mismatch');
  164. const opaque = session(); opaque.log.entries[0].request.headers[0].value = 'Bearer opaque-fixture';
  165. assert.throws(() => capturedAccounts(opaque), error => error.code === 'instance_account_unidentified');
  166. });
  167. test('deletion validates exact scope and confirmation, clears only its instance checkpoints, and leaves other collection running', async t => {
  168. const f = await fixture(t), second = f.manager.create({ name: 'Second' });
  169. f.sessions.set('default', session(alice)); f.sessions.set(second.id, session(bob));
  170. await Promise.all([f.manager.start(), f.manager.start(second.id)]); await tick();
  171. f.store.upsertRecord({ ...record(alice), source: 'browser' });
  172. f.store.setState('web-api:history:legacy', { complete: true });
  173. f.store.setState('web-api:chat-metadata:legacy', { nextCheckAt: 2000000000000 });
  174. f.store.setState(`instance:${second.id}:web-api:chat-metadata:other`, { nextCheckAt: 2000000000000 });
  175. f.store.setState(`instance:${second.id}:web-api:history:other`, { complete: true });
  176. f.store.setState('graph:cursor:keep', { keep: true });
  177. await f.manager.update('default', { keepOnline: true }); await f.manager.beginLogin();
  178. await assert.rejects(f.manager.deleteRecords('default', { ...scope(bob), confirmation: scope(bob).accountId }), /不属于/);
  179. await assert.rejects(f.manager.deleteRecords('default', { ...scope(alice), confirmation: 'wrong' }), /输入/);
  180. assert.equal(f.manager.status().running, true);
  181. const result = await f.manager.deleteRecords('default', { ...scope(alice), confirmation: scope(alice).accountId });
  182. assert.equal(result.instanceId, 'default'); assert.equal(f.store.listRecords(scope(alice)).total, 0);
  183. assert.equal(f.store.listRecords(scope(bob)).total, 1); assert.equal(f.store.listRecords({ source: 'browser' }).total, 1);
  184. assert.equal(f.manager.status().running, false); assert.equal(f.manager.status().login.state, 'cancelled');
  185. assert.equal(f.manager.status().presence.running, false); assert.equal(f.manager.status(second.id).running, true);
  186. assert.equal(f.store.getState('web-api:history:legacy'), null); assert.equal(f.store.getState('web-api:cursor:shared-test-key'), null);
  187. assert.equal(f.store.getState('web-api:chat-metadata:legacy'), null);
  188. assert.deepEqual(f.store.getState(`instance:${second.id}:web-api:chat-metadata:other`), { nextCheckAt: 2000000000000 });
  189. assert.deepEqual(f.store.getState(`instance:${second.id}:web-api:history:other`), { complete: true });
  190. assert.deepEqual(f.store.getState('graph:cursor:keep'), { keep: true });
  191. assert.deepEqual(f.store.getInstance('default').accounts, [scope(alice)]);
  192. assert.equal(f.store.getState('web-api:service').enabled, false);
  193. });
  194. test('presence import validates first, then stops only its instance and atomically preserves message templates', async t => {
  195. const f = await fixture(t), second = f.manager.create({ name: 'Second' });
  196. const path = await f.saveSession('default', session(alice)); f.sessions.set(second.id, session(bob));
  197. await Promise.all([f.manager.start(), f.manager.start(second.id)]); await tick(); await f.manager.beginLogin();
  198. const entries = presenceEntries(alice), unrelated = { request: { method: 'POST', url: 'https://login.microsoftonline.com/token', postData: { text: 'not-to-import' } }, response: { status: 200 } };
  199. await f.saveCapture('presence.har', har(...entries, unrelated));
  200. const result = await f.manager.importPresence('default', { fileName: 'presence.har' });
  201. const saved = JSON.parse(await readFile(path, 'utf8'));
  202. assert.equal(result.ok, true); assert.equal(result.imported, 2); assert.equal(saved.log.entries.length, 3);
  203. assert.deepEqual(saved.log.entries[0], messageEntry(alice)); assert.equal(saved.log.entries.filter(classifyPresenceCapture).length, 2);
  204. assert.doesNotMatch(JSON.stringify(saved), /not-to-import|login.microsoftonline/);
  205. assert.equal(f.manager.status().running, false); assert.equal(f.manager.status().login.state, 'cancelled');
  206. assert.equal(f.manager.status(second.id).running, true); assert.equal(f.store.getState('web-api:service').enabled, false);
  207. assert.equal((await readdir(f.directory)).some(name => name.endsWith('.tmp')), false);
  208. const offline = createNetworkPresence({ har: saved, fetch: () => assert.fail('Import must not request presence') });
  209. assert.equal(offline.status().configured, true); await offline.shutdown();
  210. });
  211. test('foreign, incomplete and escaped presence captures cannot stop a worker or change its session', async t => {
  212. const f = await fixture(t), path = await f.saveSession('default', session());
  213. await f.manager.start(); await tick(); const before = await readFile(path, 'utf8');
  214. await f.saveCapture('foreign.har', har(...presenceEntries(bob)));
  215. await f.saveCapture('read-only.har', har(presenceEntries(alice)[0]));
  216. for (const fileName of ['foreign.har', 'read-only.har', '../outside.har', '..\\outside.har', 'C:\\outside.har', 'presence.har:stream', 'nested/file.har']) {
  217. await assert.rejects(f.manager.importPresence('default', { fileName }));
  218. assert.equal(await readFile(path, 'utf8'), before); assert.equal(f.manager.status().running, true);
  219. }
  220. assert.equal(f.store.getState('web-api:service').enabled, true);
  221. });
  222. test('the real synchronizer and history execute through the scoped store using only a fictional fetch', async t => {
  223. const requests = [];
  224. const fetch = async raw => { requests.push(raw); return Response.json(payload()); };
  225. const f = await fixture(t, { serviceOptions: {
  226. syncFactory: options => createNetworkSynchronizer({ ...options, fetch }),
  227. historyFactory: options => createNetworkHistory({ ...options, fetch, requestMinDelayMs: 0, requestMaxDelayMs: 0 })
  228. } });
  229. f.sessions.set('default', session());
  230. await f.manager.start();
  231. for (let attempt = 0; attempt < 100 && !f.manager.status().history?.coverage; attempt++) await tick();
  232. const current = f.manager.status();
  233. assert.equal(current.sync?.ok, true, JSON.stringify(current.sync)); assert.equal(current.history?.ok, true, JSON.stringify(current.history)); assert.equal(current.error, null);
  234. assert.equal(requests.length, 2); assert.equal(f.store.listRecords({ ...scope(alice), kind: 'message' }).total, 1);
  235. assert.equal(current.history.coverage.conversations, 1); assert.equal(current.history.coverage.complete, 1);
  236. });