wip: add first IPC PoC

.editorconfig

@@ -0,0 +1,22 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 120
+tab_width = 4
+trim_trailing_whitespace = true
+
+[{*.ats,*.cts,*.mts,*.ts}]
+indent_size = 2
+tab_width = 2
+
+[{*.cjs,*.js}]
+indent_size = 2
+tab_width = 2
+
+[{*.har,*.jsb2,*.jsb3,*.json,.babelrc,.eslintrc,.prettierrc,.stylelintrc,bowerrc,jest.config}]
+indent_size = 2

detox/runners/jest/environment.js

@@ -1,11 +1,13 @@
 // @ts-nocheck
 const NodeEnvironment = require('jest-environment-node');
 
-const DetoxError = require('../../src/errors/DetoxError');
-const Timer = require('../../src/utils/Timer');
+const DetoxWorkerContext = require('../../src/DetoxWorkerContext');
+const { DetoxError } = require('../../src/errors');
+const ipcClient = require('../../src/ipc/client');
 
 const DetoxCoreListener = require('./listeners/DetoxCoreListener');
 const DetoxInitErrorListener = require('./listeners/DetoxInitErrorListener');
+const Timer = require('./utils/Timer');
 const assertExistingContext = require('./utils/assertExistingContext');
 const assertJestCircus26 = require('./utils/assertJestCircus26');
 const wrapErrorWithNoopLifecycle = require('./utils/wrapErrorWithNoopLifecycle');
