scorm-again 2.0.0 → 2.2.0

package/test/Scorm2004API.spec.ts

@@ -1,12 +1,15 @@
 import { expect } from "expect";
-import { describe, it, before, after } from "mocha";
+import { after, before, describe, it } from "mocha";
 import * as sinon from "sinon";
 import * as h from "./api_helpers";
 import Pretender from "fetch-pretender";
 import ErrorCodes from "../src/constants/error_codes";
 import Scorm2004API from "../src/Scorm2004API";
 import { scorm2004Values } from "./field_values";
-import { DefaultSettings, RefObject, Settings } from "../src/BaseAPI";
+import APIConstants from "../src/constants/api_constants";
+import { RefObject, Settings } from "../src/types/api_types";
+import { DefaultSettings } from "../src/constants/default_settings";
+import { CMI } from "../src/cmi/scorm2004/cmi";
 
 const scorm2004_error_codes = ErrorCodes.scorm2004;
 
@@ -27,6 +30,9 @@ const apiInitialized = (startingData?: RefObject) => {
 };
 
 describe("SCORM 2004 API Tests", () => {
+  let terminateStub: sinon.SinonStub;
+  let processListenersSpy: sinon.SinonSpy;
+
   before(() => {
     clock = sinon.useFakeTimers();
 
@@ -581,6 +587,158 @@ describe("SCORM 2004 API Tests", () => {
     });
   });
 
+  describe("reset()", () => {
+    it("should reset all CMI values to their default state", () => {
+      const scorm2004API = api();
+      scorm2004API.cmi.learner_id = "student_1";
+      scorm2004API.cmi.session_time = "PT1H0M0S";
+
+      scorm2004API.reset();
+
+      expect(scorm2004API.cmi).toEqual(new CMI());
+    });
+
+    it("should keep original settings", () => {
+      const scorm2004API = api({
+        dataCommitFormat: "flattened",
+        autocommit: true,
+      });
+
+      scorm2004API.reset();
+
+      expect(scorm2004API.settings.sendFullCommit).toEqual(
+        DefaultSettings.sendFullCommit,
+      );
+      expect(scorm2004API.settings.dataCommitFormat).toEqual("flattened");
+      expect(scorm2004API.settings.autocommit).toEqual(true);
+    });
+
+    it("should be able to override original settings", () => {
+      const scorm2004API = api({
+        ...DefaultSettings,
+        dataCommitFormat: "flattened",
+        autocommit: true,
+      });
+
+      scorm2004API.reset({
+        alwaysSendTotalTime: !DefaultSettings.alwaysSendTotalTime,
+      });
+
+      expect(scorm2004API.settings.sendFullCommit).toEqual(
+        DefaultSettings.sendFullCommit,
+      );
+      expect(scorm2004API.settings.dataCommitFormat).toEqual("flattened");
+      expect(scorm2004API.settings.autocommit).toEqual(true);
+      expect(scorm2004API.settings.alwaysSendTotalTime).toEqual(
+        !DefaultSettings.alwaysSendTotalTime,
+      );
+    });
+
+    it("should call commonReset from the superclass", () => {
+      const scorm2004API = api();
+      const commonResetSpy = sinon.spy(scorm2004API, "commonReset");
+
+      scorm2004API.reset();
+
+      expect(commonResetSpy.calledOnce).toBe(true);
+      commonResetSpy.restore();
+    });
+  });
+
+  describe("Scorm2004API.Finish", () => {
+    let scorm2004API = api();
+
+    beforeEach(() => {
+      scorm2004API = api();
+      terminateStub = sinon.stub(scorm2004API, "terminate");
+      processListenersSpy = sinon.spy(scorm2004API, "processListeners");
+    });
+
+    afterEach(() => {
+      terminateStub.restore();
+      processListenersSpy.restore();
+    });
+
+    describe("lmsFinish()", () => {
+      it("should call internalFinish and return SCORM_TRUE", async () => {
+        const internalFinishStub = sinon
+          .stub(scorm2004API, "internalFinish")
+          .resolves(APIConstants.global.SCORM_TRUE);
+        const result = scorm2004API.lmsFinish();
+        expect(result).toEqual(APIConstants.global.SCORM_TRUE);
+        expect(internalFinishStub.calledOnce).toBe(true);
+        internalFinishStub.restore();
+      });
+    });
+
+    describe("internalFinish()", () => {
+      const navActions: { [key: string]: string } = {
+        previous: "SequencePrevious",
+        continue: "SequenceNext",
+        choice: "SequenceChoice",
+        jump: "SequenceJump",
+        "{target=next-sco}choice": "SequenceChoice",
+        exit: "SequenceExit",
+        exitAll: "SequenceExitAll",
+        abandon: "SequenceAbandon",
+        abandonAll: "SequenceAbandonAll",
+      };
+
+      it("should call terminate with 'Terminate' and true", async () => {
+        terminateStub.resolves(APIConstants.global.SCORM_TRUE);
+        await scorm2004API.internalFinish();
+        expect(terminateStub.calledWith("Terminate", true)).toBe(true);
+      });
+
+      for (const navRequest of Object.keys(navActions)) {
+        it(`should process the correct navigation action based on adl.nav.request = ${navRequest}`, async () => {
+          terminateStub.resolves(APIConstants.global.SCORM_TRUE);
+          scorm2004API.adl.nav.request = navRequest;
+          await scorm2004API.internalFinish();
+          expect(processListenersSpy.calledWith(navActions[navRequest])).toBe(
+            true,
+          );
+        });
+      }
+
+      it("should process 'SequenceNext' if adl.nav.request is '_none_' and autoProgress is true", async () => {
+        terminateStub.resolves(APIConstants.global.SCORM_TRUE);
+        scorm2004API.adl.nav.request = "_none_";
+        scorm2004API.settings.autoProgress = true;
+        await scorm2004API.internalFinish();
+        expect(processListenersSpy.calledWith("SequenceNext")).toBe(true);
+      });
+
+      it("should not process any action if adl.nav.request is '_none_' and autoProgress is false", async () => {
+        terminateStub.resolves(APIConstants.global.SCORM_TRUE);
+        scorm2004API.adl.nav.request = "_none_";
+        scorm2004API.settings.autoProgress = false;
+        await scorm2004API.internalFinish();
+        expect(processListenersSpy.called).toBe(false);
+      });
+
+      it("should return the result of terminate", async () => {
+        terminateStub.resolves(APIConstants.global.SCORM_TRUE);
+        const result = await scorm2004API.internalFinish();
+        expect(result).toEqual(APIConstants.global.SCORM_TRUE);
+      });
+    });
+  });
+
+  describe("lmsCommit()", () => {
+    const scorm2004API = api();
+
+    it("should call commit and return SCORM_TRUE", async () => {
+      const commitStub = sinon
+        .stub(scorm2004API, "commit")
+        .resolves(APIConstants.global.SCORM_TRUE);
+      const result = scorm2004API.lmsCommit();
+      expect(result).toEqual(APIConstants.global.SCORM_TRUE);
+      expect(commitStub.calledOnce).toBe(true);
+      commitStub.restore();
+    });
+  });
+
   describe("loadFromFlattenedJSON()", () => {
     it("should load data, even if out of order", () => {
       const scorm2004API = api();
@@ -599,6 +757,8 @@ describe("SCORM 2004 API Tests", () => {
           "cmi.interactions.0.latency": "PT2M30S",
           "cmi.interactions.0.objectives.0.id": "Question14_1",
           "cmi.interactions.0.objectives.0.correct_responses.0.pattern": "CPR",
+          "adl.nav.request": "continue",
+          "adl.nav.request_valid.choice.{target=sco-id}": "true",
         },
         "",
       );
@@ -617,6 +777,351 @@ describe("SCORM 2004 API Tests", () => {
       const cmiExport: RefObject = scorm2004API.renderCommitCMI(true);
       expect(cmiExport.cmi.total_time).toEqual("P1DT12H34M55S");
     });
+
+    it("should return flattened format when dataCommitFormat is 'flattened'", function () {
+      const scorm2004API = api({
+        ...DefaultSettings,
+        dataCommitFormat: "flattened",
+      });
+      const result = scorm2004API.renderCommitCMI(false);
+      expect(result).toBeInstanceOf(Object);
+      expect({}.hasOwnProperty.call(result, "cmi.learner_id")).toBe(true);
+    });
+
+    it("should return params format when dataCommitFormat is 'params'", function () {
+      const scorm2004API = api();
+      scorm2004API.settings.dataCommitFormat = "params";
+      const result = scorm2004API.renderCommitCMI(false);
+      expect(result).toBeInstanceOf(Array);
+      expect(result).toContain("cmi.credit=credit");
+      // Add more specific assertions based on expected params output
+    });
+
+    it("should return JSON format when dataCommitFormat is 'json'", function () {
+      const scorm2004API = api();
+      scorm2004API.settings.dataCommitFormat = "json";
+      const result = scorm2004API.renderCommitCMI(false) as any;
+      expect(result).toBeInstanceOf(Object);
+      expect(result).toHaveProperty("cmi");
+      expect(result.cmi).toBeInstanceOf(Object);
+      expect(result.cmi.credit).toEqual("credit");
+      // Add more specific assertions based on expected JSON output
+    });
+
+    it("should include total_time if terminateCommit is true", function () {
+      const scorm2004API = api();
+      const spy = sinon.spy(scorm2004API.cmi, "getCurrentTotalTime");
+      const cmiExport = scorm2004API.renderCommitCMI(true) as any;
+      expect(spy.calledOnce).toBe(true);
+      expect(cmiExport.cmi.total_time).toEqual(spy.returnValues[0]);
+      spy.restore();
+    });
+
+    it("should not include total_time if terminateCommit is false", function () {
+      const scorm2004API = api();
+      const spy = sinon.spy(scorm2004API.cmi, "getCurrentTotalTime");
+      const cmiExport = scorm2004API.renderCommitCMI(false) as any;
+      expect(spy.called).toBe(false);
+      expect(cmiExport.cmi).not.toHaveProperty("total_time");
+      spy.restore();
+    });
+  });
+
+  describe("renderCommitObject()", () => {
+    it("should render commit object with default settings and no score", () => {
+      const scorm2004API = api();
+      scorm2004API.cmi.completion_status = "incomplete";
+      scorm2004API.cmi.total_time = "P12H34M56S";
+      scorm2004API.cmi.session_time = "P23H59M59S";
+      const commitObject = scorm2004API.renderCommitObject(true);
+      expect(commitObject.successStatus).toEqual("unknown");
+      expect(commitObject.completionStatus).toEqual("incomplete");
+      expect(commitObject.runtimeData.cmi.completion_status).toEqual(
+        "incomplete",
+      );
+      expect(commitObject.totalTimeSeconds).toEqual(
+        12 * 3600 + 34 * 60 + 56 + (23 * 3600 + 59 * 60 + 59),
+      );
+    });
+
+    it("should render commit object with score data", () => {
+      const scorm2004API = api();
+      scorm2004API.cmi.completion_status = "completed";
+      scorm2004API.cmi.score.raw = "85";
+      scorm2004API.cmi.score.min = "0";
+      scorm2004API.cmi.score.max = "100";
+      scorm2004API.cmi.score.scaled = "0.85";
+      const commitObject = scorm2004API.renderCommitObject(true);
+      expect(commitObject.successStatus).toEqual("unknown");
+      expect(commitObject.completionStatus).toEqual("completed");
+      expect(commitObject.runtimeData.cmi.completion_status).toEqual(
+        "completed",
+      );
+      expect(commitObject.runtimeData.cmi.score.raw).toEqual("85");
+      expect(commitObject.runtimeData.cmi.score.min).toEqual("0");
+      expect(commitObject.runtimeData.cmi.score.max).toEqual("100");
+      expect(commitObject.runtimeData.cmi.score.scaled).toEqual("0.85");
+      expect(commitObject.totalTimeSeconds).toEqual(0);
+      expect(commitObject.score).toEqual({
+        raw: 85,
+        min: 0,
+        max: 100,
+        scaled: 0.85,
+      });
+    });
+
+    it("should render commit object with completion and success status", () => {
+      const scorm2004API = api();
+      scorm2004API.cmi.success_status = "passed";
+      const commitObject = scorm2004API.renderCommitObject(true);
+      expect(commitObject.successStatus).toEqual("passed");
+      expect(commitObject.completionStatus).toEqual("unknown");
+      expect(commitObject.runtimeData.cmi.success_status).toEqual("passed");
+    });
+
+    it("should render commit object with failed success status", () => {
+      const scorm2004API = api();
+      scorm2004API.cmi.success_status = "failed";
+      const commitObject = scorm2004API.renderCommitObject(true);
+      expect(commitObject.successStatus).toEqual("failed");
+      expect(commitObject.completionStatus).toEqual("unknown");
+      expect(commitObject.runtimeData.cmi.success_status).toEqual("failed");
+    });
+
+    it("should calculate total time when terminateCommit is true", () => {
+      const scorm2004API = api();
+      scorm2004API.cmi.total_time = "P12H34M56S";
+      scorm2004API.cmi.session_time = "P23H59M59S";
+      const commitObject = scorm2004API.renderCommitObject(true);
+      expect(commitObject.runtimeData.cmi.total_time).toEqual("P1DT12H34M55S");
+    });
+  });
+
+  describe("lmsGetDiagnostic()", () => {
+    it("should return diagnostic information for a given error code", () => {
+      const scorm2004API = api();
+      const errorCode = scorm2004_error_codes.GENERAL;
+      const diagnosticInfo = scorm2004API.lmsGetDiagnostic(errorCode);
+      expect(diagnosticInfo).toEqual(
+        APIConstants.scorm2004.error_descriptions[errorCode].detailMessage,
+      );
+    });
+
+    it("should return an empty string for an unknown error code", () => {
+      const scorm2004API = api();
+      const unknownErrorCode = 9999;
+      const diagnosticInfo = scorm2004API.lmsGetDiagnostic(unknownErrorCode);
+      expect(diagnosticInfo).toEqual("");
+    });
+  });
+
+  describe("lmsGetErrorString()", () => {
+    it("should return the error string for a given error code", () => {
+      const scorm2004API = api();
+      const errorCode = scorm2004_error_codes.GENERAL;
+      const errorString = scorm2004API.lmsGetErrorString(errorCode);
+      expect(errorString).toEqual("General Exception");
+    });
+
+    it("should return an empty string for an unknown error code", () => {
+      const scorm2004API = api();
+      const unknownErrorCode = 9999;
+      const errorString = scorm2004API.lmsGetErrorString(unknownErrorCode);
+      expect(errorString).toEqual("");
+    });
+  });
+
+  describe("replaceWithAnotherScormAPI()", () => {
+    it("should replace the current API with another API", () => {
+      const firstAPI = api();
+      const secondAPI = api();
+
+      firstAPI.cmi.learner_id = "student_1";
+      firstAPI.adl.nav.request = "continue";
+      secondAPI.cmi.learner_id = "student_2";
+      secondAPI.adl.nav.request = "exit";
+
+      firstAPI.replaceWithAnotherScormAPI(secondAPI);
+      expect(firstAPI.cmi.learner_id).toEqual("student_2");
+      expect(firstAPI.adl.nav.request).toEqual("exit");
+    });
+  });
+
+  describe("checkCorrectResponseValue()", () => {
+    it("should properly handle the true-false response type for unknown value", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue("true-false", ["unknown"], "true");
+      expect(scorm2004API.lmsGetLastError()).toEqual(
+        String(scorm2004_error_codes.TYPE_MISMATCH),
+      );
+    });
+
+    it("should properly handle the true-false response type for correct value", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue("true-false", ["true"], "true");
+      expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
+    });
+
+    it("should properly handle the choice response type for value over 4000 characters", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue(
+        "choice",
+        ["x".repeat(4001)],
+        "true",
+      );
+      expect(scorm2004API.lmsGetLastError()).toEqual(
+        String(scorm2004_error_codes.TYPE_MISMATCH),
+      );
+    });
+
+    it("should properly handle the choice response type for correct value", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue("choice", ["true"], "true");
+      expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
+    });
+
+    it("should properly handle the fill-in response type for correct value", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue("fill-in", ["true"], "true");
+      expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
+    });
+
+    it("should properly handle the long-fill-in response type for correct value", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue("long-fill-in", ["true"], "true");
+      expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
+    });
+
+    it("should properly handle the matching response type for correct value", () => {
+      const scorm2004API = new Scorm2004API();
+      scorm2004API.checkCorrectResponseValue(
+        "matching",
+        ["{order_matters=true}0[.]1"],
+        "true",
+      );
+      expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
+    });
+  });
+
+  describe("removeCorrectResponsePrefixes()", () => {
+    it("should remove the prefix from the string", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "{order_matters=true}correctResponse";
+      const result = scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(result).toBe("correctResponse");
+    });
+
+    it("should return the original string if no prefix is present", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "correctResponse";
+      const result = scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(result).toBe("correctResponse");
+    });
+
+    it("should handle empty strings correctly", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "";
+      const result = scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(result).toBe("");
+    });
+
+    it("should handle multiple prefixes correctly", () => {
+      const scorm2004API = new Scorm2004API();
+      const input =
+        "{lang=en}{order_matters=true}{case_matters=false}correctResponse";
+      const result = scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(result).toBe("correctResponse");
+    });
+
+    it("should throw an error for invalid order_matters value", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "{order_matters=invalid}correctResponse";
+      scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(scorm2004API.lmsGetLastError()).toEqual(
+        String(scorm2004_error_codes.TYPE_MISMATCH),
+      );
+    });
+
+    it("should throw an error for invalid case_matters value", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "{case_matters=invalid}correctResponse";
+      scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(scorm2004API.lmsGetLastError()).toEqual(
+        String(scorm2004_error_codes.TYPE_MISMATCH),
+      );
+    });
+
+    it("should ignore an unknown prefix", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "{unknown=true}correctResponse";
+      const result = scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(result).toBe("{unknown=true}correctResponse");
+    });
+
+    it("should throw an error with an invalid language code", () => {
+      const scorm2004API = new Scorm2004API();
+      const input = "{lang=xyz}correctResponse";
+      scorm2004API.removeCorrectResponsePrefixes(input);
+      expect(scorm2004API.lmsGetLastError()).toEqual(
+        String(scorm2004_error_codes.TYPE_MISMATCH),
+      );
+    });
+  });
+
+  describe("getChildElement()", () => {
+    it("should handle missing interaction type", () => {
+      const scorm2004API = apiInitialized({
+        cmi: {
+          interactions: {
+            childArray: [{ id: "interaction-id-1" }],
+          },
+        },
+      });
+      const result = scorm2004API.getChildElement(
+        "cmi.interactions.0.correct_responses.0",
+        "response-value",
+        true,
+      );
+      expect(result).toBeNull();
+      expect(scorm2004API.lmsGetLastError()).toEqual(
+        String(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED),
+      );
+    });
+
+    it("should call throwSCORMError with the correct arguments in createCorrectResponsesObject", () => {
+      const scorm2004API = new Scorm2004API();
+      const interaction = {
+        id: "interaction-id-1",
+        type: "invalid-type",
+        correct_responses: { _count: 1 },
+      };
+
+      // Initialize the childArray with an empty array
+      scorm2004API.cmi.interactions.childArray = [];
+
+      // Add the interaction object to the childArray
+      scorm2004API.cmi.interactions.childArray[0] = interaction;
+
+      sinon.stub(scorm2004API, "isInitialized").returns(true);
+      const throwSCORMErrorSpy = sinon.spy(scorm2004API, "throwSCORMError");
+
+      try {
+        scorm2004API.getChildElement(
+          "cmi.interactions.0.correct_responses.0",
+          "response-value",
+          true,
+        );
+      } catch (e) {
+        // Expected to throw, so we catch it to prevent the test from failing
+      }
+
+      expect(
+        throwSCORMErrorSpy.calledWith(
+          ErrorCodes.scorm2004.GENERAL_SET_FAILURE,
+          "Incorrect Response Type: " + interaction.type,
+        ),
+      ).toBe(true);
+    });
   });
 
   describe("storeData()", () => {
@@ -809,4 +1314,55 @@ describe("SCORM 2004 API Tests", () => {
       expect(callback.called).toBe(true);
     });
   });
