import test from 'node:test'; import assert from 'node:assert/strict'; import { createHash } from 'node:crypto'; import { createGraphProvider, GRAPH_SCOPES, validateGraphUrl } from '../src/graph.js'; import { createStore } from '../src/store.js'; const ROOT = 'https://graph.microsoft.com/v1.0'; const USER = { homeAccountId: 'user.home', localAccountId: 'user', tenantId: 'tenant', username: 'user@example.test', name: 'Test User' }; const ACCOUNT_ID = 'graph:user.home:tenant'; const FIXED_NOW = Date.parse('2026-09-08T12:00:00Z'); const response = (body, status = 200, headers = {}) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json', ...headers } }); const tick = () => new Promise(resolve => setImmediate(resolve)); function fakeMsal(account = USER) { return { authRequest: null, codeRequest: null, silentRequests: [], cleared: 0, async getAuthCodeUrl(request) { this.authRequest = request; return `https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?state=${request.state}`; }, async acquireTokenByCode(request) { this.codeRequest = request; return { account, accessToken: 'SECRET_ACCESS_TOKEN' }; }, async acquireTokenSilent(request) { this.silentRequests.push(request); return { account, accessToken: 'SECRET_ACCESS_TOKEN' }; }, async clearCache() { this.cleared += 1; }, }; } function fakeStore() { const states = new Map(), records = new Map(), logs = []; return { states, records, logs, getState: key => structuredClone(states.get(key) ?? null), setState(key, value) { states.set(key, structuredClone(value)); }, upsertRecord(value) { const key = [value.source, value.accountId, value.kind, value.externalId].join('|'); const changed = JSON.stringify(records.get(key)) !== JSON.stringify(value); records.set(key, structuredClone(value)); return { changed, id: records.size }; }, addLog(level, message, details) { logs.push({ level, message, details }); }, }; } async function fixture(options = {}) { const store = options.store || fakeStore(); const msal = options.msal || fakeMsal(); const provider = createGraphProvider({ store, msalClient: msal, now: () => FIXED_NOW, config: { clientId: 'test-client', maxRetries: 0, ...(options.config || {}) }, ...options }); await provider.beginLogin(); await provider.completeLogin(new URLSearchParams({ state: msal.authRequest.state, code: 'one-time-code' })); return { provider, store, msal }; } function emptyRoute(url) { if (new URL(url).pathname === '/v1.0/me/chats') return response({ value: [] }); return response({ value: [], '@odata.deltaLink': `${ROOT}/me/calendarView/delta?$deltatoken=empty` }); } test('Graph HTML messages share emoji preservation for inline and emoji-only body content', async () => { const { provider, store } = await fixture({ fetchImpl: async url => { const path = new URL(url).pathname; if (path === '/v1.0/me/chats') return response({ value: [{ id: 'fictional-emoji-chat', chatType: 'group' }] }); if (path === '/v1.0/chats/fictional-emoji-chat/messages') return response({ value: [ { id: 'inline', body: { contentType: 'html', content: '

好👍的

' }, createdDateTime: '2026-09-08T11:00:00Z' }, { id: 'only-emoji', body: { contentType: 'html', content: '

👩🏽‍💻

