feat: mockservercontroller can spin up mockservers via http

Author: SgtPooki

.aegir.cjs

@@ -4,7 +4,9 @@
 require('ts-node').register({
   project: 'tsconfig.json',
 })
-const { MockServer } = require('./test/MockServer')
+
+const { MockServerController } = require('./MockServerController')
+
 
 /** @type {import('aegir').PartialOptions} */
 module.exports = {
@@ -20,19 +22,18 @@ module.exports = {
     bundlesizeMax: '44KB'
   },
   test: {
+    cov: false,
     async before () {
-
-    },
-    async beforeEach () {
-
-      // mockServer = new MockServer()
-      await mockServer.start()
-    },
-    async afterEach () {
-
-        await mockServer.stop()
+      return new MockServerController()
     },
-    async after () {
+    /**
+     *
+     * @param {GlobalOptions & TestOptions} _
+     * @param {MockServerController} controller
+     */
+    async after (_, controller) {
+      console.log('test after:')
+      await controller.shutdown()
 
     }
   }

test/MockServer.ts renamed to MockServer.ts

@@ -2,6 +2,8 @@ import { setup } from 'mock-ipfs-pinning-service'
 import type { Application } from 'express'
 import type { Server } from 'http'
 import portscanner from 'portscanner'
+import cors from 'cors'
+
 import('dotenvrc')
 
 export class MockServer {
@@ -16,7 +18,7 @@ export class MockServer {
 
   public basePath: string = ''
 
-  constructor () {
+  constructor (private readonly config: Parameters<typeof import('mock-ipfs-pinning-service')['setup']>[0] = { token: process.env.MOCK_PINNING_SERVER_SECRET }) {
     process.on('uncaughtException', MockServer.onEADDRINUSE)
   }
 
@@ -31,19 +33,19 @@ export class MockServer {
     if (server == null) {
       process.exit(1)
     }
-
+    const handler = this.cleanupSync.bind(this)
     // And you'll want to make sure you close the server when your process exits
-    process.on('beforeExit', this.cleanupSync)
-    process.on('SIGTERM', this.cleanupSync)
-    process.on('SIGINT', this.cleanupSync)
-    process.on('SIGHUP', this.cleanupSync)
+    process.on('beforeExit', handler)
+    process.on('SIGTERM', handler)
+    process.on('SIGINT', handler)
+    process.on('SIGHUP', handler)
 
     // To prevent duplicated cleanup, remove the process listeners on server close.
     server.on('close', () => {
-      process.off('beforeExit', this.cleanupSync)
-      process.off('SIGTERM', this.cleanupSync)
-      process.off('SIGINT', this.cleanupSync)
-      process.off('SIGHUP', this.cleanupSync)
+      process.off('beforeExit', handler)
+      process.off('SIGTERM', handler)
+      process.off('SIGINT', handler)
+      process.off('SIGHUP', handler)
     })
   }
 
@@ -59,6 +61,11 @@ export class MockServer {
    * Ensure the port set for this instance is not already in use by another MockServer
    */
   private async getAvailablePort (): Promise<number> {
+    // this.port = 3000
+
+    // this.setBasePath()
+
+    // return this.port
     return await new Promise((resolve, reject) => portscanner.findAPortNotInUse(3000, 3099, '127.0.0.1', (error, port) => {
       if (error != null) {
         return reject(error)
@@ -73,9 +80,12 @@ export class MockServer {
     if (this._service !== undefined) {
       return this._service
     }
-    this._service = await setup({
-      token: process.env.MOCK_PINNING_SERVER_SECRET
-    })
+    this._service = await setup(this.config)
+    // this._service = await setup({
+    //   token: process.env.MOCK_PINNING_SERVER_SECRET,
+    //   loglevel: 'debug'
+    // })
+    this._service.use(cors())
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     return this._service as Application
@@ -94,7 +104,7 @@ export class MockServer {
       MockServer.error('service error', err)
     })
     this._server = service.listen(await this.getAvailablePort(), () => {
-      MockServer.debug(`server running on port ${port}`)
+      MockServer.debug(`${Date.now()}: MockServer running on port ${this.port}`)
     })
 
     return this._server
@@ -109,10 +119,11 @@ export class MockServer {
   // Express server cleanup handling.
   private async cleanup (): Promise<void> {
     const server = await this.server()
+    const port = this.port
     server.close((err) => {
       if ((err == null) || (err as Error & { code: string })?.code === 'ERR_SERVER_NOT_RUNNING') {
         // MockServer.portsInUse.remove(this.port)
-        MockServer.debug(`server stopped listening on port ${this.port}`)
+        MockServer.debug(`${Date.now()}: MockServer stopped listening on port ${port}`)
         delete this._server
       }
       if (err != null) {

MockServerController.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env ts-node
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+/* eslint-disable no-console */
+import express from 'express'
+import { MockServer } from './MockServer'
+import Router from 'express-promise-router'
+import cors from 'cors'
+
+// const startMockServerController = async () => {
+//   /**
+//    * @type {MockServer}
+//    */
+//   const mockServer = null
+
+//   app.get('/stop', (req, res) => {
+//     res.send('Hello World!')
+//   })
+
+//   app.listen(port, () => {
+//     console.log(`Example app listening on port ${port}`)
+//   })
+// }
+
+// type ExpressGetHandler = Parameters<IRouterMatcher<'get'>>[1]
+
+class MockServerController {
+  private readonly mockServers: MockServer[] = []
+  private readonly app = express()
+  private readonly router = Router()
+
+  private readonly port = 3000
+  server: import('http').Server
+  constructor () {
+    this.router.get<'/start', {port?: string}>('/start', async (req, res, next) => {
+      const { port } = req.params
+
+      let mockServer: MockServer | null = null
+      try {
+        mockServer = await this.startIpfsPinningServer(port)
+        this.mockServers.push(mockServer)
+
+        /**
+         * We need to return the basePath and accessToken so the client can call the correct mockServer
+         */
+        res.send({
+          success: true,
+          basePath: mockServer.basePath,
+          accessToken: process.env.MOCK_PINNING_SERVER_SECRET
+        })
+      } catch (error) {
+        res.json({ success: false, error })
+        next(error)
+      }
+    })
+
+    /**
+     * A client will request to shut down it's mockServer by port, which it should have received upon calling '/start'
+     */
+    this.router.get<'/stop/:port', {port: string}>('/stop/:port', async (req, res, next) => {
+      const { port } = req.params
+
+      const mockServer = this.mockServers.find((mockS) => mockS.basePath.includes(port))
+
+      if (mockServer != null) {
+        try {
+          await mockServer.stop()
+          res.json({ success: true })
+        } catch (error) {
+          res.json({ success: false, error })
+          next(error)
+        }
+      } else {
+        console.log('Could not get mockserver')
+        throw new Error(`MockServer at port ${port} could not be found`)
+      }
+    })
+
+    this.app.use(cors())
+    this.app.use(this.router)
+
+    this.server = this.app.listen(this.port, () => {
+      console.log(`MockServerController listening on port ${this.port}`)
+    })
+
+    // And you'll want to make sure you close the server when your process exits
+    process.on('beforeExit', this.shutdown)
+    process.on('SIGTERM', this.shutdown)
+    process.on('SIGINT', this.shutdown)
+    process.on('SIGHUP', this.shutdown)
+
+    // To prevent duplicated cleanup, remove the process listeners on server close.
+    this.server.on('close', () => {
+      process.off('beforeExit', this.shutdown)
+      process.off('SIGTERM', this.shutdown)
+      process.off('SIGINT', this.shutdown)
+      process.off('SIGHUP', this.shutdown)
+    })
+  }
+
+  async shutdown () {
+    await new Promise<void>((resolve, reject) => {
+      this.server.close((err) => {
+        if (err != null) {
+          console.error('Unexpected error when shutting down the MockServerController')
+          console.error(err)
+        } else {
+          console.log(`MockServerController stopped listening on port ${this.port}`)
+        }
+        resolve()
+      })
+    })
+    for await (const mockS of this.mockServers) {
+      try {
+        await mockS.stop()
+      } catch (err) {
+        console.error(`Unexpected error when attempting to shutdown mock server at ${mockS.basePath}`)
+        console.error(err)
+      }
+    }
+  }
+
+  // async startMockServer (req: {params: { port: number}}, res: {basePath: string, accessToken: string}, next: unknown) {
+
+  // }
+
+  private async startIpfsPinningServer (port?: string) {
+    const mockServer = new MockServer({
+      token: process.env.MOCK_PINNING_SERVER_SECRET
+      // loglevel: 'info'
+    })
+    await mockServer.start(Number(port))
+
+    return mockServer
+  }
+}
+
+export { MockServerController }

package.json

@@ -144,7 +144,7 @@
     "build": "aegir build -- -p tsconfig.json --suppress 6133@generated 6192@generated --stats",
     "build:main": "aegir build -- -p tsconfig.json --suppress 6133@generated 6192@generated --stats",
     "build:docs": "aegir ts docs",
-    "test": "run-p test:*",
+    "test": "run-s test:*",
     "test:electron": "aegir test --target electron-main",
     "test:node": "aegir test --target node --cov && npx nyc report",
     "pregen": "openapi-generator-cli validate -i https://raw.githubusercontent.com/ipfs/pinning-services-api-spec/main/ipfs-pinning-service.yaml",
@@ -155,22 +155,28 @@
     "gen:ts": "openapi-generator-cli generate --generator-key ts"
   },
   "dependencies": {
-    "node-fetch": "^3.2.0",
     "patch-package": "^6.4.7"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.4.26",
     "@swc/core": "^1.2.144",
     "@swc/helpers": "^0.3.3",
+    "@types/cors": "^2.8.12",
     "@types/express": "^4.17.13",
+    "@types/express-promise-router": "^3.0.0",
     "@types/mocha": "^9.1.0",
-    "@types/node": "^17.0.16",
+    "@types/node": "^17.0.21",
     "@types/node-fetch": "^3.0.3",
     "@types/portscanner": "^2.1.1",
     "aegir": "^36.1.3",
     "check-aegir-project": "^1.0.3",
+    "cors": "^2.8.5",
     "dotenvrc": "^1.0.1",
+    "express": "^4.17.3",
+    "express-promise-router": "^4.1.1",
+    "fetch-ponyfill": "^7.1.0",
     "mock-ipfs-pinning-service": "^0.4.0",
+    "node-fetch": "^2.6.1",
     "npm-run-all": "^4.1.5",
     "openapi-typescript": "^5.1.1",
     "portscanner": "^2.2.0",

test/browser.ts

@@ -1,19 +1,17 @@
 /* eslint-disable no-console */
 
 import clientTests from './isomorphic-tests/client'
-import configurationTests from './isomorphic-tests/configuration'
-
-
+// import configurationTests from './configuration.spec'
+import fetchPonyfill from 'fetch-ponyfill'
 
 const setup = async () => {
-  return await new Promise<void>((resolve, reject) => {
-    void resolve()
-  })
+  return {
+    fetch: fetchPonyfill().fetch as GlobalFetch['fetch']
+  }
 }
 
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 describe('browser', async (): Promise<void> => {
-  console.log(fetch)
-  await configurationTests(setup)
+  // await configurationTests(setup)
   await clientTests(setup)
 })

test/configuration.spec.ts

@@ -0,0 +1,13 @@
+/* eslint-env browser, node, mocha */
+
+import { expect } from 'aegir/utils/chai'
+import { Configuration, ConfigurationParameters } from '../src'
+
+// export default async (setup: () => Promise<unknown>) => {
+describe('Configuration', () => {
+  it('Can be instantiated', () => {
+    const configuration: ConfigurationParameters = {}
+    expect(() => new Configuration(configuration)).not.to.throw()
+  })
+})
+// }