scorm-again 1.7.1 → 2.1.0

package/test/cmi_helpers.ts

@@ -0,0 +1,207 @@
+import { describe, it } from "mocha";
+import { expect } from "expect";
+import { getError } from "./api_helpers";
+import { BaseCMI, BaseRootCMI } from "../src/cmi/common/base_cmi";
+
+export type CheckFieldConstraintSize = {
+  cmi: BaseCMI;
+  fieldName: string;
+  limit: number;
+  expectedValue?: string;
+  expectedError: number;
+};
+
+export type CheckReadOnly = {
+  cmi: BaseCMI;
+  fieldName: string;
+  expectedValue?: string | number;
+  expectedError: number;
+};
+
+export type CheckRead = {
+  cmi: BaseCMI;
+  fieldName: string;
+  expectedValue?: string;
+};
+
+export type CheckReadAndWrite = {
+  cmi: BaseCMI;
+  fieldName: string;
+  expectedValue?: string;
+  valueToTest?: string;
+};
+
+export type CheckWriteOnly = {
+  cmi: BaseCMI;
+  fieldName: string;
+  valueToTest?: string;
+  expectedError: number;
+};
+
+export type CheckWrite = {
+  cmi: BaseCMI;
+  fieldName: string;
+  valueToTest?: string;
+};
+
+export type CheckValidValues = {
+  cmi: BaseCMI;
+  fieldName: string;
+  validValues: (string | number)[];
+  invalidValues: string[];
+};
+
+export type CheckGetCurrentTotalTime = {
+  cmi: BaseRootCMI;
+  totalFieldName: string;
+  sessionFieldName: string;
+  startingTotal: string;
+  sessionTime: string;
+  expectedTotal: string;
+};
+
+export const checkFieldConstraintSize = ({
+  cmi,
+  fieldName,
+  limit,
+  expectedValue = "",
+  expectedError,
+}: CheckFieldConstraintSize) => {
+  describe(`Field: ${fieldName}`, () => {
+    it(`Should be able to read from ${fieldName}`, () => {
+      expect(eval(`${fieldName}`)).toEqual(expectedValue);
+    });
+
+    it(`Should be able to write upto ${limit} characters to ${fieldName}`, () => {
+      expect(() => eval(`${fieldName} = 'x'.repeat(${limit})`)).not.toThrow();
+    });
+
+    it(`Should fail to write more than ${limit} characters to ${fieldName}`, async () => {
+      const error = await getError(async () =>
+        eval(`${fieldName} = 'x'.repeat(${limit + 1})`),
+      );
+      expect(error).toHaveProperty("errorCode", expectedError);
+    });
+  });
+};
+
+export const checkReadOnly = ({
+  cmi,
+  fieldName,
+  expectedValue = "",
+  expectedError,
+}: CheckReadOnly) => {
+  describe(`Field: ${fieldName}`, () => {
+    it(`Should be able to read from ${fieldName}`, () => {
+      expect(eval(`${fieldName}`)).toEqual(expectedValue);
+    });
+
+    it(`Should fail to write to ${fieldName}`, async () => {
+      const error = await getError(async () => eval(`${fieldName} = 'xxx'`));
+      expect(error).toHaveProperty("errorCode", expectedError);
+    });
+  });
+};
+
+export const checkRead = ({
+  cmi,
+  fieldName,
+  expectedValue = "",
+}: CheckRead) => {
+  describe(`Field: ${fieldName}`, () => {
+    it(`Should be able to read from ${fieldName}`, () => {
+      expect(eval(`${fieldName}`)).toEqual(expectedValue);
+    });
+  });
+};
+
+export const checkReadAndWrite = ({
+  cmi,
+  fieldName,
+  expectedValue = "",
+  valueToTest = "xxx",
+}: CheckReadAndWrite) => {
+  describe(`Field: ${fieldName}`, () => {
+    it(`Should be able to read from ${fieldName}`, () => {
+      expect(eval(`${fieldName}`)).toEqual(expectedValue);
+    });
+
+    it(`Should successfully write to ${fieldName}`, () => {
+      expect(() => eval(`${fieldName} = '${valueToTest}'`)).not.toThrow();
+    });
+  });
+};
+
+export const checkWriteOnly = ({
+  cmi,
+  fieldName,
+  valueToTest = "xxx",
+  expectedError,
+}: CheckWriteOnly) => {
+  describe(`Field: ${fieldName}`, () => {
+    it(`Should fail to read from ${fieldName}`, async () => {
+      const error = await getError(async () => eval(`${fieldName}`));
+      expect(error).toHaveProperty("errorCode", expectedError);
+    });
+
+    it(`Should successfully write to ${fieldName}`, () => {
+      expect(() => eval(`${fieldName} = '${valueToTest}'`)).not.toThrow();
+    });
+  });
+};
+
+export const checkWrite = ({
+  cmi,
+  fieldName,
+  valueToTest = "xxx",
+}: CheckWrite) => {
+  describe(`Field: ${fieldName}`, () => {
+    it(`Should successfully write to ${fieldName}`, () => {
+      expect(() => eval(`${fieldName} = '${valueToTest}'`)).not.toThrow();
+    });
+  });
+};
+
+export const checkValidValues = ({
+  cmi,
+  fieldName,
+  validValues,
+  invalidValues,
+}: CheckValidValues) => {
+  describe(`Field: ${fieldName}`, () => {
+    for (const idx in validValues) {
+      if ({}.hasOwnProperty.call(validValues, idx)) {
+        it(`Should successfully write '${validValues[idx]}' to ${fieldName}`, () => {
+          expect(() =>
+            eval(`${fieldName} = '${validValues[idx]}'`),
+          ).not.toThrow();
+        });
+      }
+    }
+
+    for (const idx in invalidValues) {
+      if ({}.hasOwnProperty.call(invalidValues, idx)) {
+        it(`Should fail to write '${invalidValues[idx]}' to ${fieldName}`, () => {
+          expect(() =>
+            eval(`${fieldName} = '${invalidValues[idx]}'`),
+          ).toThrow();
+        });
+      }
+    }
+  });
+};
+
+export const checkGetCurrentTotalTime = ({
+  cmi: cmi,
+  totalFieldName,
+  sessionFieldName,
+  startingTotal,
+  sessionTime,
+  expectedTotal,
+}: CheckGetCurrentTotalTime) => {
+  it(`Should return ${expectedTotal} with a starting time of ${startingTotal} and a session time of ${sessionTime}`, () => {
+    eval(`${totalFieldName} = '${startingTotal}'`);
+    eval(`${sessionFieldName} = '${sessionTime}'`);
+    expect(cmi.getCurrentTotalTime()).toEqual(expectedTotal);
+  });
+};

