Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
11.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {transitionVoiceEngineV2} from '@fluxer/voice_engine_v2/src/core/reducer';
import {
	availableVoiceEngineV2Capabilities,
	createVoiceEngineV2InitialSnapshot,
	type VoiceEngineV2OperationStatus,
	type VoiceEngineV2Snapshot,
} from '@fluxer/voice_engine_v2/src/core/state';
import type {VoiceEngineV2Command} from '@fluxer/voice_engine_v2/src/protocol/commands';
import type {VoiceEngineV2Event} from '@fluxer/voice_engine_v2/src/protocol/events';
import type {
	VoiceEngineV2AudioControls,
	VoiceEngineV2Error,
	VoiceEngineV2NativeCaptureOptions,
} from '@fluxer/voice_engine_v2/src/protocol/types';
import {describe, expect, it} from 'vitest';

const captureOptions: VoiceEngineV2NativeCaptureOptions = {
	captureId: 'capture-main',
	source: {id: 'display-1', kind: 'screen', title: 'Display 1', width: 1920, height: 1080, displayId: 'display-1'},
	width: 1920,
	height: 1080,
	frameRate: 60,
	includeCursor: true,
	includeAudio: false,
	zeroCopyRequired: true,
};
const captureError: VoiceEngineV2Error = {code: 'implementationError', message: 'Capture stopped unexpectedly'};
const previousError: VoiceEngineV2Error = {code: 'implementationError', message: 'Previous capture failed'};

function replay(events: ReadonlyArray<VoiceEngineV2Event>): VoiceEngineV2Snapshot {
	let snapshot = createVoiceEngineV2InitialSnapshot(availableVoiceEngineV2Capabilities());
	for (const event of events) {
		snapshot = transitionVoiceEngineV2(snapshot, event).snapshot;
	}
	return snapshot;
}

interface NativeCompletionCase {
	name: string;
	before: Array<VoiceEngineV2Event>;
	event: VoiceEngineV2Event;
	expectedStatus: VoiceEngineV2OperationStatus;
	expectedOperationError: VoiceEngineV2Error | null;
	expectedOperationIds: Record<string, number>;
	expectedFailure: VoiceEngineV2Error | null;
	expectedLastFailure: VoiceEngineV2Error | null;
	sameSnapshot: boolean;
}

const nativeCases: Array<NativeCompletionCase> = [
	{
		name: 'matching completion succeeds',
		before: [],
		event: {type: 'nativeCapture.started', captureId: 'capture-main', operationId: 1},
		expectedStatus: 'succeeded',
		expectedOperationError: null,
		expectedOperationIds: {},
		expectedFailure: null,
		expectedLastFailure: null,
		sameSnapshot: false,
	},
	{
		name: 'matching failure records the operation error',
		before: [],
		event: {type: 'nativeCapture.failed', captureId: 'capture-main', operationId: 1, error: captureError},
		expectedStatus: 'failed',
		expectedOperationError: captureError,
		expectedOperationIds: {},
		expectedFailure: captureError,
		expectedLastFailure: captureError,
		sameSnapshot: false,
	},
	{
		name: 'stale completion leaves the active operation pending',
		before: [],
		event: {type: 'nativeCapture.started', captureId: 'capture-main', operationId: 2},
		expectedStatus: 'queued',
		expectedOperationError: null,
		expectedOperationIds: {'capture-main': 1},
		expectedFailure: null,
		expectedLastFailure: null,
		sameSnapshot: true,
	},
	{
		name: 'stale failure cannot replace current state',
		before: [],
		event: {type: 'nativeCapture.failed', captureId: 'capture-main', operationId: 2, error: captureError},
		expectedStatus: 'queued',
		expectedOperationError: null,
		expectedOperationIds: {'capture-main': 1},
		expectedFailure: null,
		expectedLastFailure: null,
		sameSnapshot: true,
	},
	{
		name: 'unsolicited failure preserves the pending operation',
		before: [],
		event: {type: 'nativeCapture.failed', captureId: 'capture-main', operationId: null, error: captureError},
		expectedStatus: 'queued',
		expectedOperationError: null,
		expectedOperationIds: {'capture-main': 1},
		expectedFailure: captureError,
		expectedLastFailure: captureError,
		sameSnapshot: false,
	},
	{
		name: 'successful completion retains the previous failure history',
		before: [{type: 'nativeCapture.failed', captureId: 'previous-capture', operationId: null, error: previousError}],
		event: {type: 'nativeCapture.started', captureId: 'capture-main', operationId: 1},
		expectedStatus: 'succeeded',
		expectedOperationError: null,
		expectedOperationIds: {},
		expectedFailure: null,
		expectedLastFailure: previousError,
		sameSnapshot: false,
	},
];