' }, createdDateTime: '2026-09-08T11:00:01Z' }, { id: 'unknown-image', body: { contentType: 'html', content: '' }, createdDateTime: '2026-09-08T11:00:02Z' }, ] }); return emptyRoute(url); } }); await provider.sync(); assert.deepEqual([...store.records.values()].filter(record => record.kind === 'message').map(record => record.text), ['好👍的', '👩🏽‍💻', '[图片]']); }); test('Graph is optional and startup without an app registration needs no login or network', async () => { const provider = createGraphProvider({ store: fakeStore(), config: {}, fetchImpl: () => assert.fail('Unexpected request') }); assert.equal(provider.status().configured, false); assert.match(provider.status().configurationMessage, /MS_CLIENT_ID/); assert.match(provider.status().configurationMessage, /浏览器扩展/); assert.deepEqual(await provider.sync(), { skipped: true, reason: 'not_configured' }); await assert.rejects(provider.beginLogin(), { code: 'not_configured' }); provider.start(); assert.equal(provider.status().running, true); await provider.stop(); assert.equal(provider.status().running, false); }); test('OAuth callback enforces PKCE, state, one-time code, expiry and keeps tokens out of status/logs', async () => { const msal = fakeMsal(), store = fakeStore(); let time = FIXED_NOW; const provider = createGraphProvider({ store, config: { clientId: 'test-client' }, msalClient: msal, now: () => time }); await provider.beginLogin(); const auth = msal.authRequest; assert.deepEqual(auth.scopes, GRAPH_SCOPES); assert.equal(auth.codeChallengeMethod, 'S256'); assert.equal(auth.prompt, 'select_account'); await assert.rejects(provider.completeLogin(new URLSearchParams({ state: 'wrong', code: 'code' })), { code: 'invalid_state' }); await provider.completeLogin(new URLSearchParams({ state: auth.state, code: 'code' })); assert.equal(createHash('sha256').update(msal.codeRequest.codeVerifier).digest('base64url'), auth.codeChallenge); assert.equal(provider.status().account.id, ACCOUNT_ID); assert.equal(provider.status().tokenStorage, 'memory'); assert.doesNotMatch(JSON.stringify([provider.status(), store.logs]), /SECRET_ACCESS_TOKEN|one-time-code/); await assert.rejects(provider.completeLogin(new URLSearchParams({ state: auth.state, code: 'code' })), { code: 'invalid_state' }); await provider.beginLogin(); time += 11 * 60_000; await assert.rejects(provider.completeLogin(new URLSearchParams({ state: msal.authRequest.state, code: 'code' })), { code: 'login_expired' }); await provider.logout(); assert.equal(provider.status().authenticated, false); assert.ok(msal.cleared > 0); }); test('logout rejects a token exchange that finishes late and clears that detached cache', async () => { const msal = fakeMsal(); let release; msal.acquireTokenByCode = () => new Promise(resolve => { release = resolve; }); const provider = createGraphProvider({ store: fakeStore(), config: { clientId: 'test' }, msalClient: msal }); await provider.beginLogin(); const completing = provider.completeLogin(new URLSearchParams({ state: msal.authRequest.state, code: 'code' })); await provider.logout(); release({ account: USER, accessToken: 'SECRET_ACCESS_TOKEN' }); await assert.rejects(completing, { code: 'cancelled' }); assert.equal(provider.status().authenticated, false); assert.ok(msal.cleared > 0); }); test('Graph continuation URLs must retain HTTPS, origin and v1.0; redirects are disabled', async () => { for (const url of ['https://evil.test/v1.0/me', 'http://graph.microsoft.com/v1.0/me', 'https://graph.microsoft.com/beta/me', 'https://user:pass@graph.microsoft.com/v1.0/me', 'https://graph.microsoft.com:444/v1.0/me', 'https://graph.microsoft.com/v1.0/../beta/me', 'https://graph.microsoft.com/v1.0/me#fragment']) { assert.throws(() => validateGraphUrl(url), { code: 'unsafe_graph_url' }); } const calls = []; const { provider } = await fixture({ fetchImpl: async (url, options) => { calls.push(url); assert.equal(options.redirect, 'error'); return new URL(url).pathname.endsWith('/chats') ? response({ value: [], '@odata.nextLink': 'https://evil.test/steal' }) : emptyRoute(url); } }); const result = await provider.sync(); assert.equal(result.chats.error.code, 'unsafe_graph_url'); assert.equal(result.calendar.completed, true); assert.ok(calls.every(url => new URL(url).origin === 'https://graph.microsoft.com')); }); test('all chat and message pages are read; per-chat failure keeps watermark while other areas succeed', async () => { let failSecondPage = true; const calls = []; const fetchImpl = async url => { calls.push(url); const parsed = new URL(url); if (parsed.pathname === '/v1.0/me/chats') { return parsed.searchParams.has('page') ? response({ value: [{ id: 'chat-b', topic: 'B' }] }) : response({ value: [{ id: 'chat-a', topic: 'A' }], '@odata.nextLink': `${ROOT}/me/chats?page=2` }); } if (parsed.pathname === '/v1.0/chats/chat-a/messages') { if (parsed.searchParams.has('page')) return failSecondPage ? response({ error: { code: 'Forbidden', message: 'PRIVATE_ERROR_CONTENT' } }, 403) : response({ value: [{ id: 'a-old', body: { contentType: 'text', content: 'old' }, lastModifiedDateTime: '2026-09-08T10:00:00Z' }] }); return response({ value: [{ id: 'a-new', body: { contentType: 'html', content: '

