@thepalaceproject/circulation-admin 0.0.0-post.1

package/tests/browser/navigate.js

@@ -0,0 +1,294 @@
+const breadcrumbSelector = "ol.breadcrumb";
+let loadingSelector;
+let catalogPage;
+let bookPage;
+
+module.exports = {
+  /**
+   * Before any tests run, log in with the correct credentials.
+   */
+  before: (browser, done) => {
+    const { username, password } = browser.globals;
+    catalogPage = browser.page.catalog();
+    bookPage = browser.page.book();
+    loadingSelector = catalogPage.elements.loadingSelector;
+
+    browser
+      .resizeWindow(1200, 900)
+      .signIn(username, password)
+      .perform(() => {
+        done();
+      });
+  },
+
+  "navigate to the first lane and back": function(browser) {
+    const { laneSelector } = catalogPage.elements;
+    const { nthBreadcrumbSelector } = catalogPage;
+
+    browser
+      .goHome()
+      .url(function(result) {
+        let catalogUrl = result.value;
+        this.getAttribute(laneSelector, "href", function(result) {
+          let laneUrl = result.value;
+          this.getText(laneSelector, function(laneText) {
+            let laneTitle = laneText.value;
+
+            this.click(laneSelector)
+              .waitForElementNotPresent(loadingSelector, 5000)
+              .verify.noError()
+              .verify.urlEquals(laneUrl)
+              .verify.titleContains(laneTitle)
+              // when a lane selector is clicked, we go into another
+              // navigation level
+              .verify.elementPresent(nthBreadcrumbSelector(3))
+              .back()
+              .waitForElementNotPresent(loadingSelector, 5000)
+              .verify.urlEquals(catalogUrl)
+              .verify.elementNotPresent(nthBreadcrumbSelector(3));
+          });
+        });
+      });
+  },
+
+  "navigate to the first book in the first lane and back": function(browser) {
+    const {
+      bookSelector,
+      bookLinkTitleSelector
+    } = catalogPage.elements;
+    const { bookTitleSelector } = bookPage.elements;
+
+    browser
+      .goHome()
+      .url(function(result) {
+        let catalogUrl = result.value;
+        this.getAttribute(bookSelector, "href", function(result) {
+          let bookUrl = result.value;
+          this.getText(bookLinkTitleSelector, function(result) {
+            let bookTitle = result.value;
+            this
+              .click(bookSelector)
+              .waitForElementPresent(bookTitleSelector, 5000)
+              .verify.noError()
+              .verify.urlEquals(bookUrl)
+              .verify.titleContains(bookTitle)
+              .verify.containsText(bookTitleSelector, bookTitle)
+              .back()
+              .waitForElementNotPresent(loadingSelector, 5000)
+              .verify.urlEquals(catalogUrl)
+              .verify.elementNotPresent(bookTitleSelector);
+          });
+        });
+      });
+  },
+
+  "navigate to the first book, click through tabs, refresh page, go back": function(browser) {
+    const { bookSelector } = catalogPage.elements;
+    const {
+      bookTitleSelector,
+      titleInputSelector,
+      genreInputSelector,
+      coverInputSelector,
+      complaintInputSelector,
+      listInputSelector,
+      editTabSelector,
+      classificationsTabSelector,
+      coverTabSelector,
+      complaintsTabSelector,
+      listsTabSelector
+    } = bookPage.elements;
+
+    browser
+      .goHome()
+      .getAttribute(bookSelector, "href", function(result) {
+        let bookUrl = result.value;
+        this.getAttribute(bookSelector, "title", function(result) {
+          let bookTitle = result.value;
+          this
+            .click(bookSelector)
+            .waitForElementPresent(bookTitleSelector, 5000)
+            .verify.noError()
+            .verify.urlEquals(bookUrl)
+            .verify.containsText(bookTitleSelector, bookTitle)
+
+            // go to the edit tab
+            .click(editTabSelector)
+            .waitForElementPresent(titleInputSelector, 5000)
+            .verify.urlContains("tab/edit")
+            .verify.value(titleInputSelector, bookTitle)
+
+            // go to the classifications tab
+            .click(classificationsTabSelector)
+            .waitForElementPresent(genreInputSelector, 5000)
+            .verify.urlContains("tab/classifications")
+
+            // go to the image cover tab
+            .click(coverTabSelector)
+            .waitForElementPresent(coverInputSelector, 5000)
+            .verify.urlContains("tab/cover")
+
+            // go to the complaints tab
+            .click(complaintsTabSelector)
+            .waitForElementPresent(complaintInputSelector, 5000)
+            .verify.urlContains("tab/complaints")
+            .refresh()
+            .waitForElementPresent(complaintInputSelector, 5000)
+            .verify.urlContains("tab/complaints")
+            .verify.titleContains(bookTitle)
+
+            // go to the list tab
+            .click(listsTabSelector)
+            .waitForElementPresent(listInputSelector, 5000)
+            .verify.urlContains("tab/list")
+
+            // go back to the complaints tab
+            .back()
+            // go back to the cover tab
+            .back()
+            // go back to the classifications tab
+            .back()
+            // go back to the edit tab
+            .back()
+            // go back to the main details tab
+            .back()
+            .waitForElementPresent(bookTitleSelector, 5000)
+            .verify.urlEquals(bookUrl);
+        });
+      });
+  },
+
+  "navigate to top-level feeds": function(browser) {
+    const {
+      laneSelector,
+      complaintsSelector,
+      hiddenSelector
+    } = catalogPage.elements;
+    const { nthBreadcrumbSelector } = catalogPage;
+
+    browser
+      .goHome()
+      .getAttribute(complaintsSelector, "href", function(result) {
+        let complaintsUrl = result.value;
+        this.getText(complaintsSelector, function(result) {
+          let complaintsTitle = result.value;
+          this.getAttribute(hiddenSelector, "href", function(result) {
+            let hiddenUrl = result.value
+            this.getText(hiddenSelector, function(result) {
+              let hiddenTitle = result.value;
+              this.getText(laneSelector, function(result) {
+                let laneTitle = result.value;
+                this
+                  // go to the first lane
+                  .click(laneSelector)
+                  .waitForElementNotPresent(loadingSelector, 5000)
+                  .waitForElementPresent(nthBreadcrumbSelector(2), 5000)
+                  .assert.noError()
+                  .verify.containsText(nthBreadcrumbSelector(1), "All Books")
+                  .verify.containsText(nthBreadcrumbSelector(2), "Book")
+                  .verify.containsText(nthBreadcrumbSelector(3), laneTitle)
+
+                  // go to the complaints page
+                  .click(complaintsSelector)
+                  .waitForElementNotPresent(loadingSelector, 5000)
+                  .assert.noError()
+                  .assert.containsText(nthBreadcrumbSelector(1), "All Books")
+                  .assert.containsText(nthBreadcrumbSelector(2), complaintsTitle)
+                  .verify.urlEquals(complaintsUrl)
+
+                  // go to the hidden books page
+                  .click(hiddenSelector)
+                  .waitForElementNotPresent(loadingSelector, 5000)
+                  .assert.noError()
+                  .assert.containsText(nthBreadcrumbSelector(1), "All Books")
+                  .assert.containsText(nthBreadcrumbSelector(2), hiddenTitle)
+                  .verify.urlEquals(hiddenUrl);
+              });
+            });
+          });
+        });
+      });
+  },
+
+  "navigate to dashboard and back to catalog": function(browser) {
+    const {
+      catalogSelector,
+      dashboardSelector,
+      circulationLibraryStatsSelector,
+      circulationAllStatsSelector,
+    } = catalogPage.elements;
+    const { nthBreadcrumbSelector } = catalogPage;
+
+    browser
+      .goHome()
+      .getAttribute(nthBreadcrumbSelector(1), "title", function(result) {
+        let libraryName = result.value;
+        this.getAttribute(catalogSelector, "href", function(result) {
+          let catalogUrl = result.value;
+            this.getAttribute(dashboardSelector, "href", function(result) {
+            let dashboardUrl = result.value
+            this
+              // go to the dashboard
+              .click(dashboardSelector)
+              .waitForElementNotPresent(loadingSelector, 5000)
+              .assert.noError()
+              .verify.elementPresent(circulationLibraryStatsSelector)
+              .verify.elementPresent(circulationAllStatsSelector)
+              .verify.titleContains("Palace Collection Manager - Dashboard")
+
+              // click the main navigation link
+              .click(catalogSelector)
+              .waitForElementNotPresent(loadingSelector, 5000)
+              .assert.noError()
+              .verify.elementPresent(nthBreadcrumbSelector(1))
+              .verify.urlEquals(catalogUrl)
+              .verify.titleContains(`Palace Collection Manager - ${libraryName}`);
+          });
+        });
+      });
+  },
+
+  "navigate to two different book detail pages": function(browser) {
+    const {
+      laneSelector,
+      firstBookSelector,
+      secondBookSelector
+    } = catalogPage.elements;
+    const { bookTitleSelector } = bookPage.elements;
+    const { nthBreadcrumbSelector } = catalogPage;
+
+    browser
+      .goHome()
+
+      // go to the first book
+      .click(firstBookSelector)
+      .waitForElementNotPresent(loadingSelector, 5000)
+      .waitForElementPresent(bookTitleSelector, 5000)
+      .getText(bookTitleSelector, function(result) {
+        let firstTitle = result.value;
+
+        this
+          // go back to the catalog
+          .click(nthBreadcrumbSelector(1))
+          .waitForElementNotPresent(loadingSelector, 5000)
+          .waitForElementPresent(secondBookSelector, 5000)
+
+          // go to the second book
+          .click(secondBookSelector)
+          .waitForElementNotPresent(loadingSelector, 5000)
+          .waitForElementPresent(bookTitleSelector, 50000)
+
+          // making sure that we are on a new book
+          .getText(bookTitleSelector, function(result) {
+            let secondTitle = result.value;
+            this.assert.notEqual(firstTitle, secondTitle);
+          });
+      });
+  },
+
+  /**
+   * Correctly end the selenium server and tests
+   */
+  after: (browser) => {
+    browser.end();
+  }
+};

