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.

Author: cubap

test/routes/error-messenger.test.js

@@ -51,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({

test/routes/rerum.test.js

@@ -5,6 +5,8 @@ import { fetchRerum } from "../../rerum.js"
 
 const originalFetch = global.fetch
 const originalTimeout = process.env.RERUM_FETCH_TIMEOUT_MS
+const originalSetTimeout = global.setTimeout
+const originalClearTimeout = global.clearTimeout
 
 beforeEach(() => {
   process.env.RERUM_FETCH_TIMEOUT_MS = "1"
@@ -13,6 +15,8 @@ beforeEach(() => {
 afterEach(() => {
   global.fetch = originalFetch
   process.env.RERUM_FETCH_TIMEOUT_MS = originalTimeout
+  global.setTimeout = originalSetTimeout
+  global.clearTimeout = originalClearTimeout
 })
 
 describe("fetchRerum timeout behavior.  __core", () => {
@@ -37,4 +41,49 @@ describe("fetchRerum timeout behavior.  __core", () => {
       }
     )
   })
+
+  it("Maps non-timeout fetch failures to a 502 upstream network error.", async () => {
+    global.fetch = async () => {
+      throw new Error("socket hang up")
+    }
+
+    await assert.rejects(
+      () => fetchRerum("https://example.org/rerum"),
+      err => {
+        assert.equal(err.status, 502)
+        assert.match(err.message, /A RERUM error occurred/)
+        return true
+      }
+    )
+  })
+
+  it("Uses the provided signal path and still resolves successful responses.", async () => {
+    const externalController = new AbortController()
+    global.fetch = async (url, options = {}) => {
+      assert.ok(options.signal, "A signal should be forwarded to fetch")
+      return { ok: true, source: url }
+    }
+
+    const response = await fetchRerum("https://example.org/rerum", { signal: externalController.signal })
+    assert.equal(response.ok, true)
+    assert.equal(response.source, "https://example.org/rerum")
+  })
+
+  it("Falls back to default timeout when configured timeout is invalid.", async () => {
+    process.env.RERUM_FETCH_TIMEOUT_MS = "-10"
+    let capturedTimeoutMs = null
+    let timeoutFn
+
+    global.setTimeout = (fn, ms) => {
+      timeoutFn = fn
+      capturedTimeoutMs = ms
+      return 1
+    }
+    global.clearTimeout = () => {}
+    global.fetch = async () => ({ ok: true })
+
+    await fetchRerum("https://example.org/rerum")
+    assert.equal(capturedTimeoutMs, 30000)
+    assert.equal(typeof timeoutFn, "function")
+  })
 })

test/routes/tokens.test.js

@@ -0,0 +1,58 @@
+import "../helpers/env.js"
+import assert from "node:assert/strict"
+import { afterEach, describe, it } from "node:test"
+import checkAccessToken from "../../tokens.js"
+
+const originalAccessToken = process.env.ACCESS_TOKEN
+const originalFetch = global.fetch
+
+afterEach(() => {
+  process.env.ACCESS_TOKEN = originalAccessToken
+  global.fetch = originalFetch
+})
+
+function jwtWithExp(expSeconds) {
+  const payload = Buffer.from(JSON.stringify({ exp: expSeconds })).toString("base64")
+  return `header.${payload}.signature`
+}
+
+describe("checkAccessToken middleware behavior.  __core", () => {
+  it("Calls next when ACCESS_TOKEN is missing.", async () => {
+    delete process.env.ACCESS_TOKEN
+    let called = 0
+
+    await checkAccessToken({}, {}, err => {
+      assert.equal(err, undefined)
+      called += 1
+    })
+
+    assert.equal(called, 1)
+  })
+
+  it("Treats malformed token as non-expired and calls next.", async () => {
+    process.env.ACCESS_TOKEN = "not-a-jwt"
+    let called = 0
+
+    await checkAccessToken({}, {}, err => {
+      assert.equal(err, undefined)
+      called += 1
+    })
+
+    assert.equal(called, 1)
+  })
+
+  it("Propagates refresh errors to next(err) when token is expired.", async () => {
+    process.env.ACCESS_TOKEN = jwtWithExp(Math.floor(Date.now() / 1000) - 60)
+    global.fetch = async () => {
+      throw new Error("refresh failed")
+    }
+
+    let receivedError
+    await checkAccessToken({}, {}, err => {
+      receivedError = err
+    })
+
+    assert.ok(receivedError)
+    assert.match(receivedError.message, /refresh failed/)
+  })
+})