114 testing testing [coverage edition] (#116)

* Modernize testing: migrate from Jest to node:test

Add a testing modernization plan and migrate test layout and CI to the new approach. Remove the legacy Jest config and delete legacy __tests__ artifacts, add a new top-level test/ suite with helpers (including test/helpers/env.js) and route test files, and update docs and CI to run the consolidated npm script (allTests) and expose targeted scripts (coreTests, existsTests, functionalTests). Dev dependencies and package metadata were adjusted to support the new runner/coverage tools.

* Add Playwright e2e smoke tests and CI workflow

Introduce a GitHub Actions test matrix (fast and full gates) to run CI test groups. Add a Playwright-based browser smoke test (test/e2e/ui-smoke.test.js) that launches the app and verifies basic UI flows. Update README with local instructions for running e2e (install browsers) and the ci:fast/ci:full command groups.

* coverage thresholds

* e2e(ui): add browser helper and new smoke tests

Introduce launchBrowserOrSkip helper to centralize Chromium launch and skip logic when not installed, and refactor existing smoke test to use it. Add several end-to-end UI smoke tests: successful create submission (stubbing /create), client-side JSON validation that prevents network calls, query form results (stubbing /query), and overwrite conflict handling (stubbing /overwrite returning 409). Tests use Playwright routing to mock server responses and assert flash messages and object viewer output.

* Update tokens.js

* Update .github/workflows/tests.yaml

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update package.json

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* better test description

* Validate upstream RERUM contract in tests

Capture fetch URL/options in test mocks and add assertions to verify the upstream RERUM contract (URL, HTTP method, Authorization header, Content-Type). Updates test/routes/{create,delete,overwrite,query,update}.test.js to record lastFetchUrl/lastFetchOptions and assert correct endpoint/method/headers, and documents the new validation in test/TESTING.md with an example and rationale to catch breaking changes.

* overwrite header inclusion

* Accept application/ld+json in tests; add 415/502 cases

Update test suites to accept application/ld+json by configuring express.json({ type: ['application/json', 'application/ld+json'] }) across create, query, delete, overwrite, and update tests. Add new tests: create and query now verify requests with Content-Type application/ld+json are accepted. Add tests that sending text/plain yields 415 in create, delete, overwrite, and update. Import and mount the error messenger in delete, overwrite, and update tests. Add network-failure cases that map rejected fetch to a 502 response for overwrite and update.

* Update TESTING.md

* test description cleanup

* Easy gap to cover.  Cleanup dead index.js code.

* Create app-cors.test.js

* Add create id-mapping tests and content-type tests

Add tests to exercise create route behavior: ensure request body id is converted to _id before upstream, and verify a successful upstream response missing id fields is treated as an error (502). Add new tests for verifyJsonContentType middleware to ensure it returns 415 when the Content-Type header is missing or when multiple Content-Type values are provided. These tests guard against regressions in id handling and content-type validation.

* Add tests for messenger headers and text body

Add two tests to test/routes/error-messenger.test.js: one verifies the error messenger returns early when headers have already been sent (preserving partial response and leaving status 200), and another verifies that when an upstream error provides a text/plain Content-Type and a text() method, the messenger forwards the plain-text body and upstream status (example uses 418). These cover edge cases for header-sent behavior and handling of plain-text upstream responses.

* Add test for fetchRerum timeout mapping

Adds test/routes/rerum.test.js which verifies that fetchRerum maps fetch timeouts (AbortError) to a 504 upstream timeout error. The test mocks global.fetch to reject with an AbortError, sets RERUM_FETCH_TIMEOUT_MS to a low value, and asserts the returned error has status 504 and an appropriate message. Test setup/teardown restore the original global.fetch and environment variable.

* Add token tests; extend error & fetchRerum tests

Add a new test file for checkAccessToken (test/routes/tokens.test.js) to cover missing ACCESS_TOKEN, malformed JWTs, and refresh error propagation. Update error-messenger.test.js to assert statusCode/statusMessage fallback handling. Extend rerum.test.js to save/restore global setTimeout/clearTimeout and add tests that map non-timeout fetch failures to a 502 upstream error, ensure provided AbortSignal is forwarded, and verify fallback to the default timeout when the configured timeout is invalid.

* Update update.test.js

* network query failures

Add unit tests for /query to cover upstream and network failure handling: (1) preserves upstream error text when fetch returns non-ok (503), (2) falls back to a generic RERUM error message when upstream .text() throws, and (3) maps rejected fetch (e.g., socket hang up) to a 502 response. Tests mock global.fetch and assert statusCode 502 and expected response text.

* nextwork errros

* more tests for file env token refresh

* Update index.test.js

* Add error-handling and token unit tests

Add several unit tests to improve error handling coverage and token middleware behavior. create.test.js and overwrite.test.js gain tests that preserve upstream text on non-409 failures, fall back to a generic RERUM message when upstream .text() throws, and map missing-id successful payloads to 502. error-messenger.test.js replaces res.write with res.end in an existing test and introduces createMockRes plus focused messenger unit tests for headersSent, payload JSON, JSON content-type, and plain-text upstream errors. tokens.test.js adds tests ensuring valid or non-numeric-exp access tokens skip refresh. These changes increase robustness of error-path handling and token refresh logic in tests.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Bryan Haberberger <bryan.j.haberberger@slu.edu>

Author: 3 people

test/routes/app-cors.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict"
+import { afterEach, beforeEach, describe, it } from "node:test"
+import request from "supertest"
+
+const originalOpenApiCors = process.env.OPEN_API_CORS
+
+beforeEach(() => {
+  process.env.OPEN_API_CORS = "true"
+})
+
+afterEach(() => {
+  process.env.OPEN_API_CORS = originalOpenApiCors
+})
+
+describe("App CORS middleware behavior.  __core", () => {
+  it("Adds CORS headers when OPEN_API_CORS is enabled.", async () => {
+    const { default: app } = await import("../../app.js?test-cors-enabled")
+
+    const response = await request(app)
+      .get("/index.html")
+      .set("Origin", "http://example.test")
+
+    assert.equal(response.statusCode, 200)
+    assert.equal(response.header["access-control-allow-origin"], "*")
+    assert.equal(response.header["access-control-expose-headers"], "*")
+  })
+})

test/routes/create.test.js

@@ -53,6 +53,18 @@ describe("Check that the request/response behavior of the TinyNode create route
     assert.equal(lastFetchOptions.headers["Content-Type"], "application/json;charset=utf-8", "Content-Type header mismatch")
   })
 