package/tests/browser/pages/book.js

@@ -0,0 +1,21 @@
+// Page Object for a book page
+module.exports = {
+  elements: {
+    // Elements found on each tab
+    bookTitleSelector: ".book-details .title",
+    titleInputSelector: "input[name='title']",
+    genreInputSelector: "select[name='genre']",
+    // 2nd child because the first is a label
+    genreSecondOptionSelector: "select[name='genre'] option:nth-child(2)",
+    coverInputSelector: "input[name='cover_url']",
+    complaintInputSelector: "select[name='type']",
+    listInputSelector: "input[name='list']",
+    // Tab selectors
+    detailsTabSelector: "ul.nav-tabs li:nth-child(1) a",
+    editTabSelector: "ul.nav-tabs li:nth-child(2) a",
+    classificationsTabSelector: "ul.nav-tabs li:nth-child(3) a",
+    coverTabSelector: "ul.nav-tabs li:nth-child(4) a",
+    complaintsTabSelector: "ul.nav-tabs li:nth-child(5) a",
+    listsTabSelector: "ul.nav-tabs li:nth-child(6) a",
+  }
+};

package/tests/browser/pages/catalog.js

@@ -0,0 +1,24 @@
+// Page Object for the catalog
+module.exports = {
+  elements: {
+    loadingSelector: ".loading",
+    laneSelector: "li:first-child .lane h2 a",
+    bookSelector: ".lane-books li:first-child a",
+    bookLinkTitleSelector: ".lane-books li:first-child a .title",
+    catalogSelector: "ul.nav li:nth-child(1) a",
+    complaintsSelector: "ul.nav li:nth-child(2) a",
+    hiddenSelector: "ul.nav li:nth-child(3) a",
+    dashboardSelector: "ul.nav li:nth-child(6) a",
+    circulationLibraryStatsSelector: ".library-stats:nth-child(1) h2",
+    circulationAllStatsSelector: ".library-stats:nth-child(2) h2",
+    firstBookSelector: "li:nth-child(1) .book a",
+    secondBookSelector: "li:nth-child(2) .book a",
+  },
+  commands: [
+    {
+      nthBreadcrumbSelector: function(n) {
+        return `ol.breadcrumb li:nth-child(${n})`
+      }
+    }
+  ]
+};

