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

package/tests/jest/index.test.tsx

@@ -0,0 +1,50 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { Router } from "react-router";
+
+import SetupPage from "../../src/components/SetupPage";
+
+// index.tsx does `export = CirculationAdmin`.
+const CirculationAdmin = require("../../src/index");
+
+/** Walk a React element tree for an element of the given type — the structural
+ *  analog of enzyme's `wrapper.find(Type)`, used where the tree is the app root
+ *  and there is no rendered DOM to query against. */
+function containsType(node: any, type: React.ElementType): boolean {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some((n) => containsType(n, type));
+  if (node.type === type) return true;
+  return containsType(node.props && node.props.children, type);
+}
+
+describe("CirculationAdmin", () => {
+  let renderSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    // Capture what the bootstrap hands to ReactDOM.render without letting it
+    // paint into the jsdom document. We assert on the captured element tree
+    // (the structural analog of the original enzyme `wrapper.find(...)`); what
+    // SetupPage and the routed pages render is covered by their own tests.
+    renderSpy = jest
+      .spyOn(ReactDOM, "render")
+      .mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("renders the setup page when setting up", () => {
+    new CirculationAdmin({ settingUp: true, csrfToken: "token" });
+
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(containsType(renderSpy.mock.calls[0][0], SetupPage)).toBe(true);
+  });
+
+  it("renders the router otherwise", () => {
+    new CirculationAdmin({ csrfToken: "token" });
+
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(containsType(renderSpy.mock.calls[0][0], Router)).toBe(true);
+  });
+});

package/tests/jest/models/Admin.test.ts