package/test/exceptions.spec.ts

@@ -0,0 +1,79 @@
+import { describe, it } from "mocha";
+import { expect } from "expect";
+import {
+  ValidationError,
+  AICCValidationError,
+  Scorm12ValidationError,
+  Scorm2004ValidationError,
+} from "../src/exceptions";
+import APIConstants from "../src/constants/api_constants";
+
+const scorm12_errors = APIConstants.scorm12.error_descriptions;
+const aicc_errors = APIConstants.aicc.error_descriptions;
+const scorm2004_errors = APIConstants.scorm2004.error_descriptions;
+
+type CheckValidationMessage = {
+  errorClass: any;
+  errorCodes: number[];
+  error_messages: any;
+};
+
+const checkValidationMessage = ({
+  errorClass,
+  errorCodes,
+  error_messages,
+}: CheckValidationMessage) => {
+  describe(`ValidationError: ${typeof errorClass}`, () => {
+    it(`${typeof errorClass} should return general errorCode number when not recognized`, () => {
+      expect(new errorClass.prototype.constructor(53).errorCode).toEqual(101);
+    });
+    it(`${typeof errorClass}  should return general message when not recognized`, () => {
+      expect(new errorClass.prototype.constructor(53).message).toEqual(
+        error_messages["101"].basicMessage,
+      );
+    });
+
+    for (let i = 0; i < errorCodes.length; i++) {
+      const errorCode = errorCodes[i];
+      it(`${typeof errorClass} should return proper errorCode number when recognized`, () => {
+        expect(
+          new errorClass.prototype.constructor(errorCode).errorCode,
+        ).toEqual(errorCode);
+      });
+      it(`${typeof errorClass} should return proper ${errorCode} message`, () => {
+        expect(new errorClass.prototype.constructor(errorCode).message).toEqual(
+          error_messages[String(errorCode)].basicMessage,
+        );
+      });
+    }
+  });
+};
+
+describe("Exception Tests", () => {
+  it("ValidationException should return message string", () => {
+    expect(new ValidationError(0, "Error Message").message).toEqual(
+      "Error Message",
+    );
+  });
+  it("ValidationException should return errorCode number", () => {
+    expect(new ValidationError(0, "Error Message").errorCode).toEqual(0);
+  });
+  checkValidationMessage({
+    errorClass: AICCValidationError,
+    errorCodes: [101, 201, 202, 203, 301, 401, 402, 403, 404, 405, 407, 408],
+    error_messages: aicc_errors,
+  });
+  checkValidationMessage({
+    errorClass: Scorm12ValidationError,
+    errorCodes: [101, 201, 202, 203, 301, 401, 402, 403, 404, 405, 407, 408],
+    error_messages: scorm12_errors,
+  });
+  checkValidationMessage({
+    errorClass: Scorm2004ValidationError,
+    errorCodes: [
+      0, 101, 102, 103, 104, 111, 112, 113, 122, 123, 132, 133, 142, 143, 201,
+      301, 351, 391, 401, 402, 403, 404, 405, 406, 407, 408,
+    ],
+    error_messages: scorm2004_errors,
+  });
+});

