chore: Enforce a few house rules via eslint (#2539)

tests/card-controller/fullscreen/screenfull/index.test.ts

@@ -1,7 +1,7 @@
 import screenfull from 'screenfull';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { ScreenfullFullScreenProvider } from '../../../../src/card-controller/fullscreen/screenfull';
-import { createCardAPI, setScreenfulEnabled } from '../../../test-utils';
+import { createCardAPI, flushPromises, setScreenfulEnabled } from '../../../test-utils';
 
 vi.mock('screenfull', () => ({
   default: {
@@ -21,6 +21,11 @@ const setScreenfulFullscreen = (fullscreen: boolean): void => {
 
 // @vitest-environment jsdom
 describe('ScreenfullFullScreenProvider', () => {
+  beforeEach(() => {
+    vi.mocked(screenfull.request).mockResolvedValue();
+    vi.mocked(screenfull.exit).mockResolvedValue();
+  });
+
   afterEach(() => {
     vi.restoreAllMocks();
   });
@@ -158,5 +163,30 @@ describe('ScreenfullFullScreenProvider', () => {
       expect(screenfull.request).not.toBeCalled();
       expect(screenfull.exit).not.toBeCalled();
     });
+
+    it('should swallow a rejected fullscreen request', async () => {
+      setScreenfulEnabled(true);
+      const api = createCardAPI();
+      const element = document.createElement('div');
+      vi.mocked(api.getCardElementManager().getElement).mockReturnValue(element);
+      vi.mocked(screenfull.request).mockRejectedValue(new Error('denied'));
+      const provider = new ScreenfullFullScreenProvider(api, vi.fn());
+
+      provider.setFullscreen(true);
+      await flushPromises();
+
+      expect(screenfull.request).toBeCalledWith(element);
+    });
+
+    it('should swallow a rejected fullscreen exit', async () => {
+      setScreenfulEnabled(true);
+      vi.mocked(screenfull.exit).mockRejectedValue(new Error('not in fullscreen'));
+      const provider = new ScreenfullFullScreenProvider(createCardAPI(), vi.fn());
+
+      provider.setFullscreen(false);
+      await flushPromises();
+
+      expect(screenfull.exit).toBeCalled();
+    });
   });
 });

tests/card-controller/fullscreen/webkit/index.test.ts

@@ -3,7 +3,11 @@ import { mock } from 'vitest-mock-extended';
 import { WebkitFullScreenProvider } from '../../../../src/card-controller/fullscreen/webkit';
 import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
 import { MediaPlayerController, WebkitHTMLVideoElement } from '../../../../src/types';
-import { createCardAPI, createMediaLoadedInfo } from '../../../test-utils';
+import {
+  createCardAPI,
+  createMediaLoadedInfo,
+  flushPromises,
+} from '../../../test-utils';
 
 const createWebkitVideoElement = (): HTMLVideoElement &
   Partial<WebkitHTMLVideoElement> => {
@@ -242,7 +246,7 @@ describe('WebkitFullScreenProvider', () => {
     provider.connect();
 
     const element = createWebkitVideoElement();
-    element.play = vi.fn();
+    element.play = vi.fn().mockResolvedValue(undefined);
 
     const mediaPlayerController = createMediaPlayerController(element);
     vi.mocked(api.getMediaLoadedInfoManager().get).mockReturnValue(
@@ -263,4 +267,30 @@ describe('WebkitFullScreenProvider', () => {
 
     expect(element.play).toBeCalled();
   });
+
+  it('should swallow a rejected video replay after fullscreen ends', async () => {
+    const api = createCardAPI();
+    const stateManager = new ConditionStateManager();
+    vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
+
+    const provider = new WebkitFullScreenProvider(api, vi.fn());
+    provider.connect();
+
+    const element = createWebkitVideoElement();
+    element.play = vi.fn().mockRejectedValue(new Error('denied'));
+
+    const mediaPlayerController = createMediaPlayerController(element);
+    vi.mocked(api.getMediaLoadedInfoManager().get).mockReturnValue(
+      createMediaLoadedInfo({ mediaPlayerController }),
+    );
+    stateManager.setState({
+      mediaLoadedInfo: createMediaLoadedInfo({ mediaPlayerController }),
+    });
+
+    element.dispatchEvent(new Event('webkitendfullscreen'));
+    vi.runOnlyPendingTimers();
+    await flushPromises();
+
+    expect(element.play).toBeCalled();
+  });
 });