scorm-again 2.0.0 → 2.2.0

package/test/cmi/aicc_cmi.spec.ts

@@ -1,19 +1,17 @@
 import { describe, it } from "mocha";
 import APIConstants from "../../src/constants/api_constants";
 import ErrorCodes from "../../src/constants/error_codes";
-import {
-  CMI,
-  CMIEvaluationCommentsObject,
-  CMITriesObject,
-} from "../../src/cmi/aicc_cmi";
+import { CMI } from "../../src/cmi/aicc/cmi";
 import * as h from "../cmi_helpers";
-import {
-  CMIInteractionsObject,
-  CMIObjectivesObject,
-  NAV,
-} from "../../src/cmi/scorm12_cmi";
 import { expect } from "expect";
 import { scorm12Values } from "../field_values";
+import { CMITriesObject } from "../../src/cmi/aicc/tries";
+import { CMIEvaluationCommentsObject } from "../../src/cmi/aicc/evaluation";
+import { CMIObjectivesObject } from "../../src/cmi/scorm12/objectives";
+import { CMIInteractionsObject } from "../../src/cmi/scorm12/interactions";
+import { NAV } from "../../src/cmi/scorm12/nav";
+import { CMIPathsObject } from "../../src/cmi/aicc/paths";
+import { CMIStudentDemographics } from "../../src/cmi/aicc/student_demographics";
 
 const aicc_constants = APIConstants.aicc;
 const scorm12_error_codes = ErrorCodes.scorm12;
@@ -524,7 +522,7 @@ describe("AICC CMI Tests", () => {
         );
         cmiObj.student_data.tries.childArray.push(new CMITriesObject());
         expect(JSON.stringify(cmiObj)).toEqual(
-          '{"suspend_data":"","launch_data":"","comments":"","comments_from_lms":"","core":{"student_id":"","student_name":"","lesson_location":"","credit":"","lesson_status":"not attempted","entry":"","lesson_mode":"normal","exit":"","session_time":"00:00:00","score":{"raw":"","min":"","max":"100"}},"objectives":{"0":{"id":"","status":"","score":{"raw":"","min":"","max":"100"}}},"student_data":{"mastery_score":"","max_time_allowed":"","time_limit_action":"","tries":{"0":{"status":"","time":"","score":{"raw":"","min":"","max":"100"}}}},"student_preference":{"audio":"","language":"","lesson_type":"","speed":"","text":"","text_color":"","text_location":"","text_size":"","video":"","windows":{}},"student_demographics":{"city":"","class":"","company":"","country":"","experience":"","familiar_name":"","instructor_name":"","title":"","native_language":"","state":"","street_address":"","telephone":"","years_experience":""},"interactions":{"0":{"id":"","time":"","type":"","weighting":"","student_response":"","result":"","latency":"","objectives":{},"correct_responses":{}}},"evaluation":{"comments":{"0":{"content":"","location":"","time":""}}},"paths":{}}',
+          '{"suspend_data":"","launch_data":"","comments":"","comments_from_lms":"","core":{"student_id":"","student_name":"","lesson_location":"","credit":"","lesson_status":"not attempted","entry":"","lesson_mode":"normal","exit":"","session_time":"00:00:00","score":{"raw":"","min":"","max":"100"}},"objectives":{"0":{"id":"","status":"","score":{"raw":"","min":"","max":"100"}}},"student_data":{"mastery_score":"","max_time_allowed":"","time_limit_action":"","tries":{"0":{"status":"","time":"","score":{"raw":"","min":"","max":"100"}}},"attempt_records":{}},"student_preference":{"audio":"","language":"","lesson_type":"","speed":"","text":"","text_color":"","text_location":"","text_size":"","video":"","windows":{}},"student_demographics":{"city":"","class":"","company":"","country":"","experience":"","familiar_name":"","instructor_name":"","title":"","native_language":"","state":"","street_address":"","telephone":"","years_experience":""},"interactions":{"0":{"id":"","time":"","type":"","weighting":"","student_response":"","result":"","latency":"","objectives":{},"correct_responses":{}}},"evaluation":{"comments":{"0":{"content":"","location":"","time":""}}},"paths":{}}',
         );
       });
     });
