detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/src/ipc/IPCClient.js

@@ -1,23 +1,24 @@
 const { IPC } = require('node-ipc');
 
 const { DetoxInternalError } = require('../errors');
+const { serializeObjectWithError } = require('../utils/errorUtils');
 
 class IPCClient {
-  constructor({ id, logger, state }) {
+  constructor({ id, logger, sessionState }) {
     this._id = id;
     /** @type {import('../logger/DetoxLogger')} logger */
-    this._logger = logger.child({ __filename, cat: 'ipc' });
-    /** @type {import('./state').SecondarySessionState} */
-    this._state = state;
+    this._logger = logger.child({ cat: 'ipc' });
+    /** @type {import('./SessionState')} */
+    this._sessionState = sessionState;
 
-    this._client = null;
+    this._ipc = null;
     this._serverConnection = null;
   }
 
   async init() {
-    this._client = new IPC();
+    this._ipc = new IPC();
 
-    Object.assign(this._client.config, {
+    Object.assign(this._ipc.config, {
       id: this._id,
       appspace: 'detox.',
       logger: (msg) => this._logger.trace(msg),
@@ -32,14 +33,22 @@ class IPCClient {
   async dispose() {
     this._serverConnection = null;
 
-    if (this._client) {
-      this._client.disconnect(this.serverId);
-      this._client = null;
+    if (this._ipc) {
+      await new Promise((resolve, reject) => {
+        this._ipc.of[this.serverId]
+          // @ts-ignore
+          .once('disconnect', resolve)
+          .once('error', reject);
+
+        this._ipc.disconnect(this.serverId);
+      });
+
+      this._ipc = null;
     }
   }
 
   get sessionState() {
-    return this._state;
+    return this._sessionState;
   }
 
   get serverId() {
@@ -47,26 +56,29 @@ class IPCClient {
   }
 
   async registerWorker(workerId) {
-    this._state.workerId = workerId;
-    await this._emit('registerWorker', { workerId });
+    const sessionState = await this._emit('registerWorker', { workerId });
+    this._sessionState.patch(sessionState);
   }
 
   /**
-   * @param {string[]} testFilePaths
+   * @param {DetoxInternals.DetoxTestFileReport[]} testResults
    */
-  async reportFailedTests(testFilePaths) {
-    await this._emit('failedTests', { testFilePaths });
+  async reportTestResults(testResults) {
+    const sessionState = await this._emit('reportTestResults', {
+      testResults: testResults.map(r => serializeObjectWithError(r, 'testExecError')),
+    });
+    this._sessionState.patch(sessionState);
   }
 
   async _connectToServer() {
     const serverId = this.serverId;
 
     this._serverConnection = await new Promise((resolve, reject) => {
-      this._client.connectTo(serverId, (client) => {
+      this._ipc.connectTo(serverId, (client) => {
         client.of[serverId]
-          .on('error', reject)
-          .on('disconnect', () => reject(new DetoxInternalError('IPC server has unexpectedly disconnected.')))
-          .on('connect', () => resolve(client.of[serverId]));
+          .once('error', reject)
+          .once('disconnect', () => reject(new DetoxInternalError('IPC server has unexpectedly disconnected.')))
+          .once('connect', () => resolve(client.of[serverId]));
       });
     });
 
@@ -74,12 +86,8 @@ class IPCClient {
   }
 
   async _registerContext() {
-    const sessionState = await this._emit('registerContext', {
-      id: this._id,
-      logFile: this._logger.file,
-    });
-
-    this._state.patch(sessionState);
+    const sessionState = await this._emit('registerContext', { id: this._id });
+    this._sessionState.patch(sessionState);
   }
 
   async _emit(event, payload) {
@@ -90,6 +98,7 @@ class IPCClient {
     return new Promise((resolve, reject) => {
       const server = this._serverConnection;
 
+      /* istanbul ignore next */
       function onError(err) {
         server.off('error', onError);
         server.off(`${event}Done`, onDone);
@@ -110,7 +119,7 @@ class IPCClient {
   }
 
   _onSessionStateUpdate = (payload) => {
-    this._state.patch(payload);
+    this._sessionState.patch(payload);
   };
 }
 

package/src/ipc/IPCServer.js

@@ -1,21 +1,30 @@
+const { uniqBy } = require('lodash');
 const { IPC } = require('node-ipc');
 
+const { serializeObjectWithError } = require('../utils/errorUtils');
+
 class IPCServer {
   /**
    * @param {object} options
-   * @param {import('./state').PrimarySessionState} options.sessionState
+   * @param {import('./SessionState')} options.sessionState
    * @param {Detox.Logger} options.logger
    */
   constructor({ sessionState, logger }) {
     this._sessionState = sessionState;
-    this._logger = logger.child({ __filename, cat: 'ipc' });
+    this._logger = logger.child({ cat: 'ipc,ipc-server' });
     this._ipc = null;
+    this._workers = new Set();
+    this._contexts = new Set();
   }
 
   get id() {
     return this._sessionState.detoxIPCServer;
   }
 
+  get contexts() {
+    return [...this._contexts];
+  }
+
   get sessionState() {
     return this._sessionState;
   }
@@ -26,12 +35,12 @@ class IPCServer {
     this._ipc.config.appspace = 'detox.';
     this._ipc.config.logger = (msg) => this._logger.trace(msg);
 
-      await new Promise((resolve) => {
+    await new Promise((resolve) => {
       // TODO: handle reject
       this._ipc.serve(() => resolve());
       this._ipc.server.on('registerContext', this.onRegisterContext.bind(this));
       this._ipc.server.on('registerWorker', this.onRegisterWorker.bind(this));
-      this._ipc.server.on('failedTests', this.onFailedTests.bind(this));
+      this._ipc.server.on('reportTestResults', this.onReportTestResults.bind(this));
       this._ipc.server.start();
     });
   }
@@ -41,45 +50,55 @@ class IPCServer {
       return;
     }
 
-    return new Promise((resolve, reject) =>{
+    await new Promise((resolve, reject) =>{
       // @ts-ignore
-      this._ipc.server.server.close(e => e ? reject(e) : resolve());
+      this._ipc.server.server.close(e => /* istanbul ignore next */
+        e ? reject(e) : resolve());
       this._ipc.server.stop();
     });
-  }
 
-  onRegisterContext({ id, logFile }, socket) {
-    this._sessionState.contexts.push(id);
+    this._ipc = null;
+  }
 
-    if (logFile && !this._sessionState.logFiles.includes(logFile)) {
-      this._sessionState.logFiles.push(logFile);
-    }
+  onRegisterContext({ id }, socket) {
+    this._contexts.add(id);
 
     this._ipc.server.emit(socket, 'registerContextDone', {
-      failedTestFiles: this._sessionState.failedTestFiles,
+      testResults: this._sessionState.testResults,
+      testSessionIndex: this._sessionState.testSessionIndex,
     });
   }
 
-  onRegisterWorker({ workerId }, socket) {
+  onRegisterWorker({ workerId }, socket = null) {
+    const workersCount = this._workers.add(workerId).size;
+    const shouldBroadcast = workersCount > this._sessionState.workersCount;
+    this._sessionState.workersCount = workersCount;
+
     if (socket) {
-      this._ipc.server.emit(socket, 'registerWorkerDone', {});
+      this._ipc.server.emit(socket, 'registerWorkerDone', { workersCount });
     }
 
-    if (workerId > this._sessionState.workersCount) {
-      const workersCount = this._sessionState.workersCount = workerId;
+    if (shouldBroadcast) {
       this._ipc.server.broadcast('sessionStateUpdate', { workersCount });
     }
   }
 
-  onFailedTests({ testFilePaths }, socket) {
-    this._sessionState.failedTestFiles.push(...testFilePaths);
+  onReportTestResults({ testResults }, socket = null) {
+    const merged = uniqBy([
+      ...testResults.map(r => serializeObjectWithError(r, 'testExecError')),
+      ...this._sessionState.testResults
+    ], 'testFilePath');
+
+    this._sessionState.testResults.splice(0, Infinity, ...merged);
 
     if (socket) {
-      this._ipc.server.emit(socket, 'failedTestsDone', {});
+      this._ipc.server.emit(socket, 'reportTestResultsDone', {
+        testResults: this._sessionState.testResults,
+      });
     }
 
     this._ipc.server.broadcast('sessionStateUpdate', {
-      failedTestFiles: this._sessionState.failedTestFiles,
+      testResults: this._sessionState.testResults,
     });
   }
 }

package/src/ipc/SessionState.js

@@ -0,0 +1,60 @@
+const vm = require('vm');
+
+const cycle = require('json-cycle');
+
+const context = vm.createContext({ require }, {
+  name: 'VM User Context',
+});
+
+class SessionState {
+  constructor({
+    id = '',
+    detoxConfig = null,
+    detoxIPCServer = '',
+    testResults = [],
+    testSessionIndex = 0,
+    workersCount = 0
+  }) {
+    this.id = id;
+    this.detoxConfig = detoxConfig;
+    this.detoxIPCServer = detoxIPCServer;
+    this.testResults = testResults;
+    this.testSessionIndex = testSessionIndex;
+    this.workersCount = workersCount;
+  }
+
+  patch(state) {
+    Object.assign(this, state);
+  }
+
+  stringify() {
+    return cycle.stringify(this, SessionState._stringifier);
+  }
+
+  /**
+   * @return {*}
+   */
+  static parse(stringified) {
+    const Class = this; // eslint-disable-line unicorn/no-this-assignment
+    // @ts-ignore
+    return new Class(cycle.parse(stringified, SessionState._reviver));
+  }
+
+  static _reviver(key, val) {
+    if (typeof val === 'object' && val !== null && typeof val.$fn == 'string') {
+      return vm.runInContext(val.$fn, context);
+    } else {
+      return val;
+    }
+  }
+
+  static _stringifier(key, val) {
+    if (typeof val === 'function') {
+      return { $fn: `(${val})` };
+    } else {
+      return val;
+    }
+  }
+}
+
+module.exports = SessionState;