detox 20.0.2-breaking.new-global-lifecycle.0 → 20.0.2

package/android/detox/src/testFull/java/com/wix/detox/reactnative/idlingresources/timers/DefaultIdleInterrogationStrategySpec.kt

@@ -1,115 +0,0 @@
-package com.wix.detox.reactnative.idlingresources.timers
-
-import com.facebook.react.bridge.NativeModule
-import com.wix.detox.UTHelpers
-import org.assertj.core.api.Assertions
-import org.spekframework.spek2.Spek
-import org.spekframework.spek2.style.specification.describe
-import java.util.*
-import java.util.concurrent.Executors
-
-private const val BUSY_INTERVAL_MS = 1500
-private const val MEANINGFUL_TIMER_INTERVAL = BUSY_INTERVAL_MS
-
-data class TimerStub(
-        private var mCallbackID: Int,
-        private var mTargetTime: Long,
-        private var mInterval: Int,
-        private var mRepeat: Boolean)
-
-class TimersNativeModuleStub : NativeModule {
-    val mTimers: PriorityQueue<Any> = PriorityQueue(2) { _, _ -> 0}
-    val mTimerGuard = "Lock-Mock"
-
-    override fun onCatalystInstanceDestroy() {}
-    override fun invalidate() {}
-
-    override fun getName(): String = "TimersNativeModuleStub"
-    override fun canOverrideExistingModule() = false
-    override fun initialize() {}
-}
-
-private fun now() = System.nanoTime() / 1000000L
-private fun aTimer(targetTime: Long, interval: Int, isRepeating: Boolean): TimerStub {
-    return TimerStub(-1, targetTime, interval, isRepeating)
-}
-private fun aTimer(interval: Int, isRepeating: Boolean) = aTimer(now() + interval + 10, interval, isRepeating)
-private fun aOneShotTimer(interval: Int) = aTimer(interval, false)
-private fun aRepeatingTimer(interval: Int) = aTimer(interval, true)
-private fun anOverdueTimer() = aTimer(now() - 100, 123, false)
-
-object DefaultIdleInterrogationStrategySpec: Spek({
-  describe("Default timers idle-interrogation strategy") {
-
-      lateinit var timersNativeModule: TimersNativeModuleStub
-
-      beforeEachTest {
-          timersNativeModule = TimersNativeModuleStub()
-      }
-
-      fun givenTimer(timer: Any) {
-          timersNativeModule.mTimers.add(timer)
-      }
-
-      fun uut() = DefaultIdleInterrogationStrategy(timersNativeModule)
-
-      it("should be idle if there are no timers in queue") {
-          Assertions.assertThat(uut().isIdleNow()).isTrue()
-      }
-
-      it("should be busy if there's a meaningful pending timer") {
-          givenTimer(aOneShotTimer(MEANINGFUL_TIMER_INTERVAL))
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      it("should be idle if pending timer is too far away (ie not meaningful)") {
-          givenTimer(aOneShotTimer(BUSY_INTERVAL_MS + 1))
-          Assertions.assertThat(uut().isIdleNow()).isTrue()
-      }
-
-      it("should be idle if the only timer is a repeating one") {
-          givenTimer(aRepeatingTimer(MEANINGFUL_TIMER_INTERVAL))
-          Assertions.assertThat(uut().isIdleNow()).isTrue()
-      }
-
-      it("should be busy if a meaningful pending timer lies beyond a repeating one") {
-          givenTimer(aRepeatingTimer(BUSY_INTERVAL_MS / 10))
-          givenTimer(aOneShotTimer(BUSY_INTERVAL_MS))
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      /**
-       * Note: Reversed logic due to this issue: https://github.com/wix/Detox/issues/1171 !!!
-       *
-       * Apparently at times (rare) this caused Espresso to think we're idle too soon, rendering
-       * it never to query any idling resource again even after the timer effectively expires...
-       */
-      it("should be *busy* even if all timers are overdue") {
-          givenTimer(anOverdueTimer())
-          givenTimer(anOverdueTimer())
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      it("should be busy if has a meaningful pending timer set beyond an overdue timer") {
-          givenTimer(anOverdueTimer())
-          givenTimer(aOneShotTimer(MEANINGFUL_TIMER_INTERVAL))
-          Assertions.assertThat(uut().isIdleNow()).isFalse()
-      }
-
-      it("should yield to other threads using the timers module") {
-          val executor = Executors.newSingleThreadExecutor()
-          var isIdle: Boolean? = null
-
-          synchronized(timersNativeModule.mTimerGuard) {
-              executor.submit {
-                  isIdle = uut().isIdleNow()
-              }
-              UTHelpers.yieldToOtherThreads(executor)
-              Assertions.assertThat(isIdle).isNull()
-          }
-          UTHelpers.yieldToOtherThreads(executor)
-          Assertions.assertThat(isIdle).isNotNull()
-          executor.shutdownNow()
-      }
-  }
-})

package/runners/jest/deprecation.js

@@ -1,25 +0,0 @@
-const chalk = require('chalk');
-
-// @ts-ignore
-console.error(chalk.yellow(`
-=========================  THE NEW JOURNEY BEGINS  =============================
-
-                  https://wix.github.io/Detox/docs/guide/jest
-
-         Sorry to say that Detox 20 comes without old adapters for Jest.
-    You have to rearrange your init code before you can continue your journey.
-
-         Navigate to the link and follow the migration guide steps.
-
-         Sincerely yours,
-         Detox team.
-
-                  https://wix.github.io/Detox/docs/guide/jest
-
-=========================  THE NEW JOURNEY BEGINS  =============================
-
-`));
-
-throw Object.assign(new Error(
-  '\n\nPlease follow the new Jest setup guide:\nhttps://wix.github.io/Detox/docs/guide/jest\n\n'
-), { stack: '' });

package/src/configuration/utils/warnings.js

@@ -1,12 +0,0 @@
-const DEVICE_LAUNCH_ARGS_DEPRECATION = `\
---device-launch-args is a deprecated name of this option.
-Please change your scripts to use --device-boot-args instead.`;
-
-const DEVICE_LAUNCH_ARGS_GENERIC_DEPRECATION = `\
---device-launch-args / $DETOX_DEVICE_LAUNCH_ARGS is a deprecated name of this option.
-Please change your scripts to use --device-boot-args / $DETOX_DEVICE_BOOT_ARGS instead.`;
-
-module.exports = {
-  DEVICE_LAUNCH_ARGS_DEPRECATION,
-  DEVICE_LAUNCH_ARGS_GENERIC_DEPRECATION,
-};

package/src/logger/DetoxTraceEventBuilder.js

@@ -1,21 +0,0 @@
-const { AbstractEventBuilder } = require('trace-event-lib');
-
-class DetoxTraceEventBuilder extends AbstractEventBuilder {
-  constructor(forward) {
-    super();
-
-    this._forward = forward;
-  }
-
-  send(event) {
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    const { pid, ts, name, args = {}, ...trace } = event;
-    if (trace.ph === 'E') {
-      this._forward({ ...args, trace }, `end`);
-    } else {
-      this._forward({ ...args, trace }, name);
-    }
-  }
-}
-
-module.exports = DetoxTraceEventBuilder;

package/src/logger/DetoxTracer.js

@@ -1,133 +0,0 @@
-const _ = require('lodash');
-
-const isPromise = require('../utils/isPromise');
-
-const DetoxTraceEventBuilder = require('./DetoxTraceEventBuilder');
-const TraceThreadDispatcher = require('./TraceThreadDispatcher');
-
-class DetoxTracer {
-  /**
-   * @param {object} options
-   * @param {Detox.Logger} options.logger
-   */
-  constructor({ logger }) {
-    this.logger = logger;
-    this.builder = new DetoxTraceEventBuilder(this.logger.trace);
-    this.categories = {};
-    this.defaultEventDispatcher = new TraceThreadDispatcher({
-      logger,
-      name: 'Default',
-      min: 10000,
-    });
-    this.eventDispatchers = { '': this.defaultEventDispatcher };
-  }
-
-  /**
-   * @param {Detox.TraceEvent | string} eventOrName
-   * @param {Detox.TraceEvent['args']} [args]
-   * @returns {import('trace-event-lib').EndHandle<Detox.TraceEvent>}
-   */
-  begin(eventOrName, args) {
-    const event = typeof eventOrName === 'string' ? { name: eventOrName, args } : eventOrName;
-    const mainCategory = event.cat ? event.cat.split(',', 1)[0] : '';
-    const dispatcher = this.eventDispatchers[mainCategory] || this.defaultEventDispatcher;
-    const tid = dispatcher.begin(event.id);
-
-    return this.builder.begin({
-      args: event.args,
-      cat: event.cat || '',
-      cname: event.cname,
-      name: event.name,
-      tid,
-    });
-  }
-
-  end(eventOrName, args) {
-    const event = typeof eventOrName === 'string' ? { name: eventOrName, args } : eventOrName || {};
-    const mainCategory = event.cat ? event.cat.split(',', 1)[0] : '';
-    const dispatcher = this.eventDispatchers[mainCategory] || this.defaultEventDispatcher;
-    const tid = dispatcher.end(event.id);
-
-    this.builder.end({
-      args: event.args,
-      cname: event.cname,
-      tid,
-    });
-  }
-
-  section(sectionName, func) {
-    let result;
-
-    this.begin(sectionName);
-    try {
-      result = func();
-      if (!isPromise(result)) {
-        this.end(sectionName, { success: true });
-      } else {
-        result.then(
-          () => this.end(sectionName, { success: true }),
-          (err) => this.end(sectionName, { success: false, err }),
-        );
-      }
-    } catch (err) {
-      this.end(sectionName, { success: false, err });
-      throw err;
-    }
-
-    return result;
-  }
-
-  registerThreads(event, [min, max]) {
-    this.eventDispatchers[event] = new TraceThreadDispatcher({
-      logger: this.logger,
-      name: event,
-      min,
-      max,
-    });
-
-    return this;
-  }
-
-  static default(options) {
-    const tracer = new DetoxTracer(options);
-    for (const [key, range] of Object.entries(this.CATEGORIES)) {
-      tracer.registerThreads(key, range);
-    }
-
-    return Object.assign(
-      tracer.section.bind(tracer),
-      {
-        begin: tracer.begin.bind(tracer),
-        startSection: tracer.begin.bind(tracer),
-        end: tracer.end.bind(tracer),
-        endSection: tracer.end.bind(tracer),
-      });
-  }
-
-  static categorize(tid) {
-    return _.findKey(this.CATEGORIES, ([min, max]) => min <= tid && tid <= max) || 'user';
-  }
-
-  static threadize(cat) {
-    const [mainCategory] = cat ? cat.split(',', 1) : 'user';
-    const threads = _.find(this.CATEGORIES, (_, key) => key === mainCategory);
-    return threads ? threads[0] : 10000;
-  }
-
-  /**
-   * @type {Record<string, [number, number]>}
-   */
-  static CATEGORIES = {
-    'lifecycle': [0, 0],
-    'ipc': [29, 29],
-    'ws-server': [50, 99],
-    'ws-client': [100, 149],
-    'device': [150, 159],
-    'artifacts-manager': [300, 300],
-    'artifact-plugin': [310, 349],
-    'artifact': [350, 399],
-    'child-process': [400, 499],
-  };
-}
-
-module.exports = DetoxTracer;

package/src/logger/TraceThreadDispatcher.js

@@ -1,52 +0,0 @@
-const isUndefined = (x) => x === undefined;
-
-class TraceThreadDispatcher {
-  /**
-   * @param {object} options
-   * @param {Detox.Logger} options.logger
-   * @param {string} options.name
-   * @param {number} options.min
-   * @param {number} [options.max]
-   */
-  constructor({ logger, name, min, max = Infinity }) {
-    this.logger = logger;
-    this.name = name;
-    this.min = min;
-    this.max = max;
-    this.stacks = [];
-    this.threads = [];
-  }
-
-  begin(id = 0) {
-    const tid = this._findTID(id);
-    this.threads[tid] = id;
-    this.stacks[tid] = (this.stacks[tid] || 0) + 1;
-    return this._transpose(tid);
-  }
-
-  end(id = 0) {
-    const tid = this._findTID(id);
-    if (this.stacks[tid] && --this.stacks[tid] === 0) {
-      delete this.threads[tid];
-    }
-    return this._transpose(tid);
-  }
-
-  _findTID(id) {
-    let tid = this.threads.indexOf(id);
-    if (tid === -1) {
-      tid = this.threads.findIndex(isUndefined);
-    }
-    return tid === -1 ? this.threads.length : tid;
-  }
-
-  _transpose(id) {
-    const result = this.min + id;
-    if (result > this.max) {
-      this.logger.warn({ event: 'THREAD_DISPATCHER' }, `${this.name} trace thread dispatcher has run out of available thread IDs: ${this.min}..${this.max}`);
-    }
-    return Math.min(result, this.max);
-  }
-}
-
-module.exports = TraceThreadDispatcher;

package/src/utils/ChromeTracingExporter.js

@@ -1,54 +0,0 @@
-const _ = require('lodash');
-
-const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
-
-class ChromeTracingExporter {
-  constructor({
-    process,
-    thread,
-  }) {
-    this._process = {
-      id: process.id,
-      name: process.name,
-    };
-    this._thread = {
-      id: thread.id,
-      name: thread.name,
-    };
-  }
-
-  export(traceEvents, append) {
-    const _events = _.flatMap(traceEvents, this._parseEvent.bind(this));
-    const json = JSON.stringify(_events);
-    const prefix = (append ? ',' : '[');
-    return `${prefix}${json.slice(1, -1)}`;
-  }
-
-  _parseEvent(event) {
-    const { name, ts, args, type } = event;
-    const tsInMicroseconds = ts * 1000;
-    switch (type) {
-      case 'start': return this._event(name, 'B', tsInMicroseconds, args);
-      case 'end': return this._event(name, 'E', tsInMicroseconds, args);
-      case 'init': return [
-          this._event('process_name', 'M', tsInMicroseconds, { name: this._process.name }),
-          this._event('thread_name', 'M', tsInMicroseconds, { name: this._thread.name }),
-        ];
-      default:
-        throw new DetoxRuntimeError({ message: `Invalid type '${type}' in event: ${event}` });
-    }
-  }
-
-  _event(name, phase, ts, args) {
-    return {
-      name,
-      pid: this._process.id,
-      tid: this._thread.id,
-      ts,
-      ph: phase,
-      args: { ...args },
-    };
-  }
-}
-
-module.exports = ChromeTracingExporter;

package/src/utils/streamUtils.js

@@ -1,214 +0,0 @@
-const { PassThrough, Transform } = require('stream');
-
-const bunyanDebugStream = require('bunyan-debug-stream');
-const duplexify = require('duplexify');
-const multiSort = require('multi-sort-stream');
-const pipe = require('multipipe');
-const JsonlParser = require('stream-json/jsonl/Parser');
-const stripAnsi = require('strip-ansi');
-const { AbstractEventBuilder } = require('trace-event-lib');
-
-const DetoxTracer = require('../logger/DetoxTracer');
-
-const log = require('./logger').child({ __filename });
-
-function compareTimestamps(a, b) {
-  return +(a.value.time > b.value.time) - +(a.value.time < b.value.time);
-}
-
-function mapTransform(fn) {
-  return new Transform({
-    objectMode: true,
-    transform(chunk, encoding, callback){
-      this.push(fn(chunk));
-      callback();
-    },
-  });
-}
-
-function flatMapTransform(fn) {
-  let index = 0;
-
-  return new Transform({
-    objectMode: true,
-    transform(chunk, encoding, callback){
-      const result = fn(chunk, index++);
-      if (Array.isArray(result)) {
-        // eslint-disable-next-line unicorn/no-array-method-this-argument
-        result.forEach(pushThis, this);
-      } else if (result) {
-        this.push(result);
-      }
-
-      callback();
-    },
-  });
-}
-
-function pushThis(x) {
-  return this.push(x);
-}
-
-function extractValue({ value }) {
-  value.msg = stripAnsi(value.msg);
-
-  if (typeof value.time === 'string') {
-    value.time = new Date(value.time);
-  }
-
-  return value;
-}
-
-function through() {
-  return new PassThrough({ objectMode: true });
-}
-
-function mergeSortedJSONL(jsonlStreams, comparator = compareTimestamps) {
-  const intermediate = mapTransform(extractValue);
-  const reemitError = (err) => intermediate.emit('error', err);
-  const addReemit = (stream) => stream.on('error', reemitError);
-  return pipe(multiSort(jsonlStreams.map(addReemit), comparator), intermediate, through());
-}
-
-function writeJSONL() {
-  return new JsonlStringer({
-    header: '',
-    delimiter: '\n',
-    footer: '',
-  });
-}
-
-function writeJSON() {
-  return new JsonlStringer({
-    header: '[\n\t',
-    delimiter: ',\n\t',
-    footer: '\n]\n',
-  });
-}
-
-function debugStream(options) {
-  const out = new PassThrough({ encoding: 'utf8' });
-  const writable = bunyanDebugStream.default({
-    ...options,
-    colors: false,
-    out,
-  });
-
-  return duplexify(writable, out, {
-    readableObjectMode: false,
-    writableObjectMode: true
-  });
-}
-
-class JsonlStringer extends Transform {
-  constructor({ replacer = undefined, header = '', delimiter = '\n', footer = '' } = {}) {
-    super({ writableObjectMode: true, readableObjectMode: false });
-
-    this._replacer = replacer;
-    this._header = header;
-    this._delimiter = delimiter;
-    this._footer = footer;
-  }
-
-  _transform(chunk, _, callback) {
-    if (this._header) {
-      this.push(this._header);
-    }
-
-    this.push(JSON.stringify(chunk, this._replacer));
-    this._transform = this._nextTransform;
-    callback(null);
-  }
-
-  _nextTransform(chunk, _, callback) {
-    this.push(this._delimiter + JSON.stringify(chunk, this._replacer));
-    callback(null);
-  }
-
-  _flush(callback) {
-    if (this._footer) {
-      this.push(this._footer);
-    }
-
-    callback();
-  }
-}
-
-class SimpleEventBuilder extends AbstractEventBuilder {
-  events = [];
-  send(event) {
-    this.events.push(event);
-  }
-}
-
-function chromeTraceStream() {
-  const knownPids = new Set();
-  const knownTids = new Set();
-
-  return flatMapTransform((data) => {
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    const { pid, trace, msg, time, name: _name, hostname: _hostname, ...args } = data;
-    const tid = trace ? trace.tid : DetoxTracer.threadize(args.cat);
-    const ts = new Date(time).getTime() * 1E3;
-
-    const builder = new SimpleEventBuilder();
-    if (!knownPids.has(pid)) {
-      builder.process_name(pid === process.pid ? 'primary' : 'secondary', pid);
-      knownPids.add(pid);
-    }
-
-    const tidHash = `${pid}:${tid}`;
-    if (!knownTids.has(tidHash)) {
-      builder.thread_name(DetoxTracer.categorize(tid), tid, pid);
-      builder.thread_sort_index(tid, tid, pid);
-      knownTids.add(tidHash);
-    }
-
-    const event = { ph: 'i', ...data.trace, pid, tid, ts, args };
-    if (!trace || trace.ph !== 'E') {
-      event.name = msg || '';
-    }
-
-    builder.events.push(event);
-    return builder.events;
-  });
-}
-
-// TODO: create PR to https://github.com/mafintosh/duplexify
-// should be able to pass { error: false } to end-of-stream
-function preventErrorSubscriptions(emitter) {
-  const originalOn = emitter.on.bind(emitter);
-  emitter.on = (event, ...args) => {
-    if (event === 'error') {
-      return emitter;
-    }
-
-    return originalOn(event, ...args);
-  };
-
-  return emitter;
-}
-
-function readJSONL() {
-  const readable = new PassThrough({ objectMode: true });
-  const writable = JsonlParser.make({ checkErrors: true })
-    .on('error', (err) => {
-      if (err instanceof SyntaxError) {
-        log.debug({ event: 'JSONL_ERROR', err });
-        readable.end();
-      } else {
-        readable.emit('error', err);
-      }
-    });
-
-  return duplexify.obj(preventErrorSubscriptions(writable), writable.pipe(readable));
-}
-
-module.exports = {
-  readJSONL,
-  writeJSON,
-  writeJSONL,
-  mergeSortedJSONL,
-  debugStream,
-  chromeTraceStream,
-};

package/src/utils/trace.js

@@ -1,19 +0,0 @@
-/** @type {Detox.Tracer} */
-const trace = require('../..').trace;
-const traceCall = trace.bind(null);
-
-function traceMethods(obj, cat, methodNames) {
-  for (const name of methodNames) {
-    const originalMethod = obj[name];
-
-    obj[name] = function tracedMethod() {
-      return traceCall({ cat, name }, originalMethod.apply.bind(originalMethod, obj, arguments));
-    };
-  }
-}
-
-module.exports = {
-  trace,
-  traceCall,
-  traceMethods,
-};