package/tests/browser/pages/login.js

@@ -0,0 +1,11 @@
+// Page Object for the login page
+module.exports = {
+  url: function() {
+    return this.api.globals.homeUrl;
+  },
+  elements: {
+    username: "input[type='text']",
+    password: "input[type='password']",
+    submit: "button[type='submit']"
+  }
+};

package/tests/browser/redirect.js

@@ -0,0 +1,104 @@
+const http = require('follow-redirects').http
+
+const fetchGroupPage = (browser) => {
+  return new Promise((resolve, reject) => {
+    http.get({
+      host: "localhost",
+      port: 6500,
+      path: "/groups/"
+    }, (response) => {
+      let body = "";
+
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+
+      response.on("error", (err) => {
+        reject(err);
+      });
+
+      response.on("end", () => {
+        resolve(body);
+      });
+    });
+  });
+}
+const getAdminBookUrlAndTitle = (body, browser) => {
+  const bookTitle = body.match(/<entry [\s\S]+?<title>([^<]+)<\/title>/i)[1];
+  const link = body.match(/<link [^>]*rel="alternate[^>]+\/>/i)[0];
+  const id = body.match(/<id>[\s\S]+?<\/id>/i)[0];
+  const lib = id.match(/\/[\w]+/i)[0]; // includes forward slash
+  const bookUrl = link.match(/href="([^"]+)"/)[1];
+  const entryBaseUrl = browser.globals.homeUrl.replace("/admin/web/", lib + "/works");
+
+  // transform the book url into an admin book url
+  const adminBookUrl =
+    browser.globals.homeUrl + "collection" + lib + "/book" + lib +
+    encodeURIComponent(
+      bookUrl.replace(entryBaseUrl, "")
+    );
+
+  return { adminBookUrl, bookTitle };
+};
+const getAdminListUrl = (body, browser) => {
+  const listBaseUrl = `${browser.globals.homeUrl}lists`;
+  const id = body.match(/<id>[\s\S]+?<\/id>/i)[0];
+  const libraryName = id.match(/\/[\w]+/i)[0]; // includes forward slash
+
+  return `${listBaseUrl}${libraryName}`;
+};
+let body;
+let loginPage;
+let loadingSelector;
+
+module.exports = {
+  beforeEach: (browser, done) => {
+    loginPage = browser.page.login();
+    loadingSelector = browser.page.catalog().elements.loadingSelector;
+
+    fetchGroupPage(browser)
+      .then(data => {
+        body = data
+        done();
+      });
+  },
+
+  "attempt to view the admin list page before signing in": (browser) => {
+    const adminListUrl = getAdminListUrl(body, browser);
+    const { username, password, submit } = loginPage.elements;
+
+    // Go to the admin list page, get redirected to the login page with the
+    // redirect in the url, log in successfully, then go to the admin list page
+    browser
+      .url(adminListUrl)
+      .waitForElementVisible(username, 1000)
+      .assert.urlContains("redirect=" + encodeURIComponent(adminListUrl))
+      .setValue(username, browser.globals.username)
+      .setValue(password, browser.globals.password)
+      .click(submit)
+      .waitForElementVisible(loadingSelector, 1000)
+      .assert.urlContains(adminListUrl);
+  },
+
+  // TODO: Update once flask has been updated on the server
+  // "attempt to view a book page before signing in": (browser) => {
+  //   const { adminBookUrl, bookTitle }  = getAdminBookUrlAndTitle(body, browser);
+  //   const { username, password, submit } = loginPage.elements;
+  //   const { bookTitleSelector } = browser.page.book().elements;
+
+  //   browser
+  //     .url(adminBookUrl)
+  //     .waitForElementVisible(username, 1000)
+  //     .verify.urlContains("redirect=" + encodeURIComponent(adminBookUrl))
+  //     .setValue(username, browser.globals.username)
+  //     .setValue(password, browser.globals.password)
+  //     .click(submit)
+  //     .waitForElementVisible(loadingSelector, 1000)
+  //     .verify.containsText(bookTitleSelector, bookTitle)
+  //     .assert.urlContains(adminBookUrl);
+  // },
+
+  afterEach: (browser) => {
+    browser.end();
+  }
+};