@@ -604,6 +602,185 @@ describe("AICC CMI Tests", () => {
       });
     });
 
+    describe("CMIPathsObject Tests", () => {
+      const paths = () => {
+        return new CMIPathsObject();
+      };
+
+      h.checkFieldConstraintSize({
+        cmi: paths(),
+        fieldName: "cmi.location_id",
+        expectedError: type_mismatch,
+        limit: 255,
+      });
+      h.checkReadAndWrite({
+        cmi: paths(),
+        fieldName: "cmi.date",
+        valueToTest: "2021-01-01",
+      });
+      h.checkValidValues({
+        cmi: paths(),
+        fieldName: "cmi.time",
+        validValues: scorm12Values.validTime,
+        invalidValues: scorm12Values.invalidTime,
+      });
+      h.checkValidValues({
+        cmi: paths(),
+        fieldName: "cmi.status",
+        validValues: scorm12Values.validLessonStatus,
+        invalidValues: scorm12Values.invalidLessonStatus,
+      });
+      h.checkFieldConstraintSize({
+        cmi: paths(),
+        fieldName: "cmi.why_left",
+        expectedError: type_mismatch,
+        limit: 255,
+      });
+      h.checkValidValues({
+        cmi: paths(),
+        fieldName: "cmi.time_in_element",
+        validValues: scorm12Values.validTime,
+        invalidValues: scorm12Values.invalidTime,
+      });
+
+      it("should export JSON", () => {
+        const cmi = paths();
+        expect(JSON.stringify(cmi)).toEqual(
+          '{"location_id":"","date":"","time":"","status":"","why_left":"","time_in_element":""}',
+        );
+      });
+    });
+
+    describe("CMIStudentDemographicsObject Tests", () => {
+      const cmiInit = () => {
+        const cmiStudentDemographics = new CMIStudentDemographics();
+        cmiStudentDemographics.initialize();
+        return cmiStudentDemographics;
+      };
+      const cmi = () => {
+        return new CMIStudentDemographics();
+      };
+
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.city",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.class",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.company",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.country",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.experience",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.familiar_name",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.instructor_name",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.title",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.native_language",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.state",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.street_address",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.telephone",
+        expectedError: read_only,
+      });
+      h.checkReadOnly({
+        cmi: cmiInit(),
+        fieldName: "cmi.years_experience",
+        expectedError: read_only,
+      });
+
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.city",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.class",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.company",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.country",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.experience",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.familiar_name",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.instructor_name",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.title",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.native_language",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.state",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.street_address",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.telephone",
+      });
+      h.checkReadAndWrite({
+        cmi: cmi(),
+        fieldName: "cmi.years_experience",
+      });
+    });
+
     describe("CMIEvaluationCommentsObject Tests", () => {
       const evaluationComment = () => {
         return new CMIEvaluationCommentsObject();

package/test/cmi/scorm12_cmi.spec.ts

@@ -2,15 +2,15 @@ import { expect } from "expect";
 import { describe, it } from "mocha";
 import APIConstants from "../../src/constants/api_constants";
 import ErrorCodes from "../../src/constants/error_codes";
+import { CMI } from "../../src/cmi/scorm12/cmi";
+import * as h from "../cmi_helpers";
+import { scorm12Values } from "../field_values";
+import { CMIObjectivesObject } from "../../src/cmi/scorm12/objectives";
 import {
-  CMI,
   CMIInteractionsCorrectResponsesObject,
   CMIInteractionsObject,
   CMIInteractionsObjectivesObject,
-  CMIObjectivesObject,
-} from "../../src/cmi/scorm12_cmi";
-import * as h from "../cmi_helpers";
-import { scorm12Values } from "../field_values";
+} from "../../src/cmi/scorm12/interactions";
 
 const scorm12 = APIConstants.scorm12;
 const scorm12_error_codes = ErrorCodes.scorm12;

package/test/cmi/scorm2004_cmi.spec.ts

@@ -1,18 +1,18 @@
 import { describe, it } from "mocha";
 import ErrorCodes from "../../src/constants/error_codes";
 import APIConstants from "../../src/constants/api_constants";
+import { CMI } from "../../src/cmi/scorm2004/cmi";
+import * as h from "../cmi_helpers";
+import { expect } from "expect";
+import { scorm2004Values } from "../field_values";
 import {
-  ADL,
-  CMI,
-  CMICommentsObject,
   CMIInteractionsCorrectResponsesObject,
   CMIInteractionsObject,
   CMIInteractionsObjectivesObject,
-  CMIObjectivesObject,
-} from "../../src/cmi/scorm2004_cmi";
-import * as h from "../cmi_helpers";
-import { expect } from "expect";
-import { scorm2004Values } from "../field_values";
+} from "../../src/cmi/scorm2004/interactions";
+import { CMICommentsObject } from "../../src/cmi/scorm2004/comments";
+import { CMIObjectivesObject } from "../../src/cmi/scorm2004/objectives";
+import { ADL } from "../../src/cmi/scorm2004/adl";
 
 const scorm2004_constants = APIConstants.scorm2004;
 const scorm2004_error_codes = ErrorCodes.scorm2004;

package/test/cmi_helpers.ts

@@ -1,7 +1,7 @@
 import { describe, it } from "mocha";
 import { expect } from "expect";
-import { BaseCMI, BaseRootCMI } from "../src/cmi/common";
 import { getError } from "./api_helpers";
+import { BaseCMI, BaseRootCMI } from "../src/cmi/common/base_cmi";
 
 export type CheckFieldConstraintSize = {
   cmi: BaseCMI;

package/test/types/api_types.spec.ts

@@ -0,0 +1,126 @@
+import { expect } from "expect";
+import * as sinon from "sinon";
+import { ResultObject, Settings } from "../../src/types/api_types";
+import APIConstants from "../../src/constants/api_constants";
+
+describe("Settings Type", () => {
+  const defaultSettings: Settings = {
+    autocommit: false,
+    autocommitSeconds: 10,
+    asyncCommit: false,
+    sendFullCommit: true,
+    lmsCommitUrl: false,
+    dataCommitFormat: "json",
+    commitRequestDataType: "application/json;charset=UTF-8",
+    autoProgress: false,
+    logLevel: APIConstants.global.LOG_LEVEL_ERROR,
+    selfReportSessionTime: false,
+    alwaysSendTotalTime: false,
+    strict_errors: true,
+    xhrHeaders: {},
+    xhrWithCredentials: false,
+    responseHandler: async (response: Response): Promise<ResultObject> => {
+      const httpResult = JSON.parse(await response.text());
+      return {
+        result: httpResult.result || APIConstants.global.SCORM_FALSE,
+        errorCode:
+          httpResult.errorCode !== undefined ? httpResult.errorCode : 101,
+      };
+    },
+    requestHandler: (commitObject: any) => commitObject,
+    onLogMessage: (messageLevel: number, logMessage: string) => {
+      switch (messageLevel) {
+        case APIConstants.global.LOG_LEVEL_ERROR:
+          console.error(logMessage);
+          break;
+        case APIConstants.global.LOG_LEVEL_WARNING:
+          console.warn(logMessage);
+          break;
+        case APIConstants.global.LOG_LEVEL_INFO:
+          console.info(logMessage);
+          break;
+        case APIConstants.global.LOG_LEVEL_DEBUG:
+          if (console.debug) {
+            console.debug(logMessage);
+          } else {
+            console.log(logMessage);
+          }
+          break;
+      }
+    },
+  };
+
+  it("should have correct default values", () => {
+    expect(defaultSettings.autocommit).toBe(false);
+    expect(defaultSettings.autocommitSeconds).toEqual(10);
+    expect(defaultSettings.asyncCommit).toBe(false);
+    expect(defaultSettings.sendFullCommit).toBe(true);
+    expect(defaultSettings.lmsCommitUrl).toBe(false);
+    expect(defaultSettings.dataCommitFormat).toEqual("json");
+    expect(defaultSettings.commitRequestDataType).toEqual(
+      "application/json;charset=UTF-8",
+    );
+    expect(defaultSettings.autoProgress).toBe(false);
+    expect(defaultSettings.logLevel).toEqual(
+      APIConstants.global.LOG_LEVEL_ERROR,
+    );
+    expect(defaultSettings.selfReportSessionTime).toBe(false);
+    expect(defaultSettings.alwaysSendTotalTime).toBe(false);
+    expect(defaultSettings.strict_errors).toBe(true);
+    expect(defaultSettings.xhrHeaders).toEqual({});
+    expect(defaultSettings.xhrWithCredentials).toBe(false);
+  });
+
+  it("should handle response correctly in responseHandler", async () => {
+    const response = new Response(
+      JSON.stringify({ result: "true", errorCode: 0 }),
+    );
+    const result = await defaultSettings.responseHandler(response);
+    expect(result.result).toEqual("true");
+    expect(result.errorCode).toEqual(0);
+  });
+
+  it("should handle request correctly in requestHandler", () => {
+    const commitObject = { data: "test" };
+    const result = defaultSettings.requestHandler(commitObject);
+    expect(result).toEqual(commitObject);
+  });
+
+  it("should log messages correctly in onLogMessage", () => {
+    const consoleErrorStub = sinon.stub(console, "error");
+    const consoleWarnStub = sinon.stub(console, "warn");
+    const consoleInfoStub = sinon.stub(console, "info");
+    const consoleDebugStub = sinon.stub(console, "debug");
+    const consoleLogStub = sinon.stub(console, "log");
+
+    defaultSettings.onLogMessage(
+      APIConstants.global.LOG_LEVEL_ERROR,
+      "Error message",
+    );
+    expect(consoleErrorStub.calledWith("Error message")).toBe(true);
+
+    defaultSettings.onLogMessage(
+      APIConstants.global.LOG_LEVEL_WARNING,
+      "Warning message",
+    );
+    expect(consoleWarnStub.calledWith("Warning message")).toBe(true);
+
+    defaultSettings.onLogMessage(
+      APIConstants.global.LOG_LEVEL_INFO,
+      "Info message",
+    );
+    expect(consoleInfoStub.calledWith("Info message")).toBe(true);
+
+    defaultSettings.onLogMessage(
+      APIConstants.global.LOG_LEVEL_DEBUG,
+      "Debug message",
+    );
+    expect(consoleDebugStub.calledWith("Debug message")).toBe(true);
+
+    consoleErrorStub.restore();
+    consoleWarnStub.restore();
+    consoleInfoStub.restore();
+    consoleDebugStub.restore();
+    consoleLogStub.restore();
+  });
+});

package/test/utilities/debounce.spec.ts

@@ -0,0 +1,56 @@
+import { expect } from "expect";
+import * as sinon from "sinon";
+import { debounce } from "../../src/utilities/debounce";
+
+describe("debounce", () => {
+  it("executes the function after the specified wait time", (done) => {
+    const mockFunction = sinon.spy();
+    const debouncedFunction = debounce(mockFunction, 100);
+
+    debouncedFunction();
+    expect(mockFunction.called).toBe(false);
+
+    setTimeout(() => {
+      expect(mockFunction.called).toBe(true);
+      done();
+    }, 150);
+  });
+
+  it("executes the function immediately if immediate is true", () => {
+    const mockFunction = sinon.spy();
+    const debouncedFunction = debounce(mockFunction, 100, true);
+
+    debouncedFunction();
+    expect(mockFunction.called).toBe(true);
+  });
+
+  it("does not execute the function if called again within the wait time", (done) => {
+    const mockFunction = sinon.spy();
+    const debouncedFunction = debounce(mockFunction, 100);
+
+    debouncedFunction();
+    debouncedFunction();
+
+    setTimeout(() => {
+      expect(mockFunction.calledOnce).toBe(true);
+      done();
+    }, 150);
+  });
+
+  it("executes the function again after the wait time if called again", (done) => {
+    const mockFunction = sinon.spy();
+    const debouncedFunction = debounce(mockFunction, 100);
+
+    debouncedFunction();
+
+    setTimeout(() => {
+      debouncedFunction();
+      expect(mockFunction.calledOnce).toBe(true);
+
+      setTimeout(() => {
+        expect(mockFunction.calledTwice).toBe(true);
+        done();
+      }, 150);
+    }, 150);
+  });
+});