fix: Hold the 2-way audio backchannel open for the shortest possible time (#2697)
The card claimed a camera's ONVIF audio backchannel in two places that had nothing to do with a call: the capability probe at camera init (`µphone`), and a pre-armed `sendonly` audio transceiver on every live WebRTC offer. Merely looking at a dashboard occupied the camera's speaker line. Outbound audio now travels on its own audio-only WebRTC connection, opened when a call is answered and closed when it ends. - The backchannel is claimed only for the duration of a call. Idle viewing claims nothing. - Two-way audio now works in `mse`, `mp4` and `mjpeg` modes (note: the outbound audio still traverses WebRTC). - No renegotiation and no video blink at call start or end. - A call that cannot carry audio now reports it and ends, instead of showing a live microphone that goes nowhere. - `live.microphone.always_connected` is now purely about the browser microphone permission prompt. - Call setup measured at 66ms (LAN) and ~260ms (cellular) for ICE and DTLS, plus ~300ms for `go2rtc` to open an RTSP backchannel. Verified against a live Frigate + `go2rtc` instance, and by unit tests at 100% coverage. - Closes #2691 - Closes #2039 - Closes #2178 Ref #2299 -- the probe no longer opens a backchannel, but it still runs per camera on every load and reconnect, and still dials the camera on the direct-`go2rtc` path. Caching remains to be done. Ref AlexxIT/go2rtc#1860 -- once a call has opened a backchannel, `go2rtc` keeps that media set up on the camera's RTSP session for the life of the producer. Diagnoses #2678
This commit is contained in:
Dermot Duffy
@@ -160,8 +160,7 @@ describe('Camera', () => {
|
||||
expect.anything(),
|
||||
2,
|
||||
{
|
||||
endpoint:
|
||||
'http://go2rtc/api/streams?src=stream&video=all&audio=allµphone',
|
||||
endpoint: 'http://go2rtc/api/streams?src=stream&video=all&audio=all',
|
||||
sign: false,
|
||||
},
|
||||
expect.objectContaining({
|
||||
|
||||
@@ -9,6 +9,11 @@ import { CallManager } from '../../../src/card-controller/call/manager';
|
||||
import { Ringtone } from '../../../src/card-controller/call/ringtone';
|
||||
import type { CardController } from '../../../src/card-controller/controller';
|
||||
import { SubstreamViewModifier } from '../../../src/card-controller/view/modifiers/substream';
|
||||
import { createBackchannel } from '../../../src/components-lib/live/backchannel/factory';
|
||||
import {
|
||||
BackchannelError,
|
||||
type Backchannel,
|
||||
} from '../../../src/components-lib/live/backchannel/types';
|
||||
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
|
||||
import type { ConditionStateChange } from '../../../src/condition-trigger/conditions/types';
|
||||
import { CallTrigger } from '../../../src/condition-trigger/triggers/triggers/call';
|
||||
@@ -23,7 +28,7 @@ import {
|
||||
} from '../../camera-manager/test-utils';
|
||||
import { createTriggerEvaluatorContext } from '../../condition-trigger/triggers/triggers/test-utils';
|
||||
import { createCameraConfig, createConfig } from '../../config/test-utils';
|
||||
import { createCardAPI } from '../../test-utils';
|
||||
import { createCardAPI, createHASS } from '../../test-utils';
|
||||
import { createView } from '../../view/test-utils';
|
||||
|
||||
// Replace Ringtone with a fresh `mock<Ringtone>()` per construction so each
|
||||
@@ -37,6 +42,20 @@ vi.mock('../../../src/card-controller/call/ringtone', () => ({
|
||||
}),
|
||||
}));
|
||||
|
||||
vi.mock('../../../src/components-lib/live/backchannel/factory');
|
||||
|
||||
const getBackchannel = (): Backchannel => {
|
||||
const results = vi.mocked(createBackchannel).mock.results;
|
||||
const last = results.at(-1);
|
||||
assert(last);
|
||||
return last.value;
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
vi.mocked(createBackchannel).mockReset();
|
||||
vi.mocked(createBackchannel).mockImplementation(() => mock<Backchannel>());
|
||||
});
|
||||
|
||||
// Each test creates a new CallManager which constructs a new Ringtone, so the
|
||||
// most recent constructor result is always this test's mock.
|
||||
const getRingtone = (): Ringtone => {
|
||||
@@ -65,6 +84,8 @@ const createAPI = (options?: {
|
||||
config?: PartialDeep<AdvancedCameraCardConfig>;
|
||||
}): CardController => {
|
||||
const api = createCardAPI();
|
||||
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
||||
vi.mocked(api.getMicrophoneManager().getStream).mockReturnValue(mock<MediaStream>());
|
||||
vi.mocked(api.getViewManager().getView).mockReturnValue(options?.view ?? null);
|
||||
vi.mocked(api.getCameraManager).mockReturnValue(
|
||||
createCameraManager(options?.store ?? createCallableStore()),
|
||||
@@ -945,65 +966,6 @@ describe('endIf', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('reportCallMicrophoneError', () => {
|
||||
it('should report a microphone that could not be attached', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const manager = new CallManager(api);
|
||||
expect(await manager.start()).toBe(true);
|
||||
vi.mocked(api.getNotificationManager().setNotification).mockClear();
|
||||
|
||||
manager.reportCallMicrophoneError('camera.office', 'The peer connection is closed');
|
||||
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalledWith({
|
||||
heading: { text: 'Two-way audio unavailable' },
|
||||
body: { text: 'Your microphone could not be connected.' },
|
||||
context: ['The peer connection is closed'],
|
||||
});
|
||||
});
|
||||
|
||||
it('should omit the context when the browser provided none', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const manager = new CallManager(api);
|
||||
expect(await manager.start()).toBe(true);
|
||||
vi.mocked(api.getNotificationManager().setNotification).mockClear();
|
||||
|
||||
manager.reportCallMicrophoneError('camera.office');
|
||||
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalledWith(
|
||||
expect.not.objectContaining({ context: expect.anything() }),
|
||||
);
|
||||
});
|
||||
|
||||
it('should not report without a call', () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
|
||||
new CallManager(api).reportCallMicrophoneError('camera.office');
|
||||
|
||||
expect(api.getNotificationManager().setNotification).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not report while an inbound call is still ringing', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const manager = new CallManager(api);
|
||||
expect(await manager.start({ inbound: true })).toBe(true);
|
||||
|
||||
manager.reportCallMicrophoneError('camera.office');
|
||||
|
||||
expect(api.getNotificationManager().setNotification).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not report for a camera the call is not on', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const manager = new CallManager(api);
|
||||
expect(await manager.start()).toBe(true);
|
||||
vi.mocked(api.getNotificationManager().setNotification).mockClear();
|
||||
|
||||
manager.reportCallMicrophoneError('camera.other');
|
||||
|
||||
expect(api.getNotificationManager().setNotification).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('condition state changes', () => {
|
||||
it('should end the call when the selected camera changes away', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
@@ -2227,7 +2189,7 @@ describe('state changes during in-flight start', () => {
|
||||
const second = manager.start({ cameraID: 'camera.garage' });
|
||||
resolveConnect(true);
|
||||
|
||||
expect(await first).toBe(true);
|
||||
expect(await first).toBe(false);
|
||||
expect(await second).toBe(true);
|
||||
|
||||
// The second request must end the first request's session rather than
|
||||
@@ -2344,6 +2306,244 @@ describe('state changes during in-flight answer', () => {
|
||||
// these drive a real ConditionStateManager and a real CallTrigger and assert
|
||||
// the transitions an automation would fire on, rather than that `setState` was
|
||||
// called.
|
||||
describe('the backchannel', () => {
|
||||
const startAnsweredCall = async (
|
||||
api: CardController,
|
||||
): Promise<{ manager: CallManager; started: boolean }> => {
|
||||
const manager = new CallManager(api);
|
||||
manager.initialize();
|
||||
const started = await manager.start();
|
||||
return { manager, started };
|
||||
};
|
||||
|
||||
it('should open the backchannel when an outbound call starts', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
|
||||
const { started } = await startAnsweredCall(api);
|
||||
|
||||
expect(started).toBe(true);
|
||||
expect(getBackchannel().start).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not open the backchannel while an inbound call is only ringing', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const manager = new CallManager(api);
|
||||
manager.initialize();
|
||||
|
||||
await manager.start({ inbound: true });
|
||||
|
||||
expect(createBackchannel).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should open the backchannel when an inbound call is answered', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const manager = new CallManager(api);
|
||||
manager.initialize();
|
||||
await manager.start({ inbound: true });
|
||||
|
||||
expect(await manager.answer()).toBe(true);
|
||||
expect(getBackchannel().start).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should release the backchannel when the call ends', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const { manager } = await startAnsweredCall(api);
|
||||
const backchannel = getBackchannel();
|
||||
|
||||
manager.end();
|
||||
|
||||
expect(backchannel.stop).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should release the backchannel when the manager is torn down', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const { manager } = await startAnsweredCall(api);
|
||||
const backchannel = getBackchannel();
|
||||
|
||||
manager.uninitialize();
|
||||
|
||||
expect(backchannel.stop).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should end the call and report when the backchannel cannot be opened', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
vi.mocked(createBackchannel).mockImplementation(() => {
|
||||
const backchannel = mock<Backchannel>();
|
||||
backchannel.start.mockRejectedValue(new BackchannelError('no_two_way_audio'));
|
||||
return backchannel;
|
||||
});
|
||||
|
||||
const { manager, started } = await startAnsweredCall(api);
|
||||
|
||||
expect(started).toBe(false);
|
||||
expect(manager.getCall()).toBeNull();
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not report a backchannel abandoned by this manager', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
vi.mocked(createBackchannel).mockImplementation(() => {
|
||||
const backchannel = mock<Backchannel>();
|
||||
backchannel.start.mockRejectedValue(new BackchannelError('abandoned'));
|
||||
return backchannel;
|
||||
});
|
||||
|
||||
await startAnsweredCall(api);
|
||||
|
||||
expect(api.getNotificationManager().setNotification).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should release the previous backchannel before opening the next', async () => {
|
||||
const api = createAPI({
|
||||
view: createView({ camera: 'camera.office' }),
|
||||
store: createStore([
|
||||
{
|
||||
cameraID: 'camera.office',
|
||||
capabilities: createCapabilities({ live: true, '2-way-audio': true }),
|
||||
},
|
||||
{
|
||||
cameraID: 'camera.garage',
|
||||
capabilities: createCapabilities({ live: true, '2-way-audio': true }),
|
||||
},
|
||||
]),
|
||||
});
|
||||
const order: string[] = [];
|
||||
vi.mocked(createBackchannel).mockImplementation(() => {
|
||||
const backchannel = mock<Backchannel>();
|
||||
backchannel.start.mockImplementation(async () => void order.push('start'));
|
||||
backchannel.stop.mockImplementation(() => void order.push('stop'));
|
||||
return backchannel;
|
||||
});
|
||||
|
||||
const manager = new CallManager(api);
|
||||
manager.initialize();
|
||||
await manager.start();
|
||||
await manager.start({ cameraID: 'camera.garage' });
|
||||
|
||||
// A camera that permits a single backchannel must never see two at once.
|
||||
expect(order).toEqual(['start', 'stop', 'start']);
|
||||
});
|
||||
|
||||
it('should end the call when the live provider has no backchannel to offer', async () => {
|
||||
// This is reachable through `capabilities.force` which can force 2-way
|
||||
// audio on a live provider that does not support it.
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
vi.mocked(createBackchannel).mockReturnValue(null);
|
||||
|
||||
const { manager, started } = await startAnsweredCall(api);
|
||||
|
||||
expect(started).toBe(false);
|
||||
expect(manager.getCall()).toBeNull();
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should still report a failure that has no reason', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
vi.mocked(createBackchannel).mockImplementation(() => {
|
||||
const backchannel = mock<Backchannel>();
|
||||
backchannel.start.mockRejectedValue(new Error('boom'));
|
||||
return backchannel;
|
||||
});
|
||||
|
||||
await startAnsweredCall(api);
|
||||
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
body: { text: 'The camera could not be reached for two-way audio.' },
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should end the call when Home Assistant is not available', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(null);
|
||||
|
||||
const { manager, started } = await startAnsweredCall(api);
|
||||
|
||||
expect(started).toBe(false);
|
||||
expect(manager.getCall()).toBeNull();
|
||||
});
|
||||
|
||||
it('should distinguish a microphone failure from an unreachable camera', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
vi.mocked(createBackchannel).mockImplementation(() => {
|
||||
const backchannel = mock<Backchannel>();
|
||||
backchannel.start.mockRejectedValue(new BackchannelError('no_microphone'));
|
||||
return backchannel;
|
||||
});
|
||||
|
||||
await startAnsweredCall(api);
|
||||
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
body: { text: 'Your microphone could not be connected.' },
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should not report a backchannel that failed for a replaced call', async () => {
|
||||
const api = createAPI({
|
||||
view: createView({ camera: 'camera.office' }),
|
||||
store: createStore([
|
||||
{
|
||||
cameraID: 'camera.office',
|
||||
capabilities: createCapabilities({ live: true, '2-way-audio': true }),
|
||||
},
|
||||
{
|
||||
cameraID: 'camera.garage',
|
||||
capabilities: createCapabilities({ live: true, '2-way-audio': true }),
|
||||
},
|
||||
]),
|
||||
});
|
||||
|
||||
let rejectFirst: (error: unknown) => void = () => {};
|
||||
let call = 0;
|
||||
vi.mocked(createBackchannel).mockImplementation(() => {
|
||||
const backchannel = mock<Backchannel>();
|
||||
if (call++ === 0) {
|
||||
backchannel.start.mockReturnValue(
|
||||
new Promise((_resolve, reject) => (rejectFirst = reject)),
|
||||
);
|
||||
}
|
||||
return backchannel;
|
||||
});
|
||||
|
||||
const manager = new CallManager(api);
|
||||
manager.initialize();
|
||||
const first = manager.start();
|
||||
await manager.start({ cameraID: 'camera.garage' });
|
||||
|
||||
rejectFirst(new BackchannelError('failed'));
|
||||
|
||||
expect(await first).toBe(false);
|
||||
expect(api.getNotificationManager().setNotification).not.toHaveBeenCalled();
|
||||
expect(manager.getCall()?.cameraID).toBe('camera.garage');
|
||||
});
|
||||
|
||||
it('should not report a backchannel lost after its call ended', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
const { manager } = await startAnsweredCall(api);
|
||||
const errorCallback = vi.mocked(createBackchannel).mock.calls[0][2];
|
||||
assert(errorCallback);
|
||||
|
||||
manager.end();
|
||||
errorCallback(new BackchannelError('failed'));
|
||||
|
||||
expect(api.getNotificationManager().setNotification).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should report the backchannel being lost mid-call', async () => {
|
||||
const api = createAPI({ view: createView({ camera: 'camera.office' }) });
|
||||
await startAnsweredCall(api);
|
||||
|
||||
const errorCallback = vi.mocked(createBackchannel).mock.calls[0][2];
|
||||
assert(errorCallback);
|
||||
errorCallback(new BackchannelError('failed', 'the sky fell'));
|
||||
|
||||
expect(api.getNotificationManager().setNotification).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('published phase transitions in condition state', () => {
|
||||
const createAPIWithRealStateManager = (options?: {
|
||||
config?: PartialDeep<AdvancedCameraCardConfig>;
|
||||
|
||||
@@ -518,10 +518,63 @@ describe('MicrophoneManager', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('should handle the device disappearing', () => {
|
||||
const endTrack = (stream: MediaStream): void => {
|
||||
const track = getTrack(stream);
|
||||
vi.mocked(track.addEventListener)
|
||||
.mock.calls.filter(([type]) => type === 'ended')
|
||||
.forEach(([, listener]) => (listener as EventListener)(new Event('ended')));
|
||||
};
|
||||
|
||||
it('should release a stream whose track ends', async () => {
|
||||
const stream = createMockStream();
|
||||
vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(stream);
|
||||
|
||||
const api = createCardAPI();
|
||||
const manager = new MicrophoneManager(api);
|
||||
manager.setTransmissionActive(true);
|
||||
await manager.connect();
|
||||
expect(manager.isConnected()).toBeTruthy();
|
||||
|
||||
endTrack(stream);
|
||||
|
||||
expect(manager.isConnected()).toBeFalsy();
|
||||
expect(manager.getStream()).toBeNull();
|
||||
});
|
||||
|
||||
it('should stop listening to a stream that has been replaced', async () => {
|
||||
const streamA = createMockStream();
|
||||
vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(streamA);
|
||||
const api = createCardAPI();
|
||||
const manager = new MicrophoneManager(api);
|
||||
manager.setTransmissionActive(true);
|
||||
await manager.connect();
|
||||
|
||||
const streamB = createMockStream();
|
||||
vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(streamB);
|
||||
await manager.connect();
|
||||
|
||||
const track = getTrack(streamA);
|
||||
const added = vi
|
||||
.mocked(track.addEventListener)
|
||||
.mock.calls.find(([type]) => type === 'ended');
|
||||
const removed = vi
|
||||
.mocked(track.removeEventListener)
|
||||
.mock.calls.find(([type]) => type === 'ended');
|
||||
|
||||
expect(added).toBeDefined();
|
||||
expect(removed?.[1]).toBe(added?.[1]);
|
||||
expect(manager.getStream()).toBe(streamB);
|
||||
});
|
||||
});
|
||||
|
||||
describe('should require initialization', async () => {
|
||||
it('should require when configured and supported', async () => {
|
||||
const api = createCardAPI();
|
||||
const manager = new MicrophoneManager(api);
|
||||
vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(
|
||||
createMockStream(),
|
||||
);
|
||||
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
|
||||
createConfig({
|
||||
live: {
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { mock } from 'vitest-mock-extended';
|
||||
|
||||
import { Camera } from '../../../../src/camera-manager/camera';
|
||||
import type { CameraManagerEngine } from '../../../../src/camera-manager/engine';
|
||||
import { FrigateCamera } from '../../../../src/camera-manager/frigate/camera';
|
||||
import { createBackchannel } from '../../../../src/components-lib/live/backchannel/factory';
|
||||
import { Go2RTCBackchannel } from '../../../../src/components-lib/live/backchannel/go2rtc';
|
||||
import type { HomeAssistant } from '../../../../src/ha/types';
|
||||
import { createCameraConfig } from '../../../config/test-utils';
|
||||
|
||||
describe('createBackchannel', () => {
|
||||
it('should create a backchannel for a go2rtc camera', () => {
|
||||
const camera = new Camera(
|
||||
createCameraConfig({
|
||||
live_provider: 'go2rtc',
|
||||
go2rtc: { url: 'https://go2rtc', stream: 'office' },
|
||||
}),
|
||||
mock<CameraManagerEngine>(),
|
||||
);
|
||||
|
||||
expect(createBackchannel(mock<HomeAssistant>(), camera)).toBeInstanceOf(
|
||||
Go2RTCBackchannel,
|
||||
);
|
||||
});
|
||||
|
||||
it('should create a backchannel for a go2rtc-experimental camera', () => {
|
||||
const camera = new Camera(
|
||||
createCameraConfig({
|
||||
live_provider: 'go2rtc-experimental',
|
||||
go2rtc: { url: 'https://go2rtc', stream: 'office' },
|
||||
}),
|
||||
mock<CameraManagerEngine>(),
|
||||
);
|
||||
|
||||
expect(createBackchannel(mock<HomeAssistant>(), camera)).toBeInstanceOf(
|
||||
Go2RTCBackchannel,
|
||||
);
|
||||
});
|
||||
|
||||
it('should not create a backchannel for a non-go2rtc camera', () => {
|
||||
const camera = new Camera(
|
||||
createCameraConfig({
|
||||
camera_entity: 'camera.office',
|
||||
live_provider: 'ha',
|
||||
}),
|
||||
mock<CameraManagerEngine>(),
|
||||
);
|
||||
|
||||
expect(createBackchannel(mock<HomeAssistant>(), camera)).toBeNull();
|
||||
});
|
||||
|
||||
it('should not create a backchannel without a go2rtc endpoint', () => {
|
||||
const camera = new Camera(
|
||||
createCameraConfig({ live_provider: 'go2rtc' }),
|
||||
mock<CameraManagerEngine>(),
|
||||
);
|
||||
|
||||
expect(createBackchannel(mock<HomeAssistant>(), camera)).toBeNull();
|
||||
});
|
||||
|
||||
it('should use the endpoint the camera engine resolves', () => {
|
||||
// A Frigate camera serves go2rtc through the Frigate integration's proxy
|
||||
// rather than at a directly-configured URL, so the endpoint must come from
|
||||
// the camera rather than being rebuilt from its configuration.
|
||||
const camera = new FrigateCamera(
|
||||
createCameraConfig({
|
||||
live_provider: 'go2rtc',
|
||||
frigate: { client_id: 'frigate', camera_name: 'office' },
|
||||
}),
|
||||
mock<CameraManagerEngine>(),
|
||||
);
|
||||
|
||||
expect(camera.getEndpoints()?.go2rtc?.endpoint).toBe(
|
||||
'/api/frigate/frigate/mse/api/ws?src=office',
|
||||
);
|
||||
expect(createBackchannel(mock<HomeAssistant>(), camera)).toBeInstanceOf(
|
||||
Go2RTCBackchannel,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,726 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
||||
import { mock } from 'vitest-mock-extended';
|
||||
|
||||
import { Go2RTCBackchannel } from '../../../../src/components-lib/live/backchannel/go2rtc';
|
||||
import type { BackchannelErrorCallback } from '../../../../src/components-lib/live/backchannel/types';
|
||||
import {
|
||||
resolveEndpointURL,
|
||||
type ResolvedEndpoint,
|
||||
} from '../../../../src/ha/resolve-endpoint';
|
||||
import type { HomeAssistant } from '../../../../src/ha/types';
|
||||
import {
|
||||
FakeMediaStream,
|
||||
FakeMediaStreamTrack,
|
||||
FakeRTCPeerConnection,
|
||||
FakeWebSocket,
|
||||
} from '../../../go2rtc/test-utils';
|
||||
import { flushPromises } from '../../../test-utils';
|
||||
|
||||
vi.mock('../../../../src/ha/resolve-endpoint');
|
||||
|
||||
const createStream = (): FakeMediaStream =>
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
|
||||
const setup = (options?: { errorCallback?: BackchannelErrorCallback }) => {
|
||||
const pc = new FakeRTCPeerConnection();
|
||||
const websocket = new FakeWebSocket();
|
||||
const backchannel = new Go2RTCBackchannel(
|
||||
mock<HomeAssistant>(),
|
||||
{ endpoint: '/local/api/ws?src=camera', sign: true },
|
||||
undefined,
|
||||
{
|
||||
createPeerConnection: () => pc.asPeerConnection(),
|
||||
createWebSocket: () => websocket.asWebSocket(),
|
||||
...(options?.errorCallback && { errorCallback: options.errorCallback }),
|
||||
},
|
||||
);
|
||||
return { backchannel, pc, websocket };
|
||||
};
|
||||
|
||||
// Drives a successful negotiation up to (but not including) the point the
|
||||
// caller chooses to complete or fail it.
|
||||
const negotiate = async (websocket: FakeWebSocket) => {
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(JSON.stringify({ type: 'webrtc/answer', value: 'v=0\r\n' }));
|
||||
await flushPromises();
|
||||
};
|
||||
|
||||
const connect = async (pc: FakeRTCPeerConnection, websocket: FakeWebSocket) => {
|
||||
await negotiate(websocket);
|
||||
pc.fireConnectionStateChange('connected');
|
||||
await flushPromises();
|
||||
};
|
||||
|
||||
// @vitest-environment jsdom
|
||||
describe('Go2RTCBackchannel', () => {
|
||||
beforeEach(() => {
|
||||
vi.mocked(resolveEndpointURL).mockResolvedValue({
|
||||
success: true,
|
||||
url: 'http://go2rtc/api/ws',
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
|
||||
describe('start', () => {
|
||||
it('should offer exactly one outbound audio slot and no video', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
expect(pc.transceivers).toHaveLength(1);
|
||||
expect(pc.transceivers[0].direction).toBe('sendonly');
|
||||
expect(pc.transceivers[0].sender.track?.kind).toBe('audio');
|
||||
});
|
||||
|
||||
it('should resolve only once the camera is reachable', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
let resolved = false;
|
||||
const started = backchannel.start(createStream().asMediaStream()).then(() => {
|
||||
resolved = true;
|
||||
});
|
||||
|
||||
await negotiate(websocket);
|
||||
expect(resolved).toBe(false);
|
||||
|
||||
pc.fireConnectionStateChange('connected');
|
||||
await started;
|
||||
expect(resolved).toBe(true);
|
||||
});
|
||||
|
||||
it('should send the offer over the signaling channel', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
expect(websocket.sent.map((message) => JSON.parse(message).type)).toContain(
|
||||
'webrtc/offer',
|
||||
);
|
||||
});
|
||||
|
||||
it('should reject when the microphone has no audio track', async () => {
|
||||
const { backchannel } = setup();
|
||||
await expect(
|
||||
backchannel.start(new FakeMediaStream().asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'no_microphone' });
|
||||
});
|
||||
|
||||
it('should reject when the microphone track has already ended', async () => {
|
||||
const { backchannel } = setup();
|
||||
const track = new FakeMediaStreamTrack('audio');
|
||||
track.readyState = 'ended';
|
||||
await expect(
|
||||
backchannel.start(new FakeMediaStream([track]).asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'no_microphone' });
|
||||
});
|
||||
|
||||
it('should reject when the address cannot be resolved', async () => {
|
||||
vi.mocked(resolveEndpointURL).mockResolvedValue({
|
||||
success: false,
|
||||
error: 'proxy',
|
||||
});
|
||||
const { backchannel } = setup();
|
||||
await expect(
|
||||
backchannel.start(createStream().asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'failed', description: 'proxy' });
|
||||
});
|
||||
|
||||
it('should reject when the server reports the stream cannot take audio', async () => {
|
||||
const { backchannel, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(
|
||||
JSON.stringify({ type: 'error', value: 'webrtc: no backchannel' }),
|
||||
);
|
||||
await expect(started).rejects.toMatchObject({
|
||||
reason: 'no_two_way_audio',
|
||||
description: 'webrtc: no backchannel',
|
||||
});
|
||||
});
|
||||
|
||||
it('should reject when the camera declines to receive audio', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await negotiate(websocket);
|
||||
pc.getMicrophoneTransceiver().currentDirection = 'inactive';
|
||||
pc.fireConnectionStateChange('connected');
|
||||
await expect(started).rejects.toMatchObject({ reason: 'no_two_way_audio' });
|
||||
});
|
||||
|
||||
it('should reject when the signaling channel closes before connecting', async () => {
|
||||
const { backchannel, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireClose();
|
||||
await expect(started).rejects.toMatchObject({ reason: 'failed' });
|
||||
});
|
||||
|
||||
it('should reject when the peer connection fails', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await negotiate(websocket);
|
||||
pc.fireConnectionStateChange('failed');
|
||||
await expect(started).rejects.toMatchObject({ reason: 'failed' });
|
||||
});
|
||||
|
||||
it('should reject when the camera is not reached in time', async () => {
|
||||
vi.useFakeTimers();
|
||||
const { backchannel, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
vi.advanceTimersByTime(10 * 1000);
|
||||
await expect(started).rejects.toMatchObject({ reason: 'failed' });
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it('should reject when the offer cannot be created', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.createOffer.mockRejectedValue(new Error('no media'));
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
await expect(started).rejects.toMatchObject({
|
||||
reason: 'failed',
|
||||
description: 'no media',
|
||||
});
|
||||
});
|
||||
|
||||
it('should close the signaling channel once connected', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
expect(websocket.close).toHaveBeenCalled();
|
||||
expect(pc.close).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should send ICE candidates and signal the end of them', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
|
||||
pc.fireIceCandidate('candidate:1');
|
||||
pc.fireIceCandidate(null);
|
||||
|
||||
const candidates = websocket.sent
|
||||
.map((message) => JSON.parse(message))
|
||||
.filter((message) => message.type === 'webrtc/candidate')
|
||||
.map((message) => message.value);
|
||||
expect(candidates).toEqual(['candidate:1', '']);
|
||||
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
});
|
||||
|
||||
it('should apply candidates from the server', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(
|
||||
JSON.stringify({ type: 'webrtc/candidate', value: 'candidate:2' }),
|
||||
);
|
||||
await flushPromises();
|
||||
|
||||
expect(pc.addIceCandidate).toHaveBeenCalledWith({
|
||||
candidate: 'candidate:2',
|
||||
sdpMid: '0',
|
||||
});
|
||||
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
});
|
||||
});
|
||||
|
||||
describe('after connecting', () => {
|
||||
it('should report a peer connection that later fails', async () => {
|
||||
const errorCallback = vi.fn();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback });
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
pc.fireConnectionStateChange('failed');
|
||||
expect(errorCallback).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ reason: 'failed' }),
|
||||
);
|
||||
});
|
||||
|
||||
it('should release the camera when the peer connection later fails', async () => {
|
||||
const stream = createStream();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback: vi.fn() });
|
||||
const started = backchannel.start(stream.asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
pc.fireConnectionStateChange('failed');
|
||||
|
||||
expect(pc.close).toHaveBeenCalled();
|
||||
expect(stream.getAudioTracks()[0].readyState).toBe('live');
|
||||
});
|
||||
|
||||
it('should ignore the signaling channel closing', async () => {
|
||||
const errorCallback = vi.fn();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback });
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
websocket.fireClose();
|
||||
expect(errorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('setStream', () => {
|
||||
it('should swap the outbound track without reconnecting', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
const replacement = createStream();
|
||||
await backchannel.setStream(replacement.asMediaStream());
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).toHaveBeenCalledWith(
|
||||
replacement.getAudioTracks()[0],
|
||||
);
|
||||
expect(pc.close).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should do nothing without an established path', async () => {
|
||||
const { backchannel } = setup();
|
||||
await expect(
|
||||
backchannel.setStream(createStream().asMediaStream()),
|
||||
).resolves.toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('stop', () => {
|
||||
it('should close the connection but leave the microphone running', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const stream = createStream();
|
||||
const started = backchannel.start(stream.asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
backchannel.stop();
|
||||
|
||||
expect(pc.close).toHaveBeenCalled();
|
||||
expect(stream.getAudioTracks()[0].readyState).toBe('live');
|
||||
});
|
||||
|
||||
it('should not report a peer connection that fails after being stopped', async () => {
|
||||
const errorCallback = vi.fn();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback });
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await negotiate(websocket);
|
||||
|
||||
backchannel.stop();
|
||||
pc.fireConnectionStateChange('failed');
|
||||
await flushPromises();
|
||||
|
||||
await expect(started).rejects.toMatchObject({ reason: 'abandoned' });
|
||||
expect(errorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
describe('losing the microphone', () => {
|
||||
const endTrack = (stream: FakeMediaStream): void => {
|
||||
const track = stream.getAudioTracks()[0];
|
||||
track.readyState = 'ended';
|
||||
track.dispatchEvent(new Event('ended'));
|
||||
};
|
||||
|
||||
it('should fail a start whose microphone ends before connecting', async () => {
|
||||
const stream = createStream();
|
||||
const { backchannel, websocket } = setup();
|
||||
const started = backchannel.start(stream.asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
|
||||
endTrack(stream);
|
||||
|
||||
await expect(started).rejects.toMatchObject({ reason: 'no_microphone' });
|
||||
});
|
||||
|
||||
it('should release the camera and report when the microphone ends mid-call', async () => {
|
||||
const errorCallback = vi.fn();
|
||||
const stream = createStream();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback });
|
||||
const started = backchannel.start(stream.asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
endTrack(stream);
|
||||
|
||||
expect(pc.close).toHaveBeenCalled();
|
||||
expect(errorCallback).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ reason: 'no_microphone' }),
|
||||
);
|
||||
});
|
||||
|
||||
it('should stop watching a microphone that has been replaced', async () => {
|
||||
const stream = createStream();
|
||||
const errorCallback = vi.fn();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback });
|
||||
const started = backchannel.start(stream.asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
await backchannel.setStream(createStream().asMediaStream());
|
||||
endTrack(stream);
|
||||
|
||||
expect(errorCallback).not.toHaveBeenCalled();
|
||||
expect(pc.close).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should stop watching the microphone once stopped', async () => {
|
||||
const stream = createStream();
|
||||
const errorCallback = vi.fn();
|
||||
const { backchannel, pc, websocket } = setup({ errorCallback });
|
||||
const started = backchannel.start(stream.asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
backchannel.stop();
|
||||
endTrack(stream);
|
||||
|
||||
expect(errorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('stale and defensive paths', () => {
|
||||
it('should use the browser factories when none are supplied', async () => {
|
||||
const pc = new FakeRTCPeerConnection();
|
||||
const websocket = new FakeWebSocket();
|
||||
vi.stubGlobal('RTCPeerConnection', function () {
|
||||
return pc.asPeerConnection();
|
||||
});
|
||||
vi.stubGlobal('WebSocket', function () {
|
||||
return websocket.asWebSocket();
|
||||
});
|
||||
|
||||
const backchannel = new Go2RTCBackchannel(mock<HomeAssistant>(), {
|
||||
endpoint: '/local/api/ws?src=camera',
|
||||
});
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
expect(pc.transceivers).toHaveLength(1);
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
|
||||
it('should time out an address resolution that never returns', async () => {
|
||||
vi.useFakeTimers();
|
||||
vi.mocked(resolveEndpointURL).mockReturnValue(new Promise(() => {}));
|
||||
|
||||
const { backchannel } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
vi.advanceTimersByTime(10 * 1000);
|
||||
|
||||
await expect(started).rejects.toMatchObject({ reason: 'failed' });
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it('should reject with a reason and release the connection when setup throws', async () => {
|
||||
const { backchannel, pc } = setup();
|
||||
pc.addTransceiver = () => {
|
||||
throw new Error('bad track');
|
||||
};
|
||||
|
||||
await expect(
|
||||
backchannel.start(createStream().asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'failed', description: 'bad track' });
|
||||
expect(pc.close).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should reject without a description when setup throws something not error-like', async () => {
|
||||
const { backchannel, pc } = setup();
|
||||
pc.addTransceiver = () => {
|
||||
throw 'a bare string';
|
||||
};
|
||||
|
||||
await expect(
|
||||
backchannel.start(createStream().asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'failed', description: null });
|
||||
});
|
||||
|
||||
it('should abandon a start stopped while the address resolves', async () => {
|
||||
let release: (value: ResolvedEndpoint) => void = () => {};
|
||||
vi.mocked(resolveEndpointURL).mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
release = resolve;
|
||||
}),
|
||||
);
|
||||
|
||||
const { backchannel, pc } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
backchannel.stop();
|
||||
release({ success: true, url: 'http://go2rtc/api/ws' });
|
||||
await flushPromises();
|
||||
|
||||
await expect(started).rejects.toMatchObject({ reason: 'abandoned' });
|
||||
expect(pc.transceivers).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should not send candidates after being stopped', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
const before = websocket.sent.length;
|
||||
|
||||
backchannel.stop();
|
||||
pc.fireIceCandidate('candidate:late');
|
||||
|
||||
expect(websocket.sent).toHaveLength(before);
|
||||
await expect(started).rejects.toThrow();
|
||||
});
|
||||
|
||||
it('should not negotiate after being stopped', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
let releaseOffer: (value: { type: string; sdp?: string }) => void = () => {};
|
||||
pc.createOffer.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
releaseOffer = resolve;
|
||||
}),
|
||||
);
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
|
||||
backchannel.stop();
|
||||
releaseOffer({ type: 'offer', sdp: 'v=0' });
|
||||
await flushPromises();
|
||||
|
||||
expect(pc.setLocalDescription).not.toHaveBeenCalled();
|
||||
await expect(started).rejects.toThrow();
|
||||
});
|
||||
|
||||
it('should not send an offer when the local description is stopped mid-flight', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
let releaseLocal: () => void = () => {};
|
||||
pc.setLocalDescription.mockReturnValue(
|
||||
new Promise<void>((resolve) => {
|
||||
releaseLocal = resolve;
|
||||
}),
|
||||
);
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
|
||||
backchannel.stop();
|
||||
releaseLocal();
|
||||
await flushPromises();
|
||||
|
||||
expect(
|
||||
websocket.sent.filter((m) => JSON.parse(m).type === 'webrtc/offer'),
|
||||
).toHaveLength(0);
|
||||
await expect(started).rejects.toThrow();
|
||||
});
|
||||
|
||||
it('should send an empty offer when the browser produces no SDP', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.createOffer.mockResolvedValue({ type: 'offer' });
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
const offer = websocket.sent
|
||||
.map((m) => JSON.parse(m))
|
||||
.find((m) => m.type === 'webrtc/offer');
|
||||
expect(offer.value).toBe('');
|
||||
});
|
||||
|
||||
it('should reject without a description when a negotiation failure is not error-like', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.createOffer.mockRejectedValue('a bare string');
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
await expect(started).rejects.toMatchObject({
|
||||
reason: 'failed',
|
||||
description: null,
|
||||
});
|
||||
});
|
||||
|
||||
it('should describe a negotiation failure by its name when it carries no message', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.createOffer.mockRejectedValue({ name: 'InvalidStateError' });
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
await expect(started).rejects.toMatchObject({
|
||||
reason: 'failed',
|
||||
description: 'InvalidStateError',
|
||||
});
|
||||
});
|
||||
|
||||
it('should reject when the answer cannot be applied', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.setRemoteDescription.mockRejectedValue(new Error('bad sdp'));
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(JSON.stringify({ type: 'webrtc/answer', value: 'v=0' }));
|
||||
await expect(started).rejects.toMatchObject({
|
||||
reason: 'failed',
|
||||
description: 'bad sdp',
|
||||
});
|
||||
});
|
||||
|
||||
it('should ignore messages without a string payload', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(JSON.stringify({ type: 'webrtc/answer', value: 42 }));
|
||||
await flushPromises();
|
||||
|
||||
expect(pc.setRemoteDescription).not.toHaveBeenCalled();
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
});
|
||||
|
||||
it('should tolerate a candidate the browser rejects', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.addIceCandidate.mockRejectedValue(new Error('bad candidate'));
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(
|
||||
JSON.stringify({ type: 'webrtc/candidate', value: 'candidate:3' }),
|
||||
);
|
||||
await flushPromises();
|
||||
|
||||
await connect(pc, websocket);
|
||||
await expect(started).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('should ignore an empty candidate from the server', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(JSON.stringify({ type: 'webrtc/candidate', value: '' }));
|
||||
await flushPromises();
|
||||
|
||||
expect(pc.addIceCandidate).not.toHaveBeenCalled();
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
});
|
||||
|
||||
it('should ignore messages after being stopped', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
|
||||
backchannel.stop();
|
||||
websocket.fireMessage(JSON.stringify({ type: 'webrtc/answer', value: 'v=0' }));
|
||||
await flushPromises();
|
||||
|
||||
expect(pc.setRemoteDescription).not.toHaveBeenCalled();
|
||||
await expect(started).rejects.toThrow();
|
||||
});
|
||||
|
||||
it('should ignore intermediate connection states', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await negotiate(websocket);
|
||||
|
||||
pc.fireConnectionStateChange('connecting');
|
||||
await flushPromises();
|
||||
expect(websocket.close).not.toHaveBeenCalled();
|
||||
|
||||
pc.fireConnectionStateChange('connected');
|
||||
await started;
|
||||
});
|
||||
|
||||
it('should reject a replacement carrying no audio', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
await expect(
|
||||
backchannel.setStream(new FakeMediaStream().asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'no_microphone' });
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should reject a replacement whose track has ended', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await connect(pc, websocket);
|
||||
await started;
|
||||
|
||||
const track = new FakeMediaStreamTrack('audio');
|
||||
track.readyState = 'ended';
|
||||
await expect(
|
||||
backchannel.setStream(new FakeMediaStream([track]).asMediaStream()),
|
||||
).rejects.toMatchObject({ reason: 'no_microphone' });
|
||||
});
|
||||
it('should reject without a description when an answer failure names nothing', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
pc.setRemoteDescription.mockRejectedValue({});
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
websocket.fireMessage(JSON.stringify({ type: 'webrtc/answer', value: 'v=0' }));
|
||||
await expect(started).rejects.toMatchObject({
|
||||
reason: 'failed',
|
||||
description: null,
|
||||
});
|
||||
});
|
||||
|
||||
it('should ignore a negotiation failure that arrives after being stopped', async () => {
|
||||
const { backchannel, pc, websocket } = setup();
|
||||
let rejectOffer: (error: unknown) => void = () => {};
|
||||
pc.createOffer.mockReturnValue(
|
||||
new Promise((_resolve, reject) => {
|
||||
rejectOffer = reject;
|
||||
}),
|
||||
);
|
||||
const started = backchannel.start(createStream().asMediaStream());
|
||||
await flushPromises();
|
||||
websocket.fireOpen();
|
||||
await flushPromises();
|
||||
|
||||
backchannel.stop();
|
||||
await expect(started).rejects.toMatchObject({ reason: 'abandoned' });
|
||||
|
||||
rejectOffer(new Error('too late'));
|
||||
await flushPromises();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,7 +1,7 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import { OffscreenVideo } from '../../../../../src/components-lib/live/providers/go2rtc-experimental/offscreen-video';
|
||||
import { FakeMediaStream, FakeMediaStreamTrack } from './test-utils';
|
||||
import { FakeMediaStream, FakeMediaStreamTrack } from '../../../../go2rtc/test-utils';
|
||||
|
||||
// @vitest-environment jsdom
|
||||
describe('OffscreenVideo', () => {
|
||||
|
||||
@@ -26,7 +26,7 @@ import {
|
||||
FakeMediaStreamTrack,
|
||||
FakeRTCPeerConnection,
|
||||
FakeWebSocket,
|
||||
} from './test-utils';
|
||||
} from '../../../../go2rtc/test-utils';
|
||||
|
||||
const H264_PROFILE: StreamProfile = {
|
||||
hasVideo: true,
|
||||
@@ -128,7 +128,6 @@ describe('Go2RTCSessionController', () => {
|
||||
source.getCapabilities.mockReturnValue({
|
||||
supportsPause: true,
|
||||
hasAudio: true,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
source.getTechnology.mockReturnValue([mode]);
|
||||
binarySources.push(source);
|
||||
@@ -154,15 +153,12 @@ describe('Go2RTCSessionController', () => {
|
||||
source.getCapabilities.mockReturnValue({
|
||||
supportsPause: true,
|
||||
hasAudio: true,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
source.getTechnology.mockReturnValue(['webrtc']);
|
||||
source.getMediaStream.mockReturnValue(webRTCStream.asMediaStream());
|
||||
source.getPeerConnection.mockReturnValue(
|
||||
options?.webRTCPeerConnection?.asPeerConnection() ?? null,
|
||||
);
|
||||
source.setMicrophoneStream.mockResolvedValue(undefined);
|
||||
|
||||
webRTCSources.push(source);
|
||||
return source;
|
||||
},
|
||||
@@ -179,7 +175,6 @@ describe('Go2RTCSessionController', () => {
|
||||
const mediaLoadedCallback = vi.fn();
|
||||
const surfaceCommittedCallback = vi.fn();
|
||||
const streamErrorCallback = vi.fn();
|
||||
const microphoneErrorCallback = vi.fn();
|
||||
|
||||
const session = new Go2RTCSessionController(
|
||||
{
|
||||
@@ -188,7 +183,6 @@ describe('Go2RTCSessionController', () => {
|
||||
mediaLoadedCallback,
|
||||
surfaceCommittedCallback,
|
||||
streamErrorCallback,
|
||||
microphoneErrorCallback,
|
||||
},
|
||||
{ createWebSocket, createBinarySource, createWebRTCSource, createVideoElement },
|
||||
);
|
||||
@@ -204,7 +198,6 @@ describe('Go2RTCSessionController', () => {
|
||||
createWebRTCSource,
|
||||
createWebSocket,
|
||||
streamErrorCallback,
|
||||
microphoneErrorCallback,
|
||||
mediaLoadedCallback,
|
||||
offscreenVideos,
|
||||
session,
|
||||
@@ -285,7 +278,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
});
|
||||
session.connect('ws://localhost:1/api/ws', createSurfaces().surfaces, ['mse']);
|
||||
session.reset();
|
||||
@@ -528,42 +520,6 @@ describe('Go2RTCSessionController', () => {
|
||||
expect(createWebSocket).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('should pre-arm the WebRTC source with the current microphone stream', () => {
|
||||
const { session, surfaces, websockets, webRTCOptions } = setup();
|
||||
const micStream = new FakeMediaStream([
|
||||
new FakeMediaStreamTrack('audio'),
|
||||
]).asMediaStream();
|
||||
session.setMicrophoneStream(micStream);
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
|
||||
expect(webRTCOptions[0]?.microphoneStream).toBe(micStream);
|
||||
});
|
||||
|
||||
it('should report a microphone error without disturbing the stream', () => {
|
||||
const {
|
||||
session,
|
||||
surfaces,
|
||||
websockets,
|
||||
webRTCOptions,
|
||||
webRTCSources,
|
||||
microphoneErrorCallback,
|
||||
streamErrorCallback,
|
||||
} = setup();
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
|
||||
webRTCOptions[0]?.microphoneErrorCallback?.('InvalidStateError');
|
||||
|
||||
expect(microphoneErrorCallback).toHaveBeenCalledWith('InvalidStateError');
|
||||
|
||||
// The inbound video is unaffected by an outbound audio failure, so the
|
||||
// source keeps running and the session neither escalates nor reconnects.
|
||||
expect(streamErrorCallback).not.toHaveBeenCalled();
|
||||
expect(webRTCSources[0].stop).not.toHaveBeenCalled();
|
||||
expect(websockets).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('should re-dispatch loaded media on an audio mute transition', () => {
|
||||
const peerConnection = new FakeRTCPeerConnection();
|
||||
const audioTransceiver = peerConnection.addTransceiver('audio', {
|
||||
@@ -858,26 +814,6 @@ describe('Go2RTCSessionController', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('microphone', () => {
|
||||
it('should forward a microphone change to the WebRTC source', () => {
|
||||
const { session, surfaces, websockets, webRTCSources } = setup();
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
const micStream = new FakeMediaStream([
|
||||
new FakeMediaStreamTrack('audio'),
|
||||
]).asMediaStream();
|
||||
session.setMicrophoneStream(micStream);
|
||||
|
||||
expect(webRTCSources[0].setMicrophoneStream).toHaveBeenCalledWith(micStream);
|
||||
});
|
||||
|
||||
it('should tolerate a microphone change with no WebRTC source', () => {
|
||||
const { session } = setup();
|
||||
|
||||
expect(() => session.setMicrophoneStream(null)).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('lifecycle', () => {
|
||||
it('should stop the source and reconnect on unexpected closure', () => {
|
||||
const { session, surfaces, websockets, binarySources, createWebSocket } = setup();
|
||||
@@ -1078,16 +1014,6 @@ describe('Go2RTCSessionController', () => {
|
||||
expect(mediaLoadedCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should swallow a rejected microphone update', async () => {
|
||||
const { session, surfaces, websockets, webRTCSources } = setup();
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
webRTCSources[0].setMicrophoneStream.mockRejectedValue(new Error('replace'));
|
||||
|
||||
expect(() => session.setMicrophoneStream(null)).not.toThrow();
|
||||
await Promise.resolve();
|
||||
});
|
||||
|
||||
it('should ignore callbacks fired while a binary source is constructed', () => {
|
||||
const websockets: FakeWebSocket[] = [];
|
||||
const createWebSocket = vi.fn<(url: string) => WebSocket>(() => {
|
||||
@@ -1112,7 +1038,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback,
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket, createBinarySource },
|
||||
);
|
||||
@@ -1147,7 +1072,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback,
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket, createWebRTCSource },
|
||||
);
|
||||
@@ -1174,7 +1098,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket },
|
||||
);
|
||||
@@ -1206,7 +1129,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket },
|
||||
);
|
||||
@@ -1247,7 +1169,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket, createBinarySource, createWebRTCSource },
|
||||
);
|
||||
|
||||
@@ -568,7 +568,6 @@ describe('MSEStreamSource', () => {
|
||||
expect(source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: false,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
@@ -579,7 +578,6 @@ describe('MSEStreamSource', () => {
|
||||
expect(setupResult.source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: true,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
@@ -595,7 +593,6 @@ describe('MSEStreamSource', () => {
|
||||
expect(setupResult.source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: false,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
@@ -5,17 +5,17 @@ import type {
|
||||
StreamSourceContext,
|
||||
VideoStreamTarget,
|
||||
} from '../../../../../../src/components-lib/live/providers/go2rtc-experimental/types';
|
||||
import { flushPromises } from '../../../../../test-utils';
|
||||
import {
|
||||
FakeMediaStream,
|
||||
FakeMediaStreamTrack,
|
||||
FakeRTCPeerConnection,
|
||||
FakeStreamSourceChannel,
|
||||
} from '../test-utils';
|
||||
type FakeMediaStreamTrack,
|
||||
} from '../../../../../go2rtc/test-utils';
|
||||
import { flushPromises } from '../../../../../test-utils';
|
||||
import { FakeStreamSourceChannel } from '../test-utils';
|
||||
|
||||
// @vitest-environment jsdom
|
||||
describe('WebRTCStreamSource', () => {
|
||||
const setup = (options?: { microphoneStream?: FakeMediaStream | null }) => {
|
||||
const setup = () => {
|
||||
const video = document.createElement('video');
|
||||
const channel = new FakeStreamSourceChannel();
|
||||
const loadedCallback = vi.fn();
|
||||
@@ -29,13 +29,10 @@ describe('WebRTCStreamSource', () => {
|
||||
|
||||
const pc = new FakeRTCPeerConnection();
|
||||
const createPeerConnection = vi.fn(() => pc.asPeerConnection());
|
||||
const microphoneErrorCallback = vi.fn();
|
||||
const source = new WebRTCStreamSource(context, {
|
||||
createPeerConnection,
|
||||
createMediaStream: (tracks) =>
|
||||
new FakeMediaStream(tracks as unknown as FakeMediaStreamTrack[]).asMediaStream(),
|
||||
microphoneStream: options?.microphoneStream?.asMediaStream() ?? null,
|
||||
microphoneErrorCallback,
|
||||
});
|
||||
|
||||
return {
|
||||
@@ -44,7 +41,6 @@ describe('WebRTCStreamSource', () => {
|
||||
createPeerConnection,
|
||||
failedCallback,
|
||||
loadedCallback,
|
||||
microphoneErrorCallback,
|
||||
pc,
|
||||
source,
|
||||
video,
|
||||
@@ -60,27 +56,14 @@ describe('WebRTCStreamSource', () => {
|
||||
});
|
||||
|
||||
describe('transceivers', () => {
|
||||
it('should pre-arm a sendonly audio transceiver and recvonly video and audio', () => {
|
||||
it('should offer inbound video and audio only', () => {
|
||||
const { source, pc } = setup();
|
||||
source.start();
|
||||
|
||||
expect(pc.transceivers).toHaveLength(3);
|
||||
expect(pc.transceivers[0].direction).toBe('sendonly');
|
||||
expect(pc.transceivers[1].direction).toBe('recvonly');
|
||||
expect(pc.transceivers[2].direction).toBe('recvonly');
|
||||
|
||||
// Kind-only pre-arm: no track, so no getUserMedia and no permission prompt.
|
||||
expect(pc.transceivers[0].sender.track).toBeNull();
|
||||
});
|
||||
|
||||
it('should pre-arm with the current microphone track', () => {
|
||||
const micTrack = new FakeMediaStreamTrack('audio');
|
||||
const { source, pc } = setup({
|
||||
microphoneStream: new FakeMediaStream([micTrack]),
|
||||
});
|
||||
source.start();
|
||||
|
||||
expect(pc.transceivers[0].sender.track).toBe(micTrack);
|
||||
expect(pc.transceivers.map((transceiver) => transceiver.direction)).toEqual([
|
||||
'recvonly',
|
||||
'recvonly',
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -431,6 +414,17 @@ describe('WebRTCStreamSource', () => {
|
||||
expect(source.getPeerConnection()).toBe(pc.asPeerConnection());
|
||||
});
|
||||
|
||||
it('should report its media capabilities', () => {
|
||||
const { source, pc } = setup();
|
||||
source.start();
|
||||
pc.fireConnectionStateChange('connected');
|
||||
|
||||
expect(source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: expect.any(Boolean),
|
||||
});
|
||||
});
|
||||
|
||||
it('should report webrtc technology', () => {
|
||||
const { source } = setup();
|
||||
|
||||
@@ -462,139 +456,5 @@ describe('WebRTCStreamSource', () => {
|
||||
hasAACAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
it('should report 2-way audio capability once a mic track is armed', () => {
|
||||
const micTrack = new FakeMediaStreamTrack('audio');
|
||||
const { source, pc } = setup({
|
||||
microphoneStream: new FakeMediaStream([micTrack]),
|
||||
});
|
||||
source.start();
|
||||
pc.fireConnectionStateChange('connected');
|
||||
|
||||
expect(source.getCapabilities().has2WayAudio).toBe(true);
|
||||
expect(source.getCapabilities().supportsPause).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('setMicrophoneStream', () => {
|
||||
it('should do nothing for an unchanged stream', async () => {
|
||||
const stream = new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
const { source, pc } = setup({ microphoneStream: stream });
|
||||
source.start();
|
||||
await source.setMicrophoneStream(stream.asMediaStream());
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should replace the outbound track without renegotiating', async () => {
|
||||
const { source, pc } = setup();
|
||||
source.start();
|
||||
const newTrack = new FakeMediaStreamTrack('audio');
|
||||
await source.setMicrophoneStream(new FakeMediaStream([newTrack]).asMediaStream());
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).toHaveBeenCalledWith(
|
||||
newTrack,
|
||||
);
|
||||
});
|
||||
|
||||
it('should clear the outbound track for a null stream', async () => {
|
||||
const stream = new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
const { source, pc } = setup({ microphoneStream: stream });
|
||||
source.start();
|
||||
await source.setMicrophoneStream(null);
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).toHaveBeenCalledWith(
|
||||
null,
|
||||
);
|
||||
});
|
||||
|
||||
it('should do nothing before there is a peer connection', async () => {
|
||||
const { source, microphoneErrorCallback } = setup();
|
||||
await source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
|
||||
expect(microphoneErrorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it.each([
|
||||
[
|
||||
'what the browser said when the rejection has a message',
|
||||
new DOMException('The peer connection is closed', 'InvalidStateError'),
|
||||
'The peer connection is closed',
|
||||
],
|
||||
[
|
||||
'the rejection type when there is no message to quote',
|
||||
new DOMException('', 'InvalidStateError'),
|
||||
'InvalidStateError',
|
||||
],
|
||||
['nothing when the rejection is not an object', 'nope', undefined],
|
||||
[
|
||||
'nothing when the rejection describes itself with neither',
|
||||
{ message: 5, name: 7 },
|
||||
undefined,
|
||||
],
|
||||
] as const)(
|
||||
'should report %s when a current replaceTrack rejects',
|
||||
async (_summary, rejection, expected) => {
|
||||
const { source, pc, microphoneErrorCallback } = setup();
|
||||
source.start();
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockRejectedValue(rejection);
|
||||
await source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
|
||||
expect(microphoneErrorCallback).toHaveBeenCalledWith(expected);
|
||||
},
|
||||
);
|
||||
|
||||
it('should not fail the stream source when the microphone cannot attach', async () => {
|
||||
const { source, pc, failedCallback } = setup();
|
||||
source.start();
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockRejectedValue(
|
||||
new DOMException('replace failed', 'InvalidStateError'),
|
||||
);
|
||||
await source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
|
||||
// The inbound video is unaffected by an outbound audio failure, so the
|
||||
// source must keep running rather than failing over to another one.
|
||||
expect(failedCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not report a rejection when detaching the microphone', async () => {
|
||||
const stream = new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
const { source, pc, microphoneErrorCallback } = setup({
|
||||
microphoneStream: stream,
|
||||
});
|
||||
source.start();
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockRejectedValue(
|
||||
new DOMException('The peer connection is closed', 'InvalidStateError'),
|
||||
);
|
||||
await source.setMicrophoneStream(null);
|
||||
|
||||
// Ignore the error, the user is not trying to be heard anyway.
|
||||
expect(microphoneErrorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should ignore a stale replaceTrack rejection after stop', async () => {
|
||||
const { source, pc, microphoneErrorCallback } = setup();
|
||||
source.start();
|
||||
let rejectReplace: (reason: Error) => void = () => {};
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockReturnValue(
|
||||
new Promise((_resolve, reject) => {
|
||||
rejectReplace = reject;
|
||||
}),
|
||||
);
|
||||
const promise = source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
source.stop();
|
||||
rejectReplace(new Error('replace failed'));
|
||||
await promise;
|
||||
|
||||
expect(microphoneErrorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
import { vi, type Mock } from 'vitest';
|
||||
import { vi } from 'vitest';
|
||||
|
||||
import type {
|
||||
MediaSourceFactory,
|
||||
MediaSourceInterface,
|
||||
} from '../../../../../src/components-lib/live/providers/go2rtc-experimental/adapters/media-source';
|
||||
import type { StreamSourceChannel } from '../../../../../src/components-lib/live/providers/go2rtc-experimental/types';
|
||||
import type {
|
||||
BinaryCallback,
|
||||
Go2RTCMessage,
|
||||
MessageCallback,
|
||||
StreamSourceChannel,
|
||||
} from '../../../../../src/components-lib/live/providers/go2rtc-experimental/types';
|
||||
} from '../../../../../src/go2rtc/messages';
|
||||
import type { UnsubscribeCallback } from '../../../../../src/types';
|
||||
|
||||
// ===========================================================================
|
||||
@@ -28,32 +28,6 @@ export const SAFARI_17_USER_AGENT =
|
||||
// Fakes for browser APIs jsdom does not provide.
|
||||
// ===========================================================================
|
||||
|
||||
export class FakeWebSocket extends EventTarget {
|
||||
public binaryType = '';
|
||||
public sent: string[] = [];
|
||||
|
||||
public close = vi.fn();
|
||||
public send = vi.fn((data: string): void => {
|
||||
this.sent.push(data);
|
||||
});
|
||||
|
||||
public asWebSocket(): WebSocket {
|
||||
return this as unknown as WebSocket;
|
||||
}
|
||||
|
||||
public fireOpen(): void {
|
||||
this.dispatchEvent(new Event('open'));
|
||||
}
|
||||
|
||||
public fireClose(): void {
|
||||
this.dispatchEvent(new Event('close'));
|
||||
}
|
||||
|
||||
public fireMessage(data: unknown): void {
|
||||
this.dispatchEvent(new MessageEvent('message', { data }));
|
||||
}
|
||||
}
|
||||
|
||||
export const createTimeRanges = (ranges: [number, number][]): TimeRanges => ({
|
||||
length: ranges.length,
|
||||
start: (index: number) => ranges[index][0],
|
||||
@@ -77,129 +51,6 @@ class FakeSourceBuffer extends EventTarget {
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeMediaStreamTrack extends EventTarget {
|
||||
public muted = false;
|
||||
public kind: string;
|
||||
|
||||
constructor(kind: string) {
|
||||
super();
|
||||
this.kind = kind;
|
||||
}
|
||||
|
||||
public asTrack(): MediaStreamTrack {
|
||||
return this as unknown as MediaStreamTrack;
|
||||
}
|
||||
|
||||
public setMuted(muted: boolean): void {
|
||||
this.muted = muted;
|
||||
this.dispatchEvent(new Event(muted ? 'mute' : 'unmute'));
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeMediaStream {
|
||||
private _tracks: FakeMediaStreamTrack[];
|
||||
|
||||
constructor(tracks: FakeMediaStreamTrack[] = []) {
|
||||
this._tracks = tracks;
|
||||
}
|
||||
|
||||
public getTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks;
|
||||
}
|
||||
|
||||
public getVideoTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks.filter((track) => track.kind === 'video');
|
||||
}
|
||||
|
||||
public getAudioTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks.filter((track) => track.kind === 'audio');
|
||||
}
|
||||
|
||||
public asMediaStream(): MediaStream {
|
||||
return this as unknown as MediaStream;
|
||||
}
|
||||
}
|
||||
|
||||
class FakeRTCTransceiver {
|
||||
public direction: string;
|
||||
public currentDirection: string;
|
||||
public sender: {
|
||||
track: FakeMediaStreamTrack | null;
|
||||
replaceTrack: Mock<(track: MediaStreamTrack | null) => Promise<void>>;
|
||||
};
|
||||
public receiver: { track: FakeMediaStreamTrack };
|
||||
|
||||
constructor(direction: string, kind: string, track: FakeMediaStreamTrack | null) {
|
||||
this.direction = direction;
|
||||
this.currentDirection = direction;
|
||||
this.sender = {
|
||||
track,
|
||||
replaceTrack: vi.fn<(track: MediaStreamTrack | null) => Promise<void>>(() =>
|
||||
Promise.resolve(),
|
||||
),
|
||||
};
|
||||
this.receiver = { track: new FakeMediaStreamTrack(kind) };
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeRTCPeerConnection extends EventTarget {
|
||||
public connectionState: RTCPeerConnectionState = 'new';
|
||||
public remoteDescription: { sdp: string } | null = null;
|
||||
public transceivers: FakeRTCTransceiver[] = [];
|
||||
|
||||
public createOffer = vi.fn(
|
||||
(): Promise<{ type: string; sdp?: string }> =>
|
||||
Promise.resolve({ type: 'offer', sdp: 'v=0\r\noffer' }),
|
||||
);
|
||||
public setLocalDescription = vi.fn(() => Promise.resolve());
|
||||
public setRemoteDescription = vi.fn((description: { sdp: string }) => {
|
||||
this.remoteDescription = description;
|
||||
return Promise.resolve();
|
||||
});
|
||||
public addIceCandidate = vi.fn(() => Promise.resolve());
|
||||
public close = vi.fn();
|
||||
|
||||
public addTransceiver(
|
||||
trackOrKind: FakeMediaStreamTrack | string,
|
||||
init: { direction: string },
|
||||
): FakeRTCTransceiver {
|
||||
const kind = typeof trackOrKind === 'string' ? trackOrKind : trackOrKind.kind;
|
||||
const track = typeof trackOrKind === 'string' ? null : trackOrKind;
|
||||
const transceiver = new FakeRTCTransceiver(init.direction, kind, track);
|
||||
this.transceivers.push(transceiver);
|
||||
return transceiver;
|
||||
}
|
||||
|
||||
public getTransceivers(): FakeRTCTransceiver[] {
|
||||
return this.transceivers;
|
||||
}
|
||||
|
||||
public getReceivers(): { track: FakeMediaStreamTrack }[] {
|
||||
return this.transceivers.map((transceiver) => transceiver.receiver);
|
||||
}
|
||||
|
||||
public asPeerConnection(): RTCPeerConnection {
|
||||
return this as unknown as RTCPeerConnection;
|
||||
}
|
||||
|
||||
public getMicrophoneTransceiver(): FakeRTCTransceiver {
|
||||
return this.transceivers[0];
|
||||
}
|
||||
|
||||
public fireConnectionStateChange(state: RTCPeerConnectionState): void {
|
||||
this.connectionState = state;
|
||||
this.dispatchEvent(new Event('connectionstatechange'));
|
||||
}
|
||||
|
||||
public fireIceCandidate(candidate: string | null): void {
|
||||
const event = new Event('icecandidate');
|
||||
Object.assign(event, {
|
||||
candidate: candidate === null ? null : { candidate },
|
||||
});
|
||||
this.dispatchEvent(event);
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// Fakes for custom interfaces.
|
||||
// ===========================================================================
|
||||
|
||||
@@ -33,6 +33,14 @@ describe('MediaDimensionsContainerController', () => {
|
||||
});
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
|
||||
// The controller debounces its resize. Without fake timers a trailing
|
||||
// resize outlives the test that scheduled it and runs against mocks that
|
||||
// have since been cleared, in whatever test file happens to be running.
|
||||
vi.useFakeTimers();
|
||||
});
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
const configWithAspectRatio: CameraDimensionsConfig = {
|
||||
@@ -622,13 +630,6 @@ describe('MediaDimensionsContainerController', () => {
|
||||
});
|
||||
|
||||
describe('should respond to slot changes', () => {
|
||||
beforeEach(() => {
|
||||
vi.useFakeTimers();
|
||||
});
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it('should resize container on slotchange event', () => {
|
||||
const host = createLitElement();
|
||||
host.getBoundingClientRect = vi.fn().mockReturnValue({
|
||||
@@ -663,13 +664,6 @@ describe('MediaDimensionsContainerController', () => {
|
||||
});
|
||||
|
||||
describe('should respond to media load', () => {
|
||||
beforeEach(() => {
|
||||
vi.useFakeTimers();
|
||||
});
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it('should resize container on media load', () => {
|
||||
const host = createLitElement();
|
||||
host.getBoundingClientRect = vi.fn().mockReturnValue({
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
||||
import { mock } from 'vitest-mock-extended';
|
||||
|
||||
import { supports2WayAudio } from '../../../src/camera-manager/utils/go2rtc/audio';
|
||||
import { homeAssistantSignAndFetch } from '../../../src/ha/fetch';
|
||||
import type { HomeAssistant } from '../../../src/ha/types';
|
||||
import { createProxiedEndpointIfNecessary } from '../../../src/ha/web-proxy';
|
||||
import type { Endpoint } from '../../../src/types';
|
||||
import { supports2WayAudio } from '../../src/go2rtc/audio';
|
||||
import { homeAssistantSignAndFetch } from '../../src/ha/fetch';
|
||||
import type { HomeAssistant } from '../../src/ha/types';
|
||||
import { createProxiedEndpointIfNecessary } from '../../src/ha/web-proxy';
|
||||
import type { Endpoint } from '../../src/types';
|
||||
|
||||
vi.mock('../../../src/ha/fetch');
|
||||
vi.mock('../../../src/ha/web-proxy');
|
||||
vi.mock('../../src/ha/fetch');
|
||||
vi.mock('../../src/ha/web-proxy');
|
||||
|
||||
describe('supports2WayAudio', () => {
|
||||
const hass = mock<HomeAssistant>();
|
||||
@@ -3,8 +3,8 @@ import { describe, expect, it } from 'vitest';
|
||||
import {
|
||||
getGo2RTCMetadataEndpoint,
|
||||
getGo2RTCStreamEndpoint,
|
||||
} from '../../../src/camera-manager/utils/go2rtc/endpoint.js';
|
||||
import { createCameraConfig } from '../../config/test-utils';
|
||||
} from '../../src/go2rtc/endpoint.js';
|
||||
import { createCameraConfig } from '../config/test-utils';
|
||||
|
||||
describe('getGo2RTCStreamEndpoint', () => {
|
||||
it('with local configuration', () => {
|
||||
@@ -39,6 +39,22 @@ describe('getGo2RTCStreamEndpoint', () => {
|
||||
});
|
||||
});
|
||||
|
||||
it('should encode the stream name', () => {
|
||||
expect(
|
||||
getGo2RTCStreamEndpoint(
|
||||
createCameraConfig({
|
||||
go2rtc: {
|
||||
stream: 'front doorµphone',
|
||||
url: '/local/path',
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
endpoint: '/local/path/api/ws?src=front%20door%26microphone',
|
||||
sign: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('without configuration', () => {
|
||||
expect(getGo2RTCStreamEndpoint(createCameraConfig())).toBeNull();
|
||||
});
|
||||
@@ -56,7 +72,7 @@ describe('getGo2RTCMetadataEndpoint', () => {
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
endpoint: '/local/path/api/streams?src=stream&video=all&audio=allµphone',
|
||||
endpoint: '/local/path/api/streams?src=stream&video=all&audio=all',
|
||||
sign: true,
|
||||
});
|
||||
});
|
||||
@@ -72,12 +88,28 @@ describe('getGo2RTCMetadataEndpoint', () => {
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
endpoint:
|
||||
'https://my-custom-go2rtc/api/streams?src=stream&video=all&audio=allµphone',
|
||||
endpoint: 'https://my-custom-go2rtc/api/streams?src=stream&video=all&audio=all',
|
||||
sign: false,
|
||||
});
|
||||
});
|
||||
|
||||
it('should encode the stream name so it cannot add probe parameters', () => {
|
||||
expect(
|
||||
getGo2RTCMetadataEndpoint(
|
||||
createCameraConfig({
|
||||
go2rtc: {
|
||||
stream: 'front doorµphone',
|
||||
url: '/local/path',
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
endpoint:
|
||||
'/local/path/api/streams?src=front%20door%26microphone&video=all&audio=all',
|
||||
sign: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('without configuration', () => {
|
||||
expect(getGo2RTCMetadataEndpoint(createCameraConfig())).toBeNull();
|
||||
});
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { isServerErrorForMode } from '../../../../../../src/components-lib/live/providers/go2rtc-experimental/utils/messages';
|
||||
import { isServerErrorForMode } from '../../src/go2rtc/messages';
|
||||
|
||||
describe('isServerErrorForMode', () => {
|
||||
it('should match an error for the mode', () => {
|
||||
+1
-1
@@ -3,7 +3,7 @@ import { describe, expect, it, vi } from 'vitest';
|
||||
import {
|
||||
createBrowserPeerConnection,
|
||||
GO2RTC_PEER_CONNECTION_CONFIG,
|
||||
} from '../../../../../../src/components-lib/live/providers/go2rtc-experimental/adapters/peer-connection';
|
||||
} from '../../src/go2rtc/peer-connection';
|
||||
|
||||
describe('peer-connection', () => {
|
||||
it('should configure two STUN servers with max-bundle', () => {
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import { SignalingChannel } from '../../../../../src/components-lib/live/providers/go2rtc-experimental/signaling';
|
||||
import { SignalingChannel } from '../../src/go2rtc/signaling';
|
||||
import { FakeWebSocket } from './test-utils';
|
||||
|
||||
describe('SignalingChannel', () => {
|
||||
@@ -0,0 +1,155 @@
|
||||
import { vi, type Mock } from 'vitest';
|
||||
|
||||
// ===========================================================================
|
||||
// Fakes for browser APIs jsdom does not provide.
|
||||
// ===========================================================================
|
||||
|
||||
export class FakeWebSocket extends EventTarget {
|
||||
public binaryType = '';
|
||||
public sent: string[] = [];
|
||||
|
||||
public close = vi.fn();
|
||||
public send = vi.fn((data: string): void => {
|
||||
this.sent.push(data);
|
||||
});
|
||||
|
||||
public asWebSocket(): WebSocket {
|
||||
return this as unknown as WebSocket;
|
||||
}
|
||||
|
||||
public fireOpen(): void {
|
||||
this.dispatchEvent(new Event('open'));
|
||||
}
|
||||
|
||||
public fireClose(): void {
|
||||
this.dispatchEvent(new Event('close'));
|
||||
}
|
||||
|
||||
public fireMessage(data: unknown): void {
|
||||
this.dispatchEvent(new MessageEvent('message', { data }));
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeMediaStreamTrack extends EventTarget {
|
||||
public muted = false;
|
||||
public readyState: MediaStreamTrackState = 'live';
|
||||
public kind: string;
|
||||
|
||||
constructor(kind: string) {
|
||||
super();
|
||||
this.kind = kind;
|
||||
}
|
||||
|
||||
public asTrack(): MediaStreamTrack {
|
||||
return this as unknown as MediaStreamTrack;
|
||||
}
|
||||
|
||||
public setMuted(muted: boolean): void {
|
||||
this.muted = muted;
|
||||
this.dispatchEvent(new Event(muted ? 'mute' : 'unmute'));
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeMediaStream {
|
||||
private _tracks: FakeMediaStreamTrack[];
|
||||
|
||||
constructor(tracks: FakeMediaStreamTrack[] = []) {
|
||||
this._tracks = tracks;
|
||||
}
|
||||
|
||||
public getTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks;
|
||||
}
|
||||
|
||||
public getVideoTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks.filter((track) => track.kind === 'video');
|
||||
}
|
||||
|
||||
public getAudioTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks.filter((track) => track.kind === 'audio');
|
||||
}
|
||||
|
||||
public asMediaStream(): MediaStream {
|
||||
return this as unknown as MediaStream;
|
||||
}
|
||||
}
|
||||
|
||||
class FakeRTCTransceiver {
|
||||
public direction: string;
|
||||
public currentDirection: string;
|
||||
public sender: {
|
||||
track: FakeMediaStreamTrack | null;
|
||||
replaceTrack: Mock<(track: MediaStreamTrack | null) => Promise<void>>;
|
||||
};
|
||||
public receiver: { track: FakeMediaStreamTrack };
|
||||
|
||||
constructor(direction: string, kind: string, track: FakeMediaStreamTrack | null) {
|
||||
this.direction = direction;
|
||||
this.currentDirection = direction;
|
||||
this.sender = {
|
||||
track,
|
||||
replaceTrack: vi.fn<(track: MediaStreamTrack | null) => Promise<void>>(() =>
|
||||
Promise.resolve(),
|
||||
),
|
||||
};
|
||||
this.receiver = { track: new FakeMediaStreamTrack(kind) };
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeRTCPeerConnection extends EventTarget {
|
||||
public connectionState: RTCPeerConnectionState = 'new';
|
||||
public remoteDescription: { sdp: string } | null = null;
|
||||
public transceivers: FakeRTCTransceiver[] = [];
|
||||
|
||||
public createOffer = vi.fn(
|
||||
(): Promise<{ type: string; sdp?: string }> =>
|
||||
Promise.resolve({ type: 'offer', sdp: 'v=0\r\noffer' }),
|
||||
);
|
||||
public setLocalDescription = vi.fn(() => Promise.resolve());
|
||||
public setRemoteDescription = vi.fn((description: { sdp: string }) => {
|
||||
this.remoteDescription = description;
|
||||
return Promise.resolve();
|
||||
});
|
||||
public addIceCandidate = vi.fn(() => Promise.resolve());
|
||||
public close = vi.fn();
|
||||
|
||||
public addTransceiver(
|
||||
trackOrKind: FakeMediaStreamTrack | string,
|
||||
init: { direction: string },
|
||||
): FakeRTCTransceiver {
|
||||
const kind = typeof trackOrKind === 'string' ? trackOrKind : trackOrKind.kind;
|
||||
const track = typeof trackOrKind === 'string' ? null : trackOrKind;
|
||||
const transceiver = new FakeRTCTransceiver(init.direction, kind, track);
|
||||
this.transceivers.push(transceiver);
|
||||
return transceiver;
|
||||
}
|
||||
|
||||
public getTransceivers(): FakeRTCTransceiver[] {
|
||||
return this.transceivers;
|
||||
}
|
||||
|
||||
public getReceivers(): { track: FakeMediaStreamTrack }[] {
|
||||
return this.transceivers.map((transceiver) => transceiver.receiver);
|
||||
}
|
||||
|
||||
public asPeerConnection(): RTCPeerConnection {
|
||||
return this as unknown as RTCPeerConnection;
|
||||
}
|
||||
|
||||
public getMicrophoneTransceiver(): FakeRTCTransceiver {
|
||||
return this.transceivers[0];
|
||||
}
|
||||
|
||||
public fireConnectionStateChange(state: RTCPeerConnectionState): void {
|
||||
this.connectionState = state;
|
||||
this.dispatchEvent(new Event('connectionstatechange'));
|
||||
}
|
||||
|
||||
public fireIceCandidate(candidate: string | null): void {
|
||||
const event = new Event('icecandidate');
|
||||
Object.assign(event, {
|
||||
candidate: candidate === null ? null : { candidate },
|
||||
});
|
||||
this.dispatchEvent(event);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import type { EnabledProxyConfig } from '../../src/config/schema/common/proxy.js';
|
||||
import {
|
||||
PROXY_URL_SIGN_EXPIRY_SECONDS,
|
||||
resolveEndpointURL,
|
||||
} from '../../src/ha/resolve-endpoint.js';
|
||||
import { homeAssistantGetSignedURLIfNecessary } from '../../src/ha/sign-path.js';
|
||||
import { createProxiedEndpointIfNecessary } from '../../src/ha/web-proxy.js';
|
||||
import { createHASS } from '../test-utils.js';
|
||||
|
||||
vi.mock('../../src/ha/sign-path.js');
|
||||
vi.mock('../../src/ha/web-proxy.js');
|
||||
|
||||
const createEnabledProxyConfig = (
|
||||
config: Partial<EnabledProxyConfig> = {},
|
||||
): EnabledProxyConfig => ({
|
||||
ssl_verification: true,
|
||||
ssl_ciphers: 'default',
|
||||
dynamic: true,
|
||||
enabled: true,
|
||||
...config,
|
||||
});
|
||||
|
||||
// @vitest-environment jsdom
|
||||
describe('resolveEndpointURL', () => {
|
||||
beforeEach(() => {
|
||||
vi.mocked(createProxiedEndpointIfNecessary).mockImplementation(
|
||||
async (_hass, endpoint) => endpoint,
|
||||
);
|
||||
vi.mocked(homeAssistantGetSignedURLIfNecessary).mockImplementation(
|
||||
async (_hass, endpoint) => endpoint.endpoint,
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('should resolve an absolute endpoint', async () => {
|
||||
expect(
|
||||
await resolveEndpointURL(createHASS(), {
|
||||
endpoint: 'http://go2rtc/api/ws',
|
||||
sign: false,
|
||||
}),
|
||||
).toEqual({ success: true, url: 'http://go2rtc/api/ws' });
|
||||
});
|
||||
|
||||
it('should make a relative endpoint absolute before using it', async () => {
|
||||
// Proxy registration and signing both reject a relative URL.
|
||||
await resolveEndpointURL(createHASS(), { endpoint: '/api/ws', sign: true });
|
||||
|
||||
expect(homeAssistantGetSignedURLIfNecessary).toHaveBeenCalledWith(
|
||||
expect.anything(),
|
||||
expect.objectContaining({
|
||||
endpoint: new URL('/api/ws', document.baseURI).toString(),
|
||||
}),
|
||||
PROXY_URL_SIGN_EXPIRY_SECONDS,
|
||||
);
|
||||
});
|
||||
|
||||
it('should not proxy when proxying is disabled', async () => {
|
||||
await resolveEndpointURL(
|
||||
createHASS(),
|
||||
{ endpoint: 'http://go2rtc/api/ws', sign: false },
|
||||
{ proxyConfig: createEnabledProxyConfig({ enabled: false }) },
|
||||
);
|
||||
|
||||
expect(createProxiedEndpointIfNecessary).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should proxy when proxying is enabled', async () => {
|
||||
await resolveEndpointURL(
|
||||
createHASS(),
|
||||
{ endpoint: 'http://go2rtc/api/ws', sign: false },
|
||||
{
|
||||
proxyConfig: createEnabledProxyConfig(),
|
||||
proxyEndpointOptions: { websocket: true },
|
||||
},
|
||||
);
|
||||
|
||||
expect(createProxiedEndpointIfNecessary).toHaveBeenCalledWith(
|
||||
expect.anything(),
|
||||
// Signing is applied afterwards, to whatever the proxy returns.
|
||||
{ endpoint: 'http://go2rtc/api/ws', sign: false },
|
||||
expect.objectContaining({ enabled: true }),
|
||||
{ ttl: PROXY_URL_SIGN_EXPIRY_SECONDS, openLimit: 0, websocket: true },
|
||||
);
|
||||
});
|
||||
|
||||
it('should sign whatever the proxy returned', async () => {
|
||||
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue({
|
||||
endpoint: 'http://ha/api/hass_web_proxy/v0/ws?url=go2rtc',
|
||||
sign: true,
|
||||
});
|
||||
|
||||
expect(
|
||||
await resolveEndpointURL(
|
||||
createHASS(),
|
||||
{ endpoint: 'http://go2rtc/api/ws', sign: false },
|
||||
{ proxyConfig: createEnabledProxyConfig() },
|
||||
),
|
||||
).toEqual({
|
||||
success: true,
|
||||
url: 'http://ha/api/hass_web_proxy/v0/ws?url=go2rtc',
|
||||
});
|
||||
});
|
||||
|
||||
it('should report a proxy that is unavailable', async () => {
|
||||
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(null);
|
||||
|
||||
expect(
|
||||
await resolveEndpointURL(
|
||||
createHASS(),
|
||||
{ endpoint: 'http://go2rtc/api/ws', sign: false },
|
||||
{ proxyConfig: createEnabledProxyConfig() },
|
||||
),
|
||||
).toEqual({ success: false, error: 'proxy' });
|
||||
});
|
||||
|
||||
it('should report a proxy that throws', async () => {
|
||||
vi.mocked(createProxiedEndpointIfNecessary).mockRejectedValue(new Error('nope'));
|
||||
|
||||
expect(
|
||||
await resolveEndpointURL(
|
||||
createHASS(),
|
||||
{ endpoint: 'http://go2rtc/api/ws', sign: false },
|
||||
{ proxyConfig: createEnabledProxyConfig() },
|
||||
),
|
||||
).toEqual({ success: false, error: 'proxy' });
|
||||
});
|
||||
|
||||
it('should report signing that fails', async () => {
|
||||
vi.mocked(homeAssistantGetSignedURLIfNecessary).mockResolvedValue(null);
|
||||
|
||||
expect(
|
||||
await resolveEndpointURL(createHASS(), { endpoint: '/api/ws', sign: true }),
|
||||
).toEqual({ success: false, error: 'sign' });
|
||||
});
|
||||
|
||||
it('should report signing that throws', async () => {
|
||||
vi.mocked(homeAssistantGetSignedURLIfNecessary).mockRejectedValue(new Error('nope'));
|
||||
|
||||
expect(
|
||||
await resolveEndpointURL(createHASS(), { endpoint: '/api/ws', sign: true }),
|
||||
).toEqual({ success: false, error: 'sign' });
|
||||
});
|
||||
});
|
||||
@@ -2,7 +2,6 @@ import { describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import {
|
||||
addAudioTracksMuteStateListener,
|
||||
has2WayAudio,
|
||||
hasAudio,
|
||||
mayHaveAudio,
|
||||
type AudioProperties,
|
||||
@@ -176,76 +175,6 @@ describe('hasAudio', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('has2WayAudio', () => {
|
||||
const createMockTransceiver = (
|
||||
trackKind: string | null,
|
||||
direction: RTCRtpTransceiverDirection,
|
||||
): RTCRtpTransceiver => {
|
||||
return {
|
||||
sender: {
|
||||
track: trackKind ? { kind: trackKind } : null,
|
||||
},
|
||||
direction,
|
||||
} as unknown as RTCRtpTransceiver;
|
||||
};
|
||||
|
||||
const createMockPeerConnection = (
|
||||
transceivers: RTCRtpTransceiver[],
|
||||
): RTCPeerConnection => {
|
||||
return {
|
||||
getTransceivers: () => transceivers,
|
||||
} as unknown as RTCPeerConnection;
|
||||
};
|
||||
|
||||
it('should return false for null peer connection', () => {
|
||||
expect(has2WayAudio(null)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false when no transceivers', () => {
|
||||
const pc = createMockPeerConnection([]);
|
||||
expect(has2WayAudio(pc)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true when audio transceiver is sendonly', () => {
|
||||
const pc = createMockPeerConnection([createMockTransceiver('audio', 'sendonly')]);
|
||||
expect(has2WayAudio(pc)).toBe(true);
|
||||
});
|
||||
|
||||
it('should return true when audio transceiver is sendrecv', () => {
|
||||
const pc = createMockPeerConnection([createMockTransceiver('audio', 'sendrecv')]);
|
||||
expect(has2WayAudio(pc)).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false when audio transceiver is recvonly', () => {
|
||||
const pc = createMockPeerConnection([createMockTransceiver('audio', 'recvonly')]);
|
||||
expect(has2WayAudio(pc)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false when audio transceiver is inactive', () => {
|
||||
const pc = createMockPeerConnection([createMockTransceiver('audio', 'inactive')]);
|
||||
expect(has2WayAudio(pc)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false when only video transceiver with sendonly', () => {
|
||||
const pc = createMockPeerConnection([createMockTransceiver('video', 'sendonly')]);
|
||||
expect(has2WayAudio(pc)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false when transceiver has no track', () => {
|
||||
const pc = createMockPeerConnection([createMockTransceiver(null, 'sendonly')]);
|
||||
expect(has2WayAudio(pc)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true when mixed transceivers include sendonly audio', () => {
|
||||
const pc = createMockPeerConnection([
|
||||
createMockTransceiver('video', 'recvonly'),
|
||||
createMockTransceiver('audio', 'recvonly'),
|
||||
createMockTransceiver('audio', 'sendonly'),
|
||||
]);
|
||||
expect(has2WayAudio(pc)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('addAudioTracksMuteStateListener', () => {
|
||||
interface MockTrack {
|
||||
kind: string;
|
||||
|
||||
@@ -18,6 +18,7 @@ import {
|
||||
generateFloatApproximatelyEqualsCustomizer,
|
||||
getChildrenFromElement,
|
||||
getDurationString,
|
||||
getErrorDescription,
|
||||
ignoreFunctionIdentity,
|
||||
isHoverableDevice,
|
||||
isHTMLElement,
|
||||
@@ -104,6 +105,26 @@ describe('contentsChanged', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('getErrorDescription', () => {
|
||||
it('should prefer the message', () => {
|
||||
expect(getErrorDescription(new Error('the peer connection is closed'))).toBe(
|
||||
'the peer connection is closed',
|
||||
);
|
||||
});
|
||||
|
||||
it('should fall back to the name when there is no message', () => {
|
||||
expect(getErrorDescription({ name: 'InvalidStateError' })).toBe('InvalidStateError');
|
||||
});
|
||||
|
||||
it('should return null when there is neither', () => {
|
||||
expect(getErrorDescription({})).toBeNull();
|
||||
});
|
||||
|
||||
it('should return null for a value that is not error-like', () => {
|
||||
expect(getErrorDescription('a bare string')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('errorToConsole', () => {
|
||||
const spy = vi.spyOn(global.console, 'warn').mockImplementation(() => true);
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import * as go2rtcAudio from '../../src/camera-manager/utils/go2rtc/audio';
|
||||
import * as go2rtcAudio from '../../src/go2rtc/audio';
|
||||
import {
|
||||
getResolvedLiveProvider,
|
||||
isGo2RTCLiveProvider,
|
||||
@@ -9,7 +9,7 @@ import {
|
||||
import { createCameraConfig } from '../config/test-utils';
|
||||
import { createHASS } from '../test-utils';
|
||||
|
||||
vi.mock('../../src/camera-manager/utils/go2rtc/audio');
|
||||
vi.mock('../../src/go2rtc/audio');
|
||||
|
||||
describe('live-provider utils', () => {
|
||||
beforeEach(() => {
|
||||
|
||||
Reference in New Issue
Block a user