new & latest

' }, lastModifiedDateTime: '2026-09-08T11:00:00Z' }], '@odata.nextLink': `${ROOT}/chats/chat-a/messages?page=2` }); } if (parsed.pathname === '/v1.0/chats/chat-b/messages') return response({ value: [{ id: 'b', body: { contentType: 'text', content: 'B' }, lastModifiedDateTime: '2026-09-08T09:00:00Z' }] }); return emptyRoute(url); }; const { provider, store } = await fixture({ fetchImpl }); const first = await provider.sync(); assert.equal(first.chats.discovered, 2); assert.equal(first.chats.listComplete, true); assert.equal(first.chats.completed, 1); assert.equal(first.chats.failed, 1); assert.equal(first.calendar.completed, true); const chatStates = () => [...store.states.entries()].filter(([key]) => key.includes(':chat:')); assert.equal(chatStates().length, 1); assert.doesNotMatch(JSON.stringify([provider.status(), store.logs]), /PRIVATE_ERROR_CONTENT/); failSecondPage = false; const second = await provider.sync(); assert.equal(second.complete, true); assert.equal(chatStates().length, 2); const firstRequests = calls.filter(url => new URL(url).pathname === '/v1.0/chats/chat-a/messages' && !new URL(url).searchParams.has('page')); assert.ok(firstRequests.every(url => !new URL(url).searchParams.has('$filter')), 'failed initial pass must replay full history'); await provider.sync(); const latestA = calls.filter(url => new URL(url).pathname === '/v1.0/chats/chat-a/messages' && !new URL(url).searchParams.has('page')).at(-1); assert.equal(new URL(latestA).searchParams.get('$orderby'), 'lastModifiedDateTime desc'); assert.equal(new URL(latestA).searchParams.get('$filter'), 'lastModifiedDateTime gt 2026-09-08T10:58:00.000Z'); assert.equal([...store.records.values()].find(value => value.externalId === 'chat-a:a-new').text, 'new & latest'); }); test('calendar delta pages persist final cursor, preserve original tombstones and reset expired cursor', async () => { const store = createStore(':memory:'); try { store.upsertRecord({ source: 'graph', accountId: ACCOUNT_ID, kind: 'event', externalId: 'removed-event', title: 'Original title', text: 'Original body', raw: { id: 'removed-event', subject: 'Original title' } }); let generation = 0; const tombstone = { id: 'removed-event', '@removed': { reason: 'deleted' } }; const calls = []; const { provider } = await fixture({ store, fetchImpl: async url => { const parsed = new URL(url); if (parsed.pathname.endsWith('/chats')) return response({ value: [] }); calls.push(url); if (parsed.searchParams.get('$deltatoken') === 'first') return response({ error: { code: 'syncStateNotFound', message: 'PRIVATE_CURSOR' } }, 410); if (parsed.searchParams.has('page')) return response({ value: [tombstone], '@odata.deltaLink': `${ROOT}/me/calendarView/delta?$deltatoken=first` }); generation += 1; if (generation > 1) return response({ value: [{ id: 'removed-event', subject: 'Returned to view', body: { contentType: 'text', content: 'Updated body' } }], '@odata.deltaLink': `${ROOT}/me/calendarView/delta?$deltatoken=second` }); return response({ value: [{ id: 'event', subject: 'Meeting', start: { dateTime: '2026-09-08T09:30:00.0000000', timeZone: 'UTC' } }], '@odata.nextLink': `${ROOT}/me/calendarView/delta?page=2` }); } }); const first = await provider.sync(); assert.equal(first.calendar.pages, 2); assert.equal(first.calendar.completed, true); assert.deepEqual(first.calendar.window, { start: '2026-08-09T00:00:00.000Z', end: '2026-12-07T00:00:00.000Z' }); const events = store.listRecords({ kind: 'event' }).items; const deleted = events.find(value => value.externalId === 'removed-event'); assert.equal(Boolean(deleted.deleted), false); assert.equal(Boolean(deleted.removedFromView), true); assert.equal(deleted.title, 'Original title'); assert.equal(deleted.text, 'Original body'); assert.deepEqual(deleted.raw, tombstone); assert.equal(events.find(value => value.externalId === 'event').occurredAt, '2026-09-08T09:30:00.000Z'); const second = await provider.sync(); assert.equal(second.calendar.cursorResets, 1); assert.equal(second.calendar.completed, true); assert.ok(calls.some(url => new URL(url).searchParams.get('$deltatoken') === 'first')); const restored = store.listRecords({ kind: 'event' }).items.find(value => value.externalId === 'removed-event'); assert.equal(Boolean(restored.removedFromView), false); assert.equal(Boolean(restored.deleted), false); assert.equal(restored.title, 'Returned to view'); } finally { store.close(); } }); test('calendar failed pagination never advances delta cursor; a date-window change triggers a full pass', async () => { let time = FIXED_NOW, phase = 0; const calls = []; const { provider, store } = await fixture({ now: () => time, fetchImpl: async url => { const parsed = new URL(url); if (parsed.pathname.endsWith('/chats')) return response({ value: [] }); calls.push(url); if (phase === 1 && parsed.searchParams.has('page')) return response({ error: { code: 'Denied', message: 'PRIVATE' } }, 403); if (phase === 1) return response({ value: [], '@odata.nextLink': `${ROOT}/me/calendarView/delta?page=failed` }); return response({ value: [], '@odata.deltaLink': `${ROOT}/me/calendarView/delta?$deltatoken=${phase}` }); } }); await provider.sync(); const state = [...store.states.entries()].find(([key]) => key.endsWith(':calendar')); const saved = structuredClone(state[1]); phase = 1; const failed = await provider.sync(); assert.equal(failed.calendar.completed, false); assert.deepEqual(store.states.get(state[0]), saved); phase = 2; time += 86_400_000; const moved = await provider.sync(); assert.equal(moved.calendar.cursorResets, 1); assert.equal(new URL(calls.at(-1)).searchParams.get('startDateTime'), '2026-08-10T00:00:00.000Z'); assert.equal(new URL(calls.at(-1)).searchParams.has('$deltatoken'), false); }); test('429 uses Retry-After with bounded retries, and 401 forces silent refresh once', async () => { let attempts = 0; const waits = []; const { provider, msal } = await fixture({ config: { clientId: 'test', maxRetries: 3 }, sleep: async milliseconds => waits.push(milliseconds), fetchImpl: async url => { if (!new URL(url).pathname.endsWith('/chats')) return emptyRoute(url); attempts += 1; if (attempts === 1) return response({ error: { code: 'TooManyRequests' } }, 429, { 'retry-after': '2' }); if (attempts === 2) return response({ error: { code: 'InvalidAuthenticationToken' } }, 401); return response({ value: [] }); } }); const result = await provider.sync(); assert.equal(result.complete, true); assert.deepEqual(waits, [2000]); assert.equal(attempts, 3); assert.equal(msal.silentRequests.filter(request => request.forceRefresh).length, 1); }); test('excessive Retry-After is not retried early and remote response content stays private', async () => { let attempts = 0; const { provider, store } = await fixture({ config: { clientId: 'test', maxRetries: 3, maxRetryDelayMs: 1000 }, sleep: () => assert.fail('Must not shorten Retry-After'), fetchImpl: async url => { if (!new URL(url).pathname.endsWith('/chats')) return emptyRoute(url); attempts += 1; return response({ error: { code: 'SecretTenantName', message: 'SECRET_RESPONSE' } }, 429, { 'retry-after': '300' }); } }); const result = await provider.sync(); assert.equal(result.chats.error.code, 'throttled'); assert.equal(attempts, 1); assert.doesNotMatch(JSON.stringify([provider.status(), store.logs]), /SECRET_RESPONSE|SecretTenantName/); }); test('sync calls share one in-flight pass and logout prevents late responses from writing records/cursors', async () => { const pending = []; const { provider, store } = await fixture({ fetchImpl: url => new Promise(resolve => pending.push({ url, resolve })) }); const first = provider.sync(), second = provider.sync(); assert.equal(first, second); await tick(); assert.equal(pending.length, 2); await provider.logout(); for (const request of pending) request.resolve(emptyRoute(request.url)); assert.deepEqual(await first, { cancelled: true }); assert.equal(store.records.size, 0); assert.equal(store.states.size, 0); assert.equal(provider.status().authenticated, false); assert.equal(provider.status().syncing, false); }); test('switching accounts does not reuse another account message or calendar cursors', async () => { const msal = fakeMsal(); const calls = []; const { provider, store } = await fixture({ msal, fetchImpl: async url => { calls.push(url); const parsed = new URL(url); if (parsed.pathname.endsWith('/chats')) return response({ value: [{ id: 'shared-chat-id' }] }); if (parsed.pathname.endsWith('/messages')) return response({ value: [{ id: 'm', lastModifiedDateTime: '2026-09-08T11:00:00Z' }] }); return emptyRoute(url); } }); await provider.sync(); await provider.logout(); msal.acquireTokenByCode = async () => ({ accessToken: 'OTHER_TOKEN', account: { ...USER, homeAccountId: 'other.home' } }); await provider.beginLogin(); await provider.completeLogin(new URLSearchParams({ state: msal.authRequest.state, code: 'new-code' })); const callCount = calls.length; await provider.sync(); assert.equal(store.states.size, 4); for (const url of calls.slice(callCount)) { assert.equal(new URL(url).searchParams.has('$filter'), false); assert.equal(new URL(url).searchParams.has('$deltatoken'), false); } }); test('identical message IDs from different chats remain separate records', async () => { const { provider, store } = await fixture({ fetchImpl: async url => { const parsed = new URL(url); if (parsed.pathname.endsWith('/chats')) return response({ value: [{ id: 'chat:one' }, { id: 'chat:two' }] }); if (parsed.pathname.endsWith('/messages')) return response({ value: [{ id: 'same-id', body: { content: 'message' } }] }); return emptyRoute(url); } }); await provider.sync(); const messages = [...store.records.values()].filter(value => value.kind === 'message'); assert.equal(messages.length, 2); assert.notEqual(messages[0].externalId, messages[1].externalId); assert.ok(messages.every(value => value.raw.id === 'same-id')); }); test('message deletion stays a deletion while calendar removal only marks view membership', async () => { const message = { id: 'deleted-message', deletedDateTime: '2026-09-08T11:00:00Z' }; const event = { id: 'removed-event', '@removed': { reason: 'deleted' } }; const { provider, store } = await fixture({ fetchImpl: async url => { const parsed = new URL(url); if (parsed.pathname.endsWith('/chats')) return response({ value: [{ id: 'chat' }] }); if (parsed.pathname.endsWith('/messages')) return response({ value: [message] }); return response({ value: [event], '@odata.deltaLink': `${ROOT}/me/calendarView/delta?$deltatoken=final` }); } }); await provider.sync(); const savedMessage = [...store.records.values()].find(value => value.kind === 'message'); const savedEvent = [...store.records.values()].find(value => value.kind === 'event'); assert.equal(savedMessage.deleted, true); assert.equal(savedMessage.removedFromView, false); assert.equal(savedEvent.deleted, false); assert.equal(savedEvent.removedFromView, true); assert.equal(savedEvent.title, undefined); assert.equal(savedEvent.text, undefined); assert.deepEqual(savedEvent.raw, event); }); test('timeouts produce a content-free failure without advancing cursors', async () => { const { provider, store } = await fixture({ config: { clientId: 'test', maxRetries: 0, requestTimeoutMs: 10 }, fetchImpl: async (url, options) => { if (!new URL(url).pathname.endsWith('/chats')) return emptyRoute(url); return new Promise((resolve, reject) => { options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true }); }); } }); // AbortSignal.timeout is unref'ed; a referenced guard keeps this isolated offline test alive. const guard = setTimeout(() => assert.fail('Timeout not enforced'), 1000); try { const result = await provider.sync(); assert.equal(result.chats.error.code, 'network_error'); assert.equal(result.calendar.completed, true); assert.equal([...store.states.keys()].filter(key => key.includes(':chat:')).length, 0); } finally { clearTimeout(guard); } });