+  it("Converts body id to _id before sending upstream.", async () => {
+    const response = await request(routeTester)
+      .post("/create")
+      .send({ id: "https://example.org/id/abc123", test: "item" })
+      .set("Content-Type", "application/json")
+
+    assert.equal(response.statusCode, 201)
+    const upstreamBody = JSON.parse(lastFetchOptions.body)
+    assert.equal(upstreamBody._id, "abc123")
+    assert.equal(upstreamBody.id, "https://example.org/id/abc123")
+  })
+
   it("Accepts application/ld+json content type.", async () => {
     const response = await request(routeTester)
       .post("/create")
@@ -139,6 +151,39 @@ describe("Check that TinyNode create route propagates upstream and network error
     assert.equal(response.statusCode, 502)
     assert.match(response.text, /A RERUM error occurred/)
   })
+
+  it("Falls back to generic RERUM error text when upstream .text() throws.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 500,
+      text: async () => {
+        throw new Error("text stream consumed")
+      }
+    })
+
+    const response = await request(routeTester)
+      .post("/create")
+      .set("Content-Type", "application/json")
+      .send({ test: "item" })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /A RERUM error occurred/)
+  })
+
+  it("Maps successful upstream payload without id fields to 502.", async () => {
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({ test: "item" })
+    })
+
+    const response = await request(routeTester)
+      .post("/create")
+      .set("Content-Type", "application/json")
+      .send({ test: "item" })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /A RERUM error occurred/)
+  })
 })
 
 describe("Check that the properly used create endpoints function and interact with RERUM.  __e2e", () => {

test/routes/delete.test.js

@@ -104,4 +104,68 @@ describe("Delete network failure and passthrough behavior.  __rest __core", () =
       .delete("/delete/00000")
     assert.equal(response.statusCode, 502)
   })
+
+  it("Preserves upstream text error message for body delete when response is non-ok.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 503,
+      text: async () => "Upstream body delete failure"
+    })
+
+    const response = await request(routeTester)
+      .delete("/delete")
+      .set("Content-Type", "application/json")
+      .send({ "@id": rerumUri })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /Upstream body delete failure/)
+  })
+
+  it("Falls back to generic RERUM error text for body delete when upstream .text() throws.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 500,
+      text: async () => {
+        throw new Error("text stream consumed")
+      }
+    })
+
+    const response = await request(routeTester)
+      .delete("/delete")
+      .set("Content-Type", "application/json")
+      .send({ "@id": rerumUri })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /A RERUM error occurred/)
+  })
+
+  it("Preserves upstream text error message for path delete when response is non-ok.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 503,
+      text: async () => "Upstream path delete failure"
+    })
+
+    const response = await request(routeTester)
+      .delete("/delete/00000")
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /Upstream path delete failure/)
+  })
+
+  it("Falls back to generic RERUM error text for path delete when upstream .text() throws.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 500,
+      text: async () => {
+        throw new Error("text stream consumed")
+      }
+    })
+
+    const response = await request(routeTester)
+      .delete("/delete/00000")
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /A RERUM error occurred/)
+  })
 })

