@thepalaceproject/circulation-admin 1.22.0-post.1 → 1.22.0-post.3

package/package.json

@@ -149,5 +149,5 @@
     "*.{js,jsx,ts,tsx,css,md}": "prettier --write",
     "*.{js,css,md}": "prettier --write"
   },
-  "version": "1.22.0-post.1"
+  "version": "1.22.0-post.3"
 }

package/tests/jest/businessRules/roleBasedAccess.test.ts

@@ -0,0 +1,158 @@
+import { renderHook } from "@testing-library/react-hooks";
+import { componentWithProviders } from "../testUtils/withProviders";
+import { ContextProviderProps } from "../../../src/components/ContextProvider";
+import { ConfigurationSettings, FeatureFlags } from "../../../src/interfaces";
+import {
+  useMayRequestInventoryReports,
+  useMayViewCollectionBarChart,
+} from "../../../src/businessRules/roleBasedAccess";
+
+const setupWrapper = ({
+  roles,
+  featureFlags,
+}: Partial<ConfigurationSettings>) => {
+  const contextProviderProps: ContextProviderProps = {
+    featureFlags,
+    roles,
+    email: "email",
+    csrfToken: "token",
+  };
+  return componentWithProviders({ contextProviderProps });
+};
+
+describe("Business rules for role-based access", () => {
+  const libraryMatch = "match";
+  const libraryMismatch = "mismatch";
+
+  describe("controls access to inventory reports", () => {
+    const testAccess = (
+      expectedResult: boolean,
+      config: Partial<ConfigurationSettings>
+    ) => {
+      const wrapper = setupWrapper(config);
+      const { result } = renderHook(
+        () => useMayRequestInventoryReports({ library: libraryMatch }),
+        { wrapper }
+      );
+      expect(result.current).toBe(expectedResult);
+    };
+
+    it("restricts access to only sysadmins, if the restriction feature flag is true", () => {
+      const featureFlags: FeatureFlags = { reportsOnlyForSysadmins: true };
+
+      testAccess(true, { roles: [{ role: "system" }], featureFlags });
+
+      testAccess(false, { roles: [{ role: "manager-all" }], featureFlags });
+      testAccess(false, { roles: [{ role: "librarian-all" }], featureFlags });
+
+      testAccess(false, {
+        roles: [{ role: "manager", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(false, {
+        roles: [{ role: "manager", library: libraryMismatch }],
+        featureFlags,
+      });
+      testAccess(false, {
+        roles: [{ role: "librarian", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(false, {
+        roles: [{ role: "librarian", library: libraryMismatch }],
+        featureFlags,
+      });
+    });
+
+    it("allows all users, if the restriction feature flag is is false", () => {
+      const featureFlags: FeatureFlags = { reportsOnlyForSysadmins: false };
+
+      testAccess(true, { roles: [{ role: "system" }], featureFlags });
+
+      testAccess(true, { roles: [{ role: "manager-all" }], featureFlags });
+      testAccess(true, { roles: [{ role: "librarian-all" }], featureFlags });
+
+      testAccess(true, {
+        roles: [{ role: "manager", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(true, {
+        roles: [{ role: "manager", library: libraryMismatch }],
+        featureFlags,
+      });
+      testAccess(true, {
+        roles: [{ role: "librarian", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(true, {
+        roles: [{ role: "librarian", library: libraryMismatch }],
+        featureFlags,
+      });
+    });
+
+    it("allows all users, if the restriction feature flag is not set", () => {
+      const featureFlags: FeatureFlags = {};
+
+      testAccess(true, { roles: [{ role: "system" }], featureFlags });
+
+      testAccess(true, { roles: [{ role: "manager-all" }], featureFlags });
+      testAccess(true, { roles: [{ role: "librarian-all" }], featureFlags });
+
+      testAccess(true, {
+        roles: [{ role: "manager", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(true, {
+        roles: [{ role: "manager", library: libraryMismatch }],
+        featureFlags,
+      });
+      testAccess(true, {
+        roles: [{ role: "librarian", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(true, {
+        roles: [{ role: "librarian", library: libraryMismatch }],
+        featureFlags,
+      });
+    });
+  });
+
+  describe("controls access to the collection statistics barchart", () => {
+    const testAccess = (
+      expectedResult: boolean,
+      config: Partial<ConfigurationSettings>
+    ) => {
+      const wrapper = setupWrapper(config);
+      const { result } = renderHook(
+        () => useMayViewCollectionBarChart({ library: libraryMatch }),
+        { wrapper }
+      );
+      expect(result.current).toBe(expectedResult);
+    };
+
+    it("restricts access to sysadmins", () => {
+      const featureFlags: FeatureFlags = {};
+
+      testAccess(true, { roles: [{ role: "system" }], featureFlags });
+
+      testAccess(false, { roles: [{ role: "manager-all" }], featureFlags });
+      testAccess(false, { roles: [{ role: "librarian-all" }], featureFlags });
+
+      testAccess(false, {
+        roles: [{ role: "manager", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(false, {
+        roles: [{ role: "manager", library: libraryMismatch }],
+        featureFlags,
+      });
+      testAccess(false, {
+        roles: [{ role: "librarian", library: libraryMatch }],
+        featureFlags,
+      });
+      testAccess(false, {
+        roles: [{ role: "librarian", library: libraryMismatch }],
+        featureFlags,
+      });
+    });
+  });
+});

package/tests/jest/components/Stats.test.tsx

@@ -1,8 +1,9 @@
 import * as React from "react";
 import { render } from "@testing-library/react";
 import LibraryStats, {
-  CustomTooltip,
+  ALL_LIBRARIES_HEADING,
 } from "../../../src/components/LibraryStats";
+import { CustomTooltip } from "../../../src/components/StatsCollectionsBarChart";
 import {
   componentWithProviders,
   renderWithProviders,
@@ -190,7 +191,7 @@ describe("Dashboard Statistics", () => {
 
       // We should show our content without the loading state.
       assertNotLoadingState({ queryByRole });
-      getByRole("heading", { level: 2, name: "Statistics for All Libraries" });
+      getByRole("heading", { level: 2, name: ALL_LIBRARIES_HEADING });
 
       // We haven't made another call, since the response is cached.
       expect(fetchMock.calls()).toHaveLength(1);
@@ -201,7 +202,7 @@ describe("Dashboard Statistics", () => {
 
       // We should show our content immediately, without entering the loading state.
       assertNotLoadingState({ queryByRole });
-      getByRole("heading", { level: 2, name: "Statistics for All Libraries" });
+      getByRole("heading", { level: 2, name: ALL_LIBRARIES_HEADING });
 
       // We never tried to fetch anything because the result is cached.
       expect(fetchMock.calls()).toHaveLength(0);
@@ -216,10 +217,10 @@ describe("Dashboard Statistics", () => {
       assertNotLoadingState({ queryByRole });
       getByRole("heading", {
         level: 2,
-        name: `${sampleLibraryName} Statistics`,
+        name: `${sampleLibraryName} Dashboard`,
       });
-      getByRole("heading", { level: 3, name: "Patrons" });
-      getByText("132");
+      getByRole("heading", { level: 3, name: "Current Circulation Activity" });
+      getByText("623");
 
       // We never tried to fetch anything because the result is cached.
       expect(fetchMock.calls()).toHaveLength(0);
@@ -233,9 +234,9 @@ describe("Dashboard Statistics", () => {
       // We should show our content immediately, without entering the loading state.
       assertNotLoadingState({ queryByRole });
 
-      getByRole("heading", { level: 2, name: "Statistics for All Libraries" });
-      getByRole("heading", { level: 3, name: "Patrons" });
-      getByText("145");
+      getByRole("heading", { level: 2, name: ALL_LIBRARIES_HEADING });
+      getByRole("heading", { level: 3, name: "Current Circulation Activity" });
+      getByText("1.6k");
 
       // We never tried to fetch anything because the result is cached.
       expect(fetchMock.calls()).toHaveLength(0);

package/tests/jest/context/AppContext.test.tsx

@@ -0,0 +1,72 @@
+import { renderHook } from "@testing-library/react-hooks";
+import {
+  useAppAdmin,
+  useAppContext,
+  useAppEmail,
+  useAppFeatureFlags,
+  useCsrfToken,
+} from "../../../src/context/appContext";
+import { componentWithProviders } from "../testUtils/withProviders";
+import { ContextProviderProps } from "../../../src/components/ContextProvider";
+import { FeatureFlags } from "../../../src/interfaces";
+
+// TODO: These tests may need to be adjusted in the future.
+//  Currently, an AppContext.Provider is injected into the component tree
+//  by the ContextProvider, which itself uses a legacy context API. (See
+//    https://legacy.reactjs.org/docs/legacy-context.html)
+//  but that will change once uses of that API have been removed.
+
+describe("AppContext", () => {
+  const expectedCsrfToken = "token";
+  const expectedEmail = "email";
+  const expectedFeatureFlags: FeatureFlags = {
+    // @ts-expect-error - "testTrue" & "testFalse" aren't valid feature flags
+    testTrue: true,
+    testFalse: false,
+  };
+  const expectedRoles = [{ role: "system" }];
+
+  const contextProviderProps: ContextProviderProps = {
+    csrfToken: expectedCsrfToken,
+    featureFlags: expectedFeatureFlags,
+    roles: expectedRoles,
+    email: expectedEmail,
+  };
+  const wrapper = componentWithProviders({ contextProviderProps });
+
+  it("provides useAppContext context hook", () => {
+    const { result } = renderHook(() => useAppContext(), { wrapper });
+    const value = result.current;
+    expect(value.csrfToken).toEqual(expectedCsrfToken);
+    expect(value.admin.email).toEqual(expectedEmail);
+    expect(value.admin.roles).toEqual(expectedRoles);
+    expect(value.featureFlags).toEqual(expectedFeatureFlags);
+  });
+
+  it("provides useAppAdmin context hook", () => {
+    const { result } = renderHook(() => useAppAdmin(), { wrapper });
+    const admin = result.current;
+    expect(admin.email).toEqual(expectedEmail);
+    expect(admin.roles).toEqual(expectedRoles);
+  });
+
+  it("provides useAppEmail context hook", () => {
+    const { result } = renderHook(() => useAppEmail(), { wrapper });
+    const email = result.current;
+    expect(email).toEqual(expectedEmail);
+  });
+
+  it("provides useCsrfToken context hook", () => {
+    const { result } = renderHook(() => useCsrfToken(), { wrapper });
+    const token = result.current;
+    expect(token).toEqual(expectedCsrfToken);
+  });
+
+  it("provides useAppFeatureFlags context hook", () => {
+    const { result } = renderHook(() => useAppFeatureFlags(), {
+      wrapper,
+    });
+    const flags = result.current;
+    expect(flags).toEqual(expectedFeatureFlags);
+  });
+});