+
+  describe("Test issues from users", () => {
+    it("Should be able to load the JSON data from issue #678", () => {
+      const scorm20004api = api(
+        {
+          ...DefaultSettings,
+          autocommit: false,
+          lmsCommitUrl: "/scorm2004",
+          logLevel: 1,
+        },
+        {
+          comments_from_learner: {},
+          comments_from_lms: {},
+          completion_status: "incomplete",
+          completion_threshold: "",
+          credit: "credit",
+          entry: "resume",
+          exit: "suspend",
+          interactions: {},
+          launch_data: "",
+          learner_id: "Test",
+          learner_name: "User,Sample",
+          learner_preference: {
+            audio_level: "1",
+            language: "",
+            delivery_speed: "1",
+            audio_captioning: "0",
+          },
+          location: "1",
+          max_time_allowed: "",
+          mode: "normal",
+          objectives: {},
+          progress_measure: "",
+          scaled_passing_score: "",
+          score: {
+            scaled: "",
+            raw: "",
+            min: "",
+            max: "",
+          },
+          session_time: "PT19.57S",
+          success_status: "unknown",
+          suspend_data: "",
+          time_limit_action: "continue,no message",
+          total_time: "PT19.57S",
+        },
+      );
+
+      expect(scorm20004api.cmi.learner_preference).not.toBeNull();
+    });
+  });
 });