interface DeafenCase {
	name: string;
	before: Array<VoiceEngineV2Event>;
	deafened: boolean;
	expectedControls: VoiceEngineV2AudioControls;
	expectedEnabled: boolean;
	expectedSpeaking: boolean | null;
	expectedCommands: Array<VoiceEngineV2Command>;
}

const deafenCases: Array<DeafenCase> = [
	{
		name: 'deafening an unmuted microphone remembers unmute',
		before: [],
		deafened: true,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: true,
			preferredLocallyMuted: false,
			locallyDeafened: true,
			mutedByPermission: false,
			hasUserSetMute: false,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: true,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: false,
		expectedSpeaking: false,
		expectedCommands: [{type: 'microphone.setEnabled', operationId: 3, enabled: false}],
	},
	{
		name: 'undeafening restores the remembered unmute',
		before: [
			{type: 'localAudio.deafenRequested', deafened: true},
			{type: 'microphone.setEnabledSucceeded', operationId: 3},
		],
		deafened: false,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: false,
			preferredLocallyMuted: false,
			locallyDeafened: false,
			mutedByPermission: false,
			hasUserSetMute: false,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: true,
		expectedSpeaking: null,
		expectedCommands: [{type: 'microphone.setEnabled', operationId: 4, enabled: true}],
	},
	{
		name: 'deafening a user-muted microphone preserves mute',
		before: [
			{type: 'localAudio.muteRequested', muted: true},
			{type: 'microphone.setEnabledSucceeded', operationId: 3},
		],
		deafened: true,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: true,
			preferredLocallyMuted: true,
			locallyDeafened: true,
			mutedByPermission: false,
			hasUserSetMute: true,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: false,
		expectedSpeaking: false,
		expectedCommands: [],
	},
	{
		name: 'undeafening does not undo a user mute',
		before: [
			{type: 'localAudio.muteRequested', muted: true},
			{type: 'microphone.setEnabledSucceeded', operationId: 3},
			{type: 'localAudio.deafenRequested', deafened: true},
		],
		deafened: false,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: true,
			preferredLocallyMuted: true,
			locallyDeafened: false,
			mutedByPermission: false,
			hasUserSetMute: true,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: false,
		expectedSpeaking: false,
		expectedCommands: [],
	},
	{
		name: 'deafening a permission-muted microphone preserves permission mute',
		before: [
			{type: 'permissions.result', operationId: null, result: {name: 'microphone', status: 'denied', canPrompt: false}},
			{type: 'microphone.setEnabledSucceeded', operationId: 3},
		],
		deafened: true,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: true,
			preferredLocallyMuted: false,
			locallyDeafened: true,
			mutedByPermission: true,
			hasUserSetMute: false,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: false,
		expectedSpeaking: false,
		expectedCommands: [],
	},
	{
		name: 'undeafening does not bypass a denied permission',
		before: [
			{type: 'permissions.result', operationId: null, result: {name: 'microphone', status: 'denied', canPrompt: false}},
			{type: 'microphone.setEnabledSucceeded', operationId: 3},
			{type: 'localAudio.deafenRequested', deafened: true},
		],
		deafened: false,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: true,
			preferredLocallyMuted: false,
			locallyDeafened: false,
			mutedByPermission: true,
			hasUserSetMute: false,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: false,
		expectedSpeaking: false,
		expectedCommands: [],
	},
	{
		name: 'permission denial while deafened vetoes remembered unmute',
		before: [
			{type: 'localAudio.deafenRequested', deafened: true},
			{type: 'microphone.setEnabledSucceeded', operationId: 3},
			{type: 'permissions.result', operationId: null, result: {name: 'microphone', status: 'denied', canPrompt: false}},
		],
		deafened: false,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: true,
			preferredLocallyMuted: false,
			locallyDeafened: false,
			mutedByPermission: true,
			hasUserSetMute: false,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: false,
		expectedSpeaking: false,
		expectedCommands: [],
	},
	{
		name: 'undeafening an already unmuted microphone emits no command',
		before: [],
		deafened: false,
		expectedControls: {
			mode: 'voiceActivity',
			locallyMuted: false,
			preferredLocallyMuted: false,
			locallyDeafened: false,
			mutedByPermission: false,
			hasUserSetMute: false,
			hasUserSetDeaf: true,
			shouldUnmuteOnUndeafen: false,
			pushToTalkActive: false,
			pushToMuteActive: false,
			inputVolume: 1,
			outputVolume: 1,
		},
		expectedEnabled: true,
		expectedSpeaking: null,
		expectedCommands: [],
	},
];

