@thepalaceproject/circulation-admin 1.43.0-post.1 → 1.43.0-post.11

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/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/legacy-setup.ts

@@ -0,0 +1,13 @@
+import { configure } from "enzyme";
+import * as Adapter from "enzyme-adapter-react-16";
+
+// Setup for the legacy enzyme + chai + sinon tests under `src/**/__tests__/`.
+// Replaces what `src/testHelper.ts` did for mocha. Delete alongside the last
+// enzyme test.
+
+configure({ adapter: new Adapter() });
+
+// Unhandled promise rejections are tolerated for these tests — see the comment in
+// `legacyJsdomEnvironment.js`. It cannot be done from here: jest hands test code a
+// *copy* of `process`, so a listener registered in this file never reaches the real
+// one that Node checks before throwing.

package/tests/jest/legacyJsdomEnvironment.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const JSDOMEnvironment = require("jest-environment-jsdom").default;
+
+const warnUnhandledRejection = (reason) => {
+  console.warn("Unhandled promise rejection in a legacy test:", reason);
+};
+
+/**
+ * jsdom environment for the legacy enzyme tests. Delete it with the last one.
+ *
+ * Two things it restores that `src/testHelper.ts` used to provide under mocha:
+ *
+ * 1. `global.jsdom`. A handful of tests call `global.jsdom.reconfigure({ url })` to
+ *    change the page origin mid-test. `history.replaceState` is not a substitute —
+ *    they navigate across origins (`http://example.com`), which it cannot do.
+ *
+ * 2. Tolerance for unhandled promise rejections. Several suites stub a `fetch` that
+ *    rejects, and nothing awaits the result; the rejection surfaces after the test
+ *    has already passed. Mocha shrugged those off because its runner keeps an
+ *    `unhandledRejection` listener installed, and Node only throws when there are
+ *    none. Under jest they kill the worker and take the whole suite with them.
+ *
+ *    Re-arming has to happen on the `teardown` event, not in the constructor.
+ *    `jest-circus/globalErrorHandlers` reads `process.listeners()` off the sandbox's
+ *    *copied* `process` (always empty) but calls `removeAllListeners()` on the real
+ *    one. So any listener registered earlier is dropped at `setup` and "restored"
+ *    from an empty list, leaving zero listeners during the post-run window where
+ *    these rejections actually land.
+ *
+ *    Scoping this to the legacy environment keeps the modern `tests/jest/` suite
+ *    strict: jest clears listeners at each file's `setup`, and nothing re-arms one
+ *    for a project that does not use this environment.
+ */
+module.exports = class LegacyJSDOMEnvironment extends JSDOMEnvironment {
+  constructor(config, context) {
+    super(config, context);
+    this.global.jsdom = this.dom;
+  }
+
+  handleTestEvent(event) {
+    if (
+      event.name === "teardown" &&
+      process.listenerCount("unhandledRejection") === 0
+    ) {
+      process.on("unhandledRejection", warnUnhandledRejection);
+    }
+  }
+};

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