scorm-again 1.7.1 → 2.0.0

package/test/api_helpers.ts

@@ -0,0 +1,176 @@
+import { describe, it } from "mocha";
+import { expect } from "expect";
+import BaseAPI from "../src/BaseAPI";
+
+class NoErrorThrownError extends Error {}
+
+export const getError = async <TError>(
+  call: () => unknown,
+): Promise<TError> => {
+  try {
+    await call();
+
+    throw new NoErrorThrownError();
+  } catch (error: unknown) {
+    return error as TError;
+  }
+};
+
+export type CheckValidValues = {
+  api: BaseAPI;
+  fieldName: string;
+  validValues: (string | number)[];
+  invalidValues: string[];
+};
+
+export type CheckLMSSetValue = {
+  api: BaseAPI;
+  fieldName: string;
+  valueToTest?: string | number;
+  expectedError?: number;
+  errorThrown?: boolean;
+};
+
+export type CheckLMSGetValue = {
+  api: BaseAPI;
+  fieldName: string;
+  expectedValue?: string;
+  initializeFirst?: boolean;
+  initializationValue?: string;
+  expectedError?: number;
+  errorThrown?: boolean;
+};
+
+export type CheckSetCMIValue = {
+  api: BaseAPI;
+  fieldName: string;
+  valueToTest?: string;
+  expectedError?: number;
+  errorThrown?: boolean;
+};
+
+export const checkValidValues = ({
+  api,
+  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(api.lmsSetValue(fieldName, validValues[idx])).toEqual("true");
+        });
+      }
+    }
+
+    for (const idx in invalidValues) {
+      if ({}.hasOwnProperty.call(invalidValues, idx)) {
+        it(`Should fail to write '${invalidValues[idx]}' to ${fieldName}`, () => {
+          expect(api.lmsSetValue(fieldName, invalidValues[idx])).toEqual(
+            "false",
+          );
+        });
+      }
+    }
+  });
+};
+
+export const checkLMSSetValue = ({
+  api,
+  fieldName,
+  valueToTest = "xxx",
+  expectedError = 0,
+  errorThrown = false,
+}: CheckLMSSetValue) => {
+  describe(`Field: ${fieldName}`, () => {
+    const status = expectedError > 0 ? "fail to" : "successfully";
+    it(`Should ${status} set value for ${fieldName}`, async () => {
+      if (expectedError > 0) {
+        if (errorThrown) {
+          const error = await getError(async () =>
+            api.lmsSetValue(fieldName, valueToTest),
+          );
+          expect(error).toHaveProperty("errorCode", expectedError);
+        } else {
+          api.lmsSetValue(fieldName, valueToTest);
+          expect(String(api.lmsGetLastError())).toEqual(String(expectedError));
+        }
+      } else {
+        if (errorThrown) {
+          const error = await getError(async () =>
+            api.lmsSetValue(fieldName, valueToTest),
+          );
+          expect(error).toHaveProperty("errorCode", expectedError);
+        } else {
+          api.lmsSetValue(fieldName, valueToTest);
+          expect(String(api.lmsGetLastError())).toEqual(String(0));
+        }
+      }
+    });
+  });
+};
+
+export const checkLMSGetValue = ({
+  api,
+  fieldName,
+  expectedValue = "",
+  initializeFirst = false,
+  initializationValue = "",
+  expectedError = 0,
+  errorThrown = false,
+}: CheckLMSGetValue) => {
+  describe(`Field: ${fieldName}`, () => {
+    const status = expectedError > 0 ? "fail to" : "successfully";
+
+    if (initializeFirst) {
+      api.setCMIValue(fieldName, initializationValue);
+    }
+
+    it(`Should ${status} get value for ${fieldName}`, async () => {
+      if (expectedError > 0) {
+        if (errorThrown) {
+          const error = await getError(async () => api.lmsGetValue(fieldName));
+          expect(error).toHaveProperty("errorCode", expectedError);
+        } else {
+          api.lmsGetValue(fieldName);
+          expect(String(api.lmsGetLastError())).toEqual(String(expectedError));
+        }
+      } else {
+        expect(api.lmsGetValue(fieldName)).toEqual(expectedValue);
+      }
+    });
+  });
+};
+
+export const checkSetCMIValue = ({
+  api,
+  fieldName,
+  valueToTest = "xxx",
+  expectedError = 0,
+  errorThrown = true,
+}: CheckSetCMIValue) => {
+  describe(`Field: ${fieldName}`, () => {
+    const status = expectedError > 0 ? "fail to" : "successfully";
+    it(`Should ${status} set CMI value for ${fieldName}`, async () => {
+      if (expectedError > 0) {
+        if (errorThrown) {
+          const error = await getError(async () =>
+            api.setCMIValue(fieldName, valueToTest),
+          );
+          expect(error).toHaveProperty("errorCode", expectedError);
+        } else {
+          api.setCMIValue(fieldName, valueToTest);
+          expect(String(api.lmsGetLastError())).toEqual(String(expectedError));
+        }
+      } else {
+        if (errorThrown) {
+          expect(() => api.setCMIValue(fieldName, valueToTest)).not.toThrow();
+        } else {
+          api.setCMIValue(fieldName, valueToTest);
+          expect(String(api.lmsGetLastError())).toEqual(String(0));
+        }
+      }
+    });
+  });
+};