@thepalaceproject/circulation-admin 1.43.0-post.3 → 1.43.0-post.4

package/tests/jest/reducers/managePatrons.test.ts

@@ -0,0 +1,71 @@
+import ManagePatrons from "../../../src/reducers/managePatrons";
+import ActionCreator from "../../../src/actions";
+
+describe("ManagePatrons reducer", () => {
+  const initState = {
+    data: null,
+    isFetching: false,
+    isEditing: false,
+    fetchError: null,
+    formError: null,
+    responseBody: null,
+    successMessage: null,
+    isLoaded: false,
+  };
+
+  it("returns initial state for unrecognized action", () => {
+    expect(ManagePatrons(undefined, {})).toStrictEqual(initState);
+  });
+
+  it("handles CLEAR_PATRON_DATA_LOAD", () => {
+    const action = {
+      type: `${ActionCreator.CLEAR_PATRON_DATA}_LOAD`,
+      data: null,
+    };
+    const oldPatronState = {
+      url: "test url",
+      data: {
+        authorization_expires: "",
+        authorization_identifier: "1234",
+        authorization_identifiers: [],
+        block_reason: "",
+        external_type: "",
+        fines: "",
+        permanent_id: "1234",
+      },
+      isFetching: true,
+      fetchError: null,
+      editError: null,
+      isLoaded: true,
+      isEditing: false,
+    };
+    const oldErrorState = {
+      url: "test url",
+      data: null,
+      isFetching: true,
+      fetchError: {
+        status: 400,
+        response: "No patron found",
+        url: "",
+      },
+      editError: null,
+      isLoaded: true,
+      isEditing: false,
+    };
+
+    const newPatronState = Object.assign({}, oldPatronState, {
+      data: null,
+      isFetching: false,
+      isLoaded: true,
+    });
+    const newErrorState = Object.assign({}, oldErrorState, {
+      data: null,
+      isFetching: false,
+      isLoaded: true,
+      fetchError: null,
+    });
+
+    expect(ManagePatrons(oldPatronState, action)).toStrictEqual(newPatronState);
+    expect(ManagePatrons(oldErrorState, action)).toStrictEqual(newErrorState);
+  });
+});

package/tests/jest/utils/sharedFunctions.test.ts

@@ -0,0 +1,121 @@
+import {
+  findDefault,
+  formatString,
+  isEqual,
+} from "../../../src/utils/sharedFunctions";
+
+describe("findDefault", () => {
+  const settingWithoutDefaults = {
+    key: "test_setting_no_default",
+    options: [
+      { key: "true", label: "Yes" },
+      { key: "false", label: "No" },
+    ],
+  };
+
+  const settingWithOneDefault = {
+    default: "true",
+    key: "test_setting_1_default",
+    options: [
+      { key: "true", label: "Yes" },
+      { key: "false", label: "No" },
+    ],
+  };
+
+  const settingWithMultipleDefaults = {
+    default: ["first default", "second default"],
+    key: "test_setting_mult_defaults",
+    options: [
+      { key: "first default", label: "Yes" },
+      { key: "no", label: "No" },
+      { key: "second default", label: "This one too" },
+      { key: "also no", label: "Not this one" },
+    ],
+  };
+
+  it("doesn't return anything if the setting has no default value", () => {
+    const result = findDefault(settingWithoutDefaults);
+    expect(result).toBeUndefined();
+  });
+
+  it("identifies the default setting from a list of options", () => {
+    const result = findDefault(settingWithOneDefault);
+    expect(result.length).toBe(1);
+    expect(result[0].key).toBe("true");
+    expect(result[0].label).toBe("Yes");
+  });
+
+  it("identifies multiple default settings from a list of options", () => {
+    const result = findDefault(settingWithMultipleDefaults);
+    expect(result.length).toBe(2);
+    expect(result[0].key).toBe("first default");
+    expect(result[0].label).toBe("Yes");
+    expect(result[1].key).toBe("second default");
+    expect(result[1].label).toBe("This one too");
+  });
+});
+
+describe("formatString", () => {
+  const stringToFormat = "this-is-a-sentence.";
+  it("capitalizes the first letter of a string by default", () => {
+    const result = formatString(stringToFormat);
+    expect(result).toBe("This-is-a-sentence.");
+  });
+
+  it("can be prevented from capitalizing", () => {
+    const result = formatString(stringToFormat, null, false);
+    expect(result).toBe("this-is-a-sentence.");
+  });
+
+  it("replaces characters", () => {
+    const result = formatString(stringToFormat, ["-", " "], false);
+    expect(result).toBe("this is a sentence.");
+  });
+
+  it("replaces characters and capitalizes", () => {
+    const result = formatString(stringToFormat, ["-", "!"]);
+    expect(result).toBe("This!is!a!sentence.");
+  });
+
+  it("replaces multiple characters", () => {
+    const result = formatString("need-to-replace!multiple-characters", [
+      "-",
+      "!",
+      " ",
+    ]);
+    expect(result).toBe("Need to replace multiple characters");
+  });
+
+  it("defaults to replacing characters with a space", () => {
+    const result = formatString(stringToFormat, ["-"]);
+    expect(result).toBe("This is a sentence.");
+  });
+});
+
+describe("isEqual", () => {
+  const arr1 = ["a", "b", "c"];
+
+  it("returns false if the arrays are not the same length", () => {
+    const arr2 = ["a", "b", "c", "d"];
+    expect(isEqual(arr1, arr2)).toBe(false);
+  });
+  it("returns false if the lengths are the same but not all of the elements match", () => {
+    const arr2 = ["a", "b", "d"];
+    expect(isEqual(arr1, arr2)).toBe(false);
+  });
+  it("returns false if there are duplicates", () => {
+    const arr2 = ["a", "a", "b"];
+    expect(isEqual(arr1, arr2)).toBe(false);
+  });
+  it("returns true if the arrays are the same", () => {
+    const arr2 = ["a", "b", "c"];
+    expect(isEqual(arr1, arr2)).toBe(true);
+  });
+  it("returns true even if the arrays do not list the elements in the same order", () => {
+    const arr2 = ["b", "c", "a"];
+    expect(isEqual(arr1, arr2)).toBe(true);
+  });
+  it("returns true if the arrays have the same duplicates", () => {
+    expect(isEqual(["a", "a", "b"], ["b", "a", "a"])).toBe(true);
+  });
+});