Поправил пуши для личных сообщений

This commit is contained in:
AidarKC
2026-10-21 11:47:27 +03:00
parent aa5addb5d9
commit 7a6ab3b35a
22 changed files with 723 additions and 678 deletions
@@ -0,0 +1,124 @@
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;
}
});
+54
View File
@@ -0,0 +1,54 @@
const fs=require('fs');
const path=require('path');
const vm=require('vm');
const assert=require('assert');
const registrations=[];
const events={};
const stateDb=new Map();
const notifications=new Map();
const cacheObj={
async match(key){return stateDb.get(key)?.clone() || null},
async put(key, response){stateDb.set(key, response)},
};
const context={
self:{
__shineStoppedCalls:new Map(),
registration:{scope:'https://shineup.me/',
async showNotification(title, options){ registrations.push({title,options}); if(options.tag) notifications.set(options.tag,{data:options.data, close(){ notifications.delete(options.tag) }}) },
async getNotifications({tag}){return notifications.get(tag)?[notifications.get(tag)]:[]},
},
clients:{async matchAll(){return []}},
addEventListener(name, handler){events[name]=handler},
skipWaiting(){},
},
caches:{async open(){return cacheObj}},
Response, URL, Promise, Date, Number, String, Math, Map, Object, JSON, encodeURIComponent,
};
vm.createContext(context);
vm.runInContext(fs.readFileSync(path.resolve(__dirname, '../firebase-messaging-sw.js'),'utf8'), context);
async function push(data){const pending=[];events.push({data:{text(){return JSON.stringify(data)}}, waitUntil(p){pending.push(p)}});await Promise.all(pending)}
async function read(to,from){const pending=[];events.message({data:{type:'SHINE_DM_READ',toLogin:to,fromLogin:from},waitUntil(p){pending.push(p)}});await Promise.all(pending)}
(async()=>{
for(let i=1;i<=5;i++){
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'Vasya',messageKey:`m${i}`,unreadCount:i,notificationVersionMs:1000+i});
}
assert.strictEqual(registrations.length,5,'every new message renotifies');
assert(registrations.every(x=>x.options.renotify===true && x.options.silent===false));
assert.strictEqual(notifications.size,1,'one tag per conversation');
assert.strictEqual(registrations.at(-1).options.body,'5 непрочитанных сообщений');
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'Kolya',messageKey:'k1',unreadCount:2,notificationVersionMs:2000});
assert.strictEqual(notifications.size,2);
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'Vasya',messageKey:'m5',unreadCount:5,notificationVersionMs:1005});
assert.strictEqual(registrations.length,6,'duplicate push ignored');
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'Vasya',messageKey:'m6',unreadCount:4,notificationVersionMs:1003});
assert.strictEqual(registrations.at(-1).options.body,'5 непрочитанных сообщений','late push cannot downgrade unread count');
await read('AnNa','Vasya');
assert.strictEqual(notifications.size,1,'read closes only Vasya notification');
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'Vasya',messageKey:'m7',unreadCount:4,notificationVersionMs:1004});
assert.strictEqual(notifications.size,1,'old push after read suppressed');
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'Vasya',messageKey:'m8',unreadCount:1,notificationVersionMs:1008});
assert.strictEqual(notifications.size,2,'new push after read can notify');
await push({kind:'new_message',toLogin:'AnNa',fromLogin:'MashA',messageKey:'z1',unreadCount:21,notificationVersionMs:3000});
assert.strictEqual(registrations.at(-1).options.body,'21 непрочитанное сообщение');
console.log('PASS: 5 alerts, tags per conversation, counter, replay suppression, late-push ordering, read close and newer-push delivery');
})().catch(e=>{console.error(e);process.exitCode=1});