@@ -0,0 +1,206 @@
+import Admin from "../../../src/models/Admin";
+
+describe("Admin", () => {
+  const systemAdmin = new Admin([{ role: "system" }]);
+  const sitewideLibraryManager = new Admin([{ role: "manager-all" }]);
+  const sitewideLibrarian = new Admin([{ role: "librarian-all" }]);
+  const libraryManagerA = new Admin([{ role: "manager", library: "a" }]);
+  const librarianA = new Admin([{ role: "librarian", library: "a" }]);
+  const libraryManagerB = new Admin([{ role: "manager", library: "b" }]);
+  const librarianB = new Admin([{ role: "librarian", library: "b" }]);
+  const libraryManagerASitewideLibrarian = new Admin([
+    { role: "librarian-all" },
+    { role: "manager", library: "a" },
+  ]);
+  const libraryManagerALibrarianB = new Admin([
+    { role: "manager", library: "a" },
+    { role: "librarian", library: "b" },
+  ]);
+
+  it("stores email", () => {
+    expect(new Admin([], "email").email).toBe("email");
+    expect(new Admin([]).email).toBeFalsy();
+  });
+
+  it("identifies system admins", () => {
+    expect(systemAdmin.isSystemAdmin()).toBeTruthy();
+    expect(sitewideLibraryManager.isSystemAdmin()).toBeFalsy();
+    expect(sitewideLibrarian.isSystemAdmin()).toBeFalsy();
+    expect(libraryManagerA.isSystemAdmin()).toBeFalsy();
+    expect(librarianA.isSystemAdmin()).toBeFalsy();
+    expect(libraryManagerB.isSystemAdmin()).toBeFalsy();
+    expect(librarianB.isSystemAdmin()).toBeFalsy();
+    expect(libraryManagerASitewideLibrarian.isSystemAdmin()).toBeFalsy();
+    expect(libraryManagerALibrarianB.isSystemAdmin()).toBeFalsy();
+  });
+
+  it("identifies sitewide library managers", () => {
+    expect(systemAdmin.isSitewideLibraryManager()).toBeTruthy();
+    expect(sitewideLibraryManager.isSitewideLibraryManager()).toBeTruthy();
+    expect(sitewideLibrarian.isSitewideLibraryManager()).toBeFalsy();
+    expect(libraryManagerA.isSitewideLibraryManager()).toBeFalsy();
+    expect(librarianA.isSitewideLibraryManager()).toBeFalsy();
+    expect(libraryManagerB.isSitewideLibraryManager()).toBeFalsy();
+    expect(librarianB.isSitewideLibraryManager()).toBeFalsy();
+    expect(
+      libraryManagerASitewideLibrarian.isSitewideLibraryManager()
+    ).toBeFalsy();
+    expect(libraryManagerALibrarianB.isSitewideLibraryManager()).toBeFalsy();
+  });
+
+  it("identifies sitewide librarians", () => {
+    expect(systemAdmin.isSitewideLibrarian()).toBeTruthy();
+    expect(sitewideLibraryManager.isSitewideLibrarian()).toBeTruthy();
+    expect(sitewideLibrarian.isSitewideLibrarian()).toBeTruthy();
+    expect(libraryManagerA.isSitewideLibrarian()).toBeFalsy();
+    expect(librarianA.isSitewideLibrarian()).toBeFalsy();
+    expect(libraryManagerB.isSitewideLibrarian()).toBeFalsy();
+    expect(librarianB.isSitewideLibrarian()).toBeFalsy();
+    expect(libraryManagerASitewideLibrarian.isSitewideLibrarian()).toBeTruthy();
+    expect(libraryManagerALibrarianB.isSitewideLibrarian()).toBeFalsy();
+  });
+
+  it("identifies library managers", () => {
+    expect(systemAdmin.isLibraryManager("a")).toBeTruthy();
+    expect(sitewideLibraryManager.isLibraryManager("a")).toBeTruthy();
+    expect(sitewideLibrarian.isLibraryManager("a")).toBeFalsy();
+    expect(libraryManagerA.isLibraryManager("a")).toBeTruthy();
+    expect(librarianA.isLibraryManager("a")).toBeFalsy();
+    expect(libraryManagerB.isLibraryManager("a")).toBeFalsy();
+    expect(librarianB.isLibraryManager("a")).toBeFalsy();
+    expect(libraryManagerASitewideLibrarian.isLibraryManager("a")).toBeTruthy();
+    expect(libraryManagerALibrarianB.isLibraryManager("a")).toBeTruthy();
+
+    expect(systemAdmin.isLibraryManager("b")).toBeTruthy();
+    expect(sitewideLibraryManager.isLibraryManager("b")).toBeTruthy();
+    expect(sitewideLibrarian.isLibraryManager("b")).toBeFalsy();
+    expect(libraryManagerA.isLibraryManager("b")).toBeFalsy();
+    expect(librarianA.isLibraryManager("b")).toBeFalsy();
+    expect(libraryManagerB.isLibraryManager("b")).toBeTruthy();
+    expect(librarianB.isLibraryManager("b")).toBeFalsy();
+    expect(libraryManagerASitewideLibrarian.isLibraryManager("b")).toBeFalsy();
+    expect(libraryManagerALibrarianB.isLibraryManager("b")).toBeFalsy();
+  });
+
+  it("identifies librarians", () => {
+    expect(systemAdmin.isLibrarian("a")).toBeTruthy();
+    expect(sitewideLibraryManager.isLibrarian("a")).toBeTruthy();
+    expect(sitewideLibrarian.isLibrarian("a")).toBeTruthy();
+    expect(libraryManagerA.isLibrarian("a")).toBeTruthy();
+    expect(librarianA.isLibrarian("a")).toBeTruthy();
+    expect(libraryManagerB.isLibrarian("a")).toBeFalsy();
+    expect(librarianB.isLibrarian("a")).toBeFalsy();
+    expect(libraryManagerASitewideLibrarian.isLibrarian("a")).toBeTruthy();
+    expect(libraryManagerALibrarianB.isLibrarian("a")).toBeTruthy();
+
+    expect(systemAdmin.isLibrarian("b")).toBeTruthy();
+    expect(sitewideLibraryManager.isLibrarian("b")).toBeTruthy();
+    expect(sitewideLibrarian.isLibrarian("b")).toBeTruthy();
+    expect(libraryManagerA.isLibrarian("b")).toBeFalsy();
+    expect(librarianA.isLibrarian("b")).toBeFalsy();
+    expect(libraryManagerB.isLibrarian("b")).toBeTruthy();
+    expect(librarianB.isLibrarian("b")).toBeTruthy();
+    expect(libraryManagerASitewideLibrarian.isLibrarian("b")).toBeTruthy();
+    expect(libraryManagerALibrarianB.isLibrarian("b")).toBeTruthy();
+  });
+
+  it("identifies all library managers", () => {
+    expect(systemAdmin.isLibraryManagerOfSomeLibrary()).toBeTruthy();
+    expect(sitewideLibraryManager.isLibraryManagerOfSomeLibrary()).toBeTruthy();
+    expect(sitewideLibrarian.isLibraryManagerOfSomeLibrary()).toBeFalsy();
+    expect(libraryManagerA.isLibraryManagerOfSomeLibrary()).toBeTruthy();
+    expect(librarianA.isLibraryManagerOfSomeLibrary()).toBeFalsy();
+    expect(libraryManagerB.isLibraryManagerOfSomeLibrary()).toBeTruthy();
+    expect(librarianB.isLibraryManagerOfSomeLibrary()).toBeFalsy();
+    expect(
+      libraryManagerASitewideLibrarian.isLibraryManagerOfSomeLibrary()
+    ).toBeTruthy();
+    expect(
+      libraryManagerALibrarianB.isLibraryManagerOfSomeLibrary()
+    ).toBeTruthy();
+  });
+
+  it("checks for specific roles", () => {
+    expect(systemAdmin.hasRole("system")).toBeTruthy();
+    expect(systemAdmin.hasRole("manager-all")).toBeTruthy();
+    expect(systemAdmin.hasRole("librarian-all")).toBeTruthy();
+    expect(systemAdmin.hasRole("manager", "a")).toBeTruthy();
+    expect(systemAdmin.hasRole("librarian", "a")).toBeTruthy();
+    expect(systemAdmin.hasRole("manager", "b")).toBeTruthy();
+    expect(systemAdmin.hasRole("librarian", "b")).toBeTruthy();
+
+    expect(sitewideLibraryManager.hasRole("system")).toBeFalsy();
+    expect(sitewideLibraryManager.hasRole("manager-all")).toBeTruthy();
+    expect(sitewideLibraryManager.hasRole("librarian-all")).toBeTruthy();
+    expect(sitewideLibraryManager.hasRole("manager", "a")).toBeTruthy();
+    expect(sitewideLibraryManager.hasRole("librarian", "a")).toBeTruthy();
+    expect(sitewideLibraryManager.hasRole("manager", "b")).toBeTruthy();
+    expect(sitewideLibraryManager.hasRole("librarian", "b")).toBeTruthy();
+
+    expect(sitewideLibrarian.hasRole("system")).toBeFalsy();
+    expect(sitewideLibrarian.hasRole("manager-all")).toBeFalsy();
+    expect(sitewideLibrarian.hasRole("librarian-all")).toBeTruthy();
+    expect(sitewideLibrarian.hasRole("manager", "a")).toBeFalsy();
+    expect(sitewideLibrarian.hasRole("librarian", "a")).toBeTruthy();
+    expect(sitewideLibrarian.hasRole("manager", "b")).toBeFalsy();
+    expect(sitewideLibrarian.hasRole("librarian", "b")).toBeTruthy();
+
+    expect(libraryManagerA.hasRole("system")).toBeFalsy();
+    expect(libraryManagerA.hasRole("manager-all")).toBeFalsy();
+    expect(libraryManagerA.hasRole("librarian-all")).toBeFalsy();
+    expect(libraryManagerA.hasRole("manager", "a")).toBeTruthy();
+    expect(libraryManagerA.hasRole("librarian", "a")).toBeTruthy();
+    expect(libraryManagerA.hasRole("manager", "b")).toBeFalsy();
+    expect(libraryManagerA.hasRole("librarian", "b")).toBeFalsy();
+
+    expect(librarianA.hasRole("system")).toBeFalsy();
+    expect(librarianA.hasRole("manager-all")).toBeFalsy();
+    expect(librarianA.hasRole("librarian-all")).toBeFalsy();
+    expect(librarianA.hasRole("manager", "a")).toBeFalsy();
+    expect(librarianA.hasRole("librarian", "a")).toBeTruthy();
+    expect(librarianA.hasRole("manager", "b")).toBeFalsy();
+    expect(librarianA.hasRole("librarian", "b")).toBeFalsy();
+
+    expect(libraryManagerB.hasRole("system")).toBeFalsy();
+    expect(libraryManagerB.hasRole("manager-all")).toBeFalsy();
+    expect(libraryManagerB.hasRole("librarian-all")).toBeFalsy();
+    expect(libraryManagerB.hasRole("manager", "a")).toBeFalsy();
+    expect(libraryManagerB.hasRole("librarian", "a")).toBeFalsy();
+    expect(libraryManagerB.hasRole("manager", "b")).toBeTruthy();
+    expect(libraryManagerB.hasRole("librarian", "b")).toBeTruthy();
+
+    expect(librarianB.hasRole("system")).toBeFalsy();
+    expect(librarianB.hasRole("manager-all")).toBeFalsy();
+    expect(librarianB.hasRole("librarian-all")).toBeFalsy();
+    expect(librarianB.hasRole("manager", "a")).toBeFalsy();
+    expect(librarianB.hasRole("librarian", "a")).toBeFalsy();
+    expect(librarianB.hasRole("manager", "b")).toBeFalsy();
+    expect(librarianB.hasRole("librarian", "b")).toBeTruthy();
+
+    expect(libraryManagerASitewideLibrarian.hasRole("system")).toBeFalsy();
+    expect(libraryManagerASitewideLibrarian.hasRole("manager-all")).toBeFalsy();
+    expect(
+      libraryManagerASitewideLibrarian.hasRole("librarian-all")
+    ).toBeTruthy();
+    expect(
+      libraryManagerASitewideLibrarian.hasRole("manager", "a")
+    ).toBeTruthy();
+    expect(
+      libraryManagerASitewideLibrarian.hasRole("librarian", "a")
+    ).toBeTruthy();
+    expect(
+      libraryManagerASitewideLibrarian.hasRole("manager", "b")
+    ).toBeFalsy();
+    expect(
+      libraryManagerASitewideLibrarian.hasRole("librarian", "b")
+    ).toBeTruthy();
+
+    expect(libraryManagerALibrarianB.hasRole("system")).toBeFalsy();
+    expect(libraryManagerALibrarianB.hasRole("manager-all")).toBeFalsy();
+    expect(libraryManagerALibrarianB.hasRole("librarian-all")).toBeFalsy();
+    expect(libraryManagerALibrarianB.hasRole("manager", "a")).toBeTruthy();
+    expect(libraryManagerALibrarianB.hasRole("librarian", "a")).toBeTruthy();
+    expect(libraryManagerALibrarianB.hasRole("manager", "b")).toBeFalsy();
+    expect(libraryManagerALibrarianB.hasRole("librarian", "b")).toBeTruthy();
+  });
+});

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