scorm-again 2.5.0 → 2.6.0

package/src/constants/error_codes.ts

@@ -2,7 +2,7 @@ export type ErrorCode = {
   [key: string]: number;
 };
 
-const global: ErrorCode = {
+export const global_errors: ErrorCode = {
   GENERAL: 101,
   INITIALIZATION_FAILED: 101,
   INITIALIZED: 101,
@@ -33,8 +33,8 @@ const global: ErrorCode = {
   DEPENDENCY_NOT_ESTABLISHED: 101,
 };
 
-const scorm12: ErrorCode = {
-  ...global,
+export const scorm12_errors: ErrorCode = {
+  ...global_errors,
   RETRIEVE_BEFORE_INIT: 301,
   STORE_BEFORE_INIT: 301,
   COMMIT_BEFORE_INIT: 301,
@@ -52,8 +52,8 @@ const scorm12: ErrorCode = {
   DEPENDENCY_NOT_ESTABLISHED: 408,
 };
 
-const scorm2004: ErrorCode = {
-  ...global,
+export const scorm2004_errors: ErrorCode = {
+  ...global_errors,
   INITIALIZATION_FAILED: 102,
   INITIALIZED: 103,
   TERMINATED: 104,
@@ -79,10 +79,3 @@ const scorm2004: ErrorCode = {
   VALUE_OUT_OF_RANGE: 407,
   DEPENDENCY_NOT_ESTABLISHED: 408,
 };
-
-const ErrorCodes = {
-  scorm12,
-  scorm2004,
-};
-
-export default ErrorCodes;

package/src/constants/regex.ts

@@ -1,4 +1,4 @@
-const scorm12 = {
+export const scorm12_regex = {
   CMIString256: "^.{0,255}$",
   CMIString4096: "^.{0,4096}$",
   CMITime: "^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$",
@@ -28,13 +28,13 @@ const scorm12 = {
   weighting_range: "-100#100",
   text_range: "-1#1",
 };
-const aicc = {
-  ...scorm12,
+export const aicc_regex = {
+  ...scorm12_regex,
   ...{
     CMIIdentifier: "^\\w{1,255}$",
   },
 };
-const scorm2004 = {
+export const scorm2004_regex = {
   CMIString200: "^[\\u0000-\\uFFFF]{0,200}$",
   CMIString250: "^[\\u0000-\\uFFFF]{0,250}$",
   CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$",
@@ -89,9 +89,3 @@ const scorm2004 = {
   text_range: "-1#1",
   progress_range: "0#1",
 };
-const Regex = {
-  aicc: aicc,
-  scorm12: scorm12,
-  scorm2004: scorm2004,
-};
-export default Regex;

package/src/constants/response_constants.ts

@@ -1,6 +1,5 @@
-import Regex from "./regex";
+import { scorm2004_regex } from "./regex";
 
-const scorm2004_regex = Regex.scorm2004;
 export const LearnerResponses: Responses = {
   "true-false": {
     format: "^true$|^false$",

package/src/exceptions/aicc_exceptions.ts

@@ -0,0 +1,29 @@
+import { ValidationError } from "../exceptions";
+import { aicc_constants } from "../constants/api_constants";
+
+const aicc_errors = aicc_constants.error_descriptions;
+
+/**
+ * AICC Validation Error
+ */
+export class AICCValidationError extends ValidationError {
+  /**
+   * Constructor to take in an error code
+   * @param {number} errorCode
+   */
+  constructor(errorCode: number) {
+    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {
+      super(
+        errorCode,
+        aicc_errors[String(errorCode)].basicMessage,
+        aicc_errors[String(errorCode)].detailMessage,
+      );
+    } else {
+      super(
+        101,
+        aicc_errors["101"].basicMessage,
+        aicc_errors["101"].detailMessage,
+      );
+    }
+  }
+}

package/src/exceptions/scorm12_exceptions.ts

@@ -0,0 +1,29 @@
+import { ValidationError } from "../exceptions";
+import { scorm12_constants } from "../constants/api_constants";
+
+const scorm12_errors = scorm12_constants.error_descriptions;
+
+/**
+ * SCORM 1.2 Validation Error
+ */
+export class Scorm12ValidationError extends ValidationError {
+  /**
+   * Constructor to take in an error code
+   * @param {number} errorCode
+   */
+  constructor(errorCode: number) {
+    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {
+      super(
+        errorCode,
+        scorm12_errors[String(errorCode)].basicMessage,
+        scorm12_errors[String(errorCode)].detailMessage,
+      );
+    } else {
+      super(
+        101,
+        scorm12_errors["101"].basicMessage,
+        scorm12_errors["101"].detailMessage,
+      );
+    }
+  }
+}

package/src/exceptions/scorm2004_exceptions.ts

@@ -0,0 +1,29 @@
+import { ValidationError } from "../exceptions";
+import { scorm2004_constants } from "../constants/api_constants";
+
+const scorm2004_errors = scorm2004_constants.error_descriptions;
+
+/**
+ * SCORM 2004 Validation Error
+ */
+export class Scorm2004ValidationError extends ValidationError {
+  /**
+   * Constructor to take in an error code
+   * @param {number} errorCode
+   */
+  constructor(errorCode: number) {
+    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {
+      super(
+        errorCode,
+        scorm2004_errors[String(errorCode)].basicMessage,
+        scorm2004_errors[String(errorCode)].detailMessage,
+      );
+    } else {
+      super(
+        101,
+        scorm2004_errors["101"].basicMessage,
+        scorm2004_errors["101"].detailMessage,
+      );
+    }
+  }
+}

package/src/exceptions.ts

@@ -1,9 +1,3 @@
-import APIConstants from "./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 APIError = {
   errorCode: number;
   errorMessage: string;
@@ -73,78 +67,3 @@ export class ValidationError
     return this._detailedMessage;
   }
 }
-
-/**
- * SCORM 1.2 Validation Error
- */
-export class Scorm12ValidationError extends ValidationError {
-  /**
-   * Constructor to take in an error code
-   * @param {number} errorCode
-   */
-  constructor(errorCode: number) {
-    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {
-      super(
-        errorCode,
-        scorm12_errors[String(errorCode)].basicMessage,
-        scorm12_errors[String(errorCode)].detailMessage,
-      );
-    } else {
-      super(
-        101,
-        scorm12_errors["101"].basicMessage,
-        scorm12_errors["101"].detailMessage,
-      );
-    }
-  }
-}
-
-/**
- * AICC Validation Error
- */
-export class AICCValidationError extends ValidationError {
-  /**
-   * Constructor to take in an error code
-   * @param {number} errorCode
-   */
-  constructor(errorCode: number) {
-    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {
-      super(
-        errorCode,
-        aicc_errors[String(errorCode)].basicMessage,
-        aicc_errors[String(errorCode)].detailMessage,
-      );
-    } else {
-      super(
-        101,
-        aicc_errors["101"].basicMessage,
-        aicc_errors["101"].detailMessage,
-      );
-    }
-  }
-}
-
-/**
- * SCORM 2004 Validation Error
- */
-export class Scorm2004ValidationError extends ValidationError {
-  /**
-   * Constructor to take in an error code
-   * @param {number} errorCode
-   */
-  constructor(errorCode: number) {
-    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {
-      super(
-        errorCode,
-        scorm2004_errors[String(errorCode)].basicMessage,
-        scorm2004_errors[String(errorCode)].detailMessage,
-      );
-    } else {
-      super(
-        101,
-        scorm2004_errors["101"].basicMessage,
-        scorm2004_errors["101"].detailMessage,
-      );
-    }
-  }
-}

package/src/types/api_types.ts

@@ -23,10 +23,11 @@ export type Settings = {
   responseHandler?: (response: Response) => Promise<ResultObject>;
   requestHandler?: (commitObject: any) => any;
   onLogMessage?: (messageLevel: LogLevel, logMessage: string) => void;
-  scoItemIds?: string[];
-  scoItemIdValidator?: false | ((scoItemId: string) => boolean);
   mastery_override?: boolean;
   renderCommonCommitFields?: boolean;
+  scoItemIds?: string[];
+  scoItemIdValidator?: false | ((scoItemId: string) => boolean);
+  globalObjectiveIds?: string[];
 };
 
 export type RefObject = {

package/test/AICC.spec.ts

@@ -1,18 +1,25 @@
 import { expect } from "expect";
-import { describe } from "mocha";
+import { describe, it } from "mocha";
 import * as h from "./api_helpers";
-import ErrorCodes from "../src/constants/error_codes";
+import { scorm12_errors } from "../src/constants/error_codes";
 import { AICCImpl } from "../src/AICC";
+import { DefaultSettings } from "../src/constants/default_settings";
+import * as sinon from "sinon";
+import { CMITries } from "../src/cmi/aicc/tries";
+import { CMIInteractions } from "../src/cmi/scorm12/interactions";
+import { RefObject, Settings } from "../src/types/api_types";
 
-const scorm12_error_codes = ErrorCodes.scorm12;
-
-const api = () => {
-  const API = new AICCImpl();
+const api = (settings?: Settings, startingData: RefObject = {}) => {
+  const API = new AICCImpl(settings);
   API.apiLogLevel = 1;
+  if (startingData) {
+    API.startingData = startingData;
+  }
   return API;
 };
-const apiInitialized = () => {
+const apiInitialized = (startingData?: RefObject) => {
   const API = api();
+  API.loadFromJSON(startingData ? startingData : {}, "");
   API.lmsInitialize();
   return API;
 };
@@ -23,52 +30,52 @@ describe("AICC API Tests", () => {
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi._version",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi._children",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.core._children",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.core.score._children",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.objectives._children",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.objectives._count",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.interactions._children",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.interactions._count",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.interactions.0.objectives._count",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
       h.checkSetCMIValue({
         api: api(),
         fieldName: "cmi.interactions.0.correct_responses._count",
-        expectedError: scorm12_error_codes.INVALID_SET_VALUE,
+        expectedError: scorm12_errors.INVALID_SET_VALUE,
       });
     });
 
@@ -76,57 +83,57 @@ describe("AICC API Tests", () => {
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.launch_data",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.comments_from_lms",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.core.student_id",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.core.student_name",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.core.credit",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.core.entry",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.core.total_time",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.core.lesson_mode",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.student_data.mastery_score",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.student_data.max_time_allowed",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
       h.checkSetCMIValue({
         api: apiInitialized(),
         fieldName: "cmi.student_data.time_limit_action",
-        expectedError: scorm12_error_codes.READ_ONLY_ELEMENT,
+        expectedError: scorm12_errors.READ_ONLY_ELEMENT,
       });
     });
   });
@@ -136,19 +143,19 @@ describe("AICC API Tests", () => {
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.core.close",
-        expectedError: scorm12_error_codes.GENERAL,
+        expectedError: scorm12_errors.GENERAL,
         errorThrown: false,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.exit",
-        expectedError: scorm12_error_codes.GENERAL,
+        expectedError: scorm12_errors.GENERAL,
         errorThrown: false,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.entry",
-        expectedError: scorm12_error_codes.GENERAL,
+        expectedError: scorm12_errors.GENERAL,
         errorThrown: false,
       });
     });
@@ -157,66 +164,66 @@ describe("AICC API Tests", () => {
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.core.exit",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.core.session_time",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.id",
         initializeFirst: true,
         initializationValue: "AAA",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.time",
         initializeFirst: true,
         initializationValue: "12:59:59",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.type",
         initializeFirst: true,
         initializationValue: "true-false",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.weighting",
         initializeFirst: true,
         initializationValue: "0",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.student_response",
         initializeFirst: true,
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.result",
         initializeFirst: true,
         initializationValue: "correct",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.latency",
         initializeFirst: true,
         initializationValue: "01:59:59.99",
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
       h.checkLMSGetValue({
         api: apiInitialized(),
         fieldName: "cmi.interactions.0.correct_responses.0.pattern",
         initializeFirst: true,
-        expectedError: scorm12_error_codes.WRITE_ONLY_ELEMENT,
+        expectedError: scorm12_errors.WRITE_ONLY_ELEMENT,
       });
     });
   });
@@ -226,12 +233,12 @@ describe("AICC API Tests", () => {
       h.checkLMSSetValue({
         api: api(),
         fieldName: "cmi.objectives.0.id",
-        expectedError: scorm12_error_codes.STORE_BEFORE_INIT,
+        expectedError: scorm12_errors.STORE_BEFORE_INIT,
       });
       h.checkLMSSetValue({
         api: api(),
         fieldName: "cmi.interactions.0.id",
-        expectedError: scorm12_error_codes.STORE_BEFORE_INIT,
+        expectedError: scorm12_errors.STORE_BEFORE_INIT,
       });
     });
 
@@ -269,6 +276,70 @@ describe("AICC API Tests", () => {
     });
   });
 
+  describe("reset()", () => {
+    it("should reset all CMI values to their default state", () => {
+      const aiccAPI = api();
+      aiccAPI.cmi.core.student_id = "student_1";
+      aiccAPI.lmsInitialize();
+
+      aiccAPI.cmi.core.session_time = "01:00:00";
+      aiccAPI.setCMIValue("cmi.student_data.tries.0.score.max", "99");
+
+      aiccAPI.reset();
+      expect(aiccAPI.cmi.interactions).toEqual(new CMIInteractions());
+      expect(aiccAPI.cmi.core.student_id).toEqual("student_1");
+      expect(aiccAPI.getCMIValue("cmi.student_data.tries")).toEqual(
+        new CMITries(),
+      );
+    });
+
+    it("should keep original settings", () => {
+      const aiccAPI = api({
+        dataCommitFormat: "flattened",
+        autocommit: true,
+      });
+
+      aiccAPI.reset();
+
+      expect(aiccAPI.settings.sendFullCommit).toEqual(
+        DefaultSettings.sendFullCommit,
+      );
+      expect(aiccAPI.settings.dataCommitFormat).toEqual("flattened");
+      expect(aiccAPI.settings.autocommit).toEqual(true);
+    });
+
+    it("should be able to override original settings", () => {
+      const aiccAPI = api({
+        ...DefaultSettings,
+        dataCommitFormat: "flattened",
+        autocommit: true,
+      });
+
+      aiccAPI.reset({
+        alwaysSendTotalTime: !DefaultSettings.alwaysSendTotalTime,
+      });
+
+      expect(aiccAPI.settings.sendFullCommit).toEqual(
+        DefaultSettings.sendFullCommit,
+      );
+      expect(aiccAPI.settings.dataCommitFormat).toEqual("flattened");
+      expect(aiccAPI.settings.autocommit).toEqual(true);
+      expect(aiccAPI.settings.alwaysSendTotalTime).toEqual(
+        !DefaultSettings.alwaysSendTotalTime,
+      );
+    });
+
+    it("should call commonReset from the superclass", () => {
+      const aiccAPI = api();
+      const commonResetSpy = sinon.spy(aiccAPI, "commonReset");
+
+      aiccAPI.reset();
+
+      expect(commonResetSpy.calledOnce).toBe(true);
+      commonResetSpy.restore();
+    });
+  });
+
   describe("replaceWithAnotherScormAPI()", () => {
     const firstAPI = api();
     const secondAPI = api();