| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404 |
- 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(); }
- }
- });
|