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

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

@@ -0,0 +1,81 @@
+import reducer, {
+  BookCoverPreviewState,
+} from "../../../src/reducers/bookCoverPreview";
+import ActionCreator from "../../../src/actions";
+
+describe("book cover preview reducer", () => {
+  const preview = "image data";
+
+  const initState: BookCoverPreviewState = {
+    data: null,
+    isFetching: false,
+    fetchError: null,
+  };
+
+  const errorState: BookCoverPreviewState = {
+    data: null,
+    isFetching: false,
+    fetchError: { status: 401, response: "test error", url: "test url" },
+  };
+
+  const loadedState = Object.assign({}, initState, {
+    data: preview,
+  });
+
+  it("returns initial state for unrecognized action", () => {
+    expect(reducer(undefined, {})).toStrictEqual(initState);
+  });
+
+  it("handles PREVIEW_BOOK_COVER_REQUEST", () => {
+    const action = {
+      type: `${ActionCreator.PREVIEW_BOOK_COVER}_${ActionCreator.REQUEST}`,
+      url: "test url",
+    };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      isFetching: true,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isFetching: true,
+      fetchError: null,
+    });
+    expect(reducer(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles PREVIEW_BOOK_COVER_FAILURE", () => {
+    const action = {
+      type: `${ActionCreator.PREVIEW_BOOK_COVER}_${ActionCreator.FAILURE}`,
+      error: "test error",
+    };
+    const oldState = Object.assign({}, initState, { isFetching: true });
+    const newState = Object.assign({}, oldState, {
+      fetchError: "test error",
+      isFetching: false,
+    });
+    expect(reducer(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles PREVIEW_BOOK_COVER_LOAD", () => {
+    const action = {
+      type: `${ActionCreator.PREVIEW_BOOK_COVER}_${ActionCreator.LOAD}`,
+      data: preview,
+    };
+    const newState = Object.assign({}, initState, {
+      data: preview,
+      isFetching: false,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+  });
+
+  it("handles PREVIEW_BOOK_COVER_CLEAR", () => {
+    const action = {
+      type: `${ActionCreator.PREVIEW_BOOK_COVER}_${ActionCreator.CLEAR}`,
+    };
+    expect(reducer(loadedState, action)).toStrictEqual(initState);
+    expect(reducer(errorState, action)).toStrictEqual(initState);
+  });
+});

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

@@ -0,0 +1,161 @@
+import reducer, {
+  ClassificationsState,
+} from "../../../src/reducers/classifications";
+import ActionCreator from "../../../src/actions";
+
+describe("classifications reducer", () => {
+  const genreData = {
+    Fiction: {},
+    Nonfiction: {},
+  };
+
+  const classificationsData = [
+    {
+      type: "type",
+      name: "name",
+      source: "source",
+      weight: "weight",
+    },
+  ];
+
+  const initState: ClassificationsState = {
+    genreTree: null,
+    classifications: null,
+    isFetchingGenreTree: false,
+    isEditingClassifications: false,
+    isFetchingClassifications: false,
+    fetchError: null,
+  };
+
+  const errorState: ClassificationsState = {
+    genreTree: null,
+    classifications: null,
+    isFetchingGenreTree: false,
+    isEditingClassifications: false,
+    isFetchingClassifications: false,
+    fetchError: { status: 401, response: "test error", url: "test url" },
+  };
+
+  it("returns initial state for unrecognized action", () => {
+    expect(reducer(undefined, {})).toStrictEqual(initState);
+  });
+
+  it("handles GENRE_TREE_REQUEST", () => {
+    const action = { type: ActionCreator.GENRE_TREE_REQUEST, url: "test url" };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      isFetchingGenreTree: true,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isFetchingGenreTree: true,
+      fetchError: null,
+    });
+    expect(reducer(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles GENRE_TREE_FAILURE", () => {
+    const action = {
+      type: ActionCreator.GENRE_TREE_FAILURE,
+      error: "test error",
+    };
+    const oldState = Object.assign({}, initState, { isFetching: true });
+    const newState = Object.assign({}, oldState, {
+      fetchError: "test error",
+      isFetchingGenreTree: false,
+    });
+    expect(reducer(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles GENRE_TREE_LOAD", () => {
+    const action = { type: ActionCreator.GENRE_TREE_LOAD, data: genreData };
+    const newState = Object.assign({}, initState, {
+      genreTree: genreData,
+      isFetchingGenreTree: false,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+  });
+
+  it("handles EDIT_CLASSIFICATIONS_REQUEST", () => {
+    const action = {
+      type: ActionCreator.EDIT_CLASSIFICATIONS_REQUEST,
+      url: "test url",
+    };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      isEditingClassifications: true,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isEditingClassifications: true,
+      fetchError: null,
+    });
+    expect(reducer(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles EDIT_CLASSIFICATIONS_FAILURE", () => {
+    const action = {
+      type: ActionCreator.EDIT_CLASSIFICATIONS_FAILURE,
+      error: "test error",
+    };
+    const oldState = Object.assign({}, initState, {
+      isEditingClassifications: true,
+    });
+    const newState = Object.assign({}, oldState, {
+      fetchError: "test error",
+      isEditingClassifications: false,
+    });
+    expect(reducer(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles CLASSIFICATIONS_REQUEST", () => {
+    const action = {
+      type: ActionCreator.CLASSIFICATIONS_REQUEST,
+      url: "test url",
+    };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      isFetchingClassifications: true,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isFetchingClassifications: true,
+      fetchError: null,
+    });
+    expect(reducer(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles CLASSIFICATIONS_FAILURE", () => {
+    const action = {
+      type: ActionCreator.CLASSIFICATIONS_FAILURE,
+      error: "test error",
+    };
+    const oldState = Object.assign({}, initState, { isFetching: true });
+    const newState = Object.assign({}, oldState, {
+      fetchError: "test error",
+      isFetchingClassifications: false,
+    });
+    expect(reducer(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles CLASSIFICATIONS_LOAD", () => {
+    const action = {
+      type: ActionCreator.CLASSIFICATIONS_LOAD,
+      data: { classifications: classificationsData },
+    };
+    const newState = Object.assign({}, initState, {
+      classifications: classificationsData,
+      isFetchingClassifications: false,
+    });
+    expect(reducer(initState, action)).toStrictEqual(newState);
+  });
+});

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

@@ -0,0 +1,96 @@
+import collections from "../../../src/reducers/collections";
+import ActionCreator from "../../../src/actions";
+
+describe("collections reducer", () => {
+  const initState = {
+    data: null,
+    isFetching: false,
+    isEditing: false,
+    fetchError: null,
+    formError: null,
+    responseBody: null,
+    isLoaded: false,
+    successMessage: null,
+  };
+
+  it("returns initial state for unrecognized action", () => {
+    expect(collections(undefined, {})).toStrictEqual(initState);
+  });
+
+  it("handles COLLECTIONS_REQUEST", () => {
+    const action = {
+      type: `${ActionCreator.COLLECTIONS}_REQUEST`,
+      url: "test url",
+    };
+
+    // start with empty state
+    const newState = Object.assign({}, initState, {
+      isFetching: true,
+    });
+    expect(collections(initState, action)).toStrictEqual(newState);
+  });
+
+  it("handles EDIT_COLLECTION_REQUEST", () => {
+    const action = { type: `${ActionCreator.EDIT_COLLECTION}_REQUEST` };
+    const newState = Object.assign({}, initState, {
+      fetchError: null,
+      isFetching: false,
+      isEditing: true,
+    });
+    expect(collections(initState, action)).toStrictEqual(newState);
+  });
+
+  it("handles GET_SELF_TESTS_LOAD", () => {
+    const emptySelfTestData = {
+      duration: null,
+      start: "",
+      end: "",
+      results: [],
+    };
+    const selfTestData = {
+      duration: 0.12,
+      start: "start",
+      end: "end",
+      results: [],
+    };
+    const action = {
+      type: `${ActionCreator.GET_SELF_TESTS}_LOAD`,
+      data: {
+        self_test_results: {
+          id: 1,
+          self_test_results: selfTestData,
+          protocol: "",
+        },
+      },
+    };
+    const oldState = {
+      url: "test url",
+      data: {
+        collections: [
+          { id: 1, self_test_results: emptySelfTestData, protocol: "" },
+          { id: 2, protocol: "" },
+        ],
+        protocols: [],
+      },
+      isFetching: true,
+      fetchError: null,
+      editError: null,
+      isLoaded: true,
+      isEditing: false,
+    };
+
+    const newState = Object.assign({}, oldState, {
+      data: {
+        collections: [
+          { id: 1, self_test_results: selfTestData, protocol: "" },
+          { id: 2, protocol: "" },
+        ],
+        protocols: [],
+      },
+      isFetching: false,
+      isLoaded: true,
+    });
+
+    expect(collections(oldState, action)).toStrictEqual(newState);
+  });
+});

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

@@ -0,0 +1,166 @@
+import complaints from "../../../src/reducers/complaints";
+import ActionCreator from "../../../src/actions";
+
+describe("complaints reducer", () => {
+  const initState = {
+    url: null,
+    data: null,
+    isFetching: false,
+    fetchError: null,
+    postError: null,
+    resolveError: null,
+  };
+
+  const errorState = {
+    url: "test url",
+    data: null,
+    isFetching: false,
+    fetchError: { status: 401, response: "test error", url: "test url" },
+    postError: null,
+    resolveError: null,
+  };
+
+  it("returns initial state for unrecognized action", () => {
+    expect(complaints(undefined, {})).toStrictEqual(initState);
+  });
+
+  it("handles COMPLAINTS_REQUEST", () => {
+    const action = { type: ActionCreator.COMPLAINTS_REQUEST, url: "test url" };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      url: "test url",
+      isFetching: true,
+    });
+    expect(complaints(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isFetching: true,
+      fetchError: null,
+    });
+    expect(complaints(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles COMPLAINTS_FAILURE", () => {
+    const action = {
+      type: ActionCreator.COMPLAINTS_FAILURE,
+      error: "test error",
+    };
+    const oldState = {
+      url: "test url",
+      data: null,
+      isFetching: true,
+      fetchError: null,
+      postError: null,
+      resolveError: null,
+    };
+    const newState = Object.assign({}, oldState, {
+      fetchError: "test error",
+      isFetching: false,
+    });
+    expect(complaints(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles COMPLAINTS_LOAD", () => {
+    const action = {
+      type: ActionCreator.COMPLAINTS_LOAD,
+      data: { complaints: "test data" },
+    };
+    const oldState = {
+      url: "test url",
+      data: null,
+      isFetching: true,
+      fetchError: null,
+      postError: null,
+      resolveError: null,
+    };
+    const newState = Object.assign({}, oldState, {
+      data: "test data",
+      isFetching: false,
+    });
+    expect(complaints(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles POST_COMPLAINT_REQUEST", () => {
+    const action = {
+      type: ActionCreator.POST_COMPLAINT_REQUEST,
+      url: "test url",
+    };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      url: "test url",
+      isFetching: true,
+    });
+    expect(complaints(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isFetching: true,
+      fetchError: null,
+    });
+    expect(complaints(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles POST_COMPLAINT_FAILURE", () => {
+    const action = {
+      type: ActionCreator.POST_COMPLAINT_FAILURE,
+      error: "test error",
+    };
+    const oldState = {
+      url: "test url",
+      data: null,
+      isFetching: true,
+      fetchError: null,
+      postError: null,
+      resolveError: null,
+    };
+    const newState = Object.assign({}, oldState, {
+      postError: "test error",
+      isFetching: false,
+    });
+    expect(complaints(oldState, action)).toStrictEqual(newState);
+  });
+
+  it("handles RESOLVE_COMPLAINTS_REQUEST", () => {
+    const action = {
+      type: ActionCreator.RESOLVE_COMPLAINTS_REQUEST,
+      url: "test url",
+    };
+
+    // start with empty state
+    let newState = Object.assign({}, initState, {
+      url: "test url",
+      isFetching: true,
+    });
+    expect(complaints(initState, action)).toStrictEqual(newState);
+
+    // start with error state
+    newState = Object.assign({}, errorState, {
+      isFetching: true,
+      fetchError: null,
+    });
+    expect(complaints(errorState, action)).toStrictEqual(newState);
+  });
+
+  it("handles RESOLVE_COMPLAINTS_FAILURE", () => {
+    const action = {
+      type: ActionCreator.RESOLVE_COMPLAINTS_FAILURE,
+      error: "test error",
+    };
+    const oldState = {
+      url: "test url",
+      data: null,
+      isFetching: true,
+      fetchError: null,
+      postError: null,
+      resolveError: null,
+    };
+    const newState = Object.assign({}, oldState, {
+      resolveError: "test error",
+      isFetching: false,
+    });
+    expect(complaints(oldState, action)).toStrictEqual(newState);
+  });
+});