mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-04 10:24:02 +00:00
Said Turksever
46b23ccc06
Draw and Import used to be reachable by voice through DISPLAY. set_panel_open now takes 'utilities-panel', and "utilities", "draw", "drawing" and "import" reach it. This adds one value to the Realtime tool schema, so the pinned payload digest, enum list and serialized length are re-derived with a note. The show_data_layers_menu test now finds a row only inside the list that really holds it, so dropping #utilities-toggles from the lookup fails it.
386 lines
23 KiB
JavaScript
386 lines
23 KiB
JavaScript
import { readRealtimeSource } from './testSupport/readRealtimeSource.mjs';
|
|
import { GEV_REALTIME_TOOLS } from '../server/providers/openai/tools.js';
|
|
import { realtimeInstructions } from '../server/providers/openai/instructions.js';
|
|
import { readShellSource } from './testSupport/readShellSource.mjs';
|
|
import { renderApplicationHtml } from './testSupport/applicationHtml.mjs';
|
|
import { readStylesheet } from './testSupport/readStylesheet.mjs';
|
|
import { readFileSync as readRadioSource } from 'node:fs';
|
|
const radioBindings = readRadioSource(new URL('./ui/radioBindings.js', import.meta.url), 'utf8');
|
|
const radioPresentation = readRadioSource(new URL('./ui/radioPresentation.js', import.meta.url), 'utf8');
|
|
const radioControlsSource = readRadioSource(new URL('./ui/radioControls.js', import.meta.url), 'utf8');
|
|
import assert from 'node:assert/strict';
|
|
import { createHash } from 'node:crypto';
|
|
import { readFileSync } from 'node:fs';
|
|
import test from 'node:test';
|
|
|
|
const html = await renderApplicationHtml(readFileSync(new URL('../index.html', import.meta.url), 'utf8'));
|
|
const ui = readShellSource();
|
|
const radio = ['playback', 'interaction'].map(name =>
|
|
readFileSync(new URL(`./layers/radio/${name}.js`, import.meta.url), 'utf8')
|
|
).join('\n').replace(/layerState\.|parts\.\w+\./g, '');
|
|
const missionDetail = readFileSync(new URL('./ui/views/panels/MissionDetail.vue', import.meta.url), 'utf8');
|
|
const realtime = readRealtimeSource();
|
|
const voice = ['./voice/actionSchemas.js', '../server/providers/openai/toolDescriptions.js', '../server/providers/openai/instructions.js'].map(file => readFileSync(new URL(file, import.meta.url), 'utf8')).join('\n');
|
|
const css = readStylesheet(new URL('../style.css', import.meta.url));
|
|
|
|
function realtimeTools() { return GEV_REALTIME_TOOLS; }
|
|
|
|
test('Realtime schema exposes the authoritative 31-tool inventory', () => {
|
|
const tools = realtimeTools();
|
|
assert.equal(tools.length, 31);
|
|
const names = tools.map((tool) => tool.name);
|
|
assert.equal(new Set(names).size, 31, 'tool names are unique');
|
|
assert.ok(names.includes('set_context_mode'));
|
|
assert.ok(names.includes('control_cockpit'));
|
|
assert.ok(names.includes('set_voice_inactivity_timeout'));
|
|
assert.ok(names.includes('select_nearest_aircraft'));
|
|
assert.ok(names.includes('control_radio'));
|
|
assert.ok(names.includes('next_satellite_pass'));
|
|
assert.ok(names.includes('next_iss_pass'));
|
|
// Every tool closes its parameter object: an open schema lets the model
|
|
// invent arguments the runner silently drops.
|
|
for (const tool of tools) {
|
|
assert.equal(tool.type, 'function', `${tool.name} is not a function tool`);
|
|
assert.equal(
|
|
tool.parameters?.additionalProperties,
|
|
false,
|
|
`${tool.name} does not close additionalProperties`,
|
|
);
|
|
assert.ok(tool.description, `${tool.name} has no description`);
|
|
}
|
|
});
|
|
|
|
test('the counting contract is stated in the Realtime instructions', () => {
|
|
// Owner ruling: "near" has one meaning per state, and every count names its
|
|
// scope. Instruction text is the only place the narration rules can live, so
|
|
// it is pinned — a silent trim here is a silent behaviour change.
|
|
const start = voice.indexOf("'COUNTING CONTRACT");
|
|
assert.ok(start >= 0, 'the counting contract instruction is missing');
|
|
// One instruction per source line; the string carries escaped quotes, so take
|
|
// the line rather than trying to match a quoted literal.
|
|
const text = voice.slice(start, voice.indexOf('\n', start));
|
|
assert.match(text, /Contacts is ACTIVE/, 'rule 1: active means the Contacts window');
|
|
assert.match(text, /contactsWindow/, 'rule 1 names its mechanism');
|
|
assert.match(text, /call set_context_mode\{mode:"contacts"\} first/);
|
|
assert.match(text, /contactsWindow\.aircraft/);
|
|
assert.match(text, /Contacts OFF, "nearby" means in view/, 'rule 2: off means in view');
|
|
assert.match(text, /EVERY count names its scope in words/, 'rule 3');
|
|
assert.match(text, /scopeLabel/, 'rule 3 names its mechanism');
|
|
assert.match(text, /never a bare number/, 'rule 3 is stated as a prohibition too');
|
|
assert.match(text, /VERBATIM/, 'rule 4: no estimating');
|
|
// Rule 5, the loaded-data caveat, is now one word inside the spoken scope
|
|
// ("37 loaded flights over Texas"); the longer note stays on screen.
|
|
const analyst = voice.slice(
|
|
voice.indexOf("'For ANALYTICAL questions"),
|
|
voice.indexOf('\n', voice.indexOf("'For ANALYTICAL questions")),
|
|
);
|
|
assert.match(analyst, /"37 loaded flights over Texas"/, 'rule 5: loaded scope stays audible');
|
|
});
|
|
|
|
test('Context panel opening stays distinct from Contacts activation', () => {
|
|
const text = realtimeInstructions().split('\n').find(line => line.startsWith('Panels:'));
|
|
assert.ok(text, 'panel-routing instruction is missing');
|
|
assert.match(text, /"Open Context" is only set_panel_open\{panelId:"global-context-panel",open:true\}/);
|
|
assert.match(text, /opening Context or selecting\/viewing an aircraft never enters them/);
|
|
assert.match(text, /"Open Contacts" is set_context_mode contacts/);
|
|
assert.match(text, /expands Context itself/);
|
|
});
|
|
|
|
test('nearest-aircraft selection stays out of Contacts and Cockpit', () => {
|
|
const start = voice.indexOf("'For a request to enable an aircraft layer and SELECT or FIND");
|
|
assert.ok(start >= 0, 'nearest-aircraft selection routing instruction is missing');
|
|
const text = voice.slice(start, voice.indexOf('\n', start));
|
|
assert.match(text, /Turn on flights and select the closest aircraft to Austin/);
|
|
assert.match(text, /call select_nearest_aircraft once/);
|
|
assert.match(text, /atomically turns on the requested aircraft layer first/);
|
|
assert.match(text, /waits for location arrival/);
|
|
assert.match(text, /refreshes that layer for the destination viewport/);
|
|
assert.match(text, /filters out landed\/on-ground records/);
|
|
assert.match(text, /nearest airborne result/);
|
|
assert.match(text, /healthy fallback feed is valid data/i);
|
|
assert.match(text, /Do not also call fly_to_location, set_layer_visibility, analyst_query, track_entity/);
|
|
const routing = realtimeInstructions().split('\n').find(line => line.startsWith('Panels:'));
|
|
assert.match(routing, /Contacts, Space Missions and Cockpit need explicit naming/);
|
|
assert.match(text, /set_context_mode, or control_cockpit/);
|
|
|
|
const byName = new Map(realtimeTools().map((tool) => [tool.name, tool]));
|
|
assert.match(byName.get('set_context_mode').description, /only when explicitly requested/);
|
|
assert.match(routing, /selecting\/viewing an aircraft never enters them/);
|
|
assert.match(byName.get('control_cockpit').description, /Explicit Cockpit requests only/);
|
|
assert.equal(
|
|
byName.get('fly_to_location').parameters.properties.waitForArrival.type,
|
|
'boolean',
|
|
);
|
|
const nearest = byName.get('select_nearest_aircraft');
|
|
assert.deepEqual(nearest.parameters.required, ['layerId']);
|
|
assert.deepEqual(nearest.parameters.properties.layerId.enum, ['flights', 'military']);
|
|
assert.match(nearest.description, /Atomically/);
|
|
assert.match(nearest.description, /exclude on-ground records/);
|
|
assert.match(nearest.description, /fallback feeds remain usable/);
|
|
});
|
|
|
|
test('the two Context/Cockpit tools pin their enums and required arguments', () => {
|
|
const byName = new Map(realtimeTools().map((tool) => [tool.name, tool]));
|
|
|
|
const contextMode = byName.get('set_context_mode');
|
|
assert.deepEqual(contextMode.parameters.required, ['mode']);
|
|
assert.deepEqual(
|
|
contextMode.parameters.properties.mode.enum,
|
|
['off', 'contacts', 'flights', 'space-missions', 'missions'],
|
|
);
|
|
|
|
const cockpit = byName.get('control_cockpit');
|
|
assert.deepEqual(cockpit.parameters.required, ['action']);
|
|
assert.deepEqual(
|
|
cockpit.parameters.properties.action.enum,
|
|
['enter', 'exit', 'previous', 'next', 'prev', 'status'],
|
|
);
|
|
assert.deepEqual(
|
|
cockpit.parameters.properties.targetLayer.enum,
|
|
['flights', 'military', 'ais-live-vessels', 'military-installations'],
|
|
'the layer filter must match the four Context cohorts exactly',
|
|
);
|
|
// aircraftClass is deliberately open (free-form class names), but still typed.
|
|
assert.equal(cockpit.parameters.properties.aircraftClass.type, 'string');
|
|
assert.equal(cockpit.parameters.properties.aircraftClass.enum, undefined);
|
|
});
|
|
|
|
test('the edited existing tools changed exactly as intended', () => {
|
|
const byName = new Map(realtimeTools().map((tool) => [tool.name, tool]));
|
|
|
|
// Edit 1: the Context panel became voice-addressable alongside set_context_mode.
|
|
const panel = byName.get('set_panel_open');
|
|
assert.deepEqual(
|
|
panel.parameters.properties.panelId.enum,
|
|
['data-panel', 'location-bar', 'control-panel', 'cctv-panel', 'radio-panel', 'scene-panel', 'utilities-panel', 'pp-toggles', 'global-context-panel', 'weather-panel', 'recent-imagery-panel', 'voice-settings', 'voice-preview', 'provider-settings'],
|
|
);
|
|
assert.deepEqual(panel.parameters.required, ['panelId', 'open']);
|
|
|
|
// Edit 2: description only — the view state now reports Context and Cockpit.
|
|
const viewState = byName.get('get_current_view_state');
|
|
assert.match(viewState.description, /Context, Cockpit/);
|
|
assert.deepEqual(viewState.parameters.properties, {});
|
|
|
|
// Edit 3: dependent multi-tool navigation can wait for the destination view.
|
|
const location = byName.get('fly_to_location');
|
|
assert.equal(location.parameters.properties.waitForArrival.type, 'boolean');
|
|
assert.match(location.parameters.properties.waitForArrival.description, /arrived=true/);
|
|
});
|
|
|
|
test('no unchanged Realtime tool definition drifts silently', () => {
|
|
// Context/Cockpit parity, the dependent-location wait edit, and the retired
|
|
// `bing-road` stack leaving `set_map_stack`'s enum are the known schema
|
|
// changes. Everything else must be byte-identical: an unnoticed edit
|
|
// to a shipped tool changes
|
|
// model behavior in production with nothing in review to catch it.
|
|
//
|
|
// If this fails and the change was deliberate, re-derive the digest and say
|
|
// in the mic-test brief which tools moved — the session cache busts on any
|
|
// schema change.
|
|
const TOUCHED = new Set([
|
|
'set_cyber_sonar',
|
|
'set_context_mode',
|
|
'control_cockpit',
|
|
'set_panel_open',
|
|
'set_voice_inactivity_timeout',
|
|
'get_current_view_state',
|
|
'fly_to_location',
|
|
'select_nearest_aircraft',
|
|
'set_map_stack',
|
|
'analyst_query',
|
|
'next_iss_pass',
|
|
'next_satellite_pass',
|
|
// Local ADS-B adds one layer enum value and its common-name mapping.
|
|
'set_layer_visibility',
|
|
// Layer enums generated from the voice layer manifest, and the corrected
|
|
// track_entity layer hint.
|
|
'show_data_layers_menu',
|
|
'get_entity_context',
|
|
'track_entity',
|
|
// Point-and-ask: 'pointer' sentinels and referent arguments.
|
|
'annotate_map',
|
|
]);
|
|
const unchanged = realtimeTools()
|
|
.filter((tool) => !TOUCHED.has(tool.name))
|
|
.sort((a, b) => a.name.localeCompare(b.name))
|
|
.map((tool) => structuredClone(tool))
|
|
.filter((tool) => tool.name !== 'set_cyber_sonar');
|
|
// Cyber adds one HUD choice and the sonar tool, and Operator was retired;
|
|
// retain the existing pin for every legacy field.
|
|
const hudLayout = unchanged.find((tool) => tool.name === 'set_hud').parameters.properties.layout;
|
|
assert.deepEqual(hudLayout.enum, ['tactical', 'minimal', 'cyber']);
|
|
hudLayout.enum = ['tactical', 'operator', 'minimal'];
|
|
// Globe rotation adds one motion and clarifies the two affected descriptions.
|
|
// Check those edits explicitly, then keep the legacy pin for every other field.
|
|
const camera = unchanged.find((tool) => tool.name === 'move_camera');
|
|
assert.deepEqual(camera.parameters.properties.motion.enum, [
|
|
'orbit',
|
|
'pan',
|
|
'tilt',
|
|
'rotate',
|
|
'rotate_globe',
|
|
'stop',
|
|
]);
|
|
assert.equal(
|
|
camera.description,
|
|
'Direct the camera like a drone operator: orbit the current view target, pan, tilt, or rotate — one bounded nudge (mode=once) or continuous motion until stopped (mode=continuous). Continuous motion also stops on any manual camera input or when a navigation tool runs. Say the RESULTING state when confirming ("Orbiting slowly"). Globe rotation (rotate_globe) spins Earth right continuously by default; explicit direction, mode and speed take precedence. It checks fit and may refuse.',
|
|
);
|
|
assert.equal(
|
|
camera.parameters.properties.direction.description,
|
|
'Required for pan/tilt/rotate; orbit/rotate_globe default right.',
|
|
);
|
|
assert.equal(camera.parameters.properties.mode.description, 'once = bounded eased nudge; continuous = until stop/manual input. rotate_globe defaults continuous; other motions default once.');
|
|
camera.parameters.properties.mode.description = 'once = bounded eased nudge (default); continuous = until stop/manual input.';
|
|
camera.parameters.properties.motion.enum =
|
|
camera.parameters.properties.motion.enum.filter(
|
|
(motion) => motion !== 'rotate_globe',
|
|
);
|
|
camera.description =
|
|
'Direct the camera like a drone operator: orbit the current view target, pan, tilt, or rotate — one bounded nudge (mode=once) or continuous motion until stopped (mode=continuous). Continuous motion also stops on any manual camera input or when a navigation tool runs. Say the RESULTING state when confirming ("Orbiting slowly").';
|
|
camera.parameters.properties.direction.description =
|
|
'Required except for orbit (defaults right/clockwise) and stop.';
|
|
// Snow is retired from set_visual_style; restore it to keep the legacy pin.
|
|
const visualStyle = unchanged.find(
|
|
(tool) => tool.name === 'set_visual_style',
|
|
).parameters.properties.style;
|
|
assert.deepEqual(visualStyle.enum, [
|
|
'normal',
|
|
'retro',
|
|
'surveillance',
|
|
'thermal',
|
|
'anime',
|
|
'noir',
|
|
]);
|
|
visualStyle.enum = [...visualStyle.enum, 'snow'];
|
|
assert.equal(unchanged.length, 14);
|
|
const digest = createHash('sha256')
|
|
.update(JSON.stringify(unchanged))
|
|
.digest('hex')
|
|
.slice(0, 16);
|
|
// Analyst additions and ISS wording correction are explicitly excluded above; all other tool definitions retain their pin.
|
|
assert.equal(digest, '25d1b902ecaa22fb', 'an unchanged Realtime tool definition drifted');
|
|
});
|
|
|
|
test('Radio volume and mission speed share the Sharpen slider visual language', () => {
|
|
for (const id of ['cockpit-radio-volume', 'radio-volume', 'sdr-volume']) {
|
|
assert.match(
|
|
html,
|
|
new RegExp(`id="${id}"[^>]*class="gev-quantitative-slider"[^>]*type="range"`),
|
|
);
|
|
}
|
|
assert.match(
|
|
missionDetail,
|
|
/<UiSlider id="space-mission-replay-speed" hold min="0\.25" max="4" step="0\.25"[^>]*:model-value="m \? m\.replay\.speed : 1"/,
|
|
);
|
|
assert.match(missionDetail, /class="gev-slider-value"[^>]*data-mission-replay-speed-output/);
|
|
assert.match(css, /\.gev-quantitative-slider\s*\{[\s\S]*?min-width: 0;[\s\S]*?height: 18px;/);
|
|
assert.match(css, /\.gev-quantitative-slider::-webkit-slider-runnable-track\s*\{[\s\S]*?height: 3px;[\s\S]*?background: rgba\(255, 255, 255, 0\.08\);/);
|
|
assert.match(css, /\.gev-quantitative-slider::-webkit-slider-thumb\s*\{[\s\S]*?width: 10px;[\s\S]*?height: 10px;[\s\S]*?border-radius: 50%;[\s\S]*?background: var\(--accent\);/);
|
|
assert.match(css, /\.gev-quantitative-slider:focus-visible\s*\{[\s\S]*?outline: 1px solid/);
|
|
assert.match(css, /\.gev-quantitative-slider:disabled\s*\{[\s\S]*?opacity: 0\.42;[\s\S]*?cursor: not-allowed;/);
|
|
assert.match(css, /\.gev-slider-value\s*\{[\s\S]*?color: var\(--accent\);[\s\S]*?font-size: 9px;/);
|
|
assert.doesNotMatch(css, /#space-mission-panel \[data-mission-replay-speed\]::-webkit-slider-thumb/);
|
|
});
|
|
|
|
test('Radio is nested inside Context with its own disclosure and power controls', () => {
|
|
const contextStart = html.indexOf('id="global-context-panel"');
|
|
const radioStart = html.indexOf('id="radio-panel"');
|
|
// The Context view ends with the right rail, before the scene runtime.
|
|
const contextEnd = html.indexOf('id="scene-runtime"');
|
|
assert.ok(contextStart >= 0 && radioStart > contextStart && radioStart < contextEnd);
|
|
assert.match(html, /id="radio-panel"[^>]*data-panel-id="radio-panel"/);
|
|
assert.match(html, /aria-label="Radio playback"/);
|
|
// The Context header carries no Radio shortcut; Radio lives in its own
|
|
// section below the modes, with one power control.
|
|
assert.doesNotMatch(html, /context-radio-/);
|
|
assert.match(html, /<button(?=[^>]*\sid="radio-enable-btn")(?=[^>]*\saria-pressed="false")/);
|
|
assert.match(html, /id="cockpit-radio-panel"[^>]*aria-label="Cockpit compact Radio controls"[^>]*hidden/);
|
|
assert.match(html, /<button(?=[^>]*\sid="cockpit-radio-enable-btn")(?=[^>]*\saria-pressed="false")/);
|
|
assert.match(html, /id="cockpit-radio-(?:prev|play|next)-btn"/);
|
|
assert.match(html, /id="cockpit-radio-volume"/);
|
|
assert.match(html, /id="radio-tuner"[^>]*hidden/);
|
|
assert.match(html, /id="radio-tuner-band-label">DIRECTORY BAND/);
|
|
assert.match(html, /id="radio-tuner-slider"[^>]*type="range"/);
|
|
assert.match(html, /id="radio-tuner-needle"[^>]*aria-hidden="true"/);
|
|
assert.match(html, /SNAPS TO AVAILABLE STATIONS/);
|
|
assert.match(html, /class="radio-tuner-scale" aria-hidden="true"[^>]*><\/div>/);
|
|
assert.match(html, /DIRECTORY: RADIO BROWSER/);
|
|
assert.match(html, /Audio connects directly to the broadcaster/);
|
|
assert.doesNotMatch(html, /radio-(?:favicon|visualizer|spectrum)/i);
|
|
assert.match(css, /#radio-tuner-slider::-(?:webkit-slider-thumb|moz-range-thumb)/);
|
|
assert.match(css, /\.radio-tuner\.is-static/);
|
|
assert.match(css, /\.radio-tuner-tick\s*\{/);
|
|
assert.doesNotMatch(css, /radio-tuner-scale-(?:left|right)/);
|
|
assert.match(css, /\.radio-tuner-needle\s*\{[\s\S]*?transition: left 0\.18s ease-out;/);
|
|
assert.match(css, /\.radio-tuner\.is-dragging \.radio-tuner-needle,[\s\S]*?\.radio-tuner\.is-dragging \.radio-tuner-tick\s*\{\s*transition: none;/);
|
|
assert.match(css, /\.radio-tuner\s*\{[\s\S]*?max-width: 100%;[\s\S]*?overflow: hidden;/);
|
|
assert.match(css, /#radio-tuner-slider\s*\{[\s\S]*?max-width: 100%;[\s\S]*?touch-action: none;/);
|
|
assert.match(css, /#title-bar\.radio-broadcasting \.title-logo::before/);
|
|
assert.match(css, /#title-bar\.radio-broadcasting \.title-logo::after/);
|
|
assert.match(css, /--radio-broadcast-opacity: 0\.17/);
|
|
assert.match(css, /@media \(prefers-reduced-motion: reduce\)[\s\S]*?\.radio-tuner-needle,[\s\S]*?\.radio-tuner-tick\s*\{\s*transition: none;/);
|
|
assert.doesNotMatch(ui, /_radioTunerCameraRemove = this\.viewer\?\.camera\?\.changed/);
|
|
assert.match(radioPresentation, /classList\.toggle\('radio-broadcasting', state\.audioState === 'playing'\)/);
|
|
assert.match(radioBindings, /cycleStation\(direction, \{[\s\S]*?rotate,[\s\S]*?stationIds:/);
|
|
const cycleStart = radioBindings.indexOf('const cycleRadio = (direction, { rotate = true } = {}) =>');
|
|
const cycleMethod = radioBindings.slice(cycleStart, radioBindings.indexOf('const toggleRadio', cycleStart));
|
|
assert.doesNotMatch(cycleMethod, /refreshTunerBand/);
|
|
assert.match(radioBindings, /_radioTunerBandPinnedForNavigation = true/);
|
|
assert.match(radioBindings, /listen\(\s*this\.canvas,\s*'pointerdown',\s*releaseNavigationBand/);
|
|
assert.match(radioBindings, /previewTuningStation\(station\?\.id \|\| null, \{ rotate \}\)/);
|
|
assert.match(radioBindings, /tunerPreview\(\{\s*coordinate: this\._radioTunerCoordinate,\s*rotate: commit,?\s*\}\)/);
|
|
assert.match(radioBindings, /this\.radio\.cancelTuning\(\)/);
|
|
assert.match(radioControlsSource, /classList\.remove\('radio-broadcasting'\)/);
|
|
assert.match(radioBindings, /this\.radio\.getTunerStations\(750\)/);
|
|
assert.match(radioBindings, /radioTunerPointerPosition\(/);
|
|
// Only the Cyber skin promotes Radio to a peer panel. Other themes retain
|
|
// the embedded Context layout; theme round-trip behavior has separate tests.
|
|
const baseCss = css.replace(readFileSync(new URL('./ui/styles/cyber.css', import.meta.url), 'utf8'), '');
|
|
assert.doesNotMatch(baseCss, /#right-context-rail\s*>\s*#radio-panel/);
|
|
assert.match(css, /#global-context-panel #radio-panel\.collapsed/);
|
|
assert.doesNotMatch(css, /\.context-radio-/);
|
|
assert.match(css, /#right-context-rail #global-context-panel:not\(\.collapsed\) \.context-mode-view,[\s\S]*?#right-context-rail #global-context-panel:not\(\.collapsed\) #radio-panel\s*\{[\s\S]*?flex: 0 0 auto;/);
|
|
});
|
|
|
|
test('panel collapse is presentation-only and Radio exposes explicit voice playback controls', () => {
|
|
const start = ui.lastIndexOf('\n setPanelCollapsed(panelId');
|
|
const method = ui.slice(start, ui.indexOf('toggleCleanView(forceEnabled)', start));
|
|
assert.doesNotMatch(method, /stopRadio|stopPlayback|setEnabled\('radio'/);
|
|
assert.match(voice, /'radio-panel'/);
|
|
assert.ok(
|
|
realtimeTools()
|
|
.find((tool) => tool.name === 'set_layer_visibility')
|
|
.parameters.properties.layerId.enum.includes('radio'),
|
|
);
|
|
assert.match(voice, /name:\s*'control_radio'/);
|
|
assert.deepEqual(realtimeTools().find(tool => tool.name === 'control_radio').parameters.properties.action.enum, ['enable', 'disable', 'play', 'resume', 'pause', 'stop', 'next', 'previous', 'volume', 'select', 'status']);
|
|
const enableMethod = radioBindings;
|
|
assert.doesNotMatch(enableMethod, /playSelectedRadio|togglePlayback\(\).*radio-enable/i);
|
|
assert.doesNotMatch(enableMethod, /contextRadio/);
|
|
assert.match(enableMethod, /toggleRadio: \(where\) =>[\s\S]*?: this\._radioEnableBtn,/);
|
|
// The collapse buttons render aria-expanded from the state the chrome presents.
|
|
assert.match(ui, /this\._presentPanel\(panelEl, \{ collapsed: nextCollapsed, auto: null \}\)/);
|
|
assert.doesNotMatch(method, /panelId === 'global-context-panel'[\s\S]*?this\._radioState\?\.enabled[\s\S]*?setPanelCollapsed\('radio-panel', false\)/);
|
|
});
|
|
|
|
test('Radio disclosure is explicit, starts closed while off, and preserves playback state', () => {
|
|
const renderMethod = radioPresentation;
|
|
assert.doesNotMatch(renderMethod, /setPanelCollapsed\('radio-panel', true\).*stopPlayback/s);
|
|
assert.doesNotMatch(renderMethod, /_radioMiniExpanded\s*=\s*false.*audioState === 'playing'/s);
|
|
assert.doesNotMatch(renderMethod, /_syncContextRadioLauncherState/);
|
|
});
|
|
|
|
test('successful explicit user playback hands the speaker from voice to Radio', () => {
|
|
const playStart = radio.indexOf('async function playSelectedRadio');
|
|
const playMethod = radio.slice(playStart, radio.indexOf('function confirmRadioPlayback', playStart + 10)).replace(/\s+/g, ' ');
|
|
const confirmedPlaying = playMethod.indexOf("_audioState = 'playing'");
|
|
const takeoverSignal = playMethod.indexOf("if (origin === 'user') emitPlaybackControl('play', origin, ownedAttemptId)");
|
|
assert.ok(confirmedPlaying >= 0 && takeoverSignal > confirmedPlaying);
|
|
assert.match(radio, /startPlayback: \(\) =>\s*playSelectedRadio\(\{\s*origin: 'voice',\s*attemptId: options\.attemptId,?\s*\}\)/);
|
|
assert.match(radio, /selectRadioStation\(stationId, \{\s*autoplay: true,\s*origin: 'user',?\s*\}\)/);
|
|
assert.match(radioBindings, /togglePlayback\(\{ origin: 'user' \}\)/);
|
|
assert.match(radioBindings, /cycleStation\(direction, \{[\s\S]*?origin: 'user'/);
|
|
assert.match(radioBindings, /commitTuningStation\(station\.id, \{ origin: 'user' \}\)/);
|
|
assert.match(realtime, /event\.origin === 'user' &&\s*event\.action === 'play' &&\s*this\.isActive\(\)[\s\S]*?this\.stop\(\{ preserveRadioPlayback: true \}\)/);
|
|
});
|