@@ -46,9 +48,11 @@ class DetoxCircusEnvironment extends NodeEnvironment {
 
   async setup() {
     await super.setup();
+    await ipcClient.init({});
+    const detoxConfig = await ipcClient.getDetoxConfig();
 
-    this.global.detox = require('../../src')
-      ._setGlobal(this.global);
+    DetoxWorkerContext.global = this.global;
+    this.global.detox = new DetoxWorkerContext(detoxConfig);
   }
 
   async teardown() {

detox/runners/jest/globalSetup.js

@@ -1,9 +1,15 @@
 const DetoxGlobalContext = require('../../src/DetoxGlobalContext');
 const configuration = require('../../src/configuration');
+const ipcServer = require('../../src/ipc/server');
 
 module.exports = async function detoxGlobalSetup(override) {
   const config = await configuration.composeDetoxConfig({ override });
 
+  await ipcServer.start({
+    sessionId: `detox-${process.pid}`,
+    detoxConfig: config,
+  });
+
   const globalContext = global['detox'] = new DetoxGlobalContext(config);
   try {
     await globalContext.setup();

detox/runners/jest/globalTeardown.js

@@ -1,7 +1,2 @@
 module.exports = async function detoxGlobalTeardown() {
-  const instance = global['detox'];
-
-  if (instance) {
-    await instance.cleanup();
-  }
 };

detox/src/utils/Timer.js → detox/runners/jest/utils/Timer.js

@@ -1,7 +1,7 @@
 // @ts-nocheck
-const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
+const { DetoxRuntimeError } = require('../../../src/errors');
 
-const Deferred = require('./Deferred');
+const Deferred = require('../../../src/utils/Deferred');
 
 class Timer {
   /**

detox/src/client/Client.test.js

@@ -26,7 +26,7 @@ describe('Client', () => {
 
     jest.mock('../utils/logger');
     log = require('../utils/logger');
-    log.level.mockReturnValue('debug');
+    log._level.mockReturnValue('debug');
 
     const AsyncWebSocket = jest.genMockFromModule('./AsyncWebSocket');
     mockAws = new AsyncWebSocket();
@@ -503,7 +503,7 @@ describe('Client', () => {
       ['debug'],
       ['trace'],
     ])(`should throw "testFailed" error with view hierarchy (on --loglevel %s)`, async (loglevel) => {
-      log.level.mockReturnValue(loglevel);
+      log._level.mockReturnValue(loglevel);
       mockAws.mockResponse('testFailed',  { details: 'this is an error', viewHierarchy: 'mock-hierarchy' });
       await expect(client.execute(anInvocation)).rejects.toThrowErrorMatchingSnapshot();
     });
@@ -513,7 +513,7 @@ describe('Client', () => {
       ['warn'],
       ['info'],
     ])(`should throw "testFailed" error without view hierarchy but with a hint (on --loglevel %s)`, async (loglevel) => {
-      log.level.mockReturnValue(loglevel);
+      log._level.mockReturnValue(loglevel);
       mockAws.mockResponse('testFailed',  { details: 'this is an error', viewHierarchy: 'mock-hierarchy' });
       const executionPromise = client.execute(anInvocation);
       await expect(executionPromise).rejects.toThrowErrorMatchingSnapshot();

detox/src/client/actions/actions.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const { DetoxInternalError, DetoxRuntimeError } = require('../../errors');
-const { getDetoxLevel } = require('../../utils/logger');
+const logger = require('../../utils/logger');
 const formatJSONStatus = require('../actions/formatters/SyncStatusFormatter');
 
 class Action {
@@ -201,7 +201,7 @@ class Invoke extends Action {
 
         if (response.params.viewHierarchy) {
           /* istanbul ignore next */
-          if (/^(debug|trace)$/.test(getDetoxLevel())) {
+          if (/^(debug|trace)$/.test(logger.level)) {
             debugInfo = 'View Hierarchy:\n' + response.params.viewHierarchy;
           } else {
             hint = 'To print view hierarchy on failed actions/matches, use log-level verbose or higher.';

detox/src/index.js

@@ -1,3 +1,7 @@
 module.exports = {
   // ...here the new life begins...
+  hook() {
+    // TODO: noop
+
+  },
 };

detox/src/ipc/client.js

@@ -0,0 +1,66 @@
+const ipc = require('node-ipc').default;
+
+const Deferred = require('../utils/Deferred');
+
+const state = {
+  open: false,
+  detoxConfig: new Deferred(),
+};
+
+module.exports = {
+  async init({
+    serverId = process.env.DETOX_IPC_SERVER_ID,
+    workerId = process.env.JEST_WORKER_ID,
+  }) {
+    return new Promise((resolve, reject) => {
+      ipc.config.id = `${serverId}-${process.env.JEST_WORKER_ID}`;
+      ipc.config.retry = 1000;
+      ipc.config.sync = true;
+      ipc.connectTo(serverId, function() {
+        const server = state.server = ipc.of[serverId];
+        server.on('error', reject);
+        server.on('connect', () => {
+          state.open = true;
+
+          server.emit('app.message', {
+            type: 'registerWorker',
+            workerId,
+          });
+
+          resolve();
+        });
+
+        server.on('disconnect', () => {
+          state.open = false;
+        });
+
+        server.on('app.message', ({ type, ...payload }) => {
+          switch (type) {
+            case 'registerWorkerDone': {
+              const { detoxConfig } = payload;
+              state.detoxConfig.resolve(detoxConfig);
+              break;
+            }
+          }
+        });
+      });
+    });
+  },
+
+  async getDetoxConfig() {
+    return state.detoxConfig.promise;
+  },
+
+  log(level, meta, ...args) {
+    if (state.open) {
+      state.server.emit('app.message', {
+        type: 'log',
+        level,
+        meta,
+        args,
+      });
+    } else {
+      console.error('Whoops...', level, meta, ...args);
+    }
+  },
+};

detox/src/ipc/server.js

@@ -0,0 +1,46 @@
+const ipc = require('node-ipc').default;
+
+const log = require('../logger');
+
+const state = {
+  workers: 0,
+  detoxConfig: null,
+};
+
+module.exports = {
+  async start({ sessionId, detoxConfig }) {
+    state.detoxConfig = detoxConfig;
+
+    debugger;
+    ipc.config.id = process.env.DETOX_IPC_SERVER_ID = `detox-${sessionId}`;
+    ipc.config.retry = 1500;
+    ipc.config.sync = true;
+
+    return new Promise((resolve, reject) => {
+      ipc.serve(function() {
+        resolve();
+
+        ipc.server.on('app.message', function(data, socket) {
+          const { type, ...payload } = data;
+          switch (type) {
+            case 'log': {
+              const { level, args } = payload;
+              return log[level](args);
+            }
+
+            case 'registerWorker': {
+              const { workerId } = payload;
+              state.workers = Math.max(state.workers, +workerId);
+              return ipc.server.emit(socket, 'app.message', {
+                type: 'registerWorkerDone',
+                detoxConfig: state.detoxConfig,
+              });
+            }
+          }
+        });
+      });
+
+      ipc.server.start();
+    });
+  },
+};

detox/src/logger/BunyanLogger.js

@@ -1,7 +1,8 @@
 class BunyanLogger {
   constructor(config, bunyan) {
     this._config = config;
-    this._bunyan = bunyan || null; // TODO
+    this._bunyan = bunyan || console; // TODO
+    this._bunyan.child = () => this._bunyan; // TODO: remove this
   }
 
   child(overrides) {

detox/src/logger/IPCLogger.js

@@ -1 +1,51 @@
-module.exports = require('./NullLogger');
+const _ = require('lodash');
+const ipcClient = require('../ipc/client');
+
+class IPCLogger {
+  constructor(config) {
+    this._config = config;
+    this._config.level = 'info';
+    ipcClient.getDetoxConfig().then(config => {
+      if (config.cliConfig.loglevel) {
+        this._config.level = config.cliConfig.loglevel;
+      }
+    });
+
+  }
+
+  child(context) {
+    return new IPCLogger(_.merge({}, this._config, { context }));
+  }
+
+  error() {
+    return this._send('error', [...arguments]);
+  }
+
+  warn() {
+    return this._send('warn', [...arguments]);
+  }
+
+  info() {
+    return this._send('info', [...arguments]);
+  }
+
+  debug() {
+    return this._send('debug', [...arguments]);
+  }
+
+  trace() {
+    return this._send('trace', [...arguments]);
+  }
+
+  _send(level, args) {
+    const hasContext = _.isObject(arguments[0]);
+    const meta = _.defaults({}, this._config.context, hasContext ? arguments[0] : undefined);
+    ipcClient.log(level, meta, hasContext ? args.slice(1) : args);
+  }
+
+  get level() {
+    return this._config.level; // ?
+  }
+}
+
+module.exports = IPCLogger;

detox/src/logger/index.js

@@ -1,10 +1,15 @@
 function resolveLoggerClass() {
-  switch (process.env.DETOX_LOGGER_IMPL) {
-    case 'bunyan': return require('./BunyanLogger');
-    case 'ipc': return require('./IPCLogger');
-    default: return require('./NullLogger');
+  if (global.IS_RUNNING_DETOX_UNIT_TESTS) {
+    // TODO: return NullLogger maybe?
+    return require('./BunyanLogger');
+  }
+
+  if (process.env.JEST_WORKER_ID) {
+    return require('./IPCLogger');
+  } else {
+    return require('./BunyanLogger');
   }
 }
 
 const Logger = resolveLoggerClass();
-module.exports = new Logger();
+module.exports = new Logger({});

detox/src/utils/__mocks__/logger.js

@@ -7,8 +7,10 @@ class FakeLogger {
     this.opts = opts;
     this.log = jest.fn();
     this.reinitialize = jest.fn();
-    this.level = jest.fn();
-    this.getDetoxLevel = this.getDetoxLevel.bind(this);
+    this._level = jest.fn();
+    Object.defineProperty(this, 'level', {
+      get: () => this._level(),
+    });
 
     for (const method of METHODS) {
       this[method] = jest.fn().mockImplementation((...args) => {
@@ -22,10 +24,6 @@ class FakeLogger {
     return this;
   }
 
-  getDetoxLevel() {
-    return this.level();
-  }
-
   clear() {
     this.opts = {};
     return this;

detox/src/utils/trace.js

@@ -1,6 +1,7 @@
 class Trace {
   constructor() {
     this.events = [];
+    this._timestampProviderFn = Date.now; // TODO: fix me
   }
 
   init(timestampProviderFn = Date.now) {

detox/test/e2e/global-setup.js

@@ -1,6 +1 @@
-async function globalSetup() {
-  const detox = require('detox');
-  await detox.globalInit();
-}
-
-module.exports = globalSetup;
+module.exports = require('detox/runners/jest/globalSetup')

detox/test/e2e/global-teardown.js

@@ -1,7 +1 @@
-const detox = require('detox');
-
-async function globalTeardown() {
-  await detox.globalCleanup();
-}
-
-module.exports = globalTeardown;
+module.exports = require('detox/runners/jest/globalTeardown')