describe('voice engine native completion and local deafen transitions', () => {
	it.each(nativeCases)('$name', (row) => {
		const snapshot = replay([...row.before, {type: 'nativeCapture.startRequested', options: captureOptions}]);
		const saved = structuredClone(snapshot);
		const result = transitionVoiceEngineV2(snapshot, row.event);

		expect(result.commands).toEqual([]);
		expect(result.snapshot.operations['1']).toEqual({
			operationId: 1,
			resourceKey: 'nativeCapture',
			commandType: 'nativeCapture.start',
			status: row.expectedStatus,
			error: row.expectedOperationError,
		});
		expect(result.snapshot.nativeCapture.operationIds).toEqual(row.expectedOperationIds);
		expect(result.snapshot.nativeCapture.captures).toEqual({'capture-main': captureOptions});
		expect(result.snapshot.nativeCapture.captures['capture-main']).toBe(captureOptions);
		expect(result.snapshot.nativeCapture.failure).toBe(row.expectedFailure);
		expect(result.snapshot.lastFailure).toBe(row.expectedLastFailure);
		expect(result.snapshot === snapshot).toBe(row.sameSnapshot);
		expect(result.snapshot.nextOperationId).toBe(2);
		expect(snapshot).toEqual(saved);
	});

	it.each(deafenCases)('$name', (row) => {
		const snapshot = replay([
			{type: 'connection.connectRequested', options: {url: 'wss://voice.example', token: 'voice-token'}},
			{type: 'connection.connectSucceeded', operationId: 1},
			{type: 'microphone.publishRequested', options: {deviceId: 'mic-a'}},
			{type: 'microphone.publishSucceeded', operationId: 2},
			...row.before,
		]);
		const saved = structuredClone(snapshot);
		const result = transitionVoiceEngineV2(snapshot, {type: 'localAudio.deafenRequested', deafened: row.deafened});

		expect(result.commands).toEqual(row.expectedCommands);
		expect(result.snapshot.audioControls).toEqual(row.expectedControls);
		expect(result.snapshot.microphone.enabled).toBe(row.expectedEnabled);
		expect(result.snapshot.microphone.localSpeakingOverride).toBe(row.expectedSpeaking);
		expect(result.snapshot.microphone.status).toBe('published');
		expect(result.snapshot.microphone.published).toEqual({deviceId: 'mic-a'});
		expect(result.snapshot.connection.status).toBe('connected');
		expect(snapshot).toEqual(saved);
	});
});