package/tests/browser/signInFailure.js

@@ -0,0 +1,22 @@
+module.exports = {
+
+  /**
+   * The log in error page contains a simple message and a link to go back
+   * to the log in page.
+   */
+  "go to the error page with bad log in credentials": (browser) => {
+    const errorMessage = "p";
+    const tryAgainButton = "a";
+
+    browser
+      .resizeWindow(1200, 900)
+      .signIn("bad email", "bad password")
+      .waitForElementVisible("body", 10000)
+      .expect.element(errorMessage).text.to.contain("401 ERROR");
+    
+    browser
+      .assert.attributeContains(tryAgainButton, "href", "/admin/sign_in");
+    
+    browser.end();
+  }
+};

package/tests/jest/README.md

@@ -0,0 +1,6 @@
+# Jest Unit Tests
+
+This directory contains unit tests that run using jest. The directory structure should mirror that of the `src` tree.
+
+To run these tests, use the command `npm run test-jest`. These tests are executed along with the older mocha-based tests when `npm test` is run.
+To run a single test file, use the command `npm run test-jest-file [filename]`.

package/tests/jest/api/admin.test.ts

@@ -0,0 +1,60 @@
+import {
+  DEFAULT_BASE_ENDPOINT_URL,
+  getInventoryReportInfo,
+  requestInventoryReport,
+} from "../../../src/api/admin";
+import * as fetchMock from "fetch-mock-jest";
+
+const sampleInfoResponseData = { collections: [] };
+const sampleGenerateResponseData = { message: "some message" };
+
+const testAlternateBaseUrl = "/test/base/url";
+const libraryKey = "short-name";
+
+const testEndpoints = ({
+  title,
+  baseEndpointUrl: baseEndpointUrl = undefined,
+  expectedUrl = DEFAULT_BASE_ENDPOINT_URL,
+}) => {
+  describe(title, () => {
+    beforeEach(() => {
+      fetchMock
+        .get("*", { body: sampleInfoResponseData, status: 200 })
+        .post("*", { body: sampleGenerateResponseData, status: 202 });
+    });
+
+    afterEach(() => {
+      fetchMock.mockReset();
+    });
+
+    it("requests inventory report information", async () => {
+      const response = await getInventoryReportInfo({
+        library: libraryKey,
+        baseEndpointUrl,
+      });
+      expect(response).toStrictEqual(sampleInfoResponseData);
+      expect(fetchMock).toHaveBeenCalledWith(expectedUrl);
+    });
+
+    it("requests report generation via a post to the endpoint", async () => {
+      const response = await requestInventoryReport({
+        library: libraryKey,
+        baseEndpointUrl,
+      });
+      expect(response).toStrictEqual(sampleGenerateResponseData);
+      expect(fetchMock).toHaveBeenCalledWith(expectedUrl, { method: "POST" });
+    });
+  });
+};
+
+describe("Inventory report API", () => {
+  testEndpoints({
+    title: "default endpoints",
+    expectedUrl: `${DEFAULT_BASE_ENDPOINT_URL}/${libraryKey}`,
+  });
+  testEndpoints({
+    title: "alternative test endpoints",
+    baseEndpointUrl: testAlternateBaseUrl,
+    expectedUrl: `${testAlternateBaseUrl}/${libraryKey}`,
+  });
+});