SHA256
125 lines
6.6 KiB
JavaScript
125 lines
6.6 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import { fileURLToPath } from 'node:url';
|
|
import {
|
|
getConnectionsGraphCached,
|
|
cachedConnectionsGraph,
|
|
invalidateConnectionsGraphCache,
|
|
CONNECTIONS_GRAPH_CHANGED,
|
|
} from '../js/services/connections-graph-cache.js';
|
|
import { peopleFromGraphModel } from '../js/pages/network/adapter.js';
|
|
import { engineModelFromGraphModel } from '../js/pages/network-legacy/adapter.js';
|
|
|
|
const screenPaths = ['../js/pages/network-view.js', '../js/pages/network-legacy/network-view.js'];
|
|
|
|
// Исполняем саму функцию построения модели из каждого экрана в минимальном окружении.
|
|
// Это проверяет реальные реализации, не требуя браузерного DOM для огромных экранов.
|
|
function graphModelBuilder(relativePath) {
|
|
const code = readFileSync(fileURLToPath(new URL(relativePath, import.meta.url)), 'utf8');
|
|
const functionSource = code.slice(code.indexOf('function buildGraphModel('));
|
|
const stop = functionSource.indexOf('\n}\n');
|
|
assert.ok(stop > 0, `${relativePath}: buildGraphModel не найдена`);
|
|
const normalizeLogin = (value) => String(value || '').trim();
|
|
const normKey = (value) => normalizeLogin(value).toLowerCase();
|
|
const uniqueLogins = (values) => [...new Map(values.map((value) => [normKey(value), normalizeLogin(value)])).values()];
|
|
const toSet = (values) => new Set(uniqueLogins(values || []).map(normKey));
|
|
const hasLogin = (set, value) => set.has(normKey(value));
|
|
const getMarkByLogin = (rows) => new Map((rows || []).map((row) => [normKey(row.login), row]));
|
|
const state = { session: { login: 'alice' } };
|
|
const body = `${functionSource.slice(0, stop + 2)}\nreturn buildGraphModel;`;
|
|
return new Function('normalizeLogin', 'normKey', 'uniqueLogins', 'toSet', 'hasLogin', 'getMarkByLogin', 'state', 'GENDER_UNKNOWN', body)(
|
|
normalizeLogin, normKey, uniqueLogins, toSet, hasLogin, getMarkByLogin, state, 'unknown',
|
|
);
|
|
}
|
|
|
|
for (const path of screenPaths) {
|
|
test(`граф ${path}: только исходящие друзья и строгая взаимность`, () => {
|
|
const build = graphModelBuilder(path);
|
|
const graph = {
|
|
login: 'alice',
|
|
outFriends: ['Bob', 'Jill'],
|
|
outCloseFriends: ['Cara'],
|
|
inFriends: ['BOB', 'Nope'],
|
|
inCloseFriends: ['Lisa'],
|
|
outContacts: ['Contact'],
|
|
inContacts: ['Jill', 'IncomingContact'],
|
|
outFollows: ['Follow'],
|
|
};
|
|
const result = build(graph, 'alice');
|
|
assert.deepEqual(result.relations.map((r) => r.login), ['Cara', 'Bob', 'Jill']);
|
|
assert.equal(result.relations.find((r) => r.login === 'Cara').relationType, 'close_friend');
|
|
assert.equal(result.relations.find((r) => r.login === 'Bob').backward, true);
|
|
assert.equal(result.relations.find((r) => r.login === 'Jill').backward, false,
|
|
'Контакт в ответ не превращает одностороннюю дружбу во взаимную');
|
|
assert.equal(result.relations.find((r) => r.login === 'Cara').backward, false);
|
|
assert.deepEqual(build({ login: 'alice', inFriends: ['OnlyIncoming'], outContacts: ['OnlyContact'] }, 'alice').relations, []);
|
|
});
|
|
}
|
|
|
|
test('адаптеры обеих версий получают одинаковую взаимность и тип дружбы', () => {
|
|
const model = graphModelBuilder(screenPaths[0])({
|
|
login: 'alice', outFriends: ['bob'], outCloseFriends: ['cara'], inFriends: ['cara'],
|
|
}, 'alice');
|
|
const modern = peopleFromGraphModel(model).peers;
|
|
const legacy = engineModelFromGraphModel(model).nodes.slice(1);
|
|
assert.deepEqual(modern.map((peer) => [peer.person.login, peer.relationType, peer.mutual]),
|
|
[['cara', 'close_friend', true], ['bob', 'friend', false]]);
|
|
assert.deepEqual(legacy.map((peer) => [peer.login, peer.relationType, peer.mutual]),
|
|
[['cara', 'close_friend', true], ['bob', 'friend', false]]);
|
|
});
|
|
|
|
test('TTL графа — 2 минуты: до истечения повторный запрос не нужен', async () => {
|
|
const originalNow = Date.now;
|
|
let now = 10_000_000;
|
|
Date.now = () => now;
|
|
try {
|
|
invalidateConnectionsGraphCache();
|
|
let queries = 0;
|
|
const service = { serverUrl: 'wss://ttl.test', async getUserConnectionsGraph() { return { queries: ++queries }; } };
|
|
await getConnectionsGraphCached(service, 'alice');
|
|
now += 119_999;
|
|
assert.equal((await getConnectionsGraphCached(service, 'alice')).queries, 1);
|
|
now += 1;
|
|
assert.equal((await getConnectionsGraphCached(service, 'alice')).queries, 2);
|
|
} finally { Date.now = originalNow; }
|
|
});
|
|
|
|
test('общий кэш: два экрана / серверы / инвалидация / изменение в незавершённом запросе', async () => {
|
|
const previousWindow = globalThis.window;
|
|
const windowMock = new EventTarget();
|
|
globalThis.window = windowMock;
|
|
try {
|
|
let seen = 0;
|
|
windowMock.addEventListener(CONNECTIONS_GRAPH_CHANGED, () => { seen += 1; });
|
|
let queries = 0;
|
|
const service = { serverUrl: 'wss://first.test', async getUserConnectionsGraph() { return { version: ++queries }; } };
|
|
const first = await getConnectionsGraphCached(service, 'Alice');
|
|
const second = await getConnectionsGraphCached(service, 'ALICE');
|
|
assert.strictEqual(first, second);
|
|
assert.equal(queries, 1);
|
|
assert.strictEqual(cachedConnectionsGraph(service, 'alice'), first);
|
|
|
|
const secondServer = { serverUrl: 'wss://second.test', async getUserConnectionsGraph() { return { version: 77 }; } };
|
|
assert.equal((await getConnectionsGraphCached(secondServer, 'alice')).version, 77);
|
|
invalidateConnectionsGraphCache();
|
|
assert.equal(seen, 1);
|
|
assert.equal(cachedConnectionsGraph(service, 'alice'), null);
|
|
assert.equal((await getConnectionsGraphCached(service, 'alice')).version, 2);
|
|
|
|
let releaseOld;
|
|
let current = 0;
|
|
const pendingService = { serverUrl: 'wss://pending.test', getUserConnectionsGraph() {
|
|
current += 1;
|
|
return current === 1 ? new Promise((resolve) => { releaseOld = resolve; }) : Promise.resolve({ version: 'new' });
|
|
} };
|
|
const pending = getConnectionsGraphCached(pendingService, 'alice', { force: true });
|
|
invalidateConnectionsGraphCache();
|
|
releaseOld({ version: 'old' });
|
|
assert.equal((await pending).version, 'new', 'ответ старого запроса не должен воскресить устаревший снимок');
|
|
assert.equal(cachedConnectionsGraph(pendingService, 'alice').version, 'new');
|
|
} finally {
|
|
globalThis.window = previousWindow;
|
|
}
|
|
});
|