rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/compat/__tests__/clear_element_src.test.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-var-requires */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
@@ -29,14 +28,10 @@ describe("Compat - clearElementSrc", () => {
   });
 
   it("should empty the src and remove the Attribute for a given Element", () => {
-    const fakeElement : any = {
+    const fakeElement = {
       src: "foo",
       removeAttribute() { return null; },
     };
-    jest.mock("../browser_detection.ts", () => ({
-      __esModule: true as const,
-      isFirefox: false,
-    }));
     const clearElementSrc = require("../clear_element_src").default;
 
     const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
@@ -47,14 +42,10 @@ describe("Compat - clearElementSrc", () => {
   });
 
   it("should throw if failed to remove the Attribute for a given Element", () => {
-    const fakeElement : any = {
+    const fakeElement = {
       src: "foo",
       removeAttribute() { throw new Error("Oups, can't remove attribute."); },
     };
-    jest.mock("../browser_detection.ts", () => ({
-      __esModule: true as const,
-      isFirefox: false,
-    }));
     const clearElementSrc = require("../clear_element_src").default;
     const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
 
@@ -64,8 +55,8 @@ describe("Compat - clearElementSrc", () => {
     expect(spyRemoveAttribute).toHaveBeenCalledTimes(1);
   });
 
-  it("should disable text tracks and remove childs if on firefox", () => {
-    const fakeElement : any = {
+  it("should disable text tracks and remove childs", () => {
+    const fakeElement = {
       src: "foo",
       removeAttribute() { return null; },
       textTracks: [
@@ -80,15 +71,11 @@ describe("Compat - clearElementSrc", () => {
       hasChildNodes: () => true,
       removeChild: (node: { nodeName: string }) => {
         const { childNodes } = fakeElement;
-        const idx = arrayFindIndex(childNodes, (n: any) => n.nodeName === node.nodeName);
+        const idx = arrayFindIndex(childNodes, (n) => n.nodeName === node.nodeName);
         childNodes.splice(idx, 1);
       },
     };
 
-    jest.mock("../browser_detection.ts", () => ({
-      __esModule: true as const,
-      isFirefox: true,
-    }));
     const clearElementSrc = require("../clear_element_src").default;
 
     const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
@@ -108,8 +95,8 @@ describe("Compat - clearElementSrc", () => {
     expect(spyRemoveChild).toHaveBeenCalledWith({ nodeName: "track" });
   });
 
-  it("should log when failed to remove text track child node if on firefox", () => {
-    const fakeElement : any = {
+  it("should log when failed to remove text track child node", () => {
+    const fakeElement = {
       src: "foo",
       removeAttribute() { return null; },
       textTracks: [
@@ -127,11 +114,6 @@ describe("Compat - clearElementSrc", () => {
       },
     };
 
-    jest.mock("../browser_detection", () => ({
-      __esModule: true as const,
-      isFirefox: true,
-    }));
-
     const mockLogWarn = jest.fn((message) => message);
     jest.mock("../../log", () => ({
       __esModule: true as const,
@@ -163,7 +145,7 @@ describe("Compat - clearElementSrc", () => {
   });
 
   it("should not remove audio child node if on firefox and no text tracks", () => {
-    const fakeElement : any = {
+    const fakeElement = {
       src: "foo",
       removeAttribute() { return null; },
       textTracks: [],
@@ -174,10 +156,6 @@ describe("Compat - clearElementSrc", () => {
       removeChild: () => null,
     };
 
-    jest.mock("../browser_detection.ts", () => ({
-      __esModule: true as const,
-      isFirefox: true,
-    }));
     const clearElementSrc = require("../clear_element_src").default;
 
     const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
@@ -194,8 +172,8 @@ describe("Compat - clearElementSrc", () => {
     expect(spyRemoveChild).not.toHaveBeenCalled();
   });
 
-  it("should not handle text tracks nodes is has no child nodes if on firefox", () => {
-    const fakeElement : any = {
+  it("should not handle text tracks nodes is has no child nodes", () => {
+    const fakeElement = {
       src: "foo",
       removeAttribute() { return null; },
       textTracks: [],
@@ -204,10 +182,6 @@ describe("Compat - clearElementSrc", () => {
       removeChild: () => null,
     };
 
-    jest.mock("../browser_detection.ts", () => ({
-      __esModule: true as const,
-      isFirefox: true,
-    }));
     const clearElementSrc = require("../clear_element_src").default;
 
     const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
@@ -223,4 +197,56 @@ describe("Compat - clearElementSrc", () => {
     expect(spyHasChildNodes).toHaveBeenCalledTimes(1);
     expect(spyRemoveChild).not.toHaveBeenCalled();
   });
+
+  it("should not throw if the textTracks attribute is `null`", () => {
+    const fakeElement = {
+      src: "foo",
+      removeAttribute() { return null; },
+      textTracks: null,
+      childNodes: [],
+      hasChildNodes: () => false,
+      removeChild: () => null,
+    };
+
+    const clearElementSrc = require("../clear_element_src").default;
+
+    const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
+    const spyHasChildNodes = jest.spyOn(fakeElement, "hasChildNodes");
+    const spyRemoveChild = jest.spyOn(fakeElement, "removeChild");
+
+    clearElementSrc(fakeElement);
+
+    expect(fakeElement.src).toBe("");
+    expect(fakeElement.childNodes).toEqual([]);
+    expect(spyRemoveAttribute).toHaveBeenCalledTimes(1);
+    expect(spyRemoveAttribute).toHaveBeenCalledWith("src");
+    expect(spyHasChildNodes).toHaveBeenCalledTimes(0);
+    expect(spyRemoveChild).not.toHaveBeenCalled();
+  });
+
+  it("should not throw if the textTracks attribute is `undefined`", () => {
+    const fakeElement = {
+      src: "foo",
+      removeAttribute() { return null; },
+      textTracks: undefined,
+      childNodes: [],
+      hasChildNodes: () => false,
+      removeChild: () => null,
+    };
+
+    const clearElementSrc = require("../clear_element_src").default;
+
+    const spyRemoveAttribute = jest.spyOn(fakeElement, "removeAttribute");
+    const spyHasChildNodes = jest.spyOn(fakeElement, "hasChildNodes");
+    const spyRemoveChild = jest.spyOn(fakeElement, "removeChild");
+
+    clearElementSrc(fakeElement);
+
+    expect(fakeElement.src).toBe("");
+    expect(fakeElement.childNodes).toEqual([]);
+    expect(spyRemoveAttribute).toHaveBeenCalledTimes(1);
+    expect(spyRemoveAttribute).toHaveBeenCalledWith("src");
+    expect(spyHasChildNodes).toHaveBeenCalledTimes(0);
+    expect(spyRemoveChild).not.toHaveBeenCalled();
+  });
 });

package/src/compat/__tests__/fullscreen.test.ts

@@ -21,251 +21,266 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
+interface IFakeDocument {
+  createElement(eltType: string) : HTMLElement;
+  fullscreenElement? : Element | null | undefined;
+  mozCancelFullScreen? : (() => void) | undefined;
+  mozFullScreenElement? : HTMLElement | undefined;
+  msExitFullscreen? : (() => void) | undefined;
+  exitFullscreen? : (() => void) | undefined;
+  msFullscreenElement? : Element | null | undefined;
+  webkitExitFullscreen : () => void;
+  webkitFullscreenElement : Element | null | undefined;
+  webkitHidden? : boolean | undefined;
+}
+
+const doc = document as unknown as IFakeDocument;
+
 describe("compat - isFullScreen", () => {
   beforeEach(() => {
     jest.resetModules();
   });
 
   it("should return false when is not fullscreen", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origmozFullScreenElement = (document as any).mozFullScreenElement;
-    const origWebkitFullscreenElement = (document as any).webkitFullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origmozFullScreenElement = doc.mozFullScreenElement;
+    const origWebkitFullscreenElement = doc.webkitFullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
 
-    (document as any).fullscreenElement = undefined;
-    (document as any).mozFullScreenElement = undefined;
-    (document as any).webkitFullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
+    doc.fullscreenElement = undefined;
+    doc.mozFullScreenElement = undefined;
+    doc.webkitFullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
 
     const { isFullscreen } = require("../fullscreen");
     expect(isFullscreen()).toBe(false);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).mozFullScreenElement = origmozFullScreenElement;
-    (document as any).webkitFullscreenElement = origWebkitFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.mozFullScreenElement = origmozFullScreenElement;
+    doc.webkitFullscreenElement = origWebkitFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
   });
 
   it("should return true when is fullscreen", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origmozFullScreenElement = (document as any).mozFullScreenElement;
-    const origWebkitFullscreenElement = (document as any).webkitFullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origmozFullScreenElement = doc.mozFullScreenElement;
+    const origWebkitFullscreenElement = doc.webkitFullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
 
-    (document as any).fullscreenElement = document.createElement("video");
-    (document as any).mozFullScreenElement = undefined;
-    (document as any).webkitFullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
+    doc.fullscreenElement = doc.createElement("video");
+    doc.mozFullScreenElement = undefined;
+    doc.webkitFullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
 
     const { isFullscreen } = require("../fullscreen");
     expect(isFullscreen()).toBe(true);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).mozFullScreenElement = origmozFullScreenElement;
-    (document as any).webkitFullscreenElement = origWebkitFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.mozFullScreenElement = origmozFullScreenElement;
+    doc.webkitFullscreenElement = origWebkitFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
   });
 });
 
 describe("compat - requestFullscreen", () => {
   it("should request full screen with requestFullscreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    (document as any).fullscreenElement = undefined;
+    const origFullscreenElement = doc.fullscreenElement;
+    doc.fullscreenElement = undefined;
 
     const { requestFullscreen } = require("../fullscreen");
-    const videoElt = document.createElement("video");
+    const videoElt = doc.createElement("video");
     const mockRequestFullscreen = jest.fn(() =>
-      (document as any).fullscreenElement = videoElt);
+      doc.fullscreenElement = videoElt);
     const fakeElement = {
       requestFullscreen: mockRequestFullscreen,
     };
 
     requestFullscreen(fakeElement);
-    expect((document as any).fullscreenElement).toBe(videoElt);
+    expect(doc.fullscreenElement).toBe(videoElt);
 
-    (document as any).fullscreenElement = origFullscreenElement;
+    doc.fullscreenElement = origFullscreenElement;
   });
 
   it("should request full screen with msRequestFullscreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
 
-    (document as any).fullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
+    doc.fullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
 
     const { requestFullscreen } = require("../fullscreen");
-    const videoElt = document.createElement("video");
+    const videoElt = doc.createElement("video");
     const mockRequestFullscreen =
-      jest.fn(() => (document as any).msFullscreenElement = videoElt);
+      jest.fn(() => doc.msFullscreenElement = videoElt);
     const fakeElement = {
       msRequestFullscreen: mockRequestFullscreen,
     };
 
     requestFullscreen(fakeElement);
-    expect((document as any).msFullscreenElement).toBe(videoElt);
+    expect(doc.msFullscreenElement).toBe(videoElt);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
   });
 
   it("should request full screen with mozRequestFullScreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
-    const origmozFullScreenElement = (document as any).mozFullScreenElement;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
+    const origmozFullScreenElement = doc.mozFullScreenElement;
 
-    (document as any).fullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
-    (document as any).mozFullScreenElement = undefined;
+    doc.fullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
+    doc.mozFullScreenElement = undefined;
 
     const { requestFullscreen } = require("../fullscreen");
-    const videoElt = document.createElement("video");
+    const videoElt = doc.createElement("video");
     const mockRequestFullscreen =
-      jest.fn(() => (document as any).mozFullScreenElement = videoElt);
+      jest.fn(() => doc.mozFullScreenElement = videoElt);
     const fakeElement = {
       mozRequestFullScreen: mockRequestFullscreen,
     };
 
     requestFullscreen(fakeElement);
-    expect((document as any).mozFullScreenElement).toBe(videoElt);
+    expect(doc.mozFullScreenElement).toBe(videoElt);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
-    (document as any).mozFullScreenElement = origmozFullScreenElement;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
+    doc.mozFullScreenElement = origmozFullScreenElement;
   });
 
   it("should request full screen with webkitRequestFullscreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
-    const origmozFullScreenElement = (document as any).mozFullScreenElement;
-    const origWebkitFullscreenElement = (document as any).webkitFullscreenElement;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
+    const origmozFullScreenElement = doc.mozFullScreenElement;
+    const origWebkitFullscreenElement = doc.webkitFullscreenElement;
 
-    (document as any).fullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
-    (document as any).mozFullScreenElement = undefined;
-    (document as any).webkitFullscreenElement = undefined;
+    doc.fullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
+    doc.mozFullScreenElement = undefined;
+    doc.webkitFullscreenElement = undefined;
 
     const { requestFullscreen } = require("../fullscreen");
-    const videoElt = document.createElement("video");
+    const videoElt = doc.createElement("video");
     const mockRequestFullscreen =
-      jest.fn(() => (document as any).webkitFullscreenElement = videoElt);
+      jest.fn(() => doc.webkitFullscreenElement = videoElt);
     const fakeElement = {
       webkitRequestFullscreen: mockRequestFullscreen,
     };
 
     requestFullscreen(fakeElement);
-    expect((document as any).webkitFullscreenElement).toBe(videoElt);
+    expect(doc.webkitFullscreenElement).toBe(videoElt);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
-    (document as any).mozFullScreenElement = origmozFullScreenElement;
-    (document as any).webkitFullscreenElement = origWebkitFullscreenElement;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
+    doc.mozFullScreenElement = origmozFullScreenElement;
+    doc.webkitFullscreenElement = origWebkitFullscreenElement;
   });
 });
 
 describe("compat - exitFullScreen", () => {
   it("should exit full screen with exitFullscreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origExitFullscreen = (document as any).exitFullscreen;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origExitFullscreen = doc.exitFullscreen;
 
-    (document as any).fullscreenElement = document.createElement("video");
-    (document as any).exitFullscreen = jest.fn(() => {
-      (document as any).fullscreenElement = undefined;
+    doc.fullscreenElement = doc.createElement("video");
+    doc.exitFullscreen = jest.fn(() => {
+      doc.fullscreenElement = undefined;
     });
 
     const { exitFullscreen } = require("../fullscreen");
 
     exitFullscreen();
-    expect((document as any).fullscreenElement).toBe(undefined);
+    expect(doc.fullscreenElement).toBe(undefined);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).exitFullscreen = origExitFullscreen;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.exitFullscreen = origExitFullscreen;
   });
 
   it("should exit full screen with msExitFullscreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
-    const origExitFullscreen = (document as any).exitFullscreen;
-    const origMsExitFullscreen = (document as any).msExitFullscreen;
-
-    (document as any).fullscreenElement = undefined;
-    (document as any).msFullscreenElement = document.createElement("video");
-    (document as any).exitFullscreen = undefined;
-    (document as any).msExitFullscreen = jest.fn(() => {
-      (document as any).msFullscreenElement = undefined;
+    const origFullscreenElement = doc.fullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
+    const origExitFullscreen = doc.exitFullscreen;
+    const origMsExitFullscreen = doc.msExitFullscreen;
+
+    doc.fullscreenElement = undefined;
+    doc.msFullscreenElement = doc.createElement("video");
+    doc.exitFullscreen = undefined;
+    doc.msExitFullscreen = jest.fn(() => {
+      doc.msFullscreenElement = undefined;
     });
 
     const { exitFullscreen } = require("../fullscreen");
 
     exitFullscreen();
-    expect((document as any).msFullscreenElement).toBe(undefined);
+    expect(doc.msFullscreenElement).toBe(undefined);
 
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
-    (document as any).exitFullscreen = origExitFullscreen;
-    (document as any).msExitFullscreen = origMsExitFullscreen;
+    doc.fullscreenElement = origFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
+    doc.exitFullscreen = origExitFullscreen;
+    doc.msExitFullscreen = origMsExitFullscreen;
   });
 
   it("should exit full screen with mozCancelFullScreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
-    const origmozFullScreenElement = (document as any).mozFullScreenElement;
-    const origExitFullscreen = (document as any).exitFullscreen;
-    const origMsExitFullscreen = (document as any).msExitFullscreen;
-    const origmozCancelFullScreen = (document as any).mozCancelFullScreen;
-
-    (document as any).fullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
-    (document as any).mozFullScreenElement = document.createElement("video");
-    (document as any).exitFullscreen = undefined;
-    (document as any).msExitFullscreen = undefined;
-    (document as any).mozCancelFullScreen = jest.fn(() =>
-      (document as any).mozFullScreenElement = undefined);
+    const origFullscreenElement = doc.fullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
+    const origmozFullScreenElement = doc.mozFullScreenElement;
+    const origExitFullscreen = doc.exitFullscreen;
+    const origMsExitFullscreen = doc.msExitFullscreen;
+    const origmozCancelFullScreen = doc.mozCancelFullScreen;
+
+    doc.fullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
+    doc.mozFullScreenElement = doc.createElement("video");
+    doc.exitFullscreen = undefined;
+    doc.msExitFullscreen = undefined;
+    doc.mozCancelFullScreen = jest.fn(() =>
+      doc.mozFullScreenElement = undefined);
 
     const { exitFullscreen } = require("../fullscreen");
 
     exitFullscreen();
-    expect((document as any).mozFullScreenElement).toBe(undefined);
-
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
-    (document as any).mozFullScreenElement = origmozFullScreenElement;
-    (document as any).exitFullscreen = origExitFullscreen;
-    (document as any).msExitFullscreen = origMsExitFullscreen;
-    (document as any).mozCancelFullScreen = origmozCancelFullScreen;
+    expect(doc.mozFullScreenElement).toBe(undefined);
+
+    doc.fullscreenElement = origFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
+    doc.mozFullScreenElement = origmozFullScreenElement;
+    doc.exitFullscreen = origExitFullscreen;
+    doc.msExitFullscreen = origMsExitFullscreen;
+    doc.mozCancelFullScreen = origmozCancelFullScreen;
   });
 
   it("should exit full screen with webkitExitFullscreen API", () => {
-    const origFullscreenElement = (document as any).fullscreenElement;
-    const origMsFullscreenElement = (document as any).msFullscreenElement;
-    const origmozFullScreenElement = (document as any).mozFullScreenElement;
-    const origWebkitFullscreenElement = (document as any).webkitFullscreenElement;
-    const origExitFullscreen = (document as any).exitFullscreen;
-    const origMsExitFullscreen = (document as any).msExitFullscreen;
-    const origmozCancelFullScreen = (document as any).mozCancelFullScreen;
-    const origwebkitExitFullscreen = (document as any).webkitExitFullscreen;
-
-    (document as any).fullscreenElement = undefined;
-    (document as any).msFullscreenElement = undefined;
-    (document as any).mozFullScreenElement = undefined;
-    (document as any).webkitFullscreenElement = document.createElement("video");
-    (document as any).exitFullscreen = undefined;
-    (document as any).msExitFullscreen = undefined;
-    (document as any).mozCancelFullScreen = undefined;
-    (document as any).webkitExitFullscreen = jest.fn(() =>
-      (document as any).webkitFullscreenElement = undefined);
+    const origFullscreenElement = doc.fullscreenElement;
+    const origMsFullscreenElement = doc.msFullscreenElement;
+    const origmozFullScreenElement = doc.mozFullScreenElement;
+    const origWebkitFullscreenElement = doc.webkitFullscreenElement;
+    const origExitFullscreen = doc.exitFullscreen;
+    const origMsExitFullscreen = doc.msExitFullscreen;
+    const origmozCancelFullScreen = doc.mozCancelFullScreen;
+    const origwebkitExitFullscreen = doc.webkitExitFullscreen;
+
+    doc.fullscreenElement = undefined;
+    doc.msFullscreenElement = undefined;
+    doc.mozFullScreenElement = undefined;
+    doc.webkitFullscreenElement = doc.createElement("video");
+    doc.exitFullscreen = undefined;
+    doc.msExitFullscreen = undefined;
+    doc.mozCancelFullScreen = undefined;
+    doc.webkitExitFullscreen = jest.fn(() =>
+      doc.webkitFullscreenElement = undefined);
 
     const { exitFullscreen } = require("../fullscreen");
 
     exitFullscreen();
-    expect((document as any).webkitFullscreenElement).toBe(undefined);
-
-    (document as any).fullscreenElement = origFullscreenElement;
-    (document as any).msFullscreenElement = origMsFullscreenElement;
-    (document as any).mozFullScreenElement = origmozFullScreenElement;
-    (document as any).webkitFullscreenElement = origWebkitFullscreenElement;
-    (document as any).exitFullscreen = origExitFullscreen;
-    (document as any).msExitFullscreen = origMsExitFullscreen;
-    (document as any).mozCancelFullScreen = origmozCancelFullScreen;
-    (document as any).webkitExitFullscreen = origwebkitExitFullscreen;
+    expect(doc.webkitFullscreenElement).toBe(undefined);
+
+    doc.fullscreenElement = origFullscreenElement;
+    doc.msFullscreenElement = origMsFullscreenElement;
+    doc.mozFullScreenElement = origmozFullScreenElement;
+    doc.webkitFullscreenElement = origWebkitFullscreenElement;
+    doc.exitFullscreen = origExitFullscreen;
+    doc.msExitFullscreen = origMsExitFullscreen;
+    doc.mozCancelFullScreen = origmozCancelFullScreen;
+    doc.webkitExitFullscreen = origwebkitExitFullscreen;
   });
 });

package/src/compat/__tests__/is_offline.test.ts

@@ -21,37 +21,45 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
+interface IFakeNavigator {
+  onLine? : boolean | null;
+}
+interface IFakeWindow {
+  navigator : IFakeNavigator;
+}
+const win = window as IFakeWindow;
+
 // FIXME We cannot mock navigator.onLine easily, sadly
 xdescribe("Compat - isOffline", () => {
   it("should return true if navigator.onLine is `false`", () => {
-    const oldNavigator = window.navigator;
-    (window as any).navigator = { onLine: false };
+    const oldNavigator = win.navigator;
+    win.navigator = { onLine: false };
     const isOffline = require("../is_offline").default;
     expect(isOffline()).toEqual(true);
-    (window as any).navigator = oldNavigator;
+    win.navigator = oldNavigator;
   });
 
   it("should return false if navigator.onLine is `true`", () => {
-    const oldNavigator = window.navigator;
-    (window as any).navigator = { onLine: true };
+    const oldNavigator = win.navigator;
+    win.navigator = { onLine: true };
     const isOffline = require("../is_offline").default;
     expect(isOffline()).toEqual(false);
-    (window as any).navigator = oldNavigator;
+    win.navigator = oldNavigator;
   });
 
   it("should return false if navigator.onLine is `undefined`", () => {
-    const oldNavigator = window.navigator;
-    (window as any).navigator = {};
+    const oldNavigator = win.navigator;
+    win.navigator = {};
     const isOffline = require("../is_offline").default;
     expect(isOffline()).toEqual(false);
-    (window as any).navigator = oldNavigator;
+    win.navigator = oldNavigator;
   });
 
   it("should return false if navigator.onLine is `null`", () => {
-    const oldNavigator = window.navigator;
-    (window as any).navigator = { onLine: null };
+    const oldNavigator = win.navigator;
+    win.navigator = { onLine: null };
     const isOffline = require("../is_offline").default;
     expect(isOffline()).toEqual(false);
-    (window as any).navigator = oldNavigator;
+    win.navigator = oldNavigator;
   });
 });