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

package/tests/jest/editorAdapter.test.ts

@@ -0,0 +1,245 @@
+import adapter from "../../src/editorAdapter";
+import {
+  OPDSEntry,
+  Contributor,
+  Series,
+  Category,
+  Summary,
+} from "opds-feed-parser";
+
+describe("editorAdapter", () => {
+  it("adapts valid OPDS entry", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      authors: [new Contributor({ name: "name", uri: "uri", role: "role" })],
+      subtitle: "subtitle",
+      contributors: [
+        new Contributor({ name: "name2", uri: "uri2", role: "role2" }),
+      ],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [
+        new Category({ term: "term", scheme: "scheme", label: "label" }),
+        new Category({
+          term: "13-16",
+          scheme: "http://schema.org/typicalAgeRange",
+          label: "age",
+        }),
+        new Category({
+          term: "ya",
+          scheme: "http://schema.org/audience",
+          label: "ya",
+        }),
+        new Category({
+          term: "fiction",
+          scheme: "http://librarysimplified.org/terms/fiction/",
+          label: "Fiction",
+        }),
+      ],
+      identifiers: [],
+      links: [
+        {
+          href: "hide",
+          rel: "http://librarysimplified.org/terms/rel/hide",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "restore",
+          rel: "http://librarysimplified.org/terms/rel/restore",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "refresh",
+          rel: "http://librarysimplified.org/terms/rel/refresh",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "edit",
+          rel: "edit",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "issues",
+          rel: "issues",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "change-cover",
+          rel: "http://librarysimplified.org/terms/rel/change_cover",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "cover",
+          rel: "http://opds-spec.org/image",
+          type: "image/png",
+          title: "title",
+          role: "role",
+        },
+      ],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {
+        "schema:alternativeHeadline": [{ _: "subtitle" }],
+        $: {
+          "schema:additionalType": { value: "medium" },
+        },
+        "bib:publisherImprint": [{ _: "imprint" }],
+        "schema:Rating": [
+          {
+            $: {
+              "schema:ratingValue": { value: "0.3" },
+              "schema:additionalType": {
+                value: "http://librarysimplified.org/terms/rel/quality",
+              },
+            },
+          },
+          {
+            $: {
+              "schema:ratingValue": { value: "4" },
+              "schema:additionalType": {
+                value: "http://schema.org/ratingValue",
+              },
+            },
+          },
+        ],
+      },
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.title).toBe("title");
+    expect(adapted.authors).toStrictEqual([
+      { name: "name", uri: "uri", role: "aut" },
+    ]);
+    // The adapter flattens `Contributor` instances into plain objects, so assert
+    // the shape it produces rather than comparing against `entry.contributors`.
+    expect(adapted.contributors).toStrictEqual([
+      { name: "name2", uri: "uri2", role: "role2" },
+    ]);
+    expect(adapted.subtitle).toBe("subtitle");
+    expect(adapted.summary).toBe("content");
+    expect(adapted.audience).toBe("ya");
+    expect(adapted.targetAgeRange).toStrictEqual(["13", "16"]);
+    expect(adapted.fiction).toBe(true);
+    expect(adapted.categories).toStrictEqual(["label", "age", "ya", "Fiction"]);
+    expect(adapted.hideLink).toStrictEqual(entry.links[0]);
+    expect(adapted.restoreLink).toStrictEqual(entry.links[1]);
+    expect(adapted.refreshLink).toStrictEqual(entry.links[2]);
+    expect(adapted.editLink).toStrictEqual(entry.links[3]);
+    expect(adapted.issuesLink).toStrictEqual(entry.links[4]);
+    expect(adapted.changeCoverLink).toStrictEqual(entry.links[5]);
+    expect(adapted.coverUrl).toBe(entry.links[6].href);
+    expect(adapted.series).toBe("series");
+    expect(adapted.seriesPosition).toBe(2);
+    expect(adapted.medium).toBe("medium");
+    expect(adapted.language).toBe("language");
+    expect(adapted.publisher).toBe("publisher");
+    expect(adapted.imprint).toBe("imprint");
+    expect(adapted.issued).toBe("issued");
+    expect(adapted.rating).toBe("4");
+  });
+
+  it("adapts visibility status from categories", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      subtitle: "subtitle",
+      authors: [],
+      contributors: [],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [
+        new Category({ term: "term", scheme: "scheme", label: "label" }),
+        new Category({
+          term: "manually-suppressed",
+          scheme: "http://palaceproject.io/terms/visibility-status",
+          label: "Manually Suppressed",
+        }),
+      ],
+      identifiers: [],
+      links: [],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {},
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.visibilityStatus).toBe("manually-suppressed");
+  });
+
+  it("adapts policy-filtered visibility status", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      subtitle: "subtitle",
+      authors: [],
+      contributors: [],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [
+        new Category({
+          term: "policy-filtered",
+          scheme: "http://palaceproject.io/terms/visibility-status",
+          label: "Policy Filtered",
+        }),
+      ],
+      identifiers: [],
+      links: [],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {},
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.visibilityStatus).toBe("policy-filtered");
+  });
+
+  it("doesn't crash when expected data is missing", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      subtitle: "subtitle",
+      authors: [],
+      contributors: [],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [],
+      identifiers: [],
+      links: [],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {},
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.title).toBe("title");
+  });
+});

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