Dermot Duffy
3b77b11196
Refactors media player handling entirely to make the code more consistent and less boilerplate. Add testing for media player actions. - Closes #1921 - Closes #1916
705 lines
22 KiB
TypeScript
705 lines
22 KiB
TypeScript
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import { mock } from 'vitest-mock-extended';
|
|
import { MicrophoneState } from '../../src/card-controller/types';
|
|
import {
|
|
MediaActionsController,
|
|
MediaActionsControllerOptions,
|
|
} from '../../src/components-lib/media-actions-controller';
|
|
import { MediaPlayerController, MediaPlayerElement } from '../../src/types';
|
|
import {
|
|
IntersectionObserverMock,
|
|
MutationObserverMock,
|
|
callIntersectionHandler,
|
|
callMutationHandler,
|
|
createParent,
|
|
flushPromises,
|
|
} from '../test-utils';
|
|
import { callVisibilityHandler, createTestSlideNodes } from '../utils/embla/test-utils';
|
|
|
|
const getPlayer = (
|
|
element: HTMLElement,
|
|
selector: string,
|
|
): MediaPlayerElement | null => {
|
|
return element.querySelector(selector);
|
|
};
|
|
|
|
const createPlayerElement = (controller?: MediaPlayerController): MediaPlayerElement => {
|
|
const player = document.createElement('video');
|
|
player['getMediaPlayerController'] = vi
|
|
.fn()
|
|
.mockResolvedValue(controller ?? mock<MediaPlayerController>());
|
|
return player as unknown as MediaPlayerElement;
|
|
};
|
|
|
|
const createPlayerSlideNodes = (n = 10): HTMLElement[] => {
|
|
const divs = createTestSlideNodes({ n: n });
|
|
for (const div of divs) {
|
|
div.appendChild(createPlayerElement());
|
|
}
|
|
return divs;
|
|
};
|
|
|
|
// @vitest-environment jsdom
|
|
describe('MediaActionsController', () => {
|
|
beforeAll(() => {
|
|
vi.stubGlobal('IntersectionObserver', IntersectionObserverMock);
|
|
vi.stubGlobal('MutationObserver', MutationObserverMock);
|
|
});
|
|
|
|
afterAll(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
describe('should set root', () => {
|
|
it('should have root', async () => {
|
|
const controller = new MediaActionsController();
|
|
|
|
controller.setRoot(createParent());
|
|
|
|
expect(controller.hasRoot()).toBeTruthy();
|
|
});
|
|
|
|
it('should do nothing without options', async () => {
|
|
const controller = new MediaActionsController();
|
|
|
|
const children = createPlayerSlideNodes();
|
|
const parent = createParent({ children: children });
|
|
|
|
controller.setRoot(parent);
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).not.toBeCalled();
|
|
});
|
|
|
|
it('should do nothing on resetting same root', () => {
|
|
const controller = new MediaActionsController();
|
|
const parent = createParent({ children: createPlayerSlideNodes() });
|
|
|
|
expect(controller.setRoot(parent)).toBeTruthy();
|
|
expect(controller.setRoot(parent)).toBeFalsy();
|
|
});
|
|
|
|
it('should re-setRoot after mutation', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
autoPlayConditions: ['selected' as const],
|
|
});
|
|
|
|
const parent = createParent({ children: createPlayerSlideNodes(1) });
|
|
controller.setRoot(parent);
|
|
|
|
const mediaPlayerController = mock<MediaPlayerController>();
|
|
|
|
const newPlayer = createPlayerElement(mediaPlayerController);
|
|
const newChild = document.createElement('div');
|
|
newChild.appendChild(newPlayer);
|
|
parent.append(newChild);
|
|
|
|
await callMutationHandler();
|
|
|
|
await controller.setTarget(1, true);
|
|
|
|
expect(mediaPlayerController.play).toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('should destroy', () => {
|
|
it('should do nothing after destroy', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
autoPlayConditions: ['selected' as const],
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
const parent = createParent({ children: children });
|
|
controller.setRoot(parent);
|
|
|
|
controller.destroy();
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).not.toBeCalled();
|
|
});
|
|
});
|
|
|
|
describe('should respond to setting target', () => {
|
|
it.each([
|
|
['should play', { autoPlayConditions: ['selected' as const] }, 'play', true],
|
|
['should not play', { autoPlayConditions: [] }, 'play', false],
|
|
['should unmute', { autoUnmuteConditions: ['selected' as const] }, 'unmute', true],
|
|
['should not unmute', { autoUnmuteConditions: [] }, 'unmute', false],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_: string,
|
|
options: Partial<MediaActionsControllerOptions>,
|
|
func: string,
|
|
called: boolean,
|
|
) => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
...options,
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).toBeCalledTimes(called ? 1 : 0);
|
|
},
|
|
);
|
|
|
|
it('should not reselect previously selected target', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPlayConditions: ['selected' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(1);
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(1);
|
|
});
|
|
|
|
it('should unselect before selecting a new target', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPauseConditions: ['unselected' as const],
|
|
autoMuteConditions: ['unselected' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
await controller.setTarget(1, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.pause,
|
|
).toBeCalled();
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.mute,
|
|
).toBeCalled();
|
|
});
|
|
|
|
it('should select after target was previously visible', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPlayConditions: ['selected' as const],
|
|
autoUnmuteConditions: ['selected' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, false);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).not.toBeCalled();
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).not.toBeCalled();
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalled();
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalled();
|
|
});
|
|
});
|
|
|
|
it('should take no action after target unset', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPlayConditions: ['selected' as const, 'visible' as const],
|
|
autoUnmuteConditions: ['selected' as const, 'visible' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(1);
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalledTimes(1);
|
|
|
|
controller.unsetTarget();
|
|
|
|
getPlayer(children[0], 'video')?.dispatchEvent(
|
|
new Event('advanced-camera-card:media:loaded'),
|
|
);
|
|
await flushPromises();
|
|
|
|
// Play/Mute will not have been called again.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(1);
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalledTimes(1);
|
|
});
|
|
|
|
describe('should respond to media loaded', () => {
|
|
it('should play after media load', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPlayConditions: ['selected' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(1);
|
|
|
|
getPlayer(children[0], 'video')?.dispatchEvent(
|
|
new Event('advanced-camera-card:media:loaded'),
|
|
);
|
|
|
|
await flushPromises();
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(2);
|
|
});
|
|
|
|
it('should unmute after media load', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoUnmuteConditions: ['selected' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalledTimes(1);
|
|
|
|
getPlayer(children[0], 'video')?.dispatchEvent(
|
|
new Event('advanced-camera-card:media:loaded'),
|
|
);
|
|
|
|
await flushPromises();
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalledTimes(2);
|
|
});
|
|
|
|
it('should take no action on unrelated media load', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPlayConditions: ['selected' as const, 'visible' as const],
|
|
autoUnmuteConditions: ['selected' as const, 'visible' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
getPlayer(children[9], 'video')?.dispatchEvent(
|
|
new Event('advanced-camera-card:media:loaded'),
|
|
);
|
|
|
|
await flushPromises();
|
|
|
|
expect(
|
|
(await getPlayer(children[9], 'video')?.getMediaPlayerController())?.play,
|
|
).not.toBeCalled();
|
|
expect(
|
|
(await getPlayer(children[9], 'video')?.getMediaPlayerController())?.unmute,
|
|
).not.toBeCalled();
|
|
});
|
|
|
|
it('should play and unmute on unselected but targeted media load', async () => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
autoPlayConditions: ['visible' as const],
|
|
autoUnmuteConditions: ['visible' as const],
|
|
playerSelector: 'video',
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, false);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(1);
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalledTimes(1);
|
|
|
|
getPlayer(children[0], 'video')?.dispatchEvent(
|
|
new Event('advanced-camera-card:media:loaded'),
|
|
);
|
|
|
|
await flushPromises();
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.play,
|
|
).toBeCalledTimes(2);
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalledTimes(2);
|
|
});
|
|
});
|
|
|
|
describe('should take action on unselect', () => {
|
|
it.each([
|
|
['should pause', { autoPauseConditions: ['unselected' as const] }, 'pause', true],
|
|
['should not pause', { autoPauseConditions: [] }, 'pause', false],
|
|
['should mute', { autoMuteConditions: ['unselected' as const] }, 'mute', true],
|
|
['should not mute', { autoMuteConditions: [] }, 'mute', false],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_: string,
|
|
options: Partial<MediaActionsControllerOptions>,
|
|
func: string,
|
|
called: boolean,
|
|
) => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
...options,
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
await controller.setTarget(0, false);
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).toBeCalledTimes(called ? 1 : 0);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should take action on page being visible', () => {
|
|
it.each([
|
|
['should play', { autoPlayConditions: ['visible' as const] }, 'play', true],
|
|
['should not play', { autoPlayConditions: [] }, 'play', false],
|
|
['should unmute', { autoUnmuteConditions: ['visible' as const] }, 'unmute', true],
|
|
['should not unmute', { autoUnmuteConditions: [] }, 'unmute', false],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_: string,
|
|
options: Partial<MediaActionsControllerOptions>,
|
|
func: string,
|
|
called: boolean,
|
|
) => {
|
|
vi.spyOn(global.document, 'addEventListener');
|
|
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
...options,
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
await controller.setTarget(0, true);
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).not.toBeCalled();
|
|
|
|
Object.defineProperty(document, 'visibilityState', {
|
|
value: 'visible',
|
|
writable: true,
|
|
});
|
|
await callVisibilityHandler();
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).toBeCalledTimes(called ? 1 : 0);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should take action on page being hiddne', () => {
|
|
beforeAll(() => {
|
|
vi.spyOn(global.document, 'addEventListener');
|
|
});
|
|
|
|
it.each([
|
|
['should pause', { autoPauseConditions: ['hidden' as const] }, 'pause', true],
|
|
['should not pause', { autoPauseConditions: [] }, 'pause', false],
|
|
['should mute', { autoMuteConditions: ['hidden' as const] }, 'mute', true],
|
|
['should not mute', { autoMuteConditions: [] }, 'mute', false],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_: string,
|
|
options: Partial<MediaActionsControllerOptions>,
|
|
func: string,
|
|
called: boolean,
|
|
) => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
...options,
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
await controller.setTarget(0, true);
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).not.toBeCalled();
|
|
|
|
Object.defineProperty(document, 'visibilityState', {
|
|
value: 'hidden',
|
|
writable: true,
|
|
});
|
|
await callVisibilityHandler();
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).toBeCalledTimes(called ? 1 : 0);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should take action on page intersecting with viewport', () => {
|
|
it.each([
|
|
['should play', { autoPlayConditions: ['visible' as const] }, 'play', true],
|
|
['should not play', { autoPlayConditions: [] }, 'play', false],
|
|
['should unmute', { autoUnmuteConditions: ['visible' as const] }, 'unmute', true],
|
|
['should not unmute', { autoUnmuteConditions: [] }, 'unmute', false],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_: string,
|
|
options: Partial<MediaActionsControllerOptions>,
|
|
func: string,
|
|
called: boolean,
|
|
) => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
...options,
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
await controller.setTarget(0, true);
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).not.toBeCalled();
|
|
|
|
// There's always a first call to an intersection observer handler. In
|
|
// this case the MediaActionsController ignores it.
|
|
await callIntersectionHandler(false);
|
|
|
|
await callIntersectionHandler(true);
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).toBeCalledTimes(called ? 1 : 0);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should take action on page not intersecting with viewport', () => {
|
|
it.each([
|
|
['should play', { autoPlayConditions: ['visible' as const] }, 'play', true],
|
|
['should not play', { autoPlayConditions: [] }, 'play', false],
|
|
['should unmute', { autoUnmuteConditions: ['visible' as const] }, 'unmute', true],
|
|
['should not unmute', { autoUnmuteConditions: [] }, 'unmute', false],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_: string,
|
|
options: Partial<MediaActionsControllerOptions>,
|
|
func: string,
|
|
called: boolean,
|
|
) => {
|
|
const controller = new MediaActionsController();
|
|
controller.setOptions({
|
|
playerSelector: 'video',
|
|
...options,
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
await controller.setTarget(0, true);
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).not.toBeCalled();
|
|
|
|
// There's always a first call to an intersection observer handler. In
|
|
// this case the MediaActionsController ignores it.
|
|
await callIntersectionHandler(false);
|
|
|
|
await callIntersectionHandler(true);
|
|
|
|
// Not configured to take action on selection.
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.[func],
|
|
).toBeCalledTimes(called ? 1 : 0);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should take action on microphone state changes', () => {
|
|
beforeAll(() => {
|
|
vi.useFakeTimers();
|
|
});
|
|
|
|
afterAll(() => {
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
const createMicrophoneState = (
|
|
state?: Partial<MicrophoneState>,
|
|
): MicrophoneState => {
|
|
return {
|
|
muted: true,
|
|
forbidden: false,
|
|
connected: false,
|
|
...state,
|
|
};
|
|
};
|
|
|
|
it('should unmute when microphone unmuted', async () => {
|
|
const controller = new MediaActionsController();
|
|
|
|
controller.setOptions({
|
|
autoUnmuteConditions: ['microphone' as const],
|
|
playerSelector: 'video',
|
|
microphoneState: createMicrophoneState({ muted: true }),
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
controller.setOptions({
|
|
autoUnmuteConditions: ['microphone' as const],
|
|
playerSelector: 'video',
|
|
microphoneState: createMicrophoneState({ muted: false }),
|
|
});
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.unmute,
|
|
).toBeCalled();
|
|
});
|
|
|
|
it('should mute after delay after microphone muted', async () => {
|
|
const controller = new MediaActionsController();
|
|
|
|
controller.setOptions({
|
|
autoMuteConditions: ['microphone' as const],
|
|
playerSelector: 'video',
|
|
microphoneState: createMicrophoneState({ muted: false }),
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
controller.setOptions({
|
|
autoMuteConditions: ['microphone' as const],
|
|
playerSelector: 'video',
|
|
microphoneState: createMicrophoneState({ muted: true }),
|
|
});
|
|
|
|
vi.runOnlyPendingTimers();
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.mute,
|
|
).toBeCalled();
|
|
});
|
|
|
|
it('should not mute after delay after microphone muted', async () => {
|
|
const controller = new MediaActionsController();
|
|
|
|
controller.setOptions({
|
|
autoMuteConditions: [],
|
|
playerSelector: 'video',
|
|
microphoneState: createMicrophoneState({ muted: false }),
|
|
});
|
|
|
|
const children = createPlayerSlideNodes();
|
|
controller.setRoot(createParent({ children: children }));
|
|
|
|
await controller.setTarget(0, true);
|
|
|
|
controller.setOptions({
|
|
autoMuteConditions: ['microphone' as const],
|
|
playerSelector: 'video',
|
|
microphoneState: createMicrophoneState({ muted: true }),
|
|
});
|
|
|
|
vi.runOnlyPendingTimers();
|
|
|
|
expect(
|
|
(await getPlayer(children[0], 'video')?.getMediaPlayerController())?.mute,
|
|
).not.toBeCalled();
|
|
});
|
|
});
|
|
});
|