test/routes/error-messenger.test.js

@@ -13,6 +13,19 @@ function appWith(routeHandler) {
 }
 
 describe("Check shared error messenger behavior.  __rest __core", () => {
+  it("Returns early when headers are already sent.", async () => {
+    const app = express()
+    app.get("/test", (req, res, next) => {
+      res.end("partial")
+      next(new Error("late error"))
+    })
+    app.use(messenger)
+
+    const response = await request(app).get("/test")
+    assert.equal(response.statusCode, 200)
+    assert.match(response.text, /partial/)
+  })
+
   it("Returns structured JSON error bodies when upstream responds with JSON.", async () => {
     const app = appWith((req, res, next) => {
       next({
@@ -38,6 +51,21 @@ describe("Check shared error messenger behavior.  __rest __core", () => {
     assert.match(response.text, /boom/)
   })
 
+  it("Uses statusCode and statusMessage fallback fields when present.", async () => {
+    const app = appWith((req, res, next) => {
+      next({
+        statusCode: 499,
+        statusMessage: "Client closed request",
+        headers: { get: () => "text/plain" },
+        text: async () => ""
+      })
+    })
+
+    const response = await request(app).get("/test")
+    assert.equal(response.statusCode, 499)
+    assert.match(response.text, /Client closed request/)
+  })
+
   it("Uses fallback message if .text() throws.", async () => {
     const app = appWith((req, res, next) => {
       next({
@@ -55,6 +83,20 @@ describe("Check shared error messenger behavior.  __rest __core", () => {
     assert.match(response.text, /Upstream unavailable/)
   })
 
+  it("Sends plain text body from upstream text() when provided.", async () => {
+    const app = appWith((req, res, next) => {
+      next({
+        status: 418,
+        headers: { get: () => "text/plain" },
+        text: async () => "Teapot exploded"
+      })
+    })
+
+    const response = await request(app).get("/test")
+    assert.equal(response.statusCode, 418)
+    assert.match(response.text, /Teapot exploded/)
+  })
+
   it("Returns structured payload when error carries payload.", async () => {
     const app = appWith((req, res, next) => {
       next({
@@ -68,3 +110,81 @@ describe("Check shared error messenger behavior.  __rest __core", () => {
     assert.equal(response.body.code, "BAD_INPUT")
   })
 })
+
+function createMockRes(headersSent = false) {
+  const res = {
+    headersSent,
+    statusCode: null,
+    sentText: null,
+    sentJson: null,
+    setHeaders: {},
+    status(code) {
+      this.statusCode = code
+      return this
+    },
+    json(payload) {
+      this.sentJson = payload
+      return this
+    },
+    send(text) {
+      this.sentText = text
+      return this
+    },
+    set(name, value) {
+      this.setHeaders[name] = value
+      return this
+    }
+  }
+  return res
+}
+
+describe("Check shared error messenger unit branches.  __core", () => {
+  it("Returns immediately when headersSent is true.", async () => {
+    const res = createMockRes(true)
+    await messenger(new Error("ignored"), {}, res, () => {})
+    assert.equal(res.statusCode, null)
+    assert.equal(res.sentText, null)
+    assert.equal(res.sentJson, null)
+  })
+
+  it("Sends payload JSON when payload is present.", async () => {
+    const res = createMockRes(false)
+    await messenger({ status: 409, payload: { code: "CONFLICT" } }, {}, res, () => {})
+    assert.equal(res.statusCode, 409)
+    assert.equal(res.sentJson.code, "CONFLICT")
+  })
+
+  it("Uses upstream JSON response when content-type is JSON.", async () => {
+    const res = createMockRes(false)
+    await messenger(
+      {
+        status: 422,
+        headers: { get: () => "application/json; charset=utf-8" },
+        json: async () => ({ detail: "bad request" })
+      },
+      {},
+      res,
+      () => {}
+    )
+    assert.equal(res.statusCode, 422)
+    assert.equal(res.sentJson.detail, "bad request")
+  })
+
+  it("Sends plain text and sets content-type for non-JSON upstream errors.", async () => {
+    const res = createMockRes(false)
+    await messenger(
+      {
+        status: 503,
+        message: "fallback",
+        headers: { get: () => "text/plain" },
+        text: async () => "upstream text"
+      },
+      {},
+      res,
+      () => {}
+    )
+    assert.equal(res.statusCode, 503)
+    assert.equal(res.sentText, "upstream text")
+    assert.equal(res.setHeaders["Content-Type"], "text/plain; charset=utf-8")
+  })
+})

test/routes/index.test.js

@@ -1,13 +1,26 @@
 import "../helpers/env.js"
 import assert from "node:assert/strict"
 import { describe, it } from "node:test"
+import express from "express"
 import request from "supertest"
 import app from "../../app.js"
+import indexRoute from "../../routes/index.js"
+
+const routeTester = express()
+routeTester.use("/", indexRoute)
 
 describe("Make sure TinyNode demo interface is present.  __core", () => {
   it("/index.html", async () => {
     const response = await request(app).get("/index.html")
     assert.equal(response.statusCode, 200)
     assert.match(response.header["content-type"], /html/)
   })
+
+  it("Index router returns 405 for unsupported root methods.", async () => {
+    let response = await request(routeTester).get("/")
+    assert.equal(response.statusCode, 405)
+
+    response = await request(routeTester).post("/")
+    assert.equal(response.statusCode, 405)
+  })
 })

test/routes/overwrite.test.js

@@ -181,6 +181,55 @@ describe("Overwrite network failure behavior.  __rest __core", () => {
       .send({ "@id": rerumTinyTestObjId, testing: "item" })
     assert.equal(response.statusCode, 502)
   })
+
+  it("Preserves upstream text error message for non-409 overwrite failures.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 503,
+      text: async () => "Upstream overwrite failure"
+    })
+
+    const response = await request(routeTester)
+      .put("/overwrite")
+      .set("Content-Type", "application/json")
+      .send({ "@id": rerumTinyTestObjId, testing: "item" })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /Upstream overwrite failure/)
+  })
+
+  it("Falls back to generic RERUM error text when overwrite upstream .text() throws.", async () => {
+    global.fetch = async () => ({
+      ok: false,
+      status: 500,
+      text: async () => {
+        throw new Error("text stream consumed")
+      }
+    })
+
+    const response = await request(routeTester)
+      .put("/overwrite")
+      .set("Content-Type", "application/json")
+      .send({ "@id": rerumTinyTestObjId, testing: "item" })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /A RERUM error occurred/)
+  })
+
+  it("Maps successful overwrite payload without id fields to 502.", async () => {
+    global.fetch = async () => ({
+      ok: true,
+      json: async () => ({ testing: "item" })
+    })
+
+    const response = await request(routeTester)
+      .put("/overwrite")
+      .set("Content-Type", "application/json")
+      .send({ "@id": rerumTinyTestObjId, testing: "item" })
+
+    assert.equal(response.statusCode, 502)
+    assert.match(response.text, /A RERUM error occurred/)
+  })
 })
 
 describe("Check that the properly used overwrite endpoints function and interact with RERUM.  __e2e", () => {