Jannis Braun
7d2137b6d4
CallRelayResult success arm gains undeliverable: string[]. sendCallRelay parses FederationRelayResponse.undeliverable (when present) and returns the messageIds so sendFederatedCallStart can reclassify per-peer results. Old peers that omit the field → empty array → today's behavior. TDD — three tests cover old-peer, new-peer-with-undeliverable, and 5xx paths.
301 lines
10 KiB
TypeScript
301 lines
10 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
|
import Database from 'better-sqlite3';
|
|
import { drizzle } from 'drizzle-orm/better-sqlite3';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import * as schema from '../db/schema.js';
|
|
import { setWorkerId } from '../utils/snowflake.js';
|
|
|
|
setWorkerId(1);
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
type TestDb = ReturnType<typeof drizzle<typeof schema>>;
|
|
|
|
let testDb: TestDb;
|
|
|
|
vi.mock('../db/index.js', () => ({
|
|
getDb: () => testDb,
|
|
schema,
|
|
}));
|
|
|
|
vi.mock('../utils/federationAuth.js', () => ({
|
|
getOurOrigin: () => 'https://local.example',
|
|
buildFederationHeaders: () => ({}),
|
|
generateHmacSecret: () => 'test-secret',
|
|
}));
|
|
|
|
// Mock sendCallRelay so tests can control relay-result per case.
|
|
const sendCallRelayMock = vi.fn();
|
|
vi.mock('../utils/federationOutbox.js', async () => {
|
|
const actual = await vi.importActual<typeof import('../utils/federationOutbox.js')>('../utils/federationOutbox.js');
|
|
return {
|
|
...actual,
|
|
sendCallRelay: (...args: unknown[]) => sendCallRelayMock(...args),
|
|
};
|
|
});
|
|
|
|
function applyMigrations(db: Database.Database): void {
|
|
const migrationsDir = path.resolve(__dirname, '../../drizzle');
|
|
const files = fs.readdirSync(migrationsDir).filter(f => f.endsWith('.sql')).sort();
|
|
for (const f of files) {
|
|
const sql = fs.readFileSync(path.join(migrationsDir, f), 'utf8');
|
|
const statements = sql.split(/-->\s*statement-breakpoint/);
|
|
for (const stmt of statements) {
|
|
const clean = stmt.trim();
|
|
if (clean) db.exec(clean);
|
|
}
|
|
}
|
|
}
|
|
|
|
function seedPeerLabel(origin: string, instanceName: string): void {
|
|
testDb.insert(schema.federationPeers).values({
|
|
id: `peer-${origin}`,
|
|
origin,
|
|
hmacSecret: 'secret',
|
|
status: 'active',
|
|
instanceName,
|
|
lastSyncedAt: 0,
|
|
createdAt: Date.now(),
|
|
}).run();
|
|
}
|
|
|
|
function seedLocalUser(id: string, homeUserId: string | null): void {
|
|
testDb.insert(schema.users).values({
|
|
id,
|
|
username: id,
|
|
passwordHash: 'test',
|
|
homeUserId,
|
|
homeInstance: null,
|
|
createdAt: Date.now(),
|
|
}).run();
|
|
}
|
|
|
|
async function importSUT() {
|
|
// Late import so the module picks up the mocked dependencies.
|
|
return await import('./events.js');
|
|
}
|
|
|
|
async function importManager() {
|
|
const mod = await import('./handler.js');
|
|
return mod.connectionManager;
|
|
}
|
|
|
|
type FedCallEntry = import('./handler.js').FederatedCallEntry;
|
|
|
|
function makeFedCall(partial: Partial<FedCallEntry> = {}): FedCallEntry {
|
|
return {
|
|
dmChannelId: 'dm-1',
|
|
federatedId: `fed-${Math.random().toString(36).slice(2, 10)}`,
|
|
callerId: 'caller-user',
|
|
callerHomeUserId: 'caller@pi',
|
|
federatedCallHost: 'https://pi.example',
|
|
livekitUrl: 'wss://pi.example/lk',
|
|
tokens: new Map([['acceptor@vm', 'token']]),
|
|
ringedUserIds: ['acceptor-user'],
|
|
state: 'ringing',
|
|
startedAt: Date.now(),
|
|
...partial,
|
|
};
|
|
}
|
|
|
|
beforeEach(() => {
|
|
const sqlite = new Database(':memory:');
|
|
testDb = drizzle(sqlite, { schema });
|
|
applyMigrations(sqlite);
|
|
seedPeerLabel('https://pi.example', 'Pi-Instance');
|
|
seedLocalUser('acceptor-user', 'acceptor@vm');
|
|
seedLocalUser('caller-user', 'caller@pi');
|
|
sendCallRelayMock.mockReset();
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
describe('handleDmCallEnd Path-2 relay failure', () => {
|
|
it('emits dm_call_undeliverable { phase:"end", terminal:false } when the relay fails', async () => {
|
|
const { handleDmCallEndForTest } = await importSUT();
|
|
const connectionManager = await importManager();
|
|
|
|
const fedCall = makeFedCall({ state: 'active' });
|
|
connectionManager.createFederatedCall(fedCall);
|
|
const sendToUserSpy = vi.spyOn(connectionManager, 'sendToUser');
|
|
sendCallRelayMock.mockResolvedValue({ ok: false, reason: 'peer_transient_failure', error: 'timeout' });
|
|
|
|
await handleDmCallEndForTest(
|
|
{ federatedCallId: fedCall.federatedId },
|
|
fedCall.ringedUserIds[0]!,
|
|
);
|
|
|
|
const undelivCalls = sendToUserSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(undelivCalls).toHaveLength(1);
|
|
const ev = undelivCalls[0]![1] as { phase: string; terminal: boolean };
|
|
expect(ev.phase).toBe('end');
|
|
expect(ev.terminal).toBe(false);
|
|
});
|
|
|
|
it('does not emit undeliverable on relay success', async () => {
|
|
const { handleDmCallEndForTest } = await importSUT();
|
|
const connectionManager = await importManager();
|
|
|
|
const fedCall = makeFedCall({ state: 'active' });
|
|
connectionManager.createFederatedCall(fedCall);
|
|
const sendToUserSpy = vi.spyOn(connectionManager, 'sendToUser');
|
|
sendCallRelayMock.mockResolvedValue({ ok: true, undeliverable: [] });
|
|
|
|
await handleDmCallEndForTest(
|
|
{ federatedCallId: fedCall.federatedId },
|
|
fedCall.ringedUserIds[0]!,
|
|
);
|
|
|
|
const undelivCalls = sendToUserSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(undelivCalls).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('handleDmCallReject Path-2 relay failure', () => {
|
|
it('emits dm_call_undeliverable { phase:"reject", terminal:false } to the rejector when the relay fails', async () => {
|
|
const { handleDmCallRejectForTest } = await importSUT();
|
|
const connectionManager = await importManager();
|
|
|
|
const fedCall = makeFedCall();
|
|
connectionManager.createFederatedCall(fedCall);
|
|
const sendToUserSpy = vi.spyOn(connectionManager, 'sendToUser');
|
|
sendCallRelayMock.mockResolvedValue({ ok: false, reason: 'peer_rejected', error: 'rejected' });
|
|
|
|
await handleDmCallRejectForTest(
|
|
{ federatedCallId: fedCall.federatedId },
|
|
fedCall.ringedUserIds[0]!,
|
|
);
|
|
|
|
const undelivCalls = sendToUserSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(undelivCalls).toHaveLength(1);
|
|
const ev = undelivCalls[0]![1] as { phase: string; terminal: boolean };
|
|
expect(ev.phase).toBe('reject');
|
|
expect(ev.terminal).toBe(false);
|
|
// Local state was cleared before the relay even fired.
|
|
expect(connectionManager.getFederatedCall(fedCall.federatedId)).toBeUndefined();
|
|
});
|
|
|
|
it('does not emit undeliverable on relay success', async () => {
|
|
const { handleDmCallRejectForTest } = await importSUT();
|
|
const connectionManager = await importManager();
|
|
|
|
const fedCall = makeFedCall();
|
|
connectionManager.createFederatedCall(fedCall);
|
|
const sendToUserSpy = vi.spyOn(connectionManager, 'sendToUser');
|
|
sendCallRelayMock.mockResolvedValue({ ok: true, undeliverable: [] });
|
|
|
|
await handleDmCallRejectForTest(
|
|
{ federatedCallId: fedCall.federatedId },
|
|
fedCall.ringedUserIds[0]!,
|
|
);
|
|
|
|
const undelivCalls = sendToUserSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(undelivCalls).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('ring-timeout fan-out hook', () => {
|
|
it('invokes the fan-out hook when the ring timer fires', async () => {
|
|
const connectionManager = await importManager();
|
|
|
|
const hook = vi.fn(async () => {});
|
|
connectionManager.setRingTimeoutFanoutHook(hook);
|
|
|
|
vi.useFakeTimers();
|
|
try {
|
|
connectionManager.createDmRoom('dm-ringout-test', 'caller-ringout');
|
|
vi.advanceTimersByTime(60_000 + 10);
|
|
} finally {
|
|
vi.useRealTimers();
|
|
}
|
|
|
|
expect(hook).toHaveBeenCalledWith('dm-ringout-test', 'caller-ringout');
|
|
});
|
|
|
|
it('registerCallRelayHooks wires up the hook', async () => {
|
|
const connectionManager = await importManager();
|
|
const { registerCallRelayHooks } = await importSUT();
|
|
|
|
const setSpy = vi.spyOn(connectionManager, 'setRingTimeoutFanoutHook');
|
|
registerCallRelayHooks();
|
|
expect(setSpy).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|
|
|
|
describe('handleDmCallAccept Path-2 relay failure', () => {
|
|
it('emits dm_call_undeliverable { phase:"accept", terminal:true } to the acceptor ONLY and clears the fedCall when the relay fails', async () => {
|
|
const { handleDmCallAcceptForTest } = await importSUT();
|
|
const connectionManager = await importManager();
|
|
|
|
const fedCall = makeFedCall({
|
|
// Two ringed users — a group DM where only one accepts. Only the acceptor
|
|
// should receive the terminal undeliverable; the other ringee must stay
|
|
// in ring state so their own timeout/reject path governs teardown.
|
|
ringedUserIds: ['acceptor-user', 'other-ringee'],
|
|
});
|
|
connectionManager.createFederatedCall(fedCall);
|
|
const sendToUserSpy = vi.spyOn(connectionManager, 'sendToUser');
|
|
const sendToCallUsersSpy = vi.spyOn(connectionManager, 'sendToFederatedCallUsers');
|
|
sendCallRelayMock.mockResolvedValue({ ok: false, reason: 'peer_transient_failure', error: 'timeout' });
|
|
|
|
await handleDmCallAcceptForTest(
|
|
{ federatedCallId: fedCall.federatedId },
|
|
fedCall.ringedUserIds[0]!,
|
|
{} as never,
|
|
);
|
|
|
|
expect(connectionManager.getFederatedCall(fedCall.federatedId)).toBeUndefined();
|
|
|
|
// Terminal undeliverable went to the acceptor only.
|
|
const undelivCalls = sendToUserSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(undelivCalls).toHaveLength(1);
|
|
expect(undelivCalls[0]![0]).toBe('acceptor-user');
|
|
const undeliverable = undelivCalls[0]![1] as { phase: string; terminal: boolean; failures: unknown[] };
|
|
expect(undeliverable.phase).toBe('accept');
|
|
expect(undeliverable.terminal).toBe(true);
|
|
expect(undeliverable.failures).toHaveLength(1);
|
|
|
|
// No undeliverable broadcast to all ringed users.
|
|
const callUsersCalls = sendToCallUsersSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(callUsersCalls).toHaveLength(0);
|
|
});
|
|
|
|
it('does not emit undeliverable on relay success', async () => {
|
|
const { handleDmCallAcceptForTest } = await importSUT();
|
|
const connectionManager = await importManager();
|
|
|
|
const fedCall = makeFedCall();
|
|
connectionManager.createFederatedCall(fedCall);
|
|
const sendToUserSpy = vi.spyOn(connectionManager, 'sendToUser');
|
|
sendCallRelayMock.mockResolvedValue({ ok: true, undeliverable: [] });
|
|
|
|
await handleDmCallAcceptForTest(
|
|
{ federatedCallId: fedCall.federatedId },
|
|
fedCall.ringedUserIds[0]!,
|
|
{} as never,
|
|
);
|
|
|
|
const undelivCalls = sendToUserSpy.mock.calls.filter(([, ev]) =>
|
|
(ev as { type: string }).type === 'dm_call_undeliverable',
|
|
);
|
|
expect(undelivCalls).toHaveLength(0);
|
|
expect(connectionManager.getFederatedCall(fedCall.federatedId)?.state).toBe('active');
|
|
connectionManager.clearFederatedCall(fedCall.federatedId);
|
|
});
|
|
});
|