@platformatic/itc 2.0.0-alpha.7 → 2.0.0-alpha.9

package/README.md

@@ -17,7 +17,7 @@ const { port1, port2 } = new MessageChannel()
 
 
 // thread 1
-const itc1 = new ITC({ port: port1 })
+const itc1 = new ITC({ port: port1, name: 'thread-1' })
 
 itc1.handle('get-users', async (request) => {
   return [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
@@ -26,7 +26,7 @@ itc1.handle('get-users', async (request) => {
 itc1.listen()
 
 // thread 2
-const itc2 = new ITC({ port: port2 })
+const itc2 = new ITC({ port: port2, name: 'thread-2' })
 itc2.listen()
 
 const users = await itc2.send('get-users')

package/index.js

@@ -1,5 +1,3 @@
 'use strict'
 
-const ITC = require('./lib/itc')
-
-module.exports = { ITC }
+module.exports = require('./lib/itc')

package/lib/errors.js

@@ -5,52 +5,20 @@ const createError = require('@fastify/error')
 const ERROR_PREFIX = 'PLT_ITC'
 
 module.exports = {
-  HandlerFailed: createError(
-    `${ERROR_PREFIX}_HANDLER_FAILED`,
-    'Handler failed with error: %s'
-  ),
-  HandlerNotFound: createError(
-    `${ERROR_PREFIX}_HANDLER_NOT_FOUND`,
-    'Handler not found for request: "%s"'
-  ),
-  PortAlreadyListening: createError(
-    `${ERROR_PREFIX}_ALREADY_LISTENING`,
-    'ITC is already listening'
-  ),
-  SendBeforeListen: createError(
-    `${ERROR_PREFIX}_SEND_BEFORE_LISTEN`,
-    'ITC cannot send requests before listening'
-  ),
-  InvalidRequestVersion: createError(
-    `${ERROR_PREFIX}_INVALID_REQUEST_VERSION`,
-    'Invalid ITC request version: "%s"'
-  ),
-  InvalidResponseVersion: createError(
-    `${ERROR_PREFIX}_INVALID_RESPONSE_VERSION`,
-    'Invalid ITC response version: "%s"'
-  ),
-  MissingRequestName: createError(
-    `${ERROR_PREFIX}_MISSING_REQUEST_NAME`,
-    'ITC request name is missing'
-  ),
-  MissingResponseName: createError(
-    `${ERROR_PREFIX}_MISSING_RESPONSE_NAME`,
-    'ITC response name is missing'
-  ),
-  MissingRequestReqId: createError(
-    `${ERROR_PREFIX}_MISSING_REQUEST_REQ_ID`,
-    'ITC request reqId is missing'
-  ),
-  MissingResponseReqId: createError(
-    `${ERROR_PREFIX}_MISSING_RESPONSE_REQ_ID`,
-    'ITC response reqId is missing'
-  ),
+  HandlerFailed: createError(`${ERROR_PREFIX}_HANDLER_FAILED`, 'Handler failed with error: %s'),
+  HandlerNotFound: createError(`${ERROR_PREFIX}_HANDLER_NOT_FOUND`, 'Handler not found for request: "%s"'),
+  PortAlreadyListening: createError(`${ERROR_PREFIX}_ALREADY_LISTENING`, 'ITC is already listening'),
+  SendBeforeListen: createError(`${ERROR_PREFIX}_SEND_BEFORE_LISTEN`, 'ITC cannot send requests before listening'),
+  InvalidRequestVersion: createError(`${ERROR_PREFIX}_INVALID_REQUEST_VERSION`, 'Invalid ITC request version: "%s"'),
+  InvalidResponseVersion: createError(`${ERROR_PREFIX}_INVALID_RESPONSE_VERSION`, 'Invalid ITC response version: "%s"'),
+  MissingRequestName: createError(`${ERROR_PREFIX}_MISSING_REQUEST_NAME`, 'ITC request name is missing'),
+  MissingResponseName: createError(`${ERROR_PREFIX}_MISSING_RESPONSE_NAME`, 'ITC response name is missing'),
+  MissingRequestReqId: createError(`${ERROR_PREFIX}_MISSING_REQUEST_REQ_ID`, 'ITC request reqId is missing'),
+  MissingResponseReqId: createError(`${ERROR_PREFIX}_MISSING_RESPONSE_REQ_ID`, 'ITC response reqId is missing'),
   RequestNameIsNotString: createError(
     `${ERROR_PREFIX}_REQUEST_NAME_IS_NOT_STRING`,
     'ITC request name is not a string: "%s"'
   ),
-  MessagePortClosed: createError(
-    `${ERROR_PREFIX}_MESSAGE_PORT_CLOSED`,
-    'ITC MessagePort is closed'
-  ),
+  MessagePortClosed: createError(`${ERROR_PREFIX}_MESSAGE_PORT_CLOSED`, 'ITC MessagePort is closed'),
+  MissingName: createError(`${ERROR_PREFIX}_MISSING_NAME`, 'ITC name is missing')
 }

package/lib/itc.js

@@ -11,6 +11,116 @@ const PLT_ITC_NOTIFICATION_TYPE = 'PLT_ITC_NOTIFICATION'
 const PLT_ITC_UNHANDLED_ERROR_TYPE = 'PLT_ITC_UNHANDLED_ERROR'
 const PLT_ITC_VERSION = '1.0.0'
 
+function parseRequest (request) {
+  if (request.reqId === undefined) {
+    throw new errors.MissingRequestReqId()
+  }
+  if (request.version !== PLT_ITC_VERSION) {
+    throw new errors.InvalidRequestVersion(request.version)
+  }
+  if (request.name === undefined) {
+    throw new errors.MissingRequestName()
+  }
+  return request
+}
+
+function parseResponse (response) {
+  if (response.reqId === undefined) {
+    throw new errors.MissingResponseReqId()
+  }
+  if (response.version !== PLT_ITC_VERSION) {
+    throw new errors.InvalidResponseVersion(response.version)
+  }
+  if (response.name === undefined) {
+    throw new errors.MissingResponseName()
+  }
+  return response
+}
+
+function generateRequest (name, data) {
+  if (typeof name !== 'string') {
+    throw new errors.RequestNameIsNotString(name.toString())
+  }
+
+  return {
+    type: PLT_ITC_REQUEST_TYPE,
+    version: PLT_ITC_VERSION,
+    reqId: randomUUID(),
+    name,
+    data: sanitize(data)
+  }
+}
+
+function generateResponse (request, error, data) {
+  return {
+    type: PLT_ITC_RESPONSE_TYPE,
+    version: PLT_ITC_VERSION,
+    reqId: request.reqId,
+    name: request.name,
+    error,
+    data: sanitize(data)
+  }
+}
+
+function generateNotification (name, data) {
+  return {
+    type: PLT_ITC_NOTIFICATION_TYPE,
+    version: PLT_ITC_VERSION,
+    name,
+    data: sanitize(data)
+  }
+}
+
+function generateUnhandledErrorResponse (error) {
+  return {
+    type: PLT_ITC_UNHANDLED_ERROR_TYPE,
+    version: PLT_ITC_VERSION,
+    error,
+    data: null
+  }
+}
+
+function sanitize (data) {
+  if (!data || typeof data !== 'object') {
+    return data
+  }
+
+  let sanitized
+
+  if (Buffer.isBuffer(data)) {
+    return {
+      data: Array.from(data.values())
+    }
+  } else if (Array.isArray(data)) {
+    sanitized = []
+
+    for (const value of data) {
+      const valueType = typeof value
+
+      /* c8 ignore next 3 */
+      if (valueType === 'function' || valueType === 'symbol') {
+        continue
+      }
+
+      sanitized.push(value && typeof value === 'object' ? sanitize(value) : value)
+    }
+  } else {
+    sanitized = {}
+
+    for (const [key, value] of Object.entries(data)) {
+      const valueType = typeof value
+
+      if (valueType === 'function' || valueType === 'symbol') {
+        continue
+      }
+
+      sanitized[key] = value && typeof value === 'object' ? sanitize(value) : value
+    }
+  }
+
+  return sanitized
+}
+
 class ITC extends EventEmitter {
   #requestEmitter
   #handlers
@@ -18,20 +128,47 @@ class ITC extends EventEmitter {
   #handling
   #closePromise
   #closeAfterCurrentRequest
+  #throwOnMissingHandler
+  #keepAlive
+  #keepAliveCount
 
-  constructor ({ port, handlers }) {
+  constructor ({ port, handlers, throwOnMissingHandler, name }) {
     super()
 
+    if (!name) {
+      throw new errors.MissingName()
+    }
+
+    // The name property is useful only for debugging purposes.
+    // Without it, it's impossible to know which "side" of the ITC is being used.
+    this.name = name
     this.port = port
     this.#requestEmitter = new EventEmitter()
     this.#handlers = new Map()
     this.#listening = false
     this.#handling = false
     this.#closeAfterCurrentRequest = false
+    this.#throwOnMissingHandler = throwOnMissingHandler ?? true
 
     // Make sure the emitter handle a lot of listeners at once before raising a warning
     this.#requestEmitter.setMaxListeners(1e3)
 
+    /*
+      There some contexts in which a message is sent and the event loop empties up while waiting for a response.
+      For instance @platformatic/astro when doing build with custom commands.
+
+      The interval below is immediately unref() after creation.
+      Everytime a message is sent and awaiting for a response we ref() it.
+      We unref() it again as soon as the response is received.
+      This ensures the event loop stays up as intended.
+    */
+    /* c8 ignore next 4 */
+    this.#keepAlive = setInterval(() => {
+      // Debugging line used to know who is not closing the ITC
+      // process._rawDebug('Keep alive', this.name, this.#keepAliveCount)
+    }, 10000).unref()
+    this.#keepAliveCount = 0
+
     // Register handlers provided with the constructor
     if (typeof handlers === 'object') {
       for (const [name, fn] of Object.entries(handlers)) {
@@ -45,20 +182,26 @@ class ITC extends EventEmitter {
       throw new errors.SendBeforeListen()
     }
 
-    const request = this.#generateRequest(name, message)
+    try {
+      this.#enableKeepAlive()
 
-    this._send(request)
+      const request = generateRequest(name, message)
 
-    const responsePromise = once(this.#requestEmitter, request.reqId).then(([response]) => response)
+      this._send(request)
 
-    const { error, data } = await Unpromise.race([responsePromise, this.#closePromise])
+      const responsePromise = once(this.#requestEmitter, request.reqId).then(([response]) => response)
 
-    if (error !== null) throw error
-    return data
+      const { error, data } = await Unpromise.race([responsePromise, this.#closePromise])
+
+      if (error !== null) throw error
+      return data
+    } finally {
+      this.#manageKeepAlive()
+    }
   }
 
   async notify (name, message) {
-    this._send(this.#generateNotification(name, message))
+    this._send(generateNotification(name, message))
   }
 
   handle (message, handler) {
@@ -92,6 +235,8 @@ class ITC extends EventEmitter {
     this.#closePromise = this._createClosePromise().then(() => {
       this.#listening = false
       const error = new errors.MessagePortClosed()
+      clearInterval(this.#keepAlive)
+      this.#keepAliveCount = -1000
       return { error, data: null }
     })
   }
@@ -118,7 +263,8 @@ class ITC extends EventEmitter {
   }
 
   _close () {
-    this.port.close()
+    clearTimeout(this.#keepAlive)
+    this.port?.close?.()
   }
 
   async #handleRequest (raw) {
@@ -129,27 +275,31 @@ class ITC extends EventEmitter {
     this.#handling = true
 
     try {
-      request = this.#parseRequest(raw)
+      request = parseRequest(raw)
       handler = this.#handlers.get(request.name)
 
-      if (handler === undefined) {
-        throw new errors.HandlerNotFound(request.name)
-      }
+      if (handler) {
+        const result = await handler(request.data)
+        response = generateResponse(request, null, result)
+      } else {
+        if (this.#throwOnMissingHandler) {
+          throw new errors.HandlerNotFound(request.name)
+        }
 
-      const result = await handler(request.data)
-      response = this.#generateResponse(request, null, result)
+        response = generateResponse(request, null)
+      }
     } catch (error) {
       if (!request) {
-        response = this.#generateUnhandledErrorResponse(error)
+        response = generateUnhandledErrorResponse(error)
       } else if (!handler) {
-        response = this.#generateResponse(request, error, null)
+        response = generateResponse(request, error, null)
       } else {
         const failedError = new errors.HandlerFailed(error.message)
         failedError.handlerError = error
         // This is needed as the code might be lost when sending the message over the port
         failedError.handlerErrorCode = error.code
 
-        response = this.#generateResponse(request, failedError, null)
+        response = generateResponse(request, failedError, null)
       }
     } finally {
       this.#handling = false
@@ -162,24 +312,11 @@ class ITC extends EventEmitter {
     }
   }
 
-  #parseRequest (request) {
-    if (request.reqId === undefined) {
-      throw new errors.MissingRequestReqId()
-    }
-    if (request.version !== PLT_ITC_VERSION) {
-      throw new errors.InvalidRequestVersion(request.version)
-    }
-    if (request.name === undefined) {
-      throw new errors.MissingRequestName()
-    }
-    return request
-  }
-
   #handleResponse (response) {
     try {
-      response = this.#parseResponse(response)
+      response = parseResponse(response)
     } catch (error) {
-      response = this.#generateUnhandledErrorResponse(error)
+      response = generateUnhandledErrorResponse(error)
       this._send(response)
       return
     }
@@ -188,83 +325,31 @@ class ITC extends EventEmitter {
     this.#requestEmitter.emit(reqId, response)
   }
 
-  #parseResponse (response) {
-    if (response.reqId === undefined) {
-      throw new errors.MissingResponseReqId()
-    }
-    if (response.version !== PLT_ITC_VERSION) {
-      throw new errors.InvalidResponseVersion(response.version)
-    }
-    if (response.name === undefined) {
-      throw new errors.MissingResponseName()
-    }
-    return response
+  #enableKeepAlive () {
+    this.#keepAlive.ref()
+    this.#keepAliveCount++
   }
 
-  #generateRequest (name, data) {
-    if (typeof name !== 'string') {
-      throw new errors.RequestNameIsNotString(name.toString())
-    }
-
-    if (typeof data === 'object') {
-      data = this.#sanitize(data)
-    }
+  #manageKeepAlive () {
+    this.#keepAliveCount--
 
-    return {
-      type: PLT_ITC_REQUEST_TYPE,
-      version: PLT_ITC_VERSION,
-      reqId: randomUUID(),
-      name,
-      data
-    }
-  }
-
-  #generateResponse (request, error, data) {
-    return {
-      type: PLT_ITC_RESPONSE_TYPE,
-      version: PLT_ITC_VERSION,
-      reqId: request.reqId,
-      name: request.name,
-      error,
-      data
-    }
-  }
-
-  #generateNotification (name, data) {
-    return {
-      type: PLT_ITC_NOTIFICATION_TYPE,
-      version: PLT_ITC_VERSION,
-      name,
-      data
-    }
-  }
-
-  #generateUnhandledErrorResponse (error) {
-    return {
-      type: PLT_ITC_UNHANDLED_ERROR_TYPE,
-      version: PLT_ITC_VERSION,
-      error,
-      data: null
+    /* c8 ignore next 3 */
+    if (this.#keepAliveCount > 0) {
+      return
     }
-  }
-
-  #sanitize (data) {
-    const sanitizedObject = {}
-    for (const key in data) {
-      const value = data[key]
-      const type = typeof value
 
-      if (type === 'object') {
-        sanitizedObject[key] = this.#sanitize(value)
-        continue
-      }
-
-      if (type !== 'function' && type !== 'symbol') {
-        sanitizedObject[key] = value
-      }
-    }
-    return sanitizedObject
+    this.#keepAlive.unref()
+    this.#keepAliveCount = 0
   }
 }
 
-module.exports = ITC
+module.exports = {
+  ITC,
+  parseRequest,
+  parseResponse,
+  generateRequest,
+  generateResponse,
+  generateNotification,
+  generateUnhandledErrorResponse,
+  sanitize
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/itc",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.9",
   "description": "",
   "main": "index.js",
   "author": "Matteo Collina <hello@matteocollina.com>",
@@ -22,7 +22,7 @@
     "typescript": "^5.5.4"
   },
   "dependencies": {
-    "@fastify/error": "^3.4.1",
+    "@fastify/error": "^4.0.0",
     "@watchable/unpromise": "^1.0.2"
   },
   "scripts": {

package/test/helper.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const { randomUUID } = require('node:crypto')
-
-function generateItcRequest (request) {
-  return {
-    type: 'PLT_ITC_REQUEST',
-    reqId: randomUUID(),
-    version: '1.0.0',
-    name: 'test-command',
-    data: { test: 'test-req-message' },
-    ...request,
-  }
-}
-
-function generateItcResponse (response) {
-  return {
-    type: 'PLT_ITC_RESPONSE',
-    reqId: randomUUID(),
-    version: '1.0.0',
-    name: 'test-command',
-    error: null,
-    data: { test: 'test-req-message' },
-    ...response,
-  }
-}
-
-module.exports = {
-  generateItcRequest,
-  generateItcResponse,
-}

package/test/itc.test.js

@@ -1,442 +0,0 @@
-'use strict'
-
-const assert = require('node:assert/strict')
-const { once } = require('node:events')
-const { test } = require('node:test')
-const { setTimeout: sleep } = require('node:timers/promises')
-const { MessageChannel } = require('node:worker_threads')
-const { ITC } = require('../index.js')
-const { generateItcRequest, generateItcResponse } = require('./helper.js')
-
-test('should send a request between threads', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const requestName = 'test-command'
-  const testRequest = { test: 'test-req-message' }
-  const testResponse = { test: 'test-res-message' }
-
-  const requests = []
-  itc2.handle(requestName, async request => {
-    requests.push(request)
-    return testResponse
-  })
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  const response = await itc1.send(requestName, testRequest)
-  assert.deepStrictEqual(response, testResponse)
-  assert.deepStrictEqual(requests, [testRequest])
-})
-
-test('should support close while replying to a message', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const requestName = 'test-command'
-  const testRequest = { test: 'test-req-message' }
-  const testResponse = { test: 'test-res-message' }
-
-  const requests = []
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({
-    port: port2,
-    handlers: {
-      [requestName] (request) {
-        requests.push(request)
-        itc2.close()
-        return testResponse
-      }
-    }
-  })
-
-  itc2.handle()
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  const response = await itc1.send(requestName, testRequest)
-  assert.deepStrictEqual(response, testResponse)
-  assert.deepStrictEqual(requests, [testRequest])
-})
-
-test('should throw an error if send req before listen', async t => {
-  const { port1 } = new MessageChannel()
-
-  const itc = new ITC({ port: port1 })
-  t.after(() => itc.close())
-
-  try {
-    await itc.send('test', 'test-request')
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_SEND_BEFORE_LISTEN')
-    assert.strictEqual(error.message, 'ITC cannot send requests before listening')
-  }
-})
-
-test('should throw an error if request name is not a string', async t => {
-  const { port1 } = new MessageChannel()
-
-  const itc = new ITC({ port: port1 })
-  t.after(() => itc.close())
-
-  itc.listen()
-
-  try {
-    await itc.send(true, 'test-request')
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_REQUEST_NAME_IS_NOT_STRING')
-    assert.strictEqual(error.message, 'ITC request name is not a string: "true"')
-  }
-})
-
-test('should send a notification between threads', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const notificationName = 'notification'
-  const testNotification = { test: 'test-notification' }
-
-  t.after(() => itc2.close())
-  await itc2.listen()
-
-  await itc1.notify(notificationName, testNotification)
-  const [receivedNotification] = await once(itc2, notificationName)
-  assert.deepStrictEqual(testNotification, receivedNotification)
-})
-
-test('should throw if call listen twice', async t => {
-  const { port1 } = new MessageChannel()
-
-  const itc = new ITC({ port: port1 })
-  t.after(() => itc.close())
-
-  itc.listen()
-
-  try {
-    itc.listen()
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_ALREADY_LISTENING')
-    assert.strictEqual(error.message, 'ITC is already listening')
-  }
-})
-
-test('should throw an error if handler fails', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const requestName = 'test-command'
-
-  itc2.handle(requestName, async () => {
-    throw new Error('test-error')
-  })
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  try {
-    await itc1.send(requestName, 'test-request')
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_HANDLER_FAILED')
-    assert.strictEqual(error.message, 'Handler failed with error: test-error')
-    assert.strictEqual(error.handlerError.message, 'test-error')
-  }
-})
-
-test('should throw if handler is not found', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const requestName = 'test-command'
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  try {
-    await itc1.send(requestName, 'test-request')
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_HANDLER_NOT_FOUND')
-    assert.strictEqual(error.message, 'Handler not found for request: "test-command"')
-  }
-})
-
-test('should skip non-platformatic message', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const requests = []
-  itc1.handle('test', async request => {
-    requests.push(request)
-  })
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  port2.postMessage({ type: 'test' })
-  port2.postMessage({ type: 'platformatic' })
-  port2.postMessage({ type: 'test' })
-
-  await itc2.send('test', 'test-message')
-
-  assert.deepStrictEqual(requests, ['test-message'])
-})
-
-test('should emit unhandledError if request version is wrong', (t, done) => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  itc1.listen()
-  itc2.listen()
-
-  itc2.on('unhandledError', error => {
-    assert.strictEqual(error.code, 'PLT_ITC_INVALID_REQUEST_VERSION')
-    assert.strictEqual(error.message, 'Invalid ITC request version: "0.0.0"')
-    done()
-  })
-
-  const itcRequest = generateItcRequest({ version: '0.0.0' })
-  port2.postMessage(itcRequest)
-})
-
-test('should emit unhandledError if request reqId is missing', (t, done) => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  itc1.listen()
-  itc2.listen()
-
-  itc2.on('unhandledError', error => {
-    assert.strictEqual(error.code, 'PLT_ITC_MISSING_REQUEST_REQ_ID')
-    assert.strictEqual(error.message, 'ITC request reqId is missing')
-    done()
-  })
-
-  const itcRequest = generateItcRequest()
-  delete itcRequest.reqId
-
-  port2.postMessage(itcRequest)
-})
-
-test('should emit unhandledError if request name is missing', (t, done) => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  itc1.listen()
-  itc2.listen()
-
-  itc2.on('unhandledError', error => {
-    assert.strictEqual(error.code, 'PLT_ITC_MISSING_REQUEST_NAME')
-    assert.strictEqual(error.message, 'ITC request name is missing')
-    done()
-  })
-
-  const itcRequest = generateItcRequest()
-  delete itcRequest.name
-
-  port2.postMessage(itcRequest)
-})
-
-test('should emit unhandledError if response version is wrong', (t, done) => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  itc1.listen()
-  itc2.listen()
-
-  itc2.on('unhandledError', error => {
-    assert.strictEqual(error.code, 'PLT_ITC_INVALID_RESPONSE_VERSION')
-    assert.strictEqual(error.message, 'Invalid ITC response version: "0.0.0"')
-    done()
-  })
-
-  const itcResponse = generateItcResponse({ version: '0.0.0' })
-  port2.postMessage(itcResponse)
-})
-
-test('should emit unhandledError if response reqId is missing', (t, done) => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  itc1.listen()
-  itc2.listen()
-
-  itc2.on('unhandledError', error => {
-    assert.strictEqual(error.code, 'PLT_ITC_MISSING_RESPONSE_REQ_ID')
-    assert.strictEqual(error.message, 'ITC response reqId is missing')
-    done()
-  })
-
-  const itcResponse = generateItcResponse()
-  delete itcResponse.reqId
-
-  port2.postMessage(itcResponse)
-})
-
-test('should emit unhandledError if response name is missing', (t, done) => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  itc1.listen()
-  itc2.listen()
-
-  itc2.on('unhandledError', error => {
-    assert.strictEqual(error.code, 'PLT_ITC_MISSING_RESPONSE_NAME')
-    assert.strictEqual(error.message, 'ITC response name is missing')
-    done()
-  })
-
-  const itcResponse = generateItcResponse()
-  delete itcResponse.name
-
-  port2.postMessage(itcResponse)
-})
-
-test('should sanitize a request before sending', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const requestName = 'test-command'
-  const testRequest = {
-    test: 'test-req-message',
-    foo: () => {},
-    bar: Symbol('test'),
-    nested: {
-      test: 'test-req-message',
-      foo: () => {},
-      bar: Symbol('test')
-    }
-  }
-  const testResponse = { test: 'test-res-message' }
-
-  const requests = []
-  itc2.handle(requestName, async request => {
-    requests.push(request)
-    return testResponse
-  })
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  const response = await itc1.send(requestName, testRequest)
-  assert.deepStrictEqual(response, testResponse)
-  assert.deepStrictEqual(requests, [
-    {
-      test: 'test-req-message',
-      nested: { test: 'test-req-message' }
-    }
-  ])
-})
-
-test('should throw if receiver ITC port was closed', async t => {
-  const { port1, port2 } = new MessageChannel()
-
-  const itc1 = new ITC({ port: port1 })
-  const itc2 = new ITC({ port: port2 })
-
-  const requestName = 'test-command'
-  const testRequest = { test: 'test-req-message' }
-
-  itc2.handle(requestName, async () => {
-    await sleep(10000)
-    assert.fail('Handler should not be called')
-  })
-
-  itc1.listen()
-  itc2.listen()
-
-  t.after(() => itc1.close())
-  t.after(() => itc2.close())
-
-  port2.close()
-
-  try {
-    await itc1.send(requestName, testRequest)
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_MESSAGE_PORT_CLOSED')
-    assert.strictEqual(error.message, 'ITC MessagePort is closed')
-  }
-})
-
-test('should throw if sender ITC port was closed', async t => {
-  const { port1 } = new MessageChannel()
-
-  const itc = new ITC({ port: port1 })
-  itc.listen()
-
-  port1.close()
-
-  try {
-    await itc.send('test-command', 'test-req-message')
-    assert.fail('Expected an error to be thrown')
-  } catch (error) {
-    assert.strictEqual(error.code, 'PLT_ITC_MESSAGE_PORT_CLOSED')
-    assert.strictEqual(error.message, 'ITC MessagePort is closed')
-  }
-})