/**

* WebRTC Signaling Server Tests

*/

import { describe, it, before, after } from 'node:test';

import assert from 'node:assert';

import { WebSocket } from 'ws';

import {

startTestServer,

stopTestServer,

createTestPod,

getBaseUrl,

getPodToken

} from './helpers.js';

describe('WebRTC Signaling', () => {

let wsUrl;

before(async () => {

await startTestServer({ webrtc: true });

await createTestPod('alice');

await createTestPod('bob');

const base = getBaseUrl();

wsUrl = base.replace('http', 'ws') + '/.webrtc';

});

after(async () => {

await stopTestServer();

});

/** Create an authenticated WebSocket for a pod user */

function connectPeer(podName) {

const token = getPodToken(podName);

const ws = new WebSocket(wsUrl, {

headers: { 'Authorization': `Bearer ${token}` }

});

return ws;

}

/** Connect a peer and wait for the 'peers' welcome message */

async function connectAndWait(podName) {

const ws = connectPeer(podName);

const msg = await waitForMessage(ws, 'peers');

return { ws, ...msg };

}

/** Wait for a specific message type from a WebSocket */

function waitForMessage(ws, type, timeout = 3000) {

return new Promise((resolve, reject) => {

function handler(data) {

const msg = JSON.parse(data.toString());

if (msg.type === type) {

clearTimeout(timer);

ws.removeListener('message', handler);

ws.removeListener('close', onClose);

resolve(msg);

}

}

function onClose() {

clearTimeout(timer);

ws.removeListener('message', handler);

reject(new Error(`WebSocket closed while waiting for "${type}"`));

}

const timer = setTimeout(() => {

ws.removeListener('message', handler);

ws.removeListener('close', onClose);

reject(new Error(`Timeout waiting for "${type}"`));

}, timeout);

ws.on('message', handler);

ws.on('close', onClose);

});

}

/** Collect messages from a WebSocket for a duration */

function collectMessages(ws, duration = 500) {

return new Promise((resolve) => {

const msgs = [];

const handler = (data) => msgs.push(JSON.parse(data.toString()));

ws.on('message', handler);

setTimeout(() => {

ws.removeListener('message', handler);

resolve(msgs);

}, duration);

});

}

describe('Authentication', () => {

it('should allow unauthenticated connections for tracker protocol', async () => {

const ws = new WebSocket(wsUrl);

await new Promise((resolve) => { ws.onopen = resolve; });

// Unauthenticated clients can use tracker protocol

ws.send(JSON.stringify({ action: 'announce', info_hash: '01234567890123456789', peer_id: '98765432109876543210', offers: [] }));

const msg = await waitForMessage(ws, 'announce', 3000).catch(() => null);

// Should get a response (not get disconnected)

ws.close();

await new Promise(r => setTimeout(r, 50));

});

it('should reject unauthenticated identity-based signaling', async () => {

const ws = new WebSocket(wsUrl);

await new Promise((resolve) => { ws.onopen = resolve; });

ws.send(JSON.stringify({ type: 'offer', to: 'someone', sdp: 'test' }));

const msg = await waitForMessage(ws, 'error');

assert.ok(msg.message.includes('Authentication'));

ws.close();

await new Promise(r => setTimeout(r, 50));

});

it('should accept authenticated connections', async () => {

const ws = connectPeer('alice');

const msg = await waitForMessage(ws, 'peers');

assert.strictEqual(msg.type, 'peers');

assert.ok(msg.you, 'Should include own WebID');

assert.ok(Array.isArray(msg.peers), 'Should include peers list');

ws.close();

});

});

describe('Peer Presence and Signaling Relay', () => {

it('should handle full signaling lifecycle', async () => {

// Alice connects first — should see no peers

const { ws: alice, you: aliceId } = await connectAndWait('alice');

// Bob joins — set up listener for peer-joined before bob connects

const joinPromise = waitForMessage(alice, 'peer-joined');

const { ws: bob, you: bobId, peers: bobPeerList } = await connectAndWait('bob');

// Bob should see alice in the peer list

assert.strictEqual(bobPeerList.length, 1, 'Bob should see Alice');

// Alice should get peer-joined notification

const joinMsg = await joinPromise;

assert.strictEqual(joinMsg.type, 'peer-joined');

// 1. Alice sends offer to Bob

const offerPromise = waitForMessage(bob, 'offer');

alice.send(JSON.stringify({ type: 'offer', to: bobId, sdp: 'v=0\r\n' }));

const offer = await offerPromise;

assert.strictEqual(offer.type, 'offer');

assert.strictEqual(offer.from, aliceId);

assert.ok(offer.sdp, 'Should include SDP');

assert.strictEqual(offer.to, undefined, 'Should strip "to" field');

// 2. Bob sends answer to Alice

const answerPromise = waitForMessage(alice, 'answer');

bob.send(JSON.stringify({ type: 'answer', to: aliceId, sdp: 'v=0\r\n' }));

const answer = await answerPromise;

assert.strictEqual(answer.type, 'answer');

assert.strictEqual(answer.from, bobId);

// 3. Alice sends ICE candidate to Bob

const candidatePromise = waitForMessage(bob, 'candidate');

alice.send(JSON.stringify({

type: 'candidate', to: bobId,

candidate: { candidate: 'candidate:1 1 UDP 2122252543 192.168.1.1 12345 typ host', sdpMid: '0' }

}));

const candidate = await candidatePromise;

assert.strictEqual(candidate.type, 'candidate');

assert.ok(candidate.candidate.candidate);

// 4. Alice sends hangup to Bob

const hangupPromise = waitForMessage(bob, 'hangup');

alice.send(JSON.stringify({ type: 'hangup', to: bobId }));

const hangup = await hangupPromise;

assert.strictEqual(hangup.type, 'hangup');

assert.strictEqual(hangup.from, aliceId);

// 5. Bob leaves — alice should get notified

const leavePromise = waitForMessage(alice, 'peer-left');

bob.close();

const leaveMsg = await leavePromise;

assert.strictEqual(leaveMsg.type, 'peer-left');

alice.close();

await new Promise(r => setTimeout(r, 100));

});

});

describe('Error Handling', () => {

it('should reject invalid JSON', async () => {

const alice = connectPeer('alice');

await waitForMessage(alice, 'peers');

alice.send('not json');

const err = await waitForMessage(alice, 'error');

assert.strictEqual(err.message, 'Invalid JSON');

alice.close();

});

it('should reject messages without "to" field', async () => {

const alice = connectPeer('alice');

await waitForMessage(alice, 'peers');

alice.send(JSON.stringify({ type: 'offer', sdp: '...' }));

const err = await waitForMessage(alice, 'error');

assert.ok(err.message.includes('Missing'));

alice.close();

});

it('should error when target peer is not online', async () => {

const alice = connectPeer('alice');

await waitForMessage(alice, 'peers');

alice.send(JSON.stringify({

type: 'offer',

to: 'https://nobody.example/profile/card#me',

sdp: '...'

}));

const err = await waitForMessage(alice, 'error');

assert.ok(err.message.includes('not online'));

alice.close();

await new Promise(r => setTimeout(r, 50));

});

});

describe('Content-Addressed Peer Discovery', () => {

const RESOURCE_HASH = 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2';

it('should return peer count on announce', async () => {

const { ws: alice } = await connectAndWait('alice');

alice.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

const msg = await waitForMessage(alice, 'resource-peers');

assert.strictEqual(msg.resource, RESOURCE_HASH);

assert.strictEqual(msg.count, 0);

alice.close();

await new Promise(r => setTimeout(r, 50));

});

it('should relay offers between peers sharing a resource', async () => {

const { ws: alice, peerId: alicePeerId } = await connectAndWait('alice');

// Alice announces with no offers (first in group)

alice.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

await waitForMessage(alice, 'resource-peers');

// Bob announces with an offer — should be relayed to Alice

const offerPromise = waitForMessage(alice, 'offer');

const { ws: bob, peerId: bobPeerId } = await connectAndWait('bob');

bob.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: [{ sdp: 'v=0\r\nbob-offer', offer_id: 'offer1' }]

}));

const offer = await offerPromise;

assert.strictEqual(offer.type, 'offer');

assert.strictEqual(offer.resource, RESOURCE_HASH);

assert.strictEqual(offer.from, bobPeerId);

assert.strictEqual(offer.offer_id, 'offer1');

assert.ok(offer.sdp.includes('bob-offer'));

// Alice answers Bob

const answerPromise = waitForMessage(bob, 'answer');

alice.send(JSON.stringify({

type: 'answer',

resource: RESOURCE_HASH,

to: bobPeerId,

offer_id: 'offer1',

sdp: 'v=0\r\nalice-answer'

}));

const answer = await answerPromise;

assert.strictEqual(answer.type, 'answer');

assert.strictEqual(answer.resource, RESOURCE_HASH);

assert.strictEqual(answer.from, alicePeerId);

assert.ok(answer.sdp.includes('alice-answer'));

alice.close();

bob.close();

await new Promise(r => setTimeout(r, 50));

});

it('should clean up resources on disconnect', async () => {

const { ws: alice } = await connectAndWait('alice');

alice.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

await waitForMessage(alice, 'resource-peers');

// Bob joins the resource group

const { ws: bob } = await connectAndWait('bob');

bob.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

const bobPeers = await waitForMessage(bob, 'resource-peers');

assert.strictEqual(bobPeers.count, 1); // alice is there

// Alice disconnects

alice.close();

await new Promise(r => setTimeout(r, 200));

// Charlie joins — should see only bob

const { ws: charlie } = await connectAndWait('bob'); // reuse bob pod

charlie.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

const charliePeers = await waitForMessage(charlie, 'resource-peers');

// bob was reconnected (old connection closed), so count depends on timing

assert.ok(charliePeers.count >= 0);

bob.close();

charlie.close();

await new Promise(r => setTimeout(r, 50));

});

it('should handle leave message', async () => {

const { ws: alice } = await connectAndWait('alice');

alice.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

await waitForMessage(alice, 'resource-peers');

// Leave the resource group

alice.send(JSON.stringify({ type: 'leave', resource: RESOURCE_HASH }));

// Bob joins — should see 0 peers (alice left)

const { ws: bob } = await connectAndWait('bob');

bob.send(JSON.stringify({

type: 'announce',

resource: RESOURCE_HASH,

offers: []

}));

const msg = await waitForMessage(bob, 'resource-peers');

assert.strictEqual(msg.count, 0);

alice.close();

bob.close();

await new Promise(r => setTimeout(r, 50));

});

it('should reject invalid resource hash', async () => {

const { ws: alice } = await connectAndWait('alice');

alice.send(JSON.stringify({

type: 'announce',

resource: 'not-a-hex-hash!',

offers: []

}));

const err = await waitForMessage(alice, 'error');

assert.ok(err.message.includes('Invalid resource hash'));

alice.close();

await new Promise(r => setTimeout(r, 50));

});

});

});