network-service.test.js 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404
  1. import test from 'node:test';
  2. import assert from 'node:assert/strict';
  3. import { createStore } from '../src/store.js';
  4. import { createNetworkService } from '../src/network-service.js';
  5. import { mkdtemp, readFile, rm } from 'node:fs/promises';
  6. import { tmpdir } from 'node:os';
  7. import { join, resolve, sep } from 'node:path';
  8. const tick = () => new Promise(resolve => setImmediate(resolve));
  9. async function until(predicate) { for (let n = 0; n < 300; n++) { if (predicate()) return; await new Promise(resolve => setTimeout(resolve, 5)); } assert.fail('service transition did not finish'); }
  10. function fixture(overrides = {}) {
  11. const store = createStore(':memory:'), scheduled = [], calls = [];
  12. const login = { status: () => ({ state: 'idle', counts: { messages: 0, calendar: 0, chats: 0, presence: 0 } }),
  13. start: async () => { calls.push('login'); }, finish: async () => { calls.push('finish'); }, stop: async () => { calls.push('cancel'); } };
  14. const provider = createNetworkService({ store, config: { dataDir: 'test-not-a-session', pollIntervalMs: 30_000 }, login,
  15. readSession: async () => ({}), schedule: (fn, ms) => { scheduled.push({ fn, ms }); return scheduled.length; }, unschedule: () => {},
  16. syncFactory: () => ({ runOnce: async () => { calls.push('sync'); return { ok: true, authRequired: false, noUsableRequests: false }; } }),
  17. historyFactory: () => ({ refreshChats: () => calls.push('discover'), runOnce: async () => { calls.push('history'); return { ok: true }; } }),
  18. ...overrides });
  19. return { provider, store, scheduled, calls, async close() { await provider.shutdown(); store.close(); } };
  20. }
  21. test('automatic renewal swaps all collectors without resetting stored progress and keeps the instance running', async () => {
  22. const directory = await mkdtemp(join(tmpdir(), 'teams-renewal-service-')); let renewals = 0;
  23. const builds = [], login = { status: () => ({ state: 'idle' }), stop: async () => {},
  24. renewalStatus: () => ({ available: true, state: 'renewed', interactionRequired: false }),
  25. renew: async () => ++renewals === 1 ? { changed: true, har: { revision: 2, log: { entries: [] } } } : { changed: false } };
  26. const f = fixture({ config: { dataDir: directory, pollIntervalMs: 30000 }, login,
  27. readSession: async () => ({ revision: 1, log: { entries: [] } }),
  28. syncFactory: ({ har, store }) => { builds.push(har.revision); return { runOnce: async () => {
  29. assert.deepEqual(store.getState('checkpoint'), { nextPage: 'retained' }); return { ok: true, authRequired: false, noUsableRequests: false };
  30. } }; } });
  31. try {
  32. f.store.setState('checkpoint', { nextPage: 'retained' });
  33. await f.provider.start(); await until(() => f.provider.status().sync?.ok);
  34. assert.deepEqual(builds, [1, 2]); assert.equal(f.provider.status().running, true);
  35. assert.equal(JSON.parse(await readFile(join(directory, 'network-session.har'), 'utf8')).revision, 2);
  36. assert.deepEqual(f.store.getState('checkpoint'), { nextPage: 'retained' });
  37. await f.provider.stop(); for (const timer of f.scheduled) await timer.fn(); assert.equal(renewals, 1);
  38. } finally { await f.close(); assert.ok(resolve(directory).startsWith(resolve(tmpdir()) + sep)); await rm(directory, { recursive: true, force: true }); }
  39. });
  40. test('all blocked APIs keep waiting through a transient refresh error and stop only when interaction is required', async () => {
  41. let interaction = false;
  42. const login = { status: () => ({ state: 'idle' }), stop: async () => {}, renew: async () => ({ changed: false }),
  43. renewalStatus: () => ({ available: true, state: interaction ? 'interaction_required' : 'retrying', interactionRequired: interaction }) };
  44. const f = fixture({ login, syncFactory: () => ({ runOnce: async () => ({ ok: false, authRequired: true, noUsableRequests: true }) }) });
  45. try {
  46. await f.provider.start(); await tick(); assert.equal(f.provider.status().running, true); assert.match(f.provider.status().error, /自动恢复/);
  47. interaction = true; await f.scheduled[0].fn(); await tick(); assert.equal(f.provider.status().running, false);
  48. assert.equal(f.store.getState('web-api:service').enabled, true);
  49. } finally { await f.close(); }
  50. });
  51. test('stop aborts in-flight renewal and prevents late replacement of a stopped instance', async () => {
  52. let release, signal;
  53. const login = { status: () => ({ state: 'idle' }), stop: async () => {},
  54. renew: options => { signal = options.signal; return new Promise(resolve => { release = resolve; }); } };
  55. const f = fixture({ login });
  56. try {
  57. await f.provider.start(); await until(() => release);
  58. const stopping = f.provider.stop(); await tick(); assert.equal(signal.aborted, true);
  59. release({ changed: true, har: { private: 'must-not-save' } }); await stopping;
  60. assert.equal(f.provider.status().running, false); assert.deepEqual(f.calls, []); assert.equal(f.scheduled.length, 0);
  61. } finally { await f.close(); }
  62. });
  63. test('server worker syncs first then history, needs no login browser, and stops polling on shutdown', async () => {
  64. const f = fixture();
  65. try {
  66. await Promise.all([f.provider.start(), f.provider.start()]); await tick();
  67. assert.deepEqual(f.calls, ['sync', 'discover', 'history']);
  68. assert.equal(f.scheduled.length, 1); assert.equal(f.scheduled[0].ms, 30_000);
  69. assert.equal(f.store.getState('web-api:service').enabled, true);
  70. await f.provider.stop(); assert.equal(f.provider.status().running, false);
  71. await f.scheduled[0].fn(); assert.equal(f.calls.filter(c => c === 'sync').length, 1);
  72. assert.equal(f.store.getState('web-api:service').enabled, false);
  73. } finally { await f.close(); }
  74. });
  75. test('worker connects committed history evidence to the same instance synchronizer name collector', async () => {
  76. const observations = [], scope = { accountId: 'fictional-account', chatId: 'fictional-chat' }, payload = { messages: [] };
  77. const f = fixture({
  78. syncFactory: () => ({ runOnce: async () => ({ ok: true }), observeChatMetadata: (value, body) => observations.push({ value, body }) }),
  79. historyFactory: options => ({ runOnce: async () => { options.onMessages(scope, payload); return { ok: true }; } })
  80. });
  81. try {
  82. await f.provider.start(); await tick();
  83. assert.deepEqual(observations, [{ value: scope, body: payload }]);
  84. assert.equal(f.provider.status().error, null);
  85. } finally { await f.close(); }
  86. });
  87. test('stop during session loading cancels newly created worker and never leaves a future timer', async () => {
  88. let release; const f = fixture({ readSession: () => new Promise(resolve => { release = resolve; }) });
  89. try {
  90. const start = f.provider.start(); await tick(); const stop = f.provider.stop(); release({}); await Promise.all([start, stop]); await tick();
  91. assert.equal(f.provider.status().running, false); assert.equal(f.store.getState('web-api:service').enabled, false);
  92. const before = f.calls.filter(c => c === 'sync').length;
  93. for (const t of f.scheduled) await t.fn();
  94. assert.equal(f.calls.filter(c => c === 'sync').length, before);
  95. } finally { await f.close(); }
  96. });
  97. test('valid session replacement restarts worker, while failed login finish preserves running worker', async () => {
  98. let deny = true, builds = 0;
  99. const f = fixture({ login: { status: () => ({ state: 'waiting' }), start: async () => {}, stop: async () => {},
  100. finish: async () => { if (deny) throw new Error('private'); } },
  101. syncFactory: () => { builds++; return { runOnce: async () => ({ ok: true }) }; } });
  102. try {
  103. await f.provider.start(); await tick();
  104. await assert.rejects(f.provider.finishLogin()); assert.equal(f.provider.status().running, true); assert.equal(builds, 1);
  105. deny = false; await f.provider.finishLogin(); await tick(); assert.equal(builds, 2); assert.equal(f.provider.status().running, true);
  106. } finally { await f.close(); }
  107. });
  108. test('authentication loss keeps remaining resources polling; all unusable requests stop without losing resume preference', async () => {
  109. let all = false;
  110. const f = fixture({ syncFactory: () => ({ runOnce: async () => ({ ok: false, authRequired: true, noUsableRequests: all }) }) });
  111. try {
  112. await f.provider.start(); await tick(); assert.equal(f.provider.status().running, true); assert.match(f.provider.status().error, /重新登录/);
  113. all = true; await f.scheduled[0].fn(); await tick(); assert.equal(f.provider.status().running, false);
  114. assert.equal(f.store.getState('web-api:service').enabled, true);
  115. } finally { await f.close(); }
  116. });
  117. test('bad session is contained and reports no private exception contents', async () => {
  118. const f = fixture({ readSession: async () => { throw new Error('Bearer private-auth-data'); } });
  119. try {
  120. await f.provider.start(); assert.equal(f.provider.status().running, false);
  121. assert.doesNotMatch(JSON.stringify(f.provider.status()), /Bearer|private-auth-data/);
  122. assert.equal(f.scheduled.length, 0);
  123. } finally { await f.close(); }
  124. });
  125. test('history initialization failures preserve checkpoints while messages and calendar keep syncing', async () => {
  126. for (const code of ['invalid_history_cursor', 'invalid_history_checkpoint', 'private-error-code']) {
  127. let rounds = 0, historyBuilds = 0;
  128. const failure = Object.assign(new Error('Bearer private-auth-data https://private.example/?token=private-token'), { code });
  129. const f = fixture({
  130. syncFactory: ({ store }) => ({ runOnce: async () => {
  131. rounds++;
  132. for (const kind of ['message', 'event']) store.upsertRecord({ source: 'web-api', accountId: 'fictional-account', kind,
  133. externalId: `fictional-${kind}`, text: `Fictional round ${rounds}`, raw: {} });
  134. return { ok: true, authRequired: false, noUsableRequests: false, records: 2,
  135. coverage: { messages: 1, calendarRequests: 1 } };
  136. } }),
  137. historyFactory: () => { historyBuilds++; throw failure; }
  138. });
  139. try {
  140. const checkpoint = { version: 1, fixture: 'unchanged-history-progress' };
  141. f.store.setState('web-api:history:fixture', checkpoint);
  142. await f.provider.start(); await tick();
  143. const first = f.provider.status();
  144. assert.equal(first.running, true); assert.equal(first.sync.ok, true); assert.equal(first.error, null);
  145. assert.equal(first.history.ok, false); assert.equal(first.history.initializationFailed, true);
  146. assert.equal(first.history.errors.length, 1); assert.match(first.history.errors[0].reason, /聊天和日历继续同步/);
  147. assert.match(first.history.coverage.limitation, /未清除已有断点/);
  148. assert.doesNotMatch(JSON.stringify(first), /Bearer|private-auth-data|private\.example|private-token|private-error-code/);
  149. assert.equal(f.store.listRecords({ kind: 'message' }).total, 1);
  150. assert.equal(f.store.listRecords({ kind: 'event' }).total, 1);
  151. const retained = first.history;
  152. await f.scheduled[0].fn(); await tick();
  153. assert.equal(rounds, 2); assert.equal(historyBuilds, 1);
  154. assert.deepEqual(f.provider.status().history, retained);
  155. assert.deepEqual(f.store.getState('web-api:history:fixture'), checkpoint);
  156. assert.ok(f.store.listRecords().items.every(row => row.text === 'Fictional round 2'));
  157. await f.provider.stop();
  158. for (const timer of f.scheduled) await timer.fn();
  159. await tick();
  160. assert.equal(f.provider.status().running, false); assert.equal(rounds, 2);
  161. assert.equal(f.store.getState('web-api:service').enabled, false);
  162. assert.deepEqual(f.provider.status().history, retained);
  163. } finally { await f.close(); }
  164. }
  165. });
  166. test('an explicit restart can restore history after its initialization failure', async () => {
  167. let builds = 0, historyRounds = 0;
  168. const f = fixture({ historyFactory: () => {
  169. if (++builds === 1) throw new Error('private-history-error');
  170. return { runOnce: async () => { historyRounds++; return { ok: true, coverage: { conversations: 1 } }; } };
  171. } });
  172. try {
  173. await f.provider.start(); await tick();
  174. assert.equal(f.provider.status().history.initializationFailed, true);
  175. await f.provider.start(); await tick();
  176. assert.equal(builds, 1); assert.equal(historyRounds, 0);
  177. await f.provider.stop(); await f.provider.start(); await tick();
  178. assert.equal(builds, 2); assert.equal(historyRounds, 1);
  179. assert.equal(f.provider.status().history.ok, true);
  180. assert.equal(f.provider.status().history.initializationFailed, undefined);
  181. } finally { await f.close(); }
  182. });
  183. test('startup errors distinguish session and sync initialization without exposing exception values', async () => {
  184. for (const { stage, code, expected } of [
  185. { stage: 'session', code: 'instance_account_conflict', expected: /绑定到其他实例/ },
  186. { stage: 'session', code: 'instance_identity_mismatch', expected: /不属于此实例/ },
  187. { stage: 'session', code: 'instance_account_unidentified', expected: /无法确认会话的账号归属/ },
  188. { stage: 'session', code: 'instance_operation_cancelled', expected: /已取消/ },
  189. { stage: 'session', code: 'ENOENT', expected: /尚无可读取的本地会话/ },
  190. { stage: 'session', code: 'EACCES', expected: /访问权限/ },
  191. { stage: 'session', code: 'private-error-code', expected: /本地会话未能读取或验证/ },
  192. { stage: 'sync', code: 'instance_identity_mismatch', expected: /聊天和日历读取接口未能初始化/ },
  193. { stage: 'sync', code: 'private-error-code', expected: /聊天和日历读取接口未能初始化/ }
  194. ]) {
  195. const throwFailure = () => { throw Object.assign(new Error('Bearer private-auth-data https://private.example/?token=private-token'), { code }); };
  196. const f = fixture(stage === 'session' ? { readSession: throwFailure } : { syncFactory: throwFailure });
  197. try {
  198. await f.provider.start();
  199. const state = f.provider.status();
  200. assert.equal(state.running, false); assert.equal(state.sync, null);
  201. assert.match(state.error, expected);
  202. assert.doesNotMatch(JSON.stringify(state), /Bearer|private-auth-data|private\.example|private-token|private-error-code/);
  203. assert.equal(f.scheduled.length, 0); assert.deepEqual(f.calls, []);
  204. } finally { await f.close(); }
  205. }
  206. });
  207. test('stop and a following start serialize so an old request cannot enter the replacement history worker', async () => {
  208. const events = []; let release, builds = 0;
  209. const f = fixture({ syncFactory: () => { const id = ++builds; return { runOnce: async () => {
  210. events.push(`sync${id}`); if (id === 1) await new Promise(resolve => { release = resolve; }); return { ok: true };
  211. } }; }, historyFactory: () => { const id = builds; return { runOnce: async () => { events.push(`history${id}`); return { ok: true }; } }; } });
  212. try {
  213. await f.provider.start(); await tick(); const stop = f.provider.stop(), start = f.provider.start(); await tick();
  214. assert.equal(builds, 1); release(); await Promise.all([stop, start]); await tick();
  215. assert.deepEqual(events, ['sync1', 'sync2', 'history2']);
  216. assert.equal(f.provider.status().running, true); assert.equal(f.store.getState('web-api:service').enabled, true);
  217. } finally { await f.close(); }
  218. });
  219. test('a login completion arriving after shutdown cannot create a worker or reopen a browser', async () => {
  220. let release, starts = 0;
  221. const f = fixture({ login: { status: () => ({ state: 'complete' }), start: async () => { starts++; }, stop: async () => {},
  222. finish: () => new Promise(resolve => { release = resolve; }) } });
  223. try {
  224. const finish = f.provider.finishLogin(); await f.provider.shutdown(); release({ ok: true }); await finish;
  225. await f.provider.start(); await f.provider.beginLogin();
  226. assert.equal(f.provider.status().running, false); assert.equal(starts, 0); assert.deepEqual(f.calls, []);
  227. assert.equal(f.store.getState('web-api:service'), null);
  228. } finally { await f.close(); }
  229. });
  230. test('service forwards configured history jitter and exposes its live safe pacing state', async () => {
  231. let options;
  232. const pacing = { minDelayMs: 700, maxDelayMs: 1200, waiting: true, waitUntil: '2026-09-08T00:00:01Z',
  233. nextAllowedAt: null, coolingDownOrigins: 0, lastDelayMs: 900 };
  234. const f = fixture({ config: { dataDir: 'test-not-a-session', pollIntervalMs: 30_000, historyRequestMinDelayMs: 700, historyRequestMaxDelayMs: 1200 },
  235. historyFactory: input => { options = input; return { pacing: () => pacing, runOnce: async () => ({ ok: true, deferred: true }) }; } });
  236. try {
  237. await f.provider.start(); await tick();
  238. assert.equal(options.requestMinDelayMs, 700); assert.equal(options.requestMaxDelayMs, 1200);
  239. assert.deepEqual(f.provider.status().history.pacing, pacing);
  240. await f.scheduled[0].fn(); await tick();
  241. assert.equal(f.calls.filter(value => value === 'sync').length, 2);
  242. assert.equal(f.scheduled[1].ms, 30_000);
  243. } finally { await f.close(); }
  244. });
  245. test('stopping the service aborts an active history wait without starting another sync', async () => {
  246. let waiting = false, cancelled = false;
  247. const f = fixture({ historyFactory: () => ({ runOnce: ({ signal }) => new Promise(resolve => {
  248. waiting = true;
  249. signal.addEventListener('abort', () => { cancelled = true; resolve({ cancelled: true }); }, { once: true });
  250. }) }) });
  251. try {
  252. await f.provider.start(); await tick(); assert.equal(waiting, true);
  253. await f.provider.stop();
  254. assert.equal(cancelled, true); assert.equal(f.provider.status().running, false);
  255. assert.equal(f.calls.filter(value => value === 'sync').length, 1); assert.equal(f.scheduled.length, 0);
  256. } finally { await f.close(); }
  257. });
  258. function presenceSpy() {
  259. const sessions = [];
  260. return { sessions, factory: ({ har }) => {
  261. const session = { har, starts: 0, stops: 0, shutdowns: 0, running: false }; sessions.push(session);
  262. return {
  263. start: async () => { assert.equal(session.shutdowns, 0, 'A closed presence instance cannot restart'); session.starts++; session.running = true; },
  264. stop: async () => { session.stops++; session.running = false; },
  265. shutdown: async () => { session.shutdowns++; session.running = false; },
  266. status: () => ({ running: session.running, state: session.running ? 'running' : 'disabled' })
  267. };
  268. } };
  269. }
  270. test('two services maintain independent keepOnline settings, captured sessions, and presence lifecycles', async () => {
  271. const one = presenceSpy(), two = presenceSpy(), firstHar = { fixture: 'first session' }, secondHar = { fixture: 'second session' };
  272. const first = fixture({ keepOnline: true, readSession: async () => firstHar, presenceFactory: one.factory });
  273. const second = fixture({ keepOnline: false, readSession: async () => secondHar, presenceFactory: two.factory });
  274. try {
  275. assert.equal(one.sessions.length, 0); assert.equal(two.sessions.length, 0);
  276. await Promise.all([first.provider.start(), second.provider.start()]); await tick();
  277. assert.equal(one.sessions.length, 1); assert.equal(one.sessions[0].har, firstHar); assert.equal(one.sessions[0].running, true);
  278. assert.equal(two.sessions.length, 0); assert.equal(second.provider.status().keepOnline, false);
  279. await second.provider.setKeepOnline(true);
  280. assert.equal(two.sessions.length, 1); assert.equal(two.sessions[0].har, secondHar); assert.equal(two.sessions[0].running, true);
  281. await first.provider.stop();
  282. assert.equal(one.sessions[0].shutdowns, 1); assert.equal(one.sessions[0].running, false);
  283. assert.equal(second.provider.status().running, true); assert.equal(two.sessions[0].running, true);
  284. await second.provider.setKeepOnline(false);
  285. assert.equal(two.sessions[0].running, false); assert.equal(second.provider.status().running, true);
  286. await second.provider.setKeepOnline(true);
  287. assert.equal(two.sessions[0].starts, 2); assert.equal(two.sessions[0].running, true);
  288. assert.equal(one.sessions[0].starts, 1); assert.equal(first.provider.status().running, false);
  289. assert.equal(first.store.getState('web-api:service').enabled, false);
  290. assert.equal(second.store.getState('web-api:service').enabled, true);
  291. } finally { await first.close(); await second.close(); }
  292. });
  293. test('enabling keepOnline after automatic collection stop cannot start or revive a presence worker', async () => {
  294. for (const keepOnline of [false, true]) {
  295. const presence = presenceSpy();
  296. const f = fixture({ keepOnline, presenceFactory: presence.factory,
  297. syncFactory: () => ({ runOnce: async () => ({ authRequired: true, noUsableRequests: true }) }) });
  298. try {
  299. await f.provider.start(); await tick();
  300. assert.equal(f.provider.status().running, false);
  301. assert.equal(f.scheduled.length, 0);
  302. assert.equal(presence.sessions.length, Number(keepOnline));
  303. await f.provider.setKeepOnline(true);
  304. assert.equal(f.provider.status().keepOnline, true);
  305. assert.equal(f.provider.status().presence.running, false);
  306. assert.equal(presence.sessions.length, Number(keepOnline));
  307. if (keepOnline) assert.equal(presence.sessions[0].starts, 1);
  308. } finally { await f.close(); }
  309. }
  310. });
  311. test('stop and cancel while login finish is pending cannot resurrect collection or presence', async () => {
  312. let release;
  313. const presence = presenceSpy(), f = fixture({ keepOnline: true, presenceFactory: presence.factory,
  314. login: { status: () => ({ state: 'waiting' }), start: async () => {}, stop: async () => {},
  315. finish: () => new Promise(resolve => { release = resolve; }) } });
  316. try {
  317. await f.provider.start(); await tick();
  318. const finishing = f.provider.finishLogin();
  319. await Promise.all([f.provider.stop(), f.provider.cancelLogin()]);
  320. release({ ok: true }); await finishing; await tick();
  321. for (const timer of f.scheduled) await timer.fn();
  322. assert.equal(f.provider.status().running, false); assert.equal(f.provider.status().presence.running, false);
  323. assert.equal(presence.sessions.length, 1); assert.equal(presence.sessions[0].starts, 1); assert.equal(presence.sessions[0].shutdowns, 1);
  324. assert.equal(f.calls.filter(call => call === 'sync').length, 1);
  325. assert.equal(f.store.getState('web-api:service').enabled, false);
  326. await f.provider.setKeepOnline(true); assert.equal(presence.sessions.length, 1);
  327. } finally { release?.({ ok: true }); await f.close(); }
  328. });
  329. test('cancelling a first login before a late finish never starts collection or presence', async () => {
  330. let release;
  331. const presence = presenceSpy(), f = fixture({ keepOnline: true, presenceFactory: presence.factory,
  332. login: { status: () => ({ state: 'waiting' }), start: async () => {}, stop: async () => {},
  333. finish: () => new Promise(resolve => { release = resolve; }) } });
  334. try {
  335. const finishing = f.provider.finishLogin(); await f.provider.cancelLogin(); release({ ok: true }); await finishing;
  336. assert.equal(f.provider.status().running, false); assert.equal(presence.sessions.length, 0); assert.deepEqual(f.calls, []);
  337. } finally { release?.({ ok: true }); await f.close(); }
  338. });
  339. test('disabling while a presence factory is pending disposes it and later enabling creates a usable replacement', async () => {
  340. let release;
  341. const presence = presenceSpy();
  342. const f = fixture({ keepOnline: true, presenceFactory: async options => {
  343. const value = presence.factory(options);
  344. if (presence.sessions.length === 1) await new Promise(resolve => { release = resolve; });
  345. return value;
  346. } });
  347. try {
  348. const starting = f.provider.start(); await tick();
  349. assert.equal(presence.sessions.length, 1);
  350. const disabling = f.provider.setKeepOnline(false); release(); await Promise.all([starting, disabling]); await tick();
  351. assert.equal(f.provider.status().running, true); assert.equal(f.provider.status().presence.running, false);
  352. assert.equal(presence.sessions[0].starts, 0); assert.equal(presence.sessions[0].shutdowns, 1);
  353. await f.provider.setKeepOnline(true);
  354. assert.equal(presence.sessions.length, 2); assert.equal(presence.sessions[1].starts, 1);
  355. assert.equal(f.provider.status().presence.running, true); assert.equal(presence.sessions[0].starts, 0);
  356. } finally { release?.(); await f.close(); }
  357. });
  358. test('resume uses auto-start only without a saved preference and never overrides an explicit stop', async () => {
  359. for (const { autoStart, saved, expected } of [
  360. { autoStart: true, saved: undefined, expected: true },
  361. { autoStart: true, saved: false, expected: false },
  362. { autoStart: false, saved: true, expected: true }
  363. ]) {
  364. const f = fixture({ config: { dataDir: 'test-not-a-session', pollIntervalMs: 30_000, networkAutoStart: autoStart } });
  365. try {
  366. if (saved !== undefined) f.store.setState('web-api:service', { enabled: saved });
  367. else assert.equal(f.store.getState('web-api:service'), null);
  368. await f.provider.resume(); await tick();
  369. assert.equal(f.provider.status().running, expected, `autoStart=${autoStart}, saved=${saved}`);
  370. assert.equal(f.calls.filter(call => call === 'sync').length, Number(expected));
  371. await f.provider.stop();
  372. assert.equal(f.store.getState('web-api:service').enabled, false);
  373. const syncs = f.calls.filter(call => call === 'sync').length;
  374. await f.provider.resume(); await tick();
  375. assert.equal(f.provider.status().running, false);
  376. assert.equal(f.calls.filter(call => call === 'sync').length, syncs);
  377. assert.equal(f.store.getState('web-api:service').enabled, false);
  378. } finally { await f.close(); }
  379. }
  380. });