Scc 3773/utils testing

src/utils/searchUtils.ts

@@ -21,9 +21,10 @@ import type {
 function getSortQuery(sortBy = "", order = ""): string {
   const reset = sortBy === "relevance"
   let sortQuery = ""
+  const sortDirectionQuery = order === "" ? "" : `&sort_direction=${order}`
 
   if (sortBy?.length && !reset) {
-    sortQuery = `&sort=${sortBy}&sort_direction=${order}`
+    sortQuery = `&sort=${sortBy}${sortDirectionQuery}`
   }
 
   return sortQuery
@@ -85,7 +86,7 @@ function getFilterQuery(filters: SearchFilters) {
 
 /**
  * getQueryString
- * Builds a query string from a SearchParams object, setting defaults on some undefined params.
+ * Builds a query string from a SearchParams object
  */
 export function getQueryString({
   sortBy = "relevance",
@@ -162,17 +163,18 @@ export function mapQueryToSearchParams({
  * mapRequestBodyToSearchParams
  * Maps the POST request body from an JS disabled advanced search to a SearchParams object
  */
-export function mapRequestBodyToSearchParams({
-  q,
-  page,
-  contributor,
-  title,
-  subject,
-  language,
-  materialType,
-  dateAfter,
-  dateBefore,
-}): SearchParams {
+export function mapRequestBodyToSearchParams(reqBody): SearchParams {
+  const {
+    q,
+    page,
+    contributor,
+    title,
+    subject,
+    language,
+    materialType,
+    dateAfter,
+    dateBefore,
+  } = reqBody
   return {
     q,
     page,

__tests__/pages/index.test.tsx → test/__test__/pages/index.test.tsx

@@ -1,7 +1,7 @@
 import React from "react"
 import { render, screen } from "@testing-library/react"
 import "@testing-library/jest-dom"
-import Home from "../../pages/index"
+import Home from "../../../pages/index"
 
 describe("Home", () => {
   it("should render an H2", () => {

test/__test__/utils/appUtils.test.tsx

@@ -0,0 +1,24 @@
+import { getActivePage } from "../../../src/utils/appUtils"
+import { PATHS } from "../../../src/config/constants"
+
+describe("appUtils", () => {
+  describe("getActivePage", () => {
+    it("should return search for / or /search", () => {
+      expect(getActivePage(PATHS.HOME)).toBe("search")
+      expect(getActivePage(PATHS.SEARCH)).toBe("search")
+    })
+    it("should return advanced for ADVANCED SEARCH", () => {
+      expect(getActivePage(PATHS.ADVANCED_SEARCH)).toBe("advanced")
+    })
+    it("should return advanced for PATHS[404]", () => {
+      expect(getActivePage(PATHS["404"])).toBe("404")
+      expect(getActivePage(PATHS["404_REDIRECT"])).toBe("404")
+    })
+    it("should return an empty string for all other cases", () => {
+      expect(getActivePage("spaghetti")).toBe("")
+    })
+    it("should handle an empty string", () => {
+      expect(getActivePage("")).toBe("")
+    })
+  })
+})

test/__test__/utils/bibUtils.test.tsx

@@ -0,0 +1,36 @@
+import { standardizeBibId } from "../../../src/utils/bibUtils"
+
+describe("bibUtils", () => {
+  describe("standardizeBibId", () => {
+    describe("standardizeBib", () => {
+      it("doesn't mess with kosher id", () => {
+        expect(standardizeBibId("b12345678")).toBe("b12345678")
+        expect(standardizeBibId("hb123456789123456789")).toBe(
+          "hb123456789123456789"
+        )
+      })
+      it("removes check digit", () => {
+        expect(standardizeBibId("b12345678x")).toBe("b12345678")
+        expect(standardizeBibId("b12345678X")).toBe("b12345678")
+        expect(standardizeBibId("b123456781")).toBe("b12345678")
+      })
+      it("lower cases everything", () => {
+        expect(standardizeBibId("B12345678")).toBe("b12345678")
+        expect(standardizeBibId("CB1234567")).toBe("cb1234567")
+        expect(standardizeBibId("Hb123456789123456789")).toBe(
+          "hb123456789123456789"
+        )
+        expect(standardizeBibId("PB1234567")).toBe("pb1234567")
+        expect(standardizeBibId("PB1234567812345678")).toBe(
+          "pb1234567812345678"
+        )
+      })
+      it("returns value provided if input does not match bib id regexes", () => {
+        expect(standardizeBibId("b1234567899")).toBe("b1234567899")
+        expect(standardizeBibId("i am not a bib id hb123")).toBe(
+          "i am not a bib id hb123"
+        )
+      })
+    })
+  })
+})

test/__test__/utils/drbUtils.test.tsx

@@ -0,0 +1,109 @@
+import { getDRBQueryStringFromSearchParams } from "../../../src/utils/drbUtils"
+import { DRB_RESULTS_PER_PAGE } from "../../../src/config/constants"
+import { queryParamsEquality } from "../../helpers/searchHelpers"
+
+const checkQueryParamsEquality = queryParamsEquality(
+  getDRBQueryStringFromSearchParams
+)
+
+describe("researchNowUtils", () => {
+  describe("getDRBQueryStringFromSearchParams", () => {
+    it("should handle empty query", () => {
+      const testQuery = `?query=keyword%3A*&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(checkQueryParamsEquality(testQuery, {})).toBe(true)
+    })
+
+    it("should handle simple keyword query", () => {
+      const testQuery = `?query=keyword%3Atoast&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(checkQueryParamsEquality(testQuery, { q: "toast" })).toBe(true)
+    })
+
+    it("should handle field", () => {
+      const testQuery = `?query=title%3Atoast&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(
+        checkQueryParamsEquality(testQuery, { q: "toast", field: "title" })
+      ).toBe(true)
+    })
+
+    it("should handle keyword & subject query", () => {
+      const testQuery = `?query=keyword%3Atoast,subject%3ASnacks&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(
+        checkQueryParamsEquality(testQuery, {
+          q: "toast",
+          filters: { subjectLiteral: "Snacks" },
+        })
+      ).toBe(true)
+    })
+
+    it("should handle contributor filter", () => {
+      const testQuery = `?query=keyword%3A*,author%3APoe&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(
+        checkQueryParamsEquality(testQuery, {
+          filters: { contributorLiteral: "Poe" },
+        })
+      ).toBe(true)
+    })
+
+    it("should handle lang filter", () => {
+      const testQuery = `?query=keyword%3A*&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}&filter=language%3Aen`
+      expect(
+        checkQueryParamsEquality(testQuery, {
+          filters: { language: "lang:en" },
+        })
+      ).toBe(true)
+    })
+
+    it("should handle dateAfter filter", () => {
+      const testQuery = `?query=keyword%3A*&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}&filter=startYear%3A2000`
+      expect(
+        checkQueryParamsEquality(testQuery, { filters: { dateAfter: "2000" } })
+      ).toBe(true)
+    })
+
+    it("should handle dateBefore filter", () => {
+      const testQuery = `?query=keyword%3A*&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}&filter=endYear%3A2020`
+      expect(
+        checkQueryParamsEquality(testQuery, { filters: { dateBefore: "2020" } })
+      ).toBe(true)
+    })
+
+    it("should handle dateAfter & dateBefore filter", () => {
+      const testQuery = `?query=keyword%3A*&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}&filter=startYear%3A2000,endYear%3A2020`
+      expect(
+        checkQueryParamsEquality(testQuery, {
+          filters: { dateAfter: "2000", dateBefore: "2020" },
+        })
+      ).toBe(true)
+    })
+
+    it("should handle contributor param", () => {
+      const testQuery = `?query=keyword%3A*%2Cauthor%3APoe&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(checkQueryParamsEquality(testQuery, { contributor: "Poe" })).toBe(
+        true
+      )
+    })
+
+    it("should handle title param", () => {
+      const testQuery = `?query=keyword%3A*%2Ctitle%3ARaven&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(checkQueryParamsEquality(testQuery, { title: "Raven" })).toBe(true)
+    })
+
+    it("should handle subject param", () => {
+      const testQuery = `?query=keyword%3A*%2Csubject%3Acorvids&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(checkQueryParamsEquality(testQuery, { subject: "corvids" })).toBe(
+        true
+      )
+    })
+
+    it("should combine query params", () => {
+      const testQuery = `?query=keyword%3ARaven%2Cauthor%3APoe%2Csubject%3Acorvids&page=1&source=catalog&size=${DRB_RESULTS_PER_PAGE}`
+      expect(
+        checkQueryParamsEquality(testQuery, {
+          contributor: "Poe",
+          subject: "corvids",
+          q: "Raven",
+        })
+      ).toBe(true)
+    })
+  })
+})

test/__test__/utils/searchUtils.test.tsx

@@ -0,0 +1,66 @@
+import {
+  getQueryString,
+  mapQueryToSearchParams,
+  mapRequestBodyToSearchParams,
+} from "../../../src/utils/searchUtils"
+import { queryParamsEquality } from "../../helpers/searchHelpers"
+
+const checkQueryParamsEquality = queryParamsEquality(getQueryString)
+
+describe("searchUtils", () => {
+  describe("getQueryString", () => {
+    it("constructs a basic query", () => {
+      const testQuery =
+        "?q=shel%20silverstein&search_scope=contributor&sort=datePublished&sort_direction=asc"
+      expect(
+        checkQueryParamsEquality(testQuery, {
+          q: "shel silverstein",
+          field: "contributor",
+          sortBy: "datePublished",
+          order: "asc",
+        })
+      ).toBe(true)
+    })
+  })
+  describe("mapQueryToSearchParams", () => {
+    it("should consolidate identifiers and change some keys", () => {
+      expect(
+        mapQueryToSearchParams({
+          issn: "123",
+          isbn: "456",
+          search_scope: "contributor",
+          sort_direction: "asc",
+          sort: "spaghetti",
+        })
+      ).toEqual({
+        identifiers: {
+          issn: "123",
+          isbn: "456",
+        },
+        field: "contributor",
+        order: "asc",
+        sortBy: "spaghetti",
+      })
+    })
+  })
+  describe("mapRequestBodyToSearchParams", () => {
+    it("combines filters", () => {
+      const params = mapRequestBodyToSearchParams({
+        q: "spaghetti",
+        language: "igbo",
+        materialType: "scroll",
+        dateAfter: "1900",
+        dateBefore: "1902",
+      })
+      expect(params).toEqual({
+        q: "spaghetti",
+        filters: {
+          language: "igbo",
+          materialType: "scroll",
+          dateAfter: "1900",
+          dateBefore: "1902",
+        },
+      })
+    })
+  })
+})

test/helpers/searchHelpers.js

@@ -0,0 +1,21 @@
+/**
+ * An effort to avoid brittleness due to potentially variable order in query
+ * parameters. This testing util splits query strings into arrays that are
+ * compared for matching elements instead of comparing for strict equality of
+ * string literals.
+ *  */
+
+export const queryParamsEquality = (queryConstructor) => {
+  return (test, queryParamsToConstruct) => {
+    const testQueries = test.substring(1).split("&")
+    const constructedQueries = queryConstructor(queryParamsToConstruct)
+      .substring(1)
+      .split("&")
+    return (
+      testQueries.every((queryParam) =>
+        constructedQueries.includes(queryParam)
+      ) &&
+      constructedQueries.every((queryParam) => testQueries.includes(queryParam))
+    )
+  }
+}