package/test/field_values.ts

@@ -0,0 +1,202 @@
+type ValueRange = string[];
+
+interface CommonValues {
+  valid0To1Range: ValueRange;
+  invalid0To1Range: ValueRange;
+  valid0To100Range: ValueRange;
+  invalid0To100Range: ValueRange;
+  validScaledRange: ValueRange;
+  invalidScaledRange: ValueRange;
+  validIntegerScaledRange: ValueRange;
+  invalidIntegerScaledRange: ValueRange;
+}
+
+const commonValues: CommonValues = {
+  valid0To1Range: ["0.0", "0.25", "0.5", "1.0"],
+  invalid0To1Range: ["-1", "-0.1", "1.1", ".25"],
+  valid0To100Range: ["1", "50", "100"],
+  invalid0To100Range: ["invalid", "a100", "-1"],
+  validScaledRange: ["1", "0.5", "0", "-0.5", "-1"],
+  invalidScaledRange: ["-101", "25.1", "50.5", "75", "100"],
+  validIntegerScaledRange: ["1", "0", "-1"],
+  invalidIntegerScaledRange: [
+    "-101",
+    "-0.5",
+    "0.5",
+    "25.1",
+    "50.5",
+    "75",
+    "100",
+  ],
+};
+
+interface Scorm12Values extends CommonValues {
+  validResult: ValueRange;
+  invalidResult: ValueRange;
+  validLessonStatus: ValueRange;
+  invalidLessonStatus: ValueRange;
+  validExit: ValueRange;
+  invalidExit: ValueRange;
+  validType: ValueRange;
+  invalidType: ValueRange;
+  validSpeedRange: ValueRange;
+  invalidSpeedRange: ValueRange;
+  validScoreRange: (string | number)[];
+  invalidScoreRange: ValueRange;
+  validTime: ValueRange;
+  invalidTime: ValueRange;
+  validTimespan: ValueRange;
+  invalidTimespan: ValueRange;
+}
+
+export const scorm12Values: Scorm12Values = {
+  ...commonValues,
+  validResult: ["correct", "wrong", "unanticipated", "neutral"],
+  invalidResult: ["-10000", "10000", "invalid", "incorrect"],
+  validLessonStatus: ["passed", "completed", "failed", "incomplete", "browsed"],
+  invalidLessonStatus: ["Passed", "P", "F", "p", "true", "false", "complete"],
+  validExit: ["time-out", "suspend", "logout", ""],
+  invalidExit: ["close", "exit", "crash"],
+  validType: [
+    "true-false",
+    "choice",
+    "fill-in",
+    "matching",
+    "performance",
+    "sequencing",
+    "likert",
+    "numeric",
+  ],
+  invalidType: ["correct", "wrong", "logout"],
+  validSpeedRange: ["1", "50", "100", "-1", "-50", "-100"],
+  invalidSpeedRange: ["invalid", "a100", "-101", "101", "-100000", "100000"],
+  validScoreRange: ["1", "50.25", "70", "100", 1, 50.25, 70, 100],
+  invalidScoreRange: ["invalid", "a100", "-1", "101", "-100000", "100000"],
+  invalid0To100Range: ["invalid", "a100", "-2"],
+  validTime: ["10:06:57", "23:59:59", "00:00:00"],
+  invalidTime: [
+    "47:59:59",
+    "00:00:01.56",
+    "06:5:13",
+    "23:59:59.123",
+    "P1DT23H59M59S",
+  ],
+  validTimespan: ["10:06:57", "00:00:01.56", "23:59:59", "47:59:59"],
+  invalidTimespan: ["06:5:13", "23:59:59.123", "P1DT23H59M59S"],
+};
+
+interface Scorm2004Values extends CommonValues {
+  validResult: ValueRange;
+  invalidResult: ValueRange;
+  validTimestamps: ValueRange;
+  invalidTimestamps: ValueRange;
+  validCStatus: ValueRange;
+  invalidCStatus: ValueRange;
+  validSStatus: ValueRange;
+  invalidSStatus: ValueRange;
+  validExit: ValueRange;
+  invalidExit: ValueRange;
+  validType: ValueRange;
+  invalidType: ValueRange;
+  validScoreRange: ValueRange;
+  invalidScoreRange: ValueRange;
+  validISO8601Durations: ValueRange;
+  invalidISO8601Durations: ValueRange;
+  validComment: ValueRange;
+  invalidComment: ValueRange;
+  validDescription: ValueRange;
+  invalidDescription: ValueRange;
+  validNavRequest: ValueRange;
+  invalidNavRequest: ValueRange;
+}
+
+export const scorm2004Values: Scorm2004Values = {
+  ...commonValues,
+  validResult: ["correct", "incorrect", "unanticipated", "neutral"],
+  invalidResult: ["-10000", "10000", "invalid", "wrong"],
+  validTimestamps: [
+    "2019-06-25",
+    "2019-06-25T23:59",
+    "2019-06-25T23:59:59.99",
+    "1970-01-01",
+  ],
+  invalidTimestamps: [
+    "2019-06-25T",
+    "2019-06-25T23:59:59.999",
+    "2019-06-25T25:59:59.99",
+    "2019-13-31",
+    "1969-12-31",
+    "-00:00:30",
+    "0:50:30",
+    "23:00:30.",
+  ],
+  validCStatus: ["completed", "incomplete", "not attempted", "unknown"],
+  invalidCStatus: ["complete", "passed", "failed"],
+  validSStatus: ["passed", "failed", "unknown"],
+  invalidSStatus: ["complete", "incomplete", "P", "f"],
+  validExit: ["time-out", "suspend", "logout", "normal", ""],
+  invalidExit: ["close", "exit", "crash"],
+  validType: [
+    "true-false",
+    "choice",
+    "fill-in",
+    "long-fill-in",
+    "matching",
+    "performance",
+    "sequencing",
+    "likert",
+    "numeric",
+    "other",
+  ],
+  invalidType: ["correct", "wrong", "logout"],
+  validScoreRange: ["1", "50", "100", "-10000", "-1", "10000"],
+  invalidScoreRange: ["invalid", "a100", "-100000", "100000"],
+  validISO8601Durations: ["P1Y34DT23H45M15S", "PT1M45S", "P0S", "PT75M"],
+  invalidISO8601Durations: ["00:08:45", "-P1H", "1y45D", "0"],
+  validComment: [
+    "{lang=en-98} learner comment",
+    "{lang=eng-98-9} learner comment",
+    "{lang=eng-98-9fhgj}" + "x".repeat(4000),
+    "learner comment",
+    "learner comment}",
+    "{lang=i-xx}",
+    "{lang=i}",
+    "",
+  ],
+  invalidComment: [
+    "{lang=i-}",
+    "{lang=i-x}",
+    "{lang=eng-98-9fhgj}{ learner comment",
+    "{learner comment",
+    "{lang=eng-98-9fhgj}" + "x".repeat(4001),
+    "{lang=eng-98-9fhgj}{" + "x".repeat(3999),
+  ],
+  validDescription: [
+    "{lang=en-98} learner comment",
+    "{lang=eng-98-9} learner comment",
+    "{lang=eng-98-9fhgj}" + "x".repeat(250),
+    "learner comment",
+    "learner comment}",
+    "{lang=i-xx}",
+    "{lang=i}",
+    "",
+  ],
+  invalidDescription: [
+    "{lang=i-}",
+    "{lang=i-x}",
+    "{lang=eng-98-9fhgj}{ learner comment",
+    "{learner comment",
+    "{lang=eng-98-9fhgj}" + "x".repeat(251),
+    "{lang=eng-98-9fhgj}{" + "x".repeat(249),
+  ],
+  validNavRequest: [
+    "previous",
+    "continue",
+    "exit",
+    "exitAll",
+    "abandon",
+    "abandonAll",
+    "suspendAll",
+  ],
+  invalidNavRequest: ["close", "quit", "next", "before"],
+};

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);
+  });
+});