Add error handling to test mock servers

packages/cli/test/helpers/http-server.js

@@ -23,29 +23,38 @@ export async function createServer(router) {
    * @param {http.ServerResponse} response
    */
   const listener = async (request, response) => {
-    const chunks = []
-    for await (const chunk of request) {
-      chunks.push(chunk)
-    }
+    try {
+      const chunks = []
+      for await (const chunk of request) {
+        chunks.push(chunk)
+      }
+
+      const handler = router[request.url ?? '/']
+      if (!handler) {
+        response.writeHead(404)
+        response.end()
+        return undefined
+      }
+
+      const { headers, body } = await handler({
+        headers: /** @type {Readonly<Record<string, string>>} */ (
+          request.headers
+        ),
+        body: Buffer.concat(chunks),
+      })
 
-    const handler = router[request.url ?? '/']
-    if (!handler) {
-      response.writeHead(404)
+      response.writeHead(200, headers)
+      response.write(body)
+      response.end()
+      return undefined
+    } catch (error) {
+      process.stderr.write(`Error handling request: ${error}\n`)
+      if (!response.headersSent) {
+        response.writeHead(500)
+      }
       response.end()
       return undefined
     }
-
-    const { headers, body } = await handler({
-      headers: /** @type {Readonly<Record<string, string>>} */ (
-        request.headers
-      ),
-      body: Buffer.concat(chunks),
-    })
-
-    response.writeHead(200, headers)
-    response.write(body)
-    response.end()
-    return undefined
   }
 
   const server = http.createServer(listener).listen()

packages/cli/test/helpers/receipt-http-server.js

@@ -24,11 +24,20 @@ export async function createReceiptsServer() {
    * @param {http.ServerResponse} response
    */
   const listener = async (request, response) => {
-    const taskCid = request.url?.split('/')[1] ?? ''
-    const body = await generateReceipt(taskCid)
-    response.writeHead(200)
-    response.end(body)
-    return undefined
+    try {
+      const taskCid = request.url?.split('/')[1] ?? ''
+      const body = await generateReceipt(taskCid)
+      response.writeHead(200)
+      response.end(body)
+      return undefined
+    } catch (error) {
+      process.stderr.write(`Error handling request: ${error}\n`)
+      if (!response.headersSent) {
+        response.writeHead(500)
+      }
+      response.end()
+      return undefined
+    }
   }
 
   const server = http.createServer(listener).listen()
@@ -64,7 +73,6 @@ const generateReceipt = async (taskCid) => {
     fx: {
       fork: [locationClaim],
     },
-    /** @ts-expect-error not a UCAN Link */
     ran: parseLink(taskCid),
     result: {
       ok: {

packages/encrypt-upload-client/test/mocks/key-manager.js

@@ -109,49 +109,56 @@ export function createMockKeyManagerServer(
   })
 
   const httpServer = createServer(async (req, res) => {
-    res.setHeader('Access-Control-Allow-Origin', '*')
-    res.setHeader('Access-Control-Allow-Methods', '*')
-    res.setHeader('Access-Control-Allow-Headers', '*')
-    if (req.method === 'OPTIONS') return res.end()
-
-    if (req.method === 'POST') {
-      const bodyBuffer = Buffer.concat(await collect(req))
-
-      const reqHeaders = /** @type {Record<string, string>} */ (
-        Object.fromEntries(Object.entries(req.headers))
-      )
-
-      const { headers, body, status } = await ucantoServer.request({
-        body: new Uint8Array(
-          bodyBuffer.buffer,
-          bodyBuffer.byteOffset,
-          bodyBuffer.byteLength
-        ),
-        headers: reqHeaders,
-      })
+    try {
+      res.setHeader('Access-Control-Allow-Origin', '*')
+      res.setHeader('Access-Control-Allow-Methods', '*')
+      res.setHeader('Access-Control-Allow-Headers', '*')
+      if (req.method === 'OPTIONS') return res.end()
+
+      if (req.method === 'POST') {
+        const bodyBuffer = Buffer.concat(await collect(req))
+
+        const reqHeaders = /** @type {Record<string, string>} */ (
+          Object.fromEntries(Object.entries(req.headers))
+        )
+
+        const { headers, body, status } = await ucantoServer.request({
+          body: new Uint8Array(
+            bodyBuffer.buffer,
+            bodyBuffer.byteOffset,
+            bodyBuffer.byteLength
+          ),
+          headers: reqHeaders,
+        })
 
-      for (const [key, value] of Object.entries(headers)) {
-        res.setHeader(key, value)
+        for (const [key, value] of Object.entries(headers)) {
+          res.setHeader(key, value)
+        }
+        res.writeHead(status ?? 200)
+        res.end(body)
+      } else {
+        res.end()
+      }
+    } catch (error) {
+      process.stderr.write(`Error handling request: ${error}\n`)
+      if (!res.headersSent) {
+        res.writeHead(500)
       }
-      res.writeHead(status ?? 200)
-      res.end(body)
-    } else {
       res.end()
     }
   })
 
   return new Promise((resolve, reject) => {
-    httpServer.listen(port, (/** @type {Error | undefined} */ err) => {
-      if (err) {
-        reject(err)
-      } else {
-        const protocol = useHttps ? 'https' : 'http'
-        resolve({
-          server: httpServer,
-          url: `${protocol}://localhost:${port}`,
-          close: () => new Promise((resolve) => httpServer.close(resolve)),
-        })
-      }
+    httpServer.on('error', (err) => {
+      reject(err)
+    })
+    httpServer.listen(port, () => {
+      const protocol = useHttps ? 'https' : 'http'
+      resolve({
+        server: httpServer,
+        url: `${protocol}://localhost:${port}`,
+        close: () => new Promise((resolve) => httpServer.close(resolve)),
+      })
     })
   })
 }

packages/upload-api/src/test/external-service/content-claims.js

@@ -79,20 +79,28 @@ export const activate = async ({ http } = {}) => {
   }
 
   const httpServer = http.createServer(async (req, res) => {
-    const chunks = []
-    for await (const chunk of req) {
-      chunks.push(chunk)
-    }
+    try {
+      const chunks = []
+      for await (const chunk of req) {
+        chunks.push(chunk)
+      }
 
-    const { status, headers, body } = await server.request({
-      // @ts-expect-error
-      headers: req.headers,
-      body: new Uint8Array(await new Blob(chunks).arrayBuffer()),
-    })
+      const { status, headers, body } = await server.request({
+        // @ts-expect-error
+        headers: req.headers,
+        body: new Uint8Array(await new Blob(chunks).arrayBuffer()),
+      })
 
-    res.writeHead(status ?? 200, headers)
-    res.write(body)
-    res.end()
+      res.writeHead(status ?? 200, headers)
+      res.write(body)
+      res.end()
+    } catch (error) {
+      process.stderr.write(`Error handling request: ${error}\n`)
+      if (!res.headersSent) {
+        res.writeHead(500)
+      }
+      res.end()
+    }
   })
   await new Promise((resolve) => httpServer.listen(resolve))
   // @ts-expect-error

packages/upload-api/src/test/external-service/indexing-service.js

@@ -109,20 +109,28 @@ export const activate = async ({ http } = {}) => {
   }
 
   const httpServer = http.createServer(async (req, res) => {
-    const chunks = []
-    for await (const chunk of req) {
-      chunks.push(chunk)
-    }
+    try {
+      const chunks = []
+      for await (const chunk of req) {
+        chunks.push(chunk)
+      }
 
-    const { status, headers, body } = await server.request({
-      // @ts-expect-error
-      headers: req.headers,
-      body: new Uint8Array(await new Blob(chunks).arrayBuffer()),
-    })
+      const { status, headers, body } = await server.request({
+        // @ts-expect-error
+        headers: req.headers,
+        body: new Uint8Array(await new Blob(chunks).arrayBuffer()),
+      })
 
-    res.writeHead(status ?? 200, headers)
-    res.write(body)
-    res.end()
+      res.writeHead(status ?? 200, headers)
+      res.write(body)
+      res.end()
+    } catch (error) {
+      process.stderr.write(`Error handling request: ${error}\n`)
+      if (!res.headersSent) {
+        res.writeHead(500)
+      }
+      res.end()
+    }
   })
   await new Promise((resolve) => httpServer.listen(resolve))
   // @ts-expect-error

packages/upload-api/src/test/storage/blobs-storage.js

@@ -25,40 +25,50 @@ export class BlobsStorage {
     const content = new Map()
     if (http) {
       const server = http.createServer(async (request, response) => {
-        const { pathname } = new URL(request.url || '/', url)
-        if (request.method === 'PUT') {
-          const buffer = new Uint8Array(
-            parseInt(request.headers['content-length'] || '0')
-          )
-          let offset = 0
-          for await (const chunk of request) {
-            buffer.set(chunk, offset)
-            offset += chunk.length
-          }
-          const hash = await sha256.digest(buffer)
-          const checksum = base64pad.baseEncode(hash.digest)
-
-          if (checksum !== request.headers['x-amz-checksum-sha256']) {
-            response.writeHead(400, `checksum mismatch`)
+        try {
+          const { pathname } = new URL(request.url || '/', url)
+          if (request.method === 'PUT') {
+            const buffer = new Uint8Array(
+              parseInt(request.headers['content-length'] || '0')
+            )
+            let offset = 0
+            for await (const chunk of request) {
+              buffer.set(chunk, offset)
+              offset += chunk.length
+            }
+            const hash = await sha256.digest(buffer)
+            const checksum = base64pad.baseEncode(hash.digest)
+
+            if (checksum !== request.headers['x-amz-checksum-sha256']) {
+              response.writeHead(400, `checksum mismatch`)
+            } else {
+              content.set(pathname, buffer)
+              response.writeHead(200)
+            }
+          } else if (request.method === 'GET') {
+            const data = content.get(pathname)
+            if (data) {
+              response.writeHead(200)
+              response.write(data)
+            } else {
+              response.writeHead(404)
+            }
           } else {
-            content.set(pathname, buffer)
-            response.writeHead(200)
+            response.writeHead(405)
           }
-        } else if (request.method === 'GET') {
-          const data = content.get(pathname)
-          if (data) {
-            response.writeHead(200)
-            response.write(data)
-          } else {
-            response.writeHead(404)
+
+          response.end()
+          // otherwise it keep connection lingering
+          response.destroy()
+        } catch (error) {
+          process.stderr.write(`Error handling request: ${error}\n`)
+          if (!response.headersSent) {
+            response.writeHead(500)
           }
-        } else {
-          response.writeHead(405)
+          response.end()
+          // otherwise it keep connection lingering
+          response.destroy()
         }
-
-        response.end()
-        // otherwise it keep connection lingering
-        response.destroy()
       })
       await new Promise((resolve) => server.listen(resolve))