| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355 |
- import test from 'node:test';
- import assert from 'node:assert/strict';
- import { createStore } from '../src/store.js';
- import { currentChatTitle, normalizeChatName, preserveChatName, refreshChatNames } from '../src/chat-names.js';
- const tenant = '11111111-1111-1111-1111-111111111111', self = '22222222-2222-2222-2222-222222222222';
- const peer = '33333333-3333-3333-3333-333333333333', third = '44444444-4444-4444-4444-444444444444';
- const accountId = `web-api:${tenant}:${self}`;
- const chat = (overrides = {}) => ({ source: 'web-api', accountId, kind: 'chat', externalId: 'fictional-chat', title: '聊天',
- raw: { isOneOnOne: true, titleSource: 'placeholder' }, ...overrides });
- const message = (id, senderId, author, overrides = {}) => ({ source: 'web-api', accountId, kind: 'message', externalId: id,
- parentId: 'fictional-chat', title: '聊天', text: 'Fictional message', occurredAt: '2026-09-08T10:00:00Z', raw: { senderId, selfUserId: self, author }, ...overrides });
- test('member naming excludes self, validates identities and preserves explicitly named generic titles', () => {
- const item = { title: '', isOneOnOne: true, members: [
- { objectId: self, mri: `8:orgid:${self}`, friendlyName: 'Fictional self' },
- { objectId: peer, mri: `8:orgid:${peer}`, friendlyName: '<b>Fictional peer</b>', authorization: 'secret-marker' },
- ] };
- const named = normalizeChatName(item, accountId);
- assert.equal(named.title, 'Fictional peer'); assert.equal(named.raw.titleSource, 'members'); assert.equal(named.raw.peerId, peer);
- assert.equal(named.raw.members.length, 2); assert.doesNotMatch(JSON.stringify(named), /secret-marker|8:orgid/);
- assert.equal(normalizeChatName({ ...item, title: '聊天' }, accountId).raw.titleSource, 'explicit');
- assert.equal(normalizeChatName(item, 'unknown-account').title, '聊天');
- assert.equal(normalizeChatName({ ...item, members: [{ objectId: peer, mri: `8:orgid:${third}`, friendlyName: 'Unverified' }] }, accountId).title, '聊天');
- assert.equal(normalizeChatName({ ...item, members: [{ friendlyName: 'Unidentified' }] }, accountId).title, '聊天');
- });
- test('a self-authored message cannot name the peer; the most recent other-author name can', () => {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(chat());
- store.upsertRecord(message('old-peer', peer, 'Fictional former peer name'), { ingestion: 'history' });
- store.upsertRecord(message('new-peer', peer, 'Fictional current peer name', { occurredAt: '2026-09-08T11:00:00Z' }), { ingestion: 'history' });
- store.upsertRecord(message('my-message', self, 'Fictional self name', { occurredAt: '2026-09-08T12:00:00Z' }), { ingestion: 'history' });
- const snapshot = () => ({ records: store.readRows("SELECT * FROM records WHERE kind='message' ORDER BY id"),
- versions: store.readRows("SELECT v.* FROM versions v JOIN records r ON v.recordId=r.id WHERE r.kind='message' ORDER BY v.id") });
- const before = snapshot();
- assert.equal(refreshChatNames(store), 1);
- const resolved = store.getRecordByIdentity(chat());
- assert.equal(resolved.title, 'Fictional current peer name'); assert.equal(resolved.raw.titleSource, 'message-author'); assert.equal(resolved.raw.peerId, peer);
- assert.deepEqual(snapshot(), before);
- assert.equal(store.readOne('SELECT ingestion FROM change_log ORDER BY seq DESC LIMIT 1').ingestion, 'import');
- const originalUpsert = store.upsertRecord;
- store.upsertRecord = () => assert.fail('An unchanged derived title must not refresh lastSeenAt');
- assert.equal(refreshChatNames(store), 0);
- store.upsertRecord = originalUpsert;
- store.upsertRecord(message('same-peer-name', peer, 'Fictional current peer name', { occurredAt: '2026-09-08T13:00:00Z' }));
- store.upsertRecord = () => assert.fail('A newer message with the same name must not rewrite the chat');
- assert.equal(refreshChatNames(store), 0);
- } finally { store.close(); }
- });
- test('verified member names take precedence and a stored derived name tracks a new peer display name', () => {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(chat({ raw: { isOneOnOne: true, titleSource: 'placeholder', membersComplete: true,
- members: [{ userId: self, displayName: 'Fictional self' }, { userId: peer, displayName: 'Fictional roster peer' }] } }));
- store.upsertRecord(message('peer', peer, 'Fictional historical author'));
- assert.equal(refreshChatNames(store), 1);
- assert.equal(store.getRecordByIdentity(chat()).title, 'Fictional roster peer');
- store.upsertRecord(chat({ title: 'Old peer name', raw: { isOneOnOne: true, titleSource: 'message-author', peerId: peer } }));
- assert.equal(refreshChatNames(store), 1);
- assert.equal(store.getRecordByIdentity(chat()).title, 'Fictional historical author');
- } finally { store.close(); }
- });
- test('group, unknown, ambiguous, masked and explicitly named chats are not guessed', () => {
- for (const overrides of [
- { raw: { isOneOnOne: false, titleSource: 'placeholder' } }, { raw: { titleSource: 'placeholder' } },
- { title: '聊天', raw: { isOneOnOne: true, titleSource: 'explicit' } },
- { title: 'Explicit fictional title', raw: { isOneOnOne: true } },
- { raw: { isOneOnOne: true, titleSource: 'placeholder', members: [{ userId: peer, isIdentityMasked: true }] } },
- { raw: { isOneOnOne: true, titleSource: 'placeholder', membersComplete: false, members: [{ userId: peer }] } },
- { raw: { isOneOnOne: true, titleSource: 'placeholder', members: [{ userId: peer }, { userId: third }] } },
- ]) {
- const store = createStore(':memory:');
- try { store.upsertRecord(chat(overrides)); store.upsertRecord(message('peer', peer, 'Fictional peer')); assert.equal(refreshChatNames(store), 0); }
- finally { store.close(); }
- }
- const store = createStore(':memory:');
- try {
- store.upsertRecord(chat()); store.upsertRecord(message('peer', peer, 'Fictional peer')); store.upsertRecord(message('third', third, 'Fictional third'));
- assert.equal(refreshChatNames(store), 0);
- } finally { store.close(); }
- });
- test('peer author lookups remain in the same account, source and conversation', () => {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(chat());
- store.upsertRecord(message('other-account', peer, 'Wrong account', { accountId: 'another-account' }));
- store.upsertRecord(message('other-source', peer, 'Wrong source', { source: 'browser' }));
- store.upsertRecord(message('other-chat', peer, 'Wrong chat', { parentId: 'another-chat' }));
- store.upsertRecord(message('self', self, 'Fictional self'));
- assert.equal(refreshChatNames(store), 0);
- store.upsertRecord(message('correct', peer, 'Correct fictional peer'));
- assert.equal(refreshChatNames(store, { accountId, chatId: 'fictional-chat' }), 1);
- } finally { store.close(); }
- });
- test('missing list names preserve useful titles, while an explicit replacement or changed peer wins', () => {
- const previous = chat({ title: 'Fictional peer', raw: { isOneOnOne: true, titleSource: 'message-author', peerId: peer } });
- assert.equal(preserveChatName(chat(), previous).title, 'Fictional peer');
- assert.equal(preserveChatName(chat({ title: '聊天', raw: { isOneOnOne: true, titleSource: 'explicit' } }), previous).title, '聊天');
- assert.equal(preserveChatName(chat({ raw: { isOneOnOne: true, titleSource: 'placeholder', members: [{ userId: third }] } }), previous).title, '聊天');
- const store = createStore(':memory:');
- try {
- store.upsertRecord(previous);
- assert.equal(currentChatTitle(store, accountId, 'fictional-chat', '聊天'), 'Fictional peer');
- assert.equal(currentChatTitle(store, 'another-account', 'fictional-chat', 'Other fallback'), 'Other fallback');
- } finally { store.close(); }
- });
- test('derived names are not retained when the new roster contradicts private-chat or visible-identity evidence', () => {
- for (const titleSource of ['members', 'message-author']) {
- const previous = chat({ title: 'Fictional peer', raw: { isOneOnOne: true, titleSource, peerId: peer } });
- for (const evidence of [
- { chatType: 'group' }, { chatType: 'meeting' }, { threadType: 'meeting' },
- { membersComplete: false }, { members: [{ userId: peer, isIdentityMasked: true }] },
- ]) {
- const incoming = chat({ raw: { isOneOnOne: true, titleSource: 'placeholder', ...evidence } });
- assert.equal(preserveChatName(incoming, previous).title, '聊天');
- assert.equal(preserveChatName(incoming, previous).raw.titleSource, 'placeholder');
- }
- assert.equal(preserveChatName(chat(), previous).title, 'Fictional peer');
- }
- });
- const participantChatId = `19:${self}_${peer}@unq.gbl.spaces`;
- const participantChatRecord = (overrides = {}) => chat({ externalId: participantChatId, raw: { titleSource: 'placeholder' }, ...overrides });
- const participantMessage = (id, senderId, author, overrides = {}) => message(id, senderId, author, { parentId: participantChatId, ...overrides });
- const messageSnapshot = store => ({ records: store.readRows("SELECT * FROM records WHERE kind='message' ORDER BY id"),
- versions: store.readRows("SELECT v.* FROM versions v JOIN records r ON v.recordId=r.id WHERE r.kind='message' ORDER BY v.id") });
- test('canonical participant IDs and a local peer author name an uncatalogued emoji conversation without classification', () => {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(participantMessage('emoji', peer, '<b>Fictional peer</b>', { text: '🔥' }), { ingestion: 'history' });
- store.upsertRecord(participantMessage('own', self, 'Fictional self', { occurredAt: '2026-09-08T12:00:00Z' }));
- const before = messageSnapshot(store);
- assert.equal(refreshChatNames(store, { accountId, chatId: participantChatId }), 1);
- const resolved = store.getRecordByIdentity(participantChatRecord());
- assert.equal(resolved.title, 'Fictional peer');
- assert.deepEqual(resolved.raw, { chatId: participantChatId, titleSource: 'conversation-peer', peerId: peer, nameEvidence: 'unq-participant-ids' });
- assert.equal(store.getRecord(store.getRecordByIdentity(participantMessage('emoji')).id).displayTitle, 'Fictional peer');
- assert.equal(store.getRecord(store.getRecordByIdentity(participantMessage('own')).id).displayTitle, 'Fictional peer');
- assert.deepEqual(messageSnapshot(store), before);
- assert.equal(store.readOne('SELECT ingestion FROM change_log ORDER BY seq DESC LIMIT 1').ingestion, 'import');
- const records = store.readRows('SELECT * FROM records ORDER BY id'), versions = store.readRows('SELECT * FROM versions ORDER BY id');
- store.upsertRecord = () => assert.fail('An unchanged peer name must not write metadata or versions');
- assert.equal(refreshChatNames(store), 0);
- assert.deepEqual(store.readRows('SELECT * FROM records ORDER BY id'), records);
- assert.deepEqual(store.readRows('SELECT * FROM versions ORDER BY id'), versions);
- } finally { store.close(); }
- });
- test('the same participant conversation resolves the opposite peer independently for each account', () => {
- const store = createStore(':memory:'), otherAccount = `web-api:${tenant}:${peer}`;
- try {
- store.upsertRecord(participantMessage('for-first', peer, 'Fictional second person'));
- store.upsertRecord(participantMessage('for-second', self, 'Fictional first person', {
- accountId: otherAccount, raw: { senderId: self, selfUserId: peer, author: 'Fictional first person' } }));
- assert.equal(refreshChatNames(store, { accountId }), 1);
- assert.equal(store.getRecordByIdentity(participantChatRecord({ accountId: otherAccount })), null);
- assert.equal(refreshChatNames(store), 1);
- assert.equal(currentChatTitle(store, accountId, participantChatId), 'Fictional second person');
- assert.equal(currentChatTitle(store, otherAccount, participantChatId), 'Fictional first person');
- assert.equal(store.getRecordByIdentity(participantChatRecord({ accountId: otherAccount })).raw.peerId, self);
- } finally { store.close(); }
- });
- test('participant fallback rejects incomplete identifiers and missing local peer evidence', () => {
- const cases = [
- { label: 'fake UUID', parentId: `19:${self}_fake@unq.gbl.spaces` },
- { label: 'repeated self', parentId: `19:${self}_${self}@unq.gbl.spaces` },
- { label: 'account absent from pair', parentId: `19:${third}_${peer}@unq.gbl.spaces` },
- { label: 'thread suffix only', parentId: `19:${self}_${peer}@thread.v2` },
- { label: 'encoded IDs', parentId: `19%3A${self}_${peer}%40unq.gbl.spaces` },
- { label: 'trailing content', parentId: `${participantChatId}:extra` },
- { label: 'invalid account tenant', accountId: `web-api:tenant:${self}` },
- { label: 'invalid self identity', accountId: `web-api:${tenant}:self` },
- { label: 'another source', source: 'browser' },
- { label: 'only own message', raw: { senderId: self, selfUserId: self, author: 'Fictional self' } },
- { label: 'deleted peer', deleted: true },
- { label: 'unknown sender', raw: { senderId: 'not-a-uuid', selfUserId: self, author: 'Unknown person' } },
- { label: 'empty author', raw: { senderId: peer, selfUserId: self, author: '<b></b>' } },
- { label: 'wrong self claim', raw: { senderId: peer, selfUserId: third, author: 'Fictional peer' } },
- ];
- for (const { label, ...overrides } of cases) {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(participantMessage('candidate', peer, 'Fictional peer', overrides));
- assert.equal(refreshChatNames(store), 0, label);
- assert.equal(store.readOne("SELECT COUNT(*) n FROM records WHERE kind='chat'").n, 0, label);
- } finally { store.close(); }
- }
- });
- test('peer name discovery rejects contradictory senders, identity claims and conversation metadata', () => {
- const cases = [
- { label: 'third sender', extra: participantMessage('third', third, 'Third person') },
- { label: 'wrong self claim on another message', extra: participantMessage('wrong-self', self, 'Fictional self',
- { raw: { senderId: self, selfUserId: third, author: 'Fictional self' } }) },
- ...[{ isOneOnOne: false }, { chatType: 'group' }, { chatType: 'meeting' }, { threadType: 'meeting' },
- { isIdentityMasked: true }, { membersComplete: false },
- { membersComplete: true, members: [{ userId: self }, { userId: peer, isIdentityMasked: true }] },
- { membersComplete: true, members: [{ userId: self }, { userId: third }] },
- { members: 'invalid' }].map(evidence => ({ label: `message evidence ${JSON.stringify(evidence)}`,
- extra: participantMessage('message-evidence', self, 'Fictional self',
- { raw: { senderId: self, selfUserId: self, author: 'Fictional self', ...evidence } }) })),
- ...[
- { isOneOnOne: false }, { chatType: 'group' }, { chatType: 'meeting' }, { threadType: 'group' }, { threadType: 'meeting' },
- { membersComplete: false }, { isIdentityMasked: true }, { selfUserId: third }, { peerId: third },
- { members: [{ userId: self }, { userId: peer }] },
- { membersComplete: true, members: [{ userId: peer }] },
- { membersComplete: true, members: [{ userId: self }, { userId: third }] },
- { membersComplete: true, members: [{ userId: self }, { userId: peer, isIdentityMasked: true }] },
- { membersComplete: true, members: [{ userId: self }, { userId: self }] },
- { membersComplete: true, members: [{ userId: self }, { userId: 'invalid' }] },
- { membersComplete: true, members: 'invalid' },
- ].map(raw => ({ label: JSON.stringify(raw), chat: participantChatRecord({ raw: { titleSource: 'placeholder', ...raw } }) })),
- { label: 'deleted conversation', chat: participantChatRecord({ deleted: true }) },
- ];
- for (const { label, extra, chat: existing } of cases) {
- const store = createStore(':memory:');
- try {
- if (existing) store.upsertRecord(existing);
- store.upsertRecord(participantMessage('candidate', peer, 'Fictional peer'));
- if (extra) store.upsertRecord(extra);
- const before = store.readRows('SELECT * FROM records ORDER BY id');
- assert.equal(refreshChatNames(store), 0, label);
- assert.deepEqual(store.readRows('SELECT * FROM records ORDER BY id'), before, label);
- } finally { store.close(); }
- }
- });
- test('participant discovery uses only the requested source, account and conversation', () => {
- const store = createStore(':memory:'), otherChat = `19:${self}_${third}@unq.gbl.spaces`;
- try {
- store.upsertRecord(participantMessage('other-account', peer, 'Wrong account', { accountId: `web-api:${third}:${self}` }));
- store.upsertRecord(participantMessage('other-source', peer, 'Wrong source', { source: 'browser' }));
- store.upsertRecord(participantMessage('other-chat', peer, 'Wrong conversation', { parentId: otherChat }));
- store.upsertRecord(participantMessage('self-only', self, 'Fictional self'));
- assert.equal(refreshChatNames(store, { accountId, chatId: participantChatId }), 0);
- assert.equal(store.readOne("SELECT COUNT(*) n FROM records WHERE kind='chat'").n, 0);
- store.upsertRecord(participantMessage('right-peer', peer, 'Correct fictional peer'));
- assert.equal(refreshChatNames(store, { accountId, chatId: participantChatId }), 1);
- assert.equal(store.readOne("SELECT COUNT(*) n FROM records WHERE kind='chat'").n, 1);
- assert.equal(currentChatTitle(store, accountId, participantChatId), 'Correct fictional peer');
- } finally { store.close(); }
- });
- test('explicit and useful unknown titles take precedence over participant author fallback', () => {
- for (const existing of [
- participantChatRecord({ title: '聊天', raw: { titleSource: 'explicit' } }),
- participantChatRecord({ title: 'Fictional server topic', raw: { titleSource: 'conversation-details' } }),
- participantChatRecord({ title: 'Fictional named chat', raw: {} }),
- participantChatRecord({ title: 'Fictional named chat', raw: { titleSource: 'future-source' } }),
- participantChatRecord({ title: 'Fictional roster name', raw: { titleSource: 'members', peerId: peer } }),
- ]) {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(existing); store.upsertRecord(participantMessage('peer', peer, 'Fictional peer'));
- assert.equal(refreshChatNames(store), 0);
- assert.equal(store.getRecordByIdentity(existing).title, existing.title);
- } finally { store.close(); }
- }
- });
- test('a canonical participant chat keeps verified member names ahead of historical author names', () => {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(participantChatRecord({ raw: { titleSource: 'placeholder', isOneOnOne: true, membersComplete: true,
- members: [{ userId: self, displayName: 'Fictional self' }, { userId: peer, displayName: 'Fictional roster name' }] } }));
- store.upsertRecord(participantMessage('peer', peer, 'Fictional historic author'));
- assert.equal(refreshChatNames(store), 1);
- const resolved = store.getRecordByIdentity(participantChatRecord());
- assert.equal(resolved.title, 'Fictional roster name'); assert.equal(resolved.raw.titleSource, 'members');
- assert.equal(resolved.raw.isOneOnOne, true); assert.equal(resolved.raw.nameEvidence, undefined);
- assert.equal(refreshChatNames(store), 0);
- } finally { store.close(); }
- });
- test('participant fallback follows valid peer name changes while preserving existing metadata and message history', () => {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(participantChatRecord({ raw: { titleSource: 'placeholder', isOneOnOne: true, membersComplete: true,
- members: [{ userId: self }, { userId: peer }], originalEvidence: 'retained' } }));
- store.upsertRecord(participantMessage('old', peer, 'Fictional old name'));
- assert.equal(refreshChatNames(store), 1);
- store.upsertRecord(participantMessage('new', peer, 'Fictional new name', { occurredAt: '2026-09-08T07:00:00-04:00' }));
- store.upsertRecord(participantMessage('blank', peer, '<b></b>', { occurredAt: '2026-09-08T12:00:00Z' }));
- store.upsertRecord(participantMessage('self', self, 'Latest self name', { occurredAt: '2026-09-08T13:00:00Z' }));
- const before = messageSnapshot(store);
- assert.equal(refreshChatNames(store), 1);
- const updated = store.getRecordByIdentity(participantChatRecord());
- assert.equal(updated.title, 'Fictional new name'); assert.equal(updated.raw.originalEvidence, 'retained');
- assert.equal(updated.raw.isOneOnOne, true); assert.equal(updated.raw.members.length, 2);
- assert.deepEqual(messageSnapshot(store), before);
- assert.equal(refreshChatNames(store), 0);
- assert.equal(store.readOne('SELECT COUNT(*) n FROM versions WHERE recordId=?', [updated.id]).n, 3);
- } finally { store.close(); }
- });
- test('incremental placeholder names retain participant evidence only while the account, peer and roster agree', () => {
- const previous = participantChatRecord({ title: 'Fictional peer', raw: { titleSource: 'conversation-peer', peerId: peer,
- chatId: participantChatId, nameEvidence: 'unq-participant-ids' } });
- const preserved = preserveChatName(participantChatRecord(), previous);
- assert.equal(preserved.title, 'Fictional peer'); assert.equal(preserved.raw.nameEvidence, 'unq-participant-ids');
- assert.equal(preserved.raw.isOneOnOne, undefined); assert.equal(preserved.raw.chatType, undefined);
- for (const evidence of [
- { isOneOnOne: false }, { chatType: 'group' }, { threadType: 'meeting' }, { peerId: third }, { selfUserId: third },
- { membersComplete: false }, { membersComplete: true, members: [{ userId: self }, { userId: third }] },
- { membersComplete: true, members: [{ userId: self }, { userId: peer, isIdentityMasked: true }] },
- ]) {
- const incoming = participantChatRecord({ raw: { titleSource: 'placeholder', ...evidence } });
- assert.deepEqual(preserveChatName(incoming, previous), incoming);
- }
- for (const incoming of [
- participantChatRecord({ accountId: `web-api:${tenant}:${peer}` }),
- participantChatRecord({ externalId: `19:${self}_${third}@unq.gbl.spaces` }),
- participantChatRecord({ source: 'browser' }),
- participantChatRecord({ title: 'New topic', raw: { titleSource: 'explicit' } }),
- ]) assert.deepEqual(preserveChatName(incoming, previous), incoming);
- });
- test('new conflicting evidence withdraws only locally derived peer names without rewriting messages', () => {
- const cases = [
- store => store.upsertRecord(participantMessage('third', third, 'Fictional third')),
- store => store.upsertRecord(participantMessage('wrong-self', self, 'Fictional self',
- { raw: { senderId: self, selfUserId: third, author: 'Fictional self' } })),
- store => store.upsertRecord(participantMessage('peer', peer, 'Fictional peer', { deleted: true })),
- ...[{ isOneOnOne: false }, { chatType: 'meeting' }, { membersComplete: false },
- { membersComplete: true, members: [{ userId: self }, { userId: peer, isIdentityMasked: true }] }]
- .map(evidence => store => {
- const current = store.getRecordByIdentity(participantChatRecord());
- store.upsertRecord({ ...current, raw: { ...current.raw, ...evidence } });
- }),
- ];
- for (const conflict of cases) {
- const store = createStore(':memory:');
- try {
- store.upsertRecord(participantMessage('peer', peer, 'Fictional peer'));
- assert.equal(refreshChatNames(store), 1);
- conflict(store);
- const before = messageSnapshot(store);
- assert.equal(refreshChatNames(store), 1);
- const current = store.getRecordByIdentity(participantChatRecord());
- assert.equal(current.title, '聊天'); assert.equal(current.raw.titleSource, 'placeholder');
- assert.equal(current.raw.peerId, undefined); assert.equal(current.raw.nameEvidence, undefined);
- assert.deepEqual(messageSnapshot(store), before);
- assert.equal(refreshChatNames(store), 0);
- } finally { store.close(); }
- }
- });
|