mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 01:32:19 +00:00
143 lines
4.2 KiB
JavaScript
143 lines
4.2 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
harness,
|
|
deferred,
|
|
tick,
|
|
} from '../testSupport/geminiNativeHarness.mjs';
|
|
|
|
function unreadResponse(bytes = null) {
|
|
const state = { reads: 0, cancelled: 0 };
|
|
const response = new Response(
|
|
new ReadableStream(
|
|
{
|
|
pull(controller) {
|
|
state.reads++;
|
|
if (bytes) controller.enqueue(bytes);
|
|
},
|
|
cancel() {
|
|
state.cancelled++;
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
),
|
|
);
|
|
return { response, state };
|
|
}
|
|
|
|
test('already aborted token request does not acquire or read a response', async (t) => {
|
|
let fetches = 0;
|
|
const h = harness({
|
|
fetchImpl: () => {
|
|
fetches++;
|
|
throw Error('must not fetch');
|
|
},
|
|
});
|
|
t.after(() => h.c.stop());
|
|
const abort = new AbortController();
|
|
abort.abort();
|
|
await assert.rejects(h.c.requestToken(abort.signal), { name: 'AbortError' });
|
|
assert.equal(fetches, 0);
|
|
});
|
|
|
|
for (const phase of [
|
|
'before response',
|
|
'between resolution and continuation',
|
|
]) {
|
|
test(`aborted token acquisition closes the unread body ${phase}`, async (t) => {
|
|
const gate = deferred();
|
|
const h = harness({ fetchImpl: () => gate.promise });
|
|
t.after(() => h.c.stop());
|
|
const abort = new AbortController();
|
|
const { response, state } = unreadResponse();
|
|
const result = assert.rejects(h.c.requestToken(abort.signal), {
|
|
name: 'AbortError',
|
|
});
|
|
if (phase === 'before response') abort.abort();
|
|
gate.resolve(response);
|
|
if (phase !== 'before response') queueMicrotask(() => abort.abort());
|
|
await result;
|
|
await tick();
|
|
assert.deepEqual(state, { reads: 0, cancelled: 1 });
|
|
});
|
|
}
|
|
|
|
test('token body cap cancels a native response stream', async (t) => {
|
|
const { response, state } = unreadResponse(new Uint8Array(256 * 1024 + 1));
|
|
const h = harness({ fetchImpl: async () => response });
|
|
t.after(() => h.c.stop());
|
|
await assert.rejects(
|
|
h.c.requestToken(new AbortController().signal),
|
|
/too large|exceed|limit/i,
|
|
);
|
|
assert.equal(state.cancelled, 1);
|
|
assert.equal(state.reads, 1);
|
|
});
|
|
|
|
test('token body read ends promptly on caller abort and releases the reader', async (t) => {
|
|
const { response, state } = unreadResponse();
|
|
const h = harness({ fetchImpl: async () => response });
|
|
t.after(() => h.c.stop());
|
|
const abort = new AbortController();
|
|
const result = assert.rejects(h.c.requestToken(abort.signal), {
|
|
name: 'AbortError',
|
|
});
|
|
await tick();
|
|
assert.equal(state.reads, 1);
|
|
abort.abort();
|
|
await result;
|
|
assert.equal(state.cancelled, 1);
|
|
assert.equal(response.body.locked, false);
|
|
});
|
|
|
|
test('permission grant resolved just before Stop releases its tracks and preserves a fresh start', async (t) => {
|
|
const gate = deferred();
|
|
const h = harness({ getUserMedia: () => gate.promise });
|
|
t.after(() => h.c.stop());
|
|
const stream = h.makeStream();
|
|
const start = h.c.start();
|
|
gate.resolve(stream);
|
|
queueMicrotask(() => h.c.stop());
|
|
await start;
|
|
await tick();
|
|
assert.equal(h.tracks[0].readyState, 'ended');
|
|
assert.equal(h.requests.length, 0);
|
|
assert.equal(h.sockets.length, 0);
|
|
assert.equal(h.captures[0].closed, true);
|
|
h.c.getUserMedia = async () => h.makeStream();
|
|
await h.c.start();
|
|
assert.equal(h.c.status, 'listening');
|
|
assert.equal(h.tracks[1].readyState, 'live');
|
|
assert.equal(h.captures[1].closed, false);
|
|
});
|
|
|
|
test('late audio initialization cannot connect a retired microphone or close successor audio', async (t) => {
|
|
const gate = deferred();
|
|
const h = harness();
|
|
t.after(() => h.c.stop());
|
|
const createAudio = h.c.createAudio;
|
|
let first = true;
|
|
h.c.createAudio = (options) => {
|
|
const audio = createAudio(options);
|
|
if (first) {
|
|
first = false;
|
|
audio.initialize = () => gate.promise;
|
|
audio.connectMicrophone = () =>
|
|
assert.fail('retired initialization must not connect');
|
|
}
|
|
return audio;
|
|
};
|
|
const oldStart = h.c.start();
|
|
await tick();
|
|
h.c.stop();
|
|
await h.c.start();
|
|
gate.resolve();
|
|
await oldStart;
|
|
await tick();
|
|
assert.equal(h.c.status, 'listening');
|
|
assert.equal(h.captures[0].closed, true);
|
|
assert.equal(h.captures[1].closed, false);
|
|
assert.equal(h.tracks[0].readyState, 'ended');
|
|
assert.equal(h.tracks[1].readyState, 'live');
|
|
});
|