314 lines
16 KiB
JavaScript
314 lines
16 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import { createRequire } from 'node:module';
|
|
import test from 'node:test';
|
|
import ts from 'typescript';
|
|
|
|
const require = createRequire(import.meta.url);
|
|
function load(path, dependencies = {}) {
|
|
const source = readFileSync(new URL(`../src/${path}`, import.meta.url), 'utf8');
|
|
const { outputText } = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } });
|
|
const module = { exports: {} };
|
|
new Function('require', 'module', 'exports', outputText)(name => dependencies[name] ?? require(name), module, module.exports);
|
|
return module.exports;
|
|
}
|
|
const mapping = load('entities/message/model/liveMessage.ts');
|
|
const { LiveMessageStore } = load('entities/message/model/liveMessageStore.ts', { './liveMessage': mapping });
|
|
const incoming = (id, important = false, status = 'pending') => ({ id, fromId: '22', important, message: 'Сообщение', createdAt: '2026-10-28T10:00:00Z', receivers: [{ toId: '11', status }] });
|
|
const tick = () => new Promise(resolve => setImmediate(resolve));
|
|
|
|
test('preserves 64-bit message IDs, ordering, own/read/important states', () => {
|
|
const large = '9007199254740993';
|
|
const small = '9007199254740992';
|
|
assert.deepEqual(mapping.chronological([incoming(large), incoming(small), incoming(large)]).map(message => message.id), [small, large]);
|
|
assert.equal(mapping.mapLiveMessage(incoming(large, true), '11').type, 'important');
|
|
assert.equal(mapping.mapLiveMessage(incoming(large, true, 'read'), '11').confirmed, true);
|
|
const own = mapping.mapLiveMessage({ ...incoming(large), fromId: '11', receivers: [] }, '11');
|
|
assert.equal(own.type, 'driver_self');
|
|
assert.equal(own.deliveryStatus, 'sent');
|
|
});
|
|
|
|
test('reports delivery, reads visible ordinary messages, keeps every important message pending', async () => {
|
|
const writes = [];
|
|
const messages = [incoming('101'), incoming('102', true), incoming('103', true)];
|
|
const store = new LiveMessageStore('11', async (path, options) => {
|
|
if (options?.method === 'POST') { writes.push([path, options.body]); return {}; }
|
|
return { messages: path === '/messages/list' && options.query?.fromId ? [] : messages };
|
|
});
|
|
try {
|
|
store.start();
|
|
await tick();
|
|
assert.equal(store.chats.length, 3);
|
|
assert.deepEqual(writes[0], ['/messages/report/delivered', { messageIds: ['101', '102', '103'] }]);
|
|
assert.equal(writes.some(([path]) => path === '/messages/report/read'), false);
|
|
await store.markVisibleRead(['101', '102']);
|
|
assert.deepEqual(writes[1], ['/messages/report/read', { messageIds: ['101'] }]);
|
|
assert.equal(store.important.id, '102');
|
|
messages[1].receivers[0].status = 'read';
|
|
assert.equal(await store.acknowledge('102'), true);
|
|
assert.equal(store.important.id, '103');
|
|
} finally { store.stop(); }
|
|
});
|
|
|
|
test('routes answers to the selected message rather than the latest sender; failed writes retain an error', async () => {
|
|
const writes = [];
|
|
let fail = false;
|
|
const store = new LiveMessageStore('11', async (path, options) => {
|
|
if (path === '/messages/reply') {
|
|
writes.push(options.body);
|
|
if (fail) throw new Error('Нет связи');
|
|
return { ...incoming('999'), fromId: '11', replyId: options.body.replyId };
|
|
}
|
|
return { messages: [] };
|
|
});
|
|
try {
|
|
store.start();
|
|
await tick();
|
|
store.messages = [incoming('9007199254740993'), { ...incoming('9007199254740994'), fromId: '33' }];
|
|
store.selectReply('9007199254740993');
|
|
assert.equal(await store.send('Ответ'), true);
|
|
assert.deepEqual(writes[0], { replyId: '9007199254740993', message: 'Ответ' });
|
|
fail = true;
|
|
assert.equal(await store.send('Повторный ответ'), false);
|
|
assert.equal(store.sendError, 'Нет связи');
|
|
assert.equal(store.sending, false);
|
|
} finally { store.stop(); }
|
|
});
|
|
|
|
test('failed read acknowledgement does not dismiss an important message', async () => {
|
|
const store = new LiveMessageStore('11', async (path) => {
|
|
if (path === '/messages/report/read') throw new Error('Нет связи');
|
|
return { messages: [] };
|
|
});
|
|
try {
|
|
store.start();
|
|
await tick();
|
|
store.messages = [incoming('102', true)];
|
|
assert.equal(await store.acknowledge('102'), false);
|
|
assert.equal(store.important.id, '102');
|
|
} finally { store.stop(); }
|
|
});
|
|
|
|
class HttpError extends Error { constructor(status, message) { super(message); this.status = status; } }
|
|
function sessionFixture(handler, activationState = { value: { deviceId: '77', deviceSecret: 'secret' } }, suppliedStorage) {
|
|
const storage = suppliedStorage ?? { values: new Map(), getJson(key) { return this.values.get(key); }, setJson(key, value) { this.values.set(key, value); }, remove(key) { this.values.delete(key); } };
|
|
const deviceActivationStorage = { load: async () => activationState.value, save: async value => { if (activationState.failSave) throw new Error('Storage unavailable'); activationState.value = value; }, clear: async () => { activationState.value = null; } };
|
|
const { LiveSessionStore } = load('entities/session/model/liveSessionStore.ts', {
|
|
'../api/deviceActivation': { deviceActivationStorage },
|
|
'@/shared/api': { HttpError }, '@/shared/api/irida': { iridaRequest: handler },
|
|
'@/shared/lib': { storage, hydrateStorage: async () => {} }, '@/shared/config': { apiBaseUrl: 'https://irida.example' },
|
|
});
|
|
const store = new LiveSessionStore();
|
|
store.activation = activationState.value;
|
|
return store;
|
|
}
|
|
|
|
test('creates a device-bound driver session and revokes the preliminary login', async () => {
|
|
const calls = [];
|
|
const store = sessionFixture(async (path, options) => {
|
|
calls.push([path, options]);
|
|
if (path === '/auth/email/login') return { accessToken: 'access', refreshToken: options.body.shiftId ? 'bound' : 'temporary', user: { id: '11' }, ...(options.body.shiftId ? { shift: { id: '55', deviceId: '77' } } : {}) };
|
|
if (path === '/shifts/start') return { driverShift: { id: '55', deviceId: '77' } };
|
|
return {};
|
|
});
|
|
await store.login(' driver@example.com ', 'password');
|
|
assert.equal(store.session.shift.id, '55');
|
|
assert.deepEqual(calls.find(([path]) => path === '/shifts/start')[1].body, { userId: '11', deviceId: '77', deviceSecret: 'secret' });
|
|
assert.equal(calls.filter(([path]) => path === '/auth/email/login')[1][1].body.shiftId, '55');
|
|
assert.equal(calls.at(-1)[1].body.refreshToken, 'temporary');
|
|
});
|
|
|
|
test('coalesces concurrent refreshes and retries requests with Bearer authorization', async () => {
|
|
let refreshes = 0;
|
|
const store = sessionFixture(async (path, options) => {
|
|
if (path === '/auth/refresh') { refreshes++; await tick(); return { accessToken: 'fresh' }; }
|
|
if (options.headers.Authorization === 'Bearer old') throw new HttpError(401, 'Expired');
|
|
assert.equal(options.headers.Authorization, 'Bearer fresh');
|
|
return { ok: true };
|
|
});
|
|
store.session = { accessToken: 'old', refreshToken: 'refresh', user: { id: '11' }, shift: { id: '55' } };
|
|
await Promise.all([store.authorized('/messages/list'), store.authorized('/messages/pending')]);
|
|
assert.equal(refreshes, 1);
|
|
assert.equal(store.session.accessToken, 'fresh');
|
|
});
|
|
|
|
test('reuses the created shift after a network failure in the device-bound login', async () => {
|
|
let starts = 0;
|
|
let fail = true;
|
|
const store = sessionFixture(async (path, options) => {
|
|
if (path === '/shifts/start') { starts++; return { driverShift: { id: '55', deviceId: '77' } }; }
|
|
if (path === '/auth/email/login') {
|
|
if (options.body.shiftId && fail) throw new Error('Нет связи');
|
|
return { accessToken: 'access', refreshToken: 'refresh', user: { id: '11' }, ...(options.body.shiftId ? { shift: { id: '55', deviceId: '77' } } : {}) };
|
|
}
|
|
return {};
|
|
});
|
|
await store.login('driver@example.com', 'password');
|
|
assert.equal(store.session, null);
|
|
fail = false;
|
|
await store.login('driver@example.com', 'password');
|
|
assert.equal(starts, 1);
|
|
assert.equal(store.session.shift.id, '55');
|
|
});
|
|
|
|
test('an invalid refresh returns to login; a network error retains the session', async () => {
|
|
for (const status of [401, 0]) {
|
|
const store = sessionFixture(async path => { throw new HttpError(path === '/auth/refresh' ? status : 401, 'Ошибка'); });
|
|
store.session = { accessToken: 'old', refreshToken: 'refresh', user: { id: '11' }, shift: { id: '55' } };
|
|
await assert.rejects(store.authorized('/messages/pending'));
|
|
assert.equal(store.session === null, status === 401);
|
|
}
|
|
});
|
|
|
|
test('completes local logout once the server ends the shift, even if token revocation fails', async () => {
|
|
const store = sessionFixture(async path => {
|
|
if (path === '/auth/logout') throw new Error('Нет связи');
|
|
return {};
|
|
});
|
|
store.session = { accessToken: 'token', refreshToken: 'refresh', user: { id: '11' }, shift: { id: '55' } };
|
|
await store.logout();
|
|
assert.equal(store.session, null);
|
|
assert.equal(store.error, null);
|
|
});
|
|
|
|
test('only visible incoming messages are read, and stale polls preserve their read status', async () => {
|
|
const writes = [];
|
|
const store = new LiveMessageStore('11', async (path, options) => {
|
|
if (options?.method === 'POST') { writes.push([path, options.body]); return { updated: 1 }; }
|
|
return { messages: options.query?.fromId ? [] : [incoming('101'), incoming('102')] };
|
|
});
|
|
try {
|
|
store.start();
|
|
await tick();
|
|
await Promise.all([store.markVisibleRead(['101']), store.markVisibleRead(['101'])]);
|
|
assert.equal(writes.filter(([path]) => path === '/messages/report/read').length, 1);
|
|
assert.equal(store.messages.find(message => message.id === '102').receivers[0].status, 'delivered');
|
|
await store.refresh();
|
|
assert.equal(store.messages.find(message => message.id === '101').receivers[0].status, 'read');
|
|
} finally { store.stop(); }
|
|
});
|
|
|
|
test('polling replaces an outgoing delivery indicator with the server read status', async () => {
|
|
let status = 'delivered';
|
|
const store = new LiveMessageStore('11', async (path, options) => ({ messages: options.query?.fromId ? [{ ...incoming('100'), fromId: '11', receivers: [{ toId: '22', status }] }] : [] }));
|
|
try {
|
|
store.start();
|
|
await tick();
|
|
assert.equal(store.chats[0].deliveryStatus, 'delivered');
|
|
status = 'read';
|
|
await store.refresh();
|
|
assert.equal(store.chats[0].deliveryStatus, 'read');
|
|
} finally { store.stop(); }
|
|
});
|
|
|
|
test('viewport receipts exclude offscreen bubbles and support messages taller than the viewport', () => {
|
|
const { visibleMessageIds } = load('widgets/messenger/model/visibleMessages.ts');
|
|
const layouts = [{ id: 'above', y: 0, height: 80 }, { id: 'visible', y: 100, height: 60 }, { id: 'below', y: 300, height: 80 }];
|
|
assert.deepEqual(visibleMessageIds(layouts, 100, 120), ['visible']);
|
|
assert.deepEqual(visibleMessageIds([{ id: 'long', y: 0, height: 1000 }], 400, 120), ['long']);
|
|
assert.deepEqual(visibleMessageIds(layouts, 100, 0), []);
|
|
});
|
|
|
|
test('activation is saved once and restored before email/password login', async () => {
|
|
const state = { value: null };
|
|
const store = sessionFixture(async () => ({}), state);
|
|
await store.init();
|
|
assert.equal(store.activation, null);
|
|
await store.activateDevice('77', 'device-secret');
|
|
assert.deepEqual(state.value, { deviceId: '77', deviceSecret: 'device-secret' });
|
|
const restored = sessionFixture(async () => ({}), state);
|
|
await restored.init();
|
|
assert.deepEqual({ ...restored.activation }, state.value);
|
|
});
|
|
|
|
test('login requires saved activation and uses it without additional device fields', async () => {
|
|
const calls = [];
|
|
const state = { value: null };
|
|
const store = sessionFixture(async (path, options) => {
|
|
calls.push([path, options]);
|
|
if (path === '/auth/email/login') return { accessToken: 'access', refreshToken: 'refresh', user: { id: '11' }, ...(options.body.shiftId ? { shift: { id: '55', deviceId: '77' } } : {}) };
|
|
if (path === '/shifts/start') return { driverShift: { id: '55' } };
|
|
return {};
|
|
}, state);
|
|
await store.login('driver@example.com', 'password');
|
|
assert.equal(calls.length, 0);
|
|
await store.activateDevice('77', 'saved-secret');
|
|
await store.login('driver@example.com', 'password');
|
|
assert.deepEqual(calls.find(([path]) => path === '/shifts/start')[1].body, { userId: '11', deviceId: '77', deviceSecret: 'saved-secret' });
|
|
});
|
|
|
|
test('reset clears activation and the session, and the next launch requires activation', async () => {
|
|
const state = { value: { deviceId: '77', deviceSecret: 'saved-secret' } };
|
|
const store = sessionFixture(async () => ({}), state);
|
|
store.session = { accessToken: 'access', refreshToken: 'refresh', user: { id: '11' }, shift: { id: '55', deviceId: '77' } };
|
|
await store.resetDevice();
|
|
assert.equal(state.value, null);
|
|
assert.equal(store.session, null);
|
|
const restored = sessionFixture(async () => ({}), state);
|
|
await restored.init();
|
|
assert.equal(restored.activation, null);
|
|
});
|
|
|
|
test('a failed secure-store write does not activate the device', async () => {
|
|
const state = { value: null, failSave: true };
|
|
const store = sessionFixture(async () => ({}), state);
|
|
await store.activateDevice('77', 'secret');
|
|
assert.equal(store.activation, null);
|
|
assert.match(store.error, /сохранить/);
|
|
});
|
|
|
|
test('native device credentials use SecureStore rather than AsyncStorage', async () => {
|
|
const calls = [];
|
|
const memory = new Map();
|
|
const { deviceActivationStorage } = load('entities/session/api/deviceActivation.ts', {
|
|
'react-native': { Platform: { OS: 'android' } },
|
|
'expo-secure-store': {
|
|
WHEN_UNLOCKED_THIS_DEVICE_ONLY: 1,
|
|
setItemAsync: async (key, value) => { calls.push('save'); memory.set(key, value); },
|
|
getItemAsync: async key => memory.get(key) ?? null,
|
|
deleteItemAsync: async key => { calls.push('delete'); memory.delete(key); },
|
|
},
|
|
'@/shared/lib': { storage: new Proxy({}, { get() { throw new Error('Native secrets must not use AsyncStorage'); } }) },
|
|
'@/shared/config': { apiBaseUrl: 'https://irida.example' },
|
|
});
|
|
await deviceActivationStorage.save({ deviceId: '77', deviceSecret: 'secret' });
|
|
assert.deepEqual(await deviceActivationStorage.load(), { deviceId: '77', deviceSecret: 'secret' });
|
|
await deviceActivationStorage.clear();
|
|
assert.equal(await deviceActivationStorage.load(), null);
|
|
assert.deepEqual(calls, ['save', 'delete']);
|
|
});
|
|
|
|
test('reply mapping provides the quoted author and text instead of displaying an ID', () => {
|
|
const original = { ...incoming('101'), message: 'Исходный текст' };
|
|
const reply = { ...incoming('102'), fromId: '11', replyId: '101' };
|
|
const mapped = mapping.mapLiveMessage(reply, '11', [original, reply]);
|
|
assert.equal(mapped.replyToId, '101');
|
|
assert.equal(mapped.replyTo, 'Исходный текст');
|
|
assert.equal(mapped.replyToAuthor, 'Диспетчер #22');
|
|
});
|
|
|
|
test('native activation refuses a write that resolves without persisting the credentials', async () => {
|
|
const { deviceActivationStorage } = load('entities/session/api/deviceActivation.ts', {
|
|
'react-native': { Platform: { OS: 'android' } },
|
|
'expo-secure-store': {
|
|
WHEN_UNLOCKED_THIS_DEVICE_ONLY: 1,
|
|
setItemAsync: async () => {},
|
|
getItemAsync: async () => null,
|
|
},
|
|
'@/shared/lib': { storage: {} },
|
|
'@/shared/config': { apiBaseUrl: 'https://irida.example' },
|
|
});
|
|
await assert.rejects(() => deviceActivationStorage.save({ deviceId: '77', deviceSecret: 'secret' }), /сохранение/);
|
|
});
|
|
|
|
test('distinguishes device shift rejection from email login rejection', async () => {
|
|
const store = sessionFixture(async (path) => {
|
|
if (path === '/auth/email/login') return { accessToken: 'access', refreshToken: 'refresh', user: { id: '11' } };
|
|
if (path === '/shifts/start') throw new HttpError(401, 'invalid credentials');
|
|
return {};
|
|
});
|
|
await store.login('driver@example.com', 'password');
|
|
assert.equal(store.error, 'Открытие смены на устройстве 77: invalid credentials');
|
|
assert.equal(store.activation.deviceSecret, 'secret');
|
|
});
|