import test from 'node:test'; import assert from 'node:assert/strict'; import { createStore } from '../src/store.js'; import { createNetworkService } from '../src/network-service.js'; import { mkdtemp, readFile, rm } from 'node:fs/promises'; import { tmpdir } from 'node:os'; import { join, resolve, sep } from 'node:path'; const tick = () => new Promise(resolve => setImmediate(resolve)); 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'); } function fixture(overrides = {}) { const store = createStore(':memory:'), scheduled = [], calls = []; const login = { status: () => ({ state: 'idle', counts: { messages: 0, calendar: 0, chats: 0, presence: 0 } }), start: async () => { calls.push('login'); }, finish: async () => { calls.push('finish'); }, stop: async () => { calls.push('cancel'); } }; const provider = createNetworkService({ store, config: { dataDir: 'test-not-a-session', pollIntervalMs: 30_000 }, login, readSession: async () => ({}), schedule: (fn, ms) => { scheduled.push({ fn, ms }); return scheduled.length; }, unschedule: () => {}, syncFactory: () => ({ runOnce: async () => { calls.push('sync'); return { ok: true, authRequired: false, noUsableRequests: false }; } }), historyFactory: () => ({ refreshChats: () => calls.push('discover'), runOnce: async () => { calls.push('history'); return { ok: true }; } }), ...overrides }); return { provider, store, scheduled, calls, async close() { await provider.shutdown(); store.close(); } }; } test('automatic renewal swaps all collectors without resetting stored progress and keeps the instance running', async () => { const directory = await mkdtemp(join(tmpdir(), 'teams-renewal-service-')); let renewals = 0; const builds = [], login = { status: () => ({ state: 'idle' }), stop: async () => {}, renewalStatus: () => ({ available: true, state: 'renewed', interactionRequired: false }), renew: async () => ++renewals === 1 ? { changed: true, har: { revision: 2, log: { entries: [] } } } : { changed: false } }; const f = fixture({ config: { dataDir: directory, pollIntervalMs: 30000 }, login, readSession: async () => ({ revision: 1, log: { entries: [] } }), syncFactory: ({ har, store }) => { builds.push(har.revision); return { runOnce: async () => { assert.deepEqual(store.getState('checkpoint'), { nextPage: 'retained' }); return { ok: true, authRequired: false, noUsableRequests: false }; } }; } }); try { f.store.setState('checkpoint', { nextPage: 'retained' }); await f.provider.start(); await until(() => f.provider.status().sync?.ok); assert.deepEqual(builds, [1, 2]); assert.equal(f.provider.status().running, true); assert.equal(JSON.parse(await readFile(join(directory, 'network-session.har'), 'utf8')).revision, 2); assert.deepEqual(f.store.getState('checkpoint'), { nextPage: 'retained' }); await f.provider.stop(); for (const timer of f.scheduled) await timer.fn(); assert.equal(renewals, 1); } finally { await f.close(); assert.ok(resolve(directory).startsWith(resolve(tmpdir()) + sep)); await rm(directory, { recursive: true, force: true }); } }); test('all blocked APIs keep waiting through a transient refresh error and stop only when interaction is required', async () => { let interaction = false; const login = { status: () => ({ state: 'idle' }), stop: async () => {}, renew: async () => ({ changed: false }), renewalStatus: () => ({ available: true, state: interaction ? 'interaction_required' : 'retrying', interactionRequired: interaction }) }; const f = fixture({ login, syncFactory: () => ({ runOnce: async () => ({ ok: false, authRequired: true, noUsableRequests: true }) }) }); try { await f.provider.start(); await tick(); assert.equal(f.provider.status().running, true); assert.match(f.provider.status().error, /自动恢复/); interaction = true; await f.scheduled[0].fn(); await tick(); assert.equal(f.provider.status().running, false); assert.equal(f.store.getState('web-api:service').enabled, true); } finally { await f.close(); } }); test('stop aborts in-flight renewal and prevents late replacement of a stopped instance', async () => { let release, signal; const login = { status: () => ({ state: 'idle' }), stop: async () => {}, renew: options => { signal = options.signal; return new Promise(resolve => { release = resolve; }); } }; const f = fixture({ login }); try { await f.provider.start(); await until(() => release); const stopping = f.provider.stop(); await tick(); assert.equal(signal.aborted, true); release({ changed: true, har: { private: 'must-not-save' } }); await stopping; assert.equal(f.provider.status().running, false); assert.deepEqual(f.calls, []); assert.equal(f.scheduled.length, 0); } finally { await f.close(); } }); test('server worker syncs first then history, needs no login browser, and stops polling on shutdown', async () => { const f = fixture(); try { await Promise.all([f.provider.start(), f.provider.start()]); await tick(); assert.deepEqual(f.calls, ['sync', 'discover', 'history']); assert.equal(f.scheduled.length, 1); assert.equal(f.scheduled[0].ms, 30_000); assert.equal(f.store.getState('web-api:service').enabled, true); await f.provider.stop(); assert.equal(f.provider.status().running, false); await f.scheduled[0].fn(); assert.equal(f.calls.filter(c => c === 'sync').length, 1); assert.equal(f.store.getState('web-api:service').enabled, false); } finally { await f.close(); } }); test('worker connects committed history evidence to the same instance synchronizer name collector', async () => { const observations = [], scope = { accountId: 'fictional-account', chatId: 'fictional-chat' }, payload = { messages: [] }; const f = fixture({ syncFactory: () => ({ runOnce: async () => ({ ok: true }), observeChatMetadata: (value, body) => observations.push({ value, body }) }), historyFactory: options => ({ runOnce: async () => { options.onMessages(scope, payload); return { ok: true }; } }) }); try { await f.provider.start(); await tick(); assert.deepEqual(observations, [{ value: scope, body: payload }]); assert.equal(f.provider.status().error, null); } finally { await f.close(); } }); test('stop during session loading cancels newly created worker and never leaves a future timer', async () => { let release; const f = fixture({ readSession: () => new Promise(resolve => { release = resolve; }) }); try { const start = f.provider.start(); await tick(); const stop = f.provider.stop(); release({}); await Promise.all([start, stop]); await tick(); assert.equal(f.provider.status().running, false); assert.equal(f.store.getState('web-api:service').enabled, false); const before = f.calls.filter(c => c === 'sync').length; for (const t of f.scheduled) await t.fn(); assert.equal(f.calls.filter(c => c === 'sync').length, before); } finally { await f.close(); } }); test('valid session replacement restarts worker, while failed login finish preserves running worker', async () => { let deny = true, builds = 0; const f = fixture({ login: { status: () => ({ state: 'waiting' }), start: async () => {}, stop: async () => {}, finish: async () => { if (deny) throw new Error('private'); } }, syncFactory: () => { builds++; return { runOnce: async () => ({ ok: true }) }; } }); try { await f.provider.start(); await tick(); await assert.rejects(f.provider.finishLogin()); assert.equal(f.provider.status().running, true); assert.equal(builds, 1); deny = false; await f.provider.finishLogin(); await tick(); assert.equal(builds, 2); assert.equal(f.provider.status().running, true); } finally { await f.close(); } }); test('authentication loss keeps remaining resources polling; all unusable requests stop without losing resume preference', async () => { let all = false; const f = fixture({ syncFactory: () => ({ runOnce: async () => ({ ok: false, authRequired: true, noUsableRequests: all }) }) }); try { await f.provider.start(); await tick(); assert.equal(f.provider.status().running, true); assert.match(f.provider.status().error, /重新登录/); all = true; await f.scheduled[0].fn(); await tick(); assert.equal(f.provider.status().running, false); assert.equal(f.store.getState('web-api:service').enabled, true); } finally { await f.close(); } }); test('bad session is contained and reports no private exception contents', async () => { const f = fixture({ readSession: async () => { throw new Error('Bearer private-auth-data'); } }); try { await f.provider.start(); assert.equal(f.provider.status().running, false); assert.doesNotMatch(JSON.stringify(f.provider.status()), /Bearer|private-auth-data/); assert.equal(f.scheduled.length, 0); } finally { await f.close(); } }); test('history initialization failures preserve checkpoints while messages and calendar keep syncing', async () => { for (const code of ['invalid_history_cursor', 'invalid_history_checkpoint', 'private-error-code']) { let rounds = 0, historyBuilds = 0; const failure = Object.assign(new Error('Bearer private-auth-data https://private.example/?token=private-token'), { code }); const f = fixture({ syncFactory: ({ store }) => ({ runOnce: async () => { rounds++; for (const kind of ['message', 'event']) store.upsertRecord({ source: 'web-api', accountId: 'fictional-account', kind, externalId: `fictional-${kind}`, text: `Fictional round ${rounds}`, raw: {} }); return { ok: true, authRequired: false, noUsableRequests: false, records: 2, coverage: { messages: 1, calendarRequests: 1 } }; } }), historyFactory: () => { historyBuilds++; throw failure; } }); try { const checkpoint = { version: 1, fixture: 'unchanged-history-progress' }; f.store.setState('web-api:history:fixture', checkpoint); await f.provider.start(); await tick(); const first = f.provider.status(); assert.equal(first.running, true); assert.equal(first.sync.ok, true); assert.equal(first.error, null); assert.equal(first.history.ok, false); assert.equal(first.history.initializationFailed, true); assert.equal(first.history.errors.length, 1); assert.match(first.history.errors[0].reason, /聊天和日历继续同步/); assert.match(first.history.coverage.limitation, /未清除已有断点/); assert.doesNotMatch(JSON.stringify(first), /Bearer|private-auth-data|private\.example|private-token|private-error-code/); assert.equal(f.store.listRecords({ kind: 'message' }).total, 1); assert.equal(f.store.listRecords({ kind: 'event' }).total, 1); const retained = first.history; await f.scheduled[0].fn(); await tick(); assert.equal(rounds, 2); assert.equal(historyBuilds, 1); assert.deepEqual(f.provider.status().history, retained); assert.deepEqual(f.store.getState('web-api:history:fixture'), checkpoint); assert.ok(f.store.listRecords().items.every(row => row.text === 'Fictional round 2')); await f.provider.stop(); for (const timer of f.scheduled) await timer.fn(); await tick(); assert.equal(f.provider.status().running, false); assert.equal(rounds, 2); assert.equal(f.store.getState('web-api:service').enabled, false); assert.deepEqual(f.provider.status().history, retained); } finally { await f.close(); } } }); test('an explicit restart can restore history after its initialization failure', async () => { let builds = 0, historyRounds = 0; const f = fixture({ historyFactory: () => { if (++builds === 1) throw new Error('private-history-error'); return { runOnce: async () => { historyRounds++; return { ok: true, coverage: { conversations: 1 } }; } }; } }); try { await f.provider.start(); await tick(); assert.equal(f.provider.status().history.initializationFailed, true); await f.provider.start(); await tick(); assert.equal(builds, 1); assert.equal(historyRounds, 0); await f.provider.stop(); await f.provider.start(); await tick(); assert.equal(builds, 2); assert.equal(historyRounds, 1); assert.equal(f.provider.status().history.ok, true); assert.equal(f.provider.status().history.initializationFailed, undefined); } finally { await f.close(); } }); test('startup errors distinguish session and sync initialization without exposing exception values', async () => { for (const { stage, code, expected } of [ { stage: 'session', code: 'instance_account_conflict', expected: /绑定到其他实例/ }, { stage: 'session', code: 'instance_identity_mismatch', expected: /不属于此实例/ }, { stage: 'session', code: 'instance_account_unidentified', expected: /无法确认会话的账号归属/ }, { stage: 'session', code: 'instance_operation_cancelled', expected: /已取消/ }, { stage: 'session', code: 'ENOENT', expected: /尚无可读取的本地会话/ }, { stage: 'session', code: 'EACCES', expected: /访问权限/ }, { stage: 'session', code: 'private-error-code', expected: /本地会话未能读取或验证/ }, { stage: 'sync', code: 'instance_identity_mismatch', expected: /聊天和日历读取接口未能初始化/ }, { stage: 'sync', code: 'private-error-code', expected: /聊天和日历读取接口未能初始化/ } ]) { const throwFailure = () => { throw Object.assign(new Error('Bearer private-auth-data https://private.example/?token=private-token'), { code }); }; const f = fixture(stage === 'session' ? { readSession: throwFailure } : { syncFactory: throwFailure }); try { await f.provider.start(); const state = f.provider.status(); assert.equal(state.running, false); assert.equal(state.sync, null); assert.match(state.error, expected); assert.doesNotMatch(JSON.stringify(state), /Bearer|private-auth-data|private\.example|private-token|private-error-code/); assert.equal(f.scheduled.length, 0); assert.deepEqual(f.calls, []); } finally { await f.close(); } } }); test('stop and a following start serialize so an old request cannot enter the replacement history worker', async () => { const events = []; let release, builds = 0; const f = fixture({ syncFactory: () => { const id = ++builds; return { runOnce: async () => { events.push(`sync${id}`); if (id === 1) await new Promise(resolve => { release = resolve; }); return { ok: true }; } }; }, historyFactory: () => { const id = builds; return { runOnce: async () => { events.push(`history${id}`); return { ok: true }; } }; } }); try { await f.provider.start(); await tick(); const stop = f.provider.stop(), start = f.provider.start(); await tick(); assert.equal(builds, 1); release(); await Promise.all([stop, start]); await tick(); assert.deepEqual(events, ['sync1', 'sync2', 'history2']); assert.equal(f.provider.status().running, true); assert.equal(f.store.getState('web-api:service').enabled, true); } finally { await f.close(); } }); test('a login completion arriving after shutdown cannot create a worker or reopen a browser', async () => { let release, starts = 0; const f = fixture({ login: { status: () => ({ state: 'complete' }), start: async () => { starts++; }, stop: async () => {}, finish: () => new Promise(resolve => { release = resolve; }) } }); try { const finish = f.provider.finishLogin(); await f.provider.shutdown(); release({ ok: true }); await finish; await f.provider.start(); await f.provider.beginLogin(); assert.equal(f.provider.status().running, false); assert.equal(starts, 0); assert.deepEqual(f.calls, []); assert.equal(f.store.getState('web-api:service'), null); } finally { await f.close(); } }); test('service forwards configured history jitter and exposes its live safe pacing state', async () => { let options; const pacing = { minDelayMs: 700, maxDelayMs: 1200, waiting: true, waitUntil: '2026-09-08T00:00:01Z', nextAllowedAt: null, coolingDownOrigins: 0, lastDelayMs: 900 }; const f = fixture({ config: { dataDir: 'test-not-a-session', pollIntervalMs: 30_000, historyRequestMinDelayMs: 700, historyRequestMaxDelayMs: 1200 }, historyFactory: input => { options = input; return { pacing: () => pacing, runOnce: async () => ({ ok: true, deferred: true }) }; } }); try { await f.provider.start(); await tick(); assert.equal(options.requestMinDelayMs, 700); assert.equal(options.requestMaxDelayMs, 1200); assert.deepEqual(f.provider.status().history.pacing, pacing); await f.scheduled[0].fn(); await tick(); assert.equal(f.calls.filter(value => value === 'sync').length, 2); assert.equal(f.scheduled[1].ms, 30_000); } finally { await f.close(); } }); test('stopping the service aborts an active history wait without starting another sync', async () => { let waiting = false, cancelled = false; const f = fixture({ historyFactory: () => ({ runOnce: ({ signal }) => new Promise(resolve => { waiting = true; signal.addEventListener('abort', () => { cancelled = true; resolve({ cancelled: true }); }, { once: true }); }) }) }); try { await f.provider.start(); await tick(); assert.equal(waiting, true); await f.provider.stop(); assert.equal(cancelled, true); assert.equal(f.provider.status().running, false); assert.equal(f.calls.filter(value => value === 'sync').length, 1); assert.equal(f.scheduled.length, 0); } finally { await f.close(); } }); function presenceSpy() { const sessions = []; return { sessions, factory: ({ har }) => { const session = { har, starts: 0, stops: 0, shutdowns: 0, running: false }; sessions.push(session); return { start: async () => { assert.equal(session.shutdowns, 0, 'A closed presence instance cannot restart'); session.starts++; session.running = true; }, stop: async () => { session.stops++; session.running = false; }, shutdown: async () => { session.shutdowns++; session.running = false; }, status: () => ({ running: session.running, state: session.running ? 'running' : 'disabled' }) }; } }; } test('two services maintain independent keepOnline settings, captured sessions, and presence lifecycles', async () => { const one = presenceSpy(), two = presenceSpy(), firstHar = { fixture: 'first session' }, secondHar = { fixture: 'second session' }; const first = fixture({ keepOnline: true, readSession: async () => firstHar, presenceFactory: one.factory }); const second = fixture({ keepOnline: false, readSession: async () => secondHar, presenceFactory: two.factory }); try { assert.equal(one.sessions.length, 0); assert.equal(two.sessions.length, 0); await Promise.all([first.provider.start(), second.provider.start()]); await tick(); assert.equal(one.sessions.length, 1); assert.equal(one.sessions[0].har, firstHar); assert.equal(one.sessions[0].running, true); assert.equal(two.sessions.length, 0); assert.equal(second.provider.status().keepOnline, false); await second.provider.setKeepOnline(true); assert.equal(two.sessions.length, 1); assert.equal(two.sessions[0].har, secondHar); assert.equal(two.sessions[0].running, true); await first.provider.stop(); assert.equal(one.sessions[0].shutdowns, 1); assert.equal(one.sessions[0].running, false); assert.equal(second.provider.status().running, true); assert.equal(two.sessions[0].running, true); await second.provider.setKeepOnline(false); assert.equal(two.sessions[0].running, false); assert.equal(second.provider.status().running, true); await second.provider.setKeepOnline(true); assert.equal(two.sessions[0].starts, 2); assert.equal(two.sessions[0].running, true); assert.equal(one.sessions[0].starts, 1); assert.equal(first.provider.status().running, false); assert.equal(first.store.getState('web-api:service').enabled, false); assert.equal(second.store.getState('web-api:service').enabled, true); } finally { await first.close(); await second.close(); } }); test('enabling keepOnline after automatic collection stop cannot start or revive a presence worker', async () => { for (const keepOnline of [false, true]) { const presence = presenceSpy(); const f = fixture({ keepOnline, presenceFactory: presence.factory, syncFactory: () => ({ runOnce: async () => ({ authRequired: true, noUsableRequests: true }) }) }); try { await f.provider.start(); await tick(); assert.equal(f.provider.status().running, false); assert.equal(f.scheduled.length, 0); assert.equal(presence.sessions.length, Number(keepOnline)); await f.provider.setKeepOnline(true); assert.equal(f.provider.status().keepOnline, true); assert.equal(f.provider.status().presence.running, false); assert.equal(presence.sessions.length, Number(keepOnline)); if (keepOnline) assert.equal(presence.sessions[0].starts, 1); } finally { await f.close(); } } }); test('stop and cancel while login finish is pending cannot resurrect collection or presence', async () => { let release; const presence = presenceSpy(), f = fixture({ keepOnline: true, presenceFactory: presence.factory, login: { status: () => ({ state: 'waiting' }), start: async () => {}, stop: async () => {}, finish: () => new Promise(resolve => { release = resolve; }) } }); try { await f.provider.start(); await tick(); const finishing = f.provider.finishLogin(); await Promise.all([f.provider.stop(), f.provider.cancelLogin()]); release({ ok: true }); await finishing; await tick(); for (const timer of f.scheduled) await timer.fn(); assert.equal(f.provider.status().running, false); assert.equal(f.provider.status().presence.running, false); assert.equal(presence.sessions.length, 1); assert.equal(presence.sessions[0].starts, 1); assert.equal(presence.sessions[0].shutdowns, 1); assert.equal(f.calls.filter(call => call === 'sync').length, 1); assert.equal(f.store.getState('web-api:service').enabled, false); await f.provider.setKeepOnline(true); assert.equal(presence.sessions.length, 1); } finally { release?.({ ok: true }); await f.close(); } }); test('cancelling a first login before a late finish never starts collection or presence', async () => { let release; const presence = presenceSpy(), f = fixture({ keepOnline: true, presenceFactory: presence.factory, login: { status: () => ({ state: 'waiting' }), start: async () => {}, stop: async () => {}, finish: () => new Promise(resolve => { release = resolve; }) } }); try { const finishing = f.provider.finishLogin(); await f.provider.cancelLogin(); release({ ok: true }); await finishing; assert.equal(f.provider.status().running, false); assert.equal(presence.sessions.length, 0); assert.deepEqual(f.calls, []); } finally { release?.({ ok: true }); await f.close(); } }); test('disabling while a presence factory is pending disposes it and later enabling creates a usable replacement', async () => { let release; const presence = presenceSpy(); const f = fixture({ keepOnline: true, presenceFactory: async options => { const value = presence.factory(options); if (presence.sessions.length === 1) await new Promise(resolve => { release = resolve; }); return value; } }); try { const starting = f.provider.start(); await tick(); assert.equal(presence.sessions.length, 1); const disabling = f.provider.setKeepOnline(false); release(); await Promise.all([starting, disabling]); await tick(); assert.equal(f.provider.status().running, true); assert.equal(f.provider.status().presence.running, false); assert.equal(presence.sessions[0].starts, 0); assert.equal(presence.sessions[0].shutdowns, 1); await f.provider.setKeepOnline(true); assert.equal(presence.sessions.length, 2); assert.equal(presence.sessions[1].starts, 1); assert.equal(f.provider.status().presence.running, true); assert.equal(presence.sessions[0].starts, 0); } finally { release?.(); await f.close(); } }); test('resume uses auto-start only without a saved preference and never overrides an explicit stop', async () => { for (const { autoStart, saved, expected } of [ { autoStart: true, saved: undefined, expected: true }, { autoStart: true, saved: false, expected: false }, { autoStart: false, saved: true, expected: true } ]) { const f = fixture({ config: { dataDir: 'test-not-a-session', pollIntervalMs: 30_000, networkAutoStart: autoStart } }); try { if (saved !== undefined) f.store.setState('web-api:service', { enabled: saved }); else assert.equal(f.store.getState('web-api:service'), null); await f.provider.resume(); await tick(); assert.equal(f.provider.status().running, expected, `autoStart=${autoStart}, saved=${saved}`); assert.equal(f.calls.filter(call => call === 'sync').length, Number(expected)); await f.provider.stop(); assert.equal(f.store.getState('web-api:service').enabled, false); const syncs = f.calls.filter(call => call === 'sync').length; await f.provider.resume(); await tick(); assert.equal(f.provider.status().running, false); assert.equal(f.calls.filter(call => call === 'sync').length, syncs); assert.equal(f.store.getState('web-api:service').enabled, false); } finally { await f.close(); } } });