mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
createVoiceControl now returns a presenter instead of building the control with innerHTML: the session, cost, input, card and panel owners write its state by part and listen for interactions, and VoiceControl.vue renders it in the command dock, between the location bar and the visual presets as before. Focus moves wait for the render; the waveform's bars publish apart from the control and only when they change; the minutes field keeps a draft until its owner writes it. Owner tests use a real presenter on their own store, and view tests render the control.
146 lines
4.8 KiB
JavaScript
146 lines
4.8 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createTestVoiceUi } from '../testSupport/voiceUi.mjs';
|
|
import { createRealtimeBackend } from './realtimeBackend.js';
|
|
import { GevRealtimeController } from './realtimeController.js';
|
|
|
|
const tokenReply = () =>
|
|
Response.json({
|
|
value: 'ephemeral-test',
|
|
session: { model: 'compatible-model' },
|
|
expires_at: Math.floor(Date.now() / 1000) + 60,
|
|
});
|
|
|
|
test('separate configured token and SDP transports preserve model metadata and credential scope', async () => {
|
|
const calls = [];
|
|
const backend = createRealtimeBackend({
|
|
tokenEndpoint: '/api/voice/token',
|
|
callsEndpoint: 'https://voice.example/calls',
|
|
tokenTransport: async (input, init) => {
|
|
calls.push(input);
|
|
assert.equal(init.redirect, 'error');
|
|
assert.equal(init.headers, undefined);
|
|
return tokenReply();
|
|
},
|
|
connectionTransport: async (input, init) => {
|
|
calls.push(input);
|
|
assert.equal(init.redirect, 'error');
|
|
assert.equal(init.body, 'offer');
|
|
assert.equal(init.headers.Authorization, 'Bearer ephemeral-test');
|
|
return new Response('answer');
|
|
},
|
|
});
|
|
const credential = await backend.requestToken({ tier: 'mini' });
|
|
assert.equal(credential.model, 'compatible-model');
|
|
assert.equal(
|
|
await backend.negotiate({ credential, offerSdp: 'offer' }),
|
|
'answer',
|
|
);
|
|
assert.deepEqual(calls, [
|
|
'/api/voice/token?tier=mini',
|
|
'https://voice.example/calls',
|
|
]);
|
|
});
|
|
|
|
test('OAuth is an additive token query while API key stays the default', async () => {
|
|
const calls = [];
|
|
const backend = createRealtimeBackend({
|
|
tokenTransport: async (input) => {
|
|
calls.push(input);
|
|
return tokenReply();
|
|
},
|
|
});
|
|
await backend.requestToken();
|
|
await backend.requestToken({ authMode: 'oauth' });
|
|
assert.deepEqual(calls, [
|
|
'/api/realtime/token?tier=standard',
|
|
'/api/realtime/token?tier=standard&auth=oauth',
|
|
]);
|
|
});
|
|
|
|
test('denied tokens never negotiate or retry; reconnect requests a fresh token', async () => {
|
|
let requests = 0;
|
|
const backend = createRealtimeBackend({
|
|
tokenTransport: async () => {
|
|
requests++;
|
|
return requests === 1
|
|
? Response.json({ error: 'Unavailable' }, { status: 401 })
|
|
: tokenReply();
|
|
},
|
|
connectionTransport: () => assert.fail('unexpected connection'),
|
|
});
|
|
await assert.rejects(backend.requestToken(), /Unavailable/);
|
|
assert.equal(requests, 1);
|
|
assert.equal((await backend.requestToken()).token, 'ephemeral-test');
|
|
assert.equal(requests, 2);
|
|
});
|
|
|
|
test('expired and malformed client secrets are rejected before SDP exchange', async () => {
|
|
for (const data of [
|
|
{ value: 'test', expires_at: 1 },
|
|
{ value: {} },
|
|
{ value: 'test', expires_at: 'later' },
|
|
]) {
|
|
const backend = createRealtimeBackend({
|
|
tokenTransport: async () => Response.json(data),
|
|
});
|
|
await assert.rejects(backend.requestToken(), /expired|client secret/);
|
|
}
|
|
const backend = createRealtimeBackend({
|
|
connectionTransport: () => assert.fail('expired token transmitted'),
|
|
});
|
|
await assert.rejects(
|
|
backend.negotiate({
|
|
credential: { token: 'test', expiresAt: 1 },
|
|
offerSdp: 'offer',
|
|
}),
|
|
/expired/,
|
|
);
|
|
});
|
|
|
|
test('cancellation rejects late token and SDP bodies without promoting a stopped connection', async () => {
|
|
for (const phase of ['token', 'sdp']) {
|
|
const lifetime = new AbortController();
|
|
let release;
|
|
const pending = new Promise((resolve) => {
|
|
release = resolve;
|
|
});
|
|
const backend = createRealtimeBackend({
|
|
signal: lifetime.signal,
|
|
tokenTransport: async () => ({ ok: true, json: () => pending }),
|
|
connectionTransport: async () => ({ ok: true, text: () => pending }),
|
|
});
|
|
const result =
|
|
phase === 'token'
|
|
? backend.requestToken()
|
|
: backend.negotiate({
|
|
credential: { token: 'test' },
|
|
offerSdp: 'offer',
|
|
signal: lifetime.signal,
|
|
});
|
|
await Promise.resolve();
|
|
lifetime.abort();
|
|
release(phase === 'token' ? { value: 'late' } : 'late answer');
|
|
await assert.rejects(result, { name: 'AbortError' });
|
|
}
|
|
});
|
|
|
|
test('controller lifetime stops pending transport and releases resources through normal teardown', () => {
|
|
const lifetime = new AbortController();
|
|
let stopped = 0;
|
|
const controller = new GevRealtimeController({
|
|
runner: async () => ({}),
|
|
signal: lifetime.signal,
|
|
debugSink: null,
|
|
ui: createTestVoiceUi(),
|
|
});
|
|
controller.connectionAbort = new AbortController();
|
|
const connection = controller.connectionAbort.signal;
|
|
controller.stream = { getTracks: () => [{ stop: () => stopped++ }] };
|
|
lifetime.abort();
|
|
assert.equal(connection.aborted, true);
|
|
assert.equal(stopped, 1);
|
|
assert.equal(controller.stream, null);
|
|
assert.equal(controller.isActive(), false);
|
|
});
|