testkit-backend: Separate the socket connection, protocol and controller

The logic of reading and writing in the socket, call the handlers and parse the messages were mixed in the Backend class. This makes difficult to add different protocols, socket implementation or controllers to the backend.

The goal of this change is separate this three concerns in `SocketServer`, `Controller` and `Protocol` with the `Backend` class as the glue between these concepts. New implementations of the `Controller` could enable this backend to test the driver running in the browser without have to change the logic of parsing the messages between testkit and testkit-backend, for instance.

Author: bigmontz

packages/testkit-backend/package.json

@@ -6,7 +6,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "start": "node -r esm src/main.js",
+    "start": "node -r esm src/index.js",
     "clean": "rm -fr node_modules"
   },
   "repository": {

packages/testkit-backend/src/backend.js

@@ -0,0 +1,36 @@
+import SocketServer from './socket.server'
+import Controller from './controller'
+
+export default class Backend {
+  constructor (port, newController = () => new Controller(), newSocketServer = port => new SocketServer(port)) {
+    this._socketServer = newSocketServer(port)
+    this._controller = newController()
+
+    this._controller.on('response', ({ contextId, response }) => {
+      this._socketServer.writeResponse(contextId, response.name, response.data)
+    })
+
+    this._socketServer.on('contextOpen', ({ contextId }) => this._controller.onContextOpen(contextId))
+    this._socketServer.on('contextClose', ({ contextId }) => this._controller.onContextClose(contextId))
+
+    this._socketServer.on('request', ({ contextId, request }) => { 
+      try {
+        this._controller.handle(contextId, request.name, request.data )
+      } catch (e) {
+        this._socketServer.writeBackendError(contextId, e)
+      }
+    })
+  }
+
+  start () {
+    this._controller.start()
+    this._socketServer.start()
+  }
+
+  stop () {
+    this._socketServer.stop()
+    this._controller.stop()
+  }
+
+}
+

packages/testkit-backend/src/controller.js

@@ -0,0 +1,24 @@
+import { EventEmitter } from 'events'
+
+export default class Controller extends EventEmitter {
+
+  start () {
+
+  }
+
+  stop () {
+
+  }
+
+  onContextOpen(contextId) {
+    throw new Error('not implemented')
+  }
+
+  onContextClose(contextId) {
+    throw new Error('not implemented')
+  }
+
+  handle(contextId, name, data) {
+    throw new Error('not implemented')
+  }
+}

packages/testkit-backend/src/index.js

@@ -0,0 +1,19 @@
+import Backend from './backend'
+import NodeController from './node.controller'
+
+function main( ) {
+  const backend = new Backend(process.env.BACKEND_PORT || 9876, () => new NodeController())
+    
+  backend.start()
+
+  // cleaning up
+  process.on('exit', backend.stop.bind(backend));
+
+  // Capturing signals
+  process.on('SIGINT', process.exit.bind(process));
+  process.on('SIGUSR1', process.exit.bind(process));
+  process.on('SIGUSR2', process.exit.bind(process));
+  process.on('uncaughtException', process.exit.bind(process));
+}
+
+main()

packages/testkit-backend/src/main.js

@@ -0,0 +1,67 @@
+import Context from './context'
+import Controller from './controller'
+import * as _requestHandlers from './request-handlers'
+
+
+export default class NodeController extends Controller {
+
+  constructor(requestHandlers = _requestHandlers) {
+    super()
+    this._requestHandlers = requestHandlers
+    this._contexts = new Map()
+  }
+
+  onContextOpen(contextId) {
+    this._contexts.set(contextId, new Context())
+  }
+
+  onContextClose(contextId) {
+    this._contexts.delete(contextId)
+  }
+
+  
+  handle(contextId, name, data) {
+    if (!this._contexts.has(contextId)) {
+      throw new Error(`Context ${contextId} does not exist`)
+    } else if (!(name in this._requestHandlers)) {
+      console.log('Unknown request: ' + name)
+      console.log(stringify(data))
+      throw new Error(`Unknown request: ${name}`)
+    }
+
+    this._requestHandlers[name](this._contexts.get(contextId), data, {
+      writeResponse: (name, data) => this._writeResponse(contextId, name, data),
+      writeError: (e) => this._writeError(contextId, e),
+      writeBackendError: (msg) => this._writeBackendError(contextId, msg)
+    })
+
+  }
+
+  _writeResponse (contextId, name, data) {
+    console.log('> writing response', name, data)
+    let response = {
+      name: name,
+      data: data
+    }
+
+    this.emit('response', { contextId, response })
+  }
+
+  _writeBackendError (contextId, msg) {
+    this._writeResponse(contextId, 'BackendError', { msg: msg })
+  }
+
+  _writeError (contextId, e) {
+    if (e.name) {
+      const id = this._contexts.get(contextId).addError(e)
+      this._writeResponse(contextId, 'DriverError', {
+        id,
+        msg: e.message + ' (' + e.code + ')',
+        code: e.code
+      })
+      return
+    }
+    this._writeBackendError(contextId, e)
+  }
+  
+}

packages/testkit-backend/src/node.controller.js

@@ -0,0 +1,65 @@
+
+import EventEmitter from 'events'
+
+export default class Protocol extends EventEmitter {
+  constructor () {
+    super()
+    console.log('Backend connected')
+    this._inRequest = false
+    this._request = ''
+  }
+
+  // Called whenever a new line is received.
+  processLine (line) {
+    switch (line) {
+      case '#request begin':
+        if (this._inRequest) {
+          throw new Error('Already in request')
+        }
+        this._inRequest = true
+        break
+      case '#request end':
+        if (!this._inRequest) {
+          throw new Error('End while not in request')
+        }
+        try {
+          this._emitRequest()
+        } catch (e) {
+          console.log('error', e)
+          this.emit('error', e)
+        }
+        this._request = ''
+        this._inRequest = false
+        break
+      default:
+        if (!this._inRequest) {
+          throw new Error('Line while not in request')
+        }
+        this._request += line
+        break
+    }
+  }
+
+  serializeResponse (name, data) {
+    console.log('> writing response', name, data)
+    let response = {
+      name: name,
+      data: data
+    }
+    response = this._stringify(response)
+    return  ['#response begin', response, '#response end'].join('\n') + '\n'
+  }
+
+  _emitRequest () {
+    const request = JSON.parse(this._request)
+    const { name, data } = request
+    console.log('> Got request ' + name, data)
+    this.emit('request', { name, data })
+  }
+  
+  _stringify (val) {
+    return JSON.stringify(val, (_, value) =>
+      typeof value === 'bigint' ? `${value}n` : value
+    )
+  }
+}