Files
SHiNE-server/shine-UI/tests/connections-graph-cache.test.mjs

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