rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/manifest/__tests__/period.test.ts

@@ -27,7 +27,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if no adaptation is given", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -47,13 +47,19 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
     expect(errorReceived.message).toContain("No supported audio and video tracks.");
     expect(adaptationSpy).not.toHaveBeenCalled();
   });
 
   it("should throw if no audio nor video adaptation is given", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -74,7 +80,7 @@ describe("Manifest - Period", () => {
     let period = null;
     let errorReceived = null;
     try {
-      period = new Period(args as any);
+      period = new Period(args);
     } catch (e) {
       errorReceived = e;
     }
@@ -82,8 +88,14 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
+    expect((errorReceived as { type? : string }).type).toBe("MEDIA_ERROR");
     expect(errorReceived.message).toContain("No supported audio and video tracks.");
 
     expect(adaptationSpy).toHaveBeenCalledTimes(2);
@@ -92,7 +104,7 @@ describe("Manifest - Period", () => {
   });
 
   it("should throw if only empty audio and/or video adaptations is given", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -112,15 +124,21 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
+    expect((errorReceived as { type? : string }).type).toBe("MEDIA_ERROR");
     expect(errorReceived.message).toContain("No supported audio and video tracks.");
 
     expect(adaptationSpy).toHaveBeenCalledTimes(0);
   });
 
   it("should throw if we are left with no audio representation", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -155,7 +173,7 @@ describe("Manifest - Period", () => {
     let period = null;
     let errorReceived = null;
     try {
-      period = new Period(args as any);
+      period = new Period(args);
     } catch (e) {
       errorReceived = e;
     }
@@ -163,13 +181,19 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
+    expect((errorReceived as { type? : string }).type).toBe("MEDIA_ERROR");
     expect(errorReceived.message).toContain("No supported audio adaptations");
   });
 
   it("should throw if no audio Adaptation is supported", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -204,7 +228,7 @@ describe("Manifest - Period", () => {
     let period = null;
     let errorReceived = null;
     try {
-      period = new Period(args as any);
+      period = new Period(args);
     } catch (e) {
       errorReceived = e;
     }
@@ -212,13 +236,19 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
+    expect((errorReceived as { type? : string }).type).toBe("MEDIA_ERROR");
     expect(errorReceived.message).toContain("No supported audio adaptations");
   });
 
   it("should throw if we are left with no video representation", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -253,7 +283,7 @@ describe("Manifest - Period", () => {
     let period = null;
     let errorReceived = null;
     try {
-      period = new Period(args as any);
+      period = new Period(args);
     } catch (e) {
       errorReceived = e;
     }
@@ -261,13 +291,19 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
+    expect((errorReceived as { type? : string }).type).toBe("MEDIA_ERROR");
     expect(errorReceived.message).toContain("No supported video adaptation");
   });
 
   it("should throw if no video adaptation is supported", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -302,7 +338,7 @@ describe("Manifest - Period", () => {
     let period = null;
     let errorReceived = null;
     try {
-      period = new Period(args as any);
+      period = new Period(args);
     } catch (e) {
       errorReceived = e;
     }
@@ -310,19 +346,20 @@ describe("Manifest - Period", () => {
     expect(period).toBe(null);
     expect(errorReceived).not.toBe(null);
     expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived.code).toBe("MANIFEST_PARSE_ERROR");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
+
+    // Impossible check to shut-up TypeScript
+    if (!(errorReceived instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+
+    expect((errorReceived as { code? : string }).code).toBe("MANIFEST_PARSE_ERROR");
+    expect((errorReceived as { type? : string }).type).toBe("MEDIA_ERROR");
     expect(errorReceived.message).toContain("No supported video adaptation");
   });
 
   it("should set a parsing error if an unsupported adaptation is given", () => {
-    const { MediaError } = require("../../errors");
-
     const adaptationSpy = jest.fn(arg => {
-      if (arg.type === "bar") {
-        throw new MediaError("MANIFEST_UNSUPPORTED_ADAPTATION_TYPE", "");
-      }
-      return { ...arg, parsingErrors: [] };
+      return { ...arg };
     });
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
@@ -337,76 +374,29 @@ describe("Manifest - Period", () => {
                         isSupported: true,
                         representations: [{}] };
     const video = [videoAda1];
-    const barAda1 = { type: "bar",
-                      id: "55",
-                      isSupported: true,
-                      representations: [{}] };
-    const bar = [barAda1];
-    const args = { id: "12", adaptations: { bar, video }, start: 0 };
-    const period = new Period(args as any);
-    expect(period.adaptations).toEqual({
-      video: video.map(v => ({ ...v, parsingErrors: [] })),
-    });
-    expect(period.parsingErrors).toHaveLength(1);
+    const videoAda2 = { type: "video",
+                        id: "55",
+                        isSupported: false,
+                        representations: [{}] };
+    const video2 = [videoAda2];
+    const args = { id: "12", adaptations: { video, video2 }, start: 0 };
+    const period = new Period(args);
+    expect(period.contentWarnings).toHaveLength(1);
 
     expect(adaptationSpy).toHaveBeenCalledTimes(2);
-    expect(adaptationSpy).toHaveReturnedTimes(1);
+    expect(adaptationSpy).toHaveReturnedTimes(2);
     expect(adaptationSpy).toHaveBeenCalledWith(videoAda1, {});
-    expect(adaptationSpy).toHaveBeenCalledWith(barAda1, {});
+    expect(adaptationSpy).toHaveBeenCalledWith(videoAda2, {});
     expect(adaptationSpy).toHaveReturnedWith(period.adaptations.video[0]);
 
-    const [error] = period.parsingErrors;
+    const [error] = period.contentWarnings;
     expect(error).toBeInstanceOf(Error);
-    expect(error.code).toBe("MANIFEST_UNSUPPORTED_ADAPTATION_TYPE");
+    expect(error.code).toBe("MANIFEST_INCOMPATIBLE_CODECS_ERROR");
     expect(error.type).toBe("MEDIA_ERROR");
   });
 
-  /* eslint-disable max-len */
-  it("should throw if the adaptation throws for another reason than an unsupported type", () => {
-  /* eslint-enable max-len */
-    const { MediaError } = require("../../errors");
-    const adaptationSpy = jest.fn(arg => {
-      if (arg.type === "bar") {
-        throw new MediaError("MEDIA_ERR_UNKNOWN", "");
-      }
-      return { ...arg, parsingErrors: [] };
-    });
-    jest.mock("../adaptation", () => ({
-      __esModule: true as const,
-      default: adaptationSpy,
-    }));
-
-    const Period = require("../period").default;
-
-    const videoAda1 = { type: "video",
-                        id: "55",
-                        isSupported: true,
-                        representations: [{}] };
-    const video = [videoAda1];
-    const barAda1 = { type: "bar",
-                      id: "55",
-                      isSupported: true,
-                      representations: [{}] };
-    const bar = [barAda1];
-    const args = { id: "12", adaptations: { bar, video }, start: 0 };
-    let period = null;
-    let errorReceived = null;
-    try {
-      period = new Period(args as any);
-    } catch (e) {
-      errorReceived = e;
-    }
-
-    expect(period).toBe(null);
-    expect(errorReceived).not.toBe(null);
-    expect(errorReceived).toBeInstanceOf(Error);
-    expect(errorReceived).toBeInstanceOf(MediaError);
-    expect(errorReceived.code).toBe("MEDIA_ERR_UNKNOWN");
-    expect(errorReceived.type).toBe("MEDIA_ERROR");
-  });
-
   it("should not set a parsing error if an empty unsupported adaptation is given", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -422,18 +412,18 @@ describe("Manifest - Period", () => {
     const video = [videoAda1];
     const bar = undefined;
     const args = { id: "12", adaptations: { bar, video }, start: 0 };
-    const period = new Period(args as any);
+    const period = new Period(args);
     expect(period.adaptations).toEqual({
-      video: video.map(v => ({ ...v, parsingErrors: [] })),
+      video: video.map(v => ({ ...v, contentWarnings: [] })),
     });
-    expect(period.parsingErrors).toHaveLength(0);
+    expect(period.contentWarnings).toHaveLength(0);
 
     expect(adaptationSpy).toHaveBeenCalledTimes(1);
     expect(adaptationSpy).toHaveBeenCalledWith(videoAda1, {});
   });
 
   it("should give a representationFilter to the adaptation", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     const representationFilter = jest.fn();
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
@@ -452,9 +442,9 @@ describe("Manifest - Period", () => {
                         representations: [{}] };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 0 };
-    const period = new Period(args as any, representationFilter);
+    const period = new Period(args, representationFilter);
 
-    expect(period.parsingErrors).toHaveLength(0);
+    expect(period.contentWarnings).toHaveLength(0);
     expect(period.adaptations.video).toHaveLength(2);
 
     expect(adaptationSpy).toHaveBeenCalledTimes(2);
@@ -463,8 +453,8 @@ describe("Manifest - Period", () => {
     expect(representationFilter).not.toHaveBeenCalled();
   });
 
-  it("should combine parsing errors from the Period and from the Adaptations", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [arg.id] }));
+  it("should add contentWarnings if Adaptations are not supported", () => {
+    const adaptationSpy = jest.fn(arg => ({ ...arg }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -474,7 +464,7 @@ describe("Manifest - Period", () => {
     const Period = require("../period").default;
     const videoAda1 = { type: "video",
                         id: "54",
-                        isSupported: true,
+                        isSupported: false,
                         representations: [{}] };
     const videoAda2 = { type: "video",
                         id: "55",
@@ -482,20 +472,54 @@ describe("Manifest - Period", () => {
                         representations: [{}] };
     const fooAda1 = { type: "foo",
                       id: "12",
-                      isSupported: true,
+                      isSupported: false,
                       representations: [{}] };
     const video = [videoAda1, videoAda2];
     const foo = [fooAda1];
     const args = { id: "12", adaptations: { video, foo }, start: 0 };
-    const period = new Period(args as any);
+    const period = new Period(args);
+
+    expect(period.contentWarnings).toHaveLength(2);
+    const error = period.contentWarnings[0];
+    expect(error.code).toEqual("MANIFEST_INCOMPATIBLE_CODECS_ERROR");
+    expect(error.type).toEqual("MEDIA_ERROR");
+
+    const error2 = period.contentWarnings[1];
+    expect(error2.code).toEqual("MANIFEST_INCOMPATIBLE_CODECS_ERROR");
+    expect(error2.type).toEqual("MEDIA_ERROR");
+  });
+
+  it("should not add contentWarnings if an Adaptation has no Representation", () => {
+    const adaptationSpy = jest.fn(arg => ({ ...arg }));
+    jest.mock("../adaptation", () => ({
+      __esModule: true as const,
+      default: adaptationSpy,
+      SUPPORTED_ADAPTATIONS_TYPE: ["audio", "video", "text", "image"],
+    }));
+
+    const Period = require("../period").default;
+    const videoAda1 = { type: "video",
+                        id: "54",
+                        isSupported: false,
+                        representations: [] };
+    const videoAda2 = { type: "video",
+                        id: "55",
+                        isSupported: true,
+                        representations: [{}] };
+    const fooAda1 = { type: "foo",
+                      id: "12",
+                      isSupported: false,
+                      representations: [] };
+    const video = [videoAda1, videoAda2];
+    const foo = [fooAda1];
+    const args = { id: "12", adaptations: { video, foo }, start: 0 };
+    const period = new Period(args);
 
-    expect(period.parsingErrors).toHaveLength(3);
-    expect(period.parsingErrors).toContain("54");
-    expect(period.parsingErrors).toContain("55");
+    expect(period.contentWarnings).toHaveLength(0);
   });
 
   it("should set the given start", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -513,14 +537,14 @@ describe("Manifest - Period", () => {
                         representations: [{}] };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 72 };
-    const period = new Period(args as any);
+    const period = new Period(args);
     expect(period.start).toEqual(72);
     expect(period.duration).toEqual(undefined);
     expect(period.end).toEqual(undefined);
   });
 
   it("should set a given duration", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -538,14 +562,14 @@ describe("Manifest - Period", () => {
                         representations: [{}] };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 0, duration: 12 };
-    const period = new Period(args as any);
+    const period = new Period(args);
     expect(period.start).toEqual(0);
     expect(period.duration).toEqual(12);
     expect(period.end).toEqual(12);
   });
 
   it("should infer the end from the start and the duration", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -563,14 +587,14 @@ describe("Manifest - Period", () => {
                         representations: [{}] };
     const video = [videoAda1, videoAda2];
     const args = { id: "12", adaptations: { video }, start: 50, duration: 12 };
-    const period = new Period(args as any);
+    const period = new Period(args);
     expect(period.start).toEqual(50);
     expect(period.duration).toEqual(12);
     expect(period.end).toEqual(62);
   });
 
   it("should return every Adaptations combined with `getAdaptations`", () => {
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -595,7 +619,7 @@ describe("Manifest - Period", () => {
     const audio = [audioAda1];
 
     const args = { id: "12", adaptations: { video, audio }, start: 50, duration: 12 };
-    const period = new Period(args as any);
+    const period = new Period(args);
 
     expect(period.getAdaptations()).toHaveLength(3);
     expect(period.getAdaptations()).toContain(period.adaptations.video[0]);
@@ -606,7 +630,7 @@ describe("Manifest - Period", () => {
   /* eslint-disable max-len */
   it("should return every Adaptations from a given type with `getAdaptationsForType`", () => {
   /* eslint-enable max-len */
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -631,7 +655,7 @@ describe("Manifest - Period", () => {
     const audio = [audioAda1];
 
     const args = { id: "12", adaptations: { video, audio }, start: 50, duration: 12 };
-    const period = new Period(args as any);
+    const period = new Period(args);
 
     expect(period.getAdaptationsForType("video")).toHaveLength(2);
     expect(period.getAdaptationsForType("video"))
@@ -649,7 +673,7 @@ describe("Manifest - Period", () => {
   /* eslint-disable max-len */
   it("should return the first Adaptations with a given Id when calling `getAdaptation`", () => {
   /* eslint-enable max-len */
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,
@@ -678,7 +702,7 @@ describe("Manifest - Period", () => {
     const audio = [audioAda1];
 
     const args = { id: "12", adaptations: { video, audio }, start: 50, duration: 12 };
-    const period = new Period(args as any);
+    const period = new Period(args);
 
     expect(period.getAdaptation("54")).toEqual(period.adaptations.video[0]);
     expect(period.getAdaptation("55")).toEqual(period.adaptations.video[1]);
@@ -688,7 +712,7 @@ describe("Manifest - Period", () => {
   /* eslint-disable max-len */
   it("should return undefind if no adaptation has the given Id when calling `getAdaptation`", () => {
   /* eslint-enable max-len */
-    const adaptationSpy = jest.fn(arg => ({ ...arg, parsingErrors: [] }));
+    const adaptationSpy = jest.fn(arg => ({ ...arg, contentWarnings: [] }));
     jest.mock("../adaptation", () => ({
       __esModule: true as const,
       default: adaptationSpy,