creevey 0.9.0-beta.1 → 0.9.0-beta.2

package/lib/cjs/server/logger.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "getLogger", {
+  enumerable: true,
+  get: function () {
+    return _loglevel.getLogger;
+  }
+});
+exports.logger = exports.colors = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _loglevel = _interopRequireWildcard(require("loglevel"));
+
+var _loglevelPluginPrefix = _interopRequireDefault(require("loglevel-plugin-prefix"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const colors = {
+  TRACE: _chalk.default.magenta,
+  DEBUG: _chalk.default.cyan,
+  INFO: _chalk.default.blue,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+exports.colors = colors;
+
+_loglevelPluginPrefix.default.reg(_loglevel.default);
+
+_loglevelPluginPrefix.default.apply(_loglevel.default, {
+  format(level, name = 'Creevey') {
+    const levelColor = colors[level.toUpperCase()];
+    return `[${name}:${_chalk.default.gray(process.pid)}] ${levelColor(level)} =>`;
+  }
+
+});
+
+const logger = _loglevel.default.getLogger('Creevey');
+
+exports.logger = logger;

package/lib/cjs/server/master/api.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = creeveyApi;
+
+var _ws = _interopRequireDefault(require("ws"));
+
+var _logger = require("../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function broadcast(wss, message) {
+  wss.clients.forEach(ws => {
+    if (ws.readyState === _ws.default.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  });
+}
+
+function creeveyApi(runner) {
+  return {
+    subscribe(wss) {
+      runner.on('update', payload => broadcast(wss, {
+        type: 'update',
+        payload
+      }));
+    },
+
+    handleMessage(ws, message) {
+      if (typeof message != 'string') {
+        _logger.logger.info('unhandled message', message);
+
+        return;
+      }
+
+      const command = JSON.parse(message);
+
+      switch (command.type) {
+        case 'status':
+          {
+            ws.send(JSON.stringify({
+              type: 'status',
+              payload: runner.status
+            }));
+            return;
+          }
+
+        case 'start':
+          {
+            runner.start(command.payload);
+            return;
+          }
+
+        case 'stop':
+          {
+            runner.stop();
+            return;
+          }
+
+        case 'approve':
+          {
+            void runner.approve(command.payload);
+            return;
+          }
+      }
+    }
+
+  };
+}

package/lib/cjs/server/master/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = require("fs");
+
+var _util = require("util");
+
+var _master = _interopRequireDefault(require("./master"));
+
+var _api = _interopRequireDefault(require("./api"));
+
+var _types = require("../../types");
+
+var _utils = require("../utils");
+
+var _messages = require("../messages");
+
+var _logger = require("../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const copyFileAsync = (0, _util.promisify)(_fs.copyFile);
+const readdirAsync = (0, _util.promisify)(_fs.readdir);
+const mkdirAsync = (0, _util.promisify)(_fs.mkdir);
+
+async function copyStatics(reportDir) {
+  const clientDir = _path.default.join(__dirname, '../../client/web');
+
+  const files = (await readdirAsync(clientDir, {
+    withFileTypes: true
+  })).filter(dirent => dirent.isFile() && !dirent.name.endsWith('.d.ts') && !dirent.name.endsWith('.tsx')).map(dirent => dirent.name);
+  await mkdirAsync(reportDir, {
+    recursive: true
+  });
+
+  for (const file of files) {
+    await copyFileAsync(_path.default.join(clientDir, file), _path.default.join(reportDir, file));
+  }
+}
+
+function reportDataModule(data) {
+  return `
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.__CREEVEY_DATA__ = factory();
+  }
+}(this, function () { return ${JSON.stringify(data)} }));
+`;
+}
+
+function outputUnnecessaryImages(imagesDir, images) {
+  if (!(0, _fs.existsSync)(imagesDir)) return;
+  const unnecessaryImages = (0, _utils.readDirRecursive)(imagesDir).map(imagePath => _path.default.posix.relative(imagesDir, imagePath)).filter(imagePath => !images.has(imagePath));
+
+  if (unnecessaryImages.length > 0) {
+    _logger.logger.warn('We found unnecessary screenshot images, those can be safely removed:\n', unnecessaryImages.join('\n'));
+  }
+}
+
+async function _default(config, options, resolveApi) {
+  let runner = null;
+
+  if (config.hooks.before) {
+    await config.hooks.before();
+  }
+
+  (0, _messages.subscribeOn)('shutdown', () => {
+    var _config$hooks$after, _config$hooks;
+
+    return (_config$hooks$after = (_config$hooks = config.hooks).after) === null || _config$hooks$after === void 0 ? void 0 : _config$hooks$after.call(_config$hooks);
+  });
+  process.removeListener('SIGINT', _utils.shutdown);
+  process.on('SIGINT', () => {
+    var _runner, _runner2;
+
+    (_runner = runner) === null || _runner === void 0 ? void 0 : _runner.removeAllListeners('stop');
+
+    if ((_runner2 = runner) !== null && _runner2 !== void 0 && _runner2.isRunning) {
+      var _runner4;
+
+      // TODO Better handle stop
+      void Promise.race([new Promise(resolve => setTimeout(resolve, 10000)), new Promise(resolve => {
+        var _runner3;
+
+        return (_runner3 = runner) === null || _runner3 === void 0 ? void 0 : _runner3.once('stop', resolve);
+      })]).then(() => (0, _utils.shutdownWorkers)());
+      (_runner4 = runner) === null || _runner4 === void 0 ? void 0 : _runner4.stop();
+    } else {
+      void (0, _utils.shutdownWorkers)();
+    }
+  });
+  runner = await (0, _master.default)(config, {
+    watch: options.ui,
+    debug: options.debug,
+    port: options.port
+  });
+
+  if (options.saveReport) {
+    await copyStatics(config.reportDir);
+    runner.on('stop', () => {
+      var _runner5;
+
+      return (0, _fs.writeFileSync)(_path.default.join(config.reportDir, 'data.js'), reportDataModule((_runner5 = runner) === null || _runner5 === void 0 ? void 0 : _runner5.status.tests));
+    });
+  }
+
+  if (options.ui) {
+    resolveApi((0, _api.default)(runner));
+
+    _logger.logger.info(`Started on http://localhost:${options.port}`);
+  } else {
+    if (Object.values(runner.status.tests).filter(test => test && !test.skip).length == 0) {
+      _logger.logger.warn("Don't have any tests to run"); // eslint-disable-next-line no-process-exit
+
+
+      void (0, _utils.shutdownWorkers)().then(() => process.exit());
+      return;
+    }
+
+    runner.once('stop', () => {
+      var _runner$status$tests, _runner6;
+
+      const tests = Object.values((_runner$status$tests = (_runner6 = runner) === null || _runner6 === void 0 ? void 0 : _runner6.status.tests) !== null && _runner$status$tests !== void 0 ? _runner$status$tests : {});
+      const isSuccess = tests.filter(_types.isDefined).filter(({
+        skip
+      }) => !skip).every(({
+        status
+      }) => status == 'success'); // TODO output summary
+
+      process.exitCode = isSuccess ? 0 : -1;
+      if (!config.failFast) outputUnnecessaryImages(config.screenDir, (0, _utils.testsToImages)(tests)); // eslint-disable-next-line no-process-exit
+
+      void (0, _utils.shutdownWorkers)().then(() => process.exit());
+    }); // TODO grep
+
+    runner.start(Object.keys(runner.status.tests));
+  }
+}

package/lib/cjs/server/master/master.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = master;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _types = require("../../types");
+
+var _stories = require("../stories");
+
+var _runner = _interopRequireDefault(require("./runner"));
+
+var _start = require("../loaders/webpack/start");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function mergeTests(testsWithReports, testsFromStories) {
+  Object.values(testsFromStories).filter(_types.isDefined).forEach(test => {
+    const testWithReport = testsWithReports[test.id];
+    if (!testWithReport) return;
+    test.retries = testWithReport.retries;
+    if (testWithReport.status == 'success' || testWithReport.status == 'failed') test.status = testWithReport.status;
+    test.results = testWithReport.results;
+    test.approved = testWithReport.approved;
+  });
+  return testsFromStories;
+}
+
+async function master(config, options) {
+  if (config.useWebpackToExtractTests) await (0, _start.startWebpackCompiler)();
+  const runner = new _runner.default(config);
+
+  const reportDataPath = _path.default.join(config.reportDir, 'data.js');
+
+  let testsFromReport = {};
+
+  try {
+    testsFromReport = await Promise.resolve(`${reportDataPath}`).then(s => _interopRequireWildcard(require(s)));
+  } catch (error) {// Ignore error
+  }
+
+  await runner.init();
+  const tests = await (0, _stories.loadTestsFromStories)(Object.keys(config.browsers), listener => config.storiesProvider(config, options, listener), testsDiff => {
+    runner.updateTests(testsDiff);
+    (0, _stories.saveTestsJson)(runner.tests, config.reportDir);
+  });
+  runner.tests = mergeTests(testsFromReport, tests);
+  (0, _stories.saveTestsJson)(runner.tests, config.reportDir);
+  return runner;
+}

package/lib/cjs/server/master/pool.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _cluster = _interopRequireDefault(require("cluster"));
+
+var _events = require("events");
+
+var _types = require("../../types");
+
+var _messages = require("../messages");
+
+var _utils = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const FORK_RETRIES = 5;
+
+class Pool extends _events.EventEmitter {
+  get isRunning() {
+    return this.workers.length !== this.freeWorkers.length;
+  }
+
+  constructor(config, browser) {
+    super();
+    this.browser = browser;
+
+    _defineProperty(this, "maxRetries", void 0);
+
+    _defineProperty(this, "config", void 0);
+
+    _defineProperty(this, "workers", []);
+
+    _defineProperty(this, "queue", []);
+
+    _defineProperty(this, "forcedStop", false);
+
+    _defineProperty(this, "failFast", void 0);
+
+    this.failFast = config.failFast;
+    this.maxRetries = config.maxRetries;
+    this.config = config.browsers[browser];
+  }
+
+  async init() {
+    const poolSize = this.config.limit || 1;
+    this.workers = (await Promise.all(Array.from({
+      length: poolSize
+    }).map(() => this.forkWorker()))).filter(workerOrError => workerOrError instanceof _cluster.default.Worker);
+    if (this.workers.length != poolSize) throw new Error(`Can't instantiate workers for ${this.browser} due many errors`);
+    this.workers.forEach(worker => this.exitHandler(worker));
+  }
+
+  start(tests) {
+    if (this.isRunning) return false;
+    this.queue = tests.map(({
+      id,
+      path
+    }) => ({
+      id,
+      path,
+      retries: 0
+    }));
+    this.process();
+    return true;
+  }
+
+  stop() {
+    if (!this.isRunning) {
+      this.emit('stop');
+      return;
+    }
+
+    this.forcedStop = true;
+    this.queue = [];
+  }
+
+  process() {
+    const worker = this.getFreeWorker();
+    const [test] = this.queue;
+
+    if (this.queue.length == 0 && this.workers.length === this.freeWorkers.length) {
+      this.forcedStop = false;
+      this.emit('stop');
+      return;
+    }
+
+    if (!worker || !test) return;
+    worker.isRunning = true;
+    const {
+      id
+    } = test;
+    this.queue.shift();
+    this.sendStatus({
+      id,
+      status: 'running'
+    });
+    this.subscribe(worker, test);
+    (0, _messages.sendTestMessage)(worker, {
+      type: 'start',
+      payload: test
+    });
+    this.process();
+  }
+
+  sendStatus(message) {
+    this.emit('test', message);
+  }
+
+  getFreeWorker() {
+    return this.freeWorkers[Math.floor(Math.random() * this.freeWorkers.length)];
+  }
+
+  get aliveWorkers() {
+    return this.workers.filter(worker => !worker.exitedAfterDisconnect);
+  }
+
+  get freeWorkers() {
+    return this.aliveWorkers.filter(worker => !worker.isRunning);
+  }
+
+  async forkWorker(retry = 0) {
+    _cluster.default.setupMaster({
+      args: ['--browser', this.browser, ...process.argv.slice(2)]
+    });
+
+    const worker = _cluster.default.fork();
+
+    const message = await new Promise(resolve => {
+      const readyHandler = message => {
+        if (!(0, _types.isWorkerMessage)(message)) return;
+        worker.off('message', readyHandler);
+        resolve(message);
+      };
+
+      worker.on('message', readyHandler);
+    });
+    if (message.type != 'error') return worker;
+    this.gracefullyKill(worker);
+    if (retry == FORK_RETRIES) return message.payload;
+    return this.forkWorker(retry + 1);
+  }
+
+  exitHandler(worker) {
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    worker.once('exit', async () => {
+      if (_utils.isShuttingDown.current) return;
+      const workerOrError = await this.forkWorker();
+      if (!(workerOrError instanceof _cluster.default.Worker)) throw new Error(`Can't instantiate worker for ${this.browser} due many errors`);
+      this.exitHandler(workerOrError);
+      this.workers[this.workers.indexOf(worker)] = workerOrError;
+      this.process();
+    });
+  }
+
+  gracefullyKill(worker) {
+    const timeout = setTimeout(() => worker.kill(), 10000);
+    worker.on('exit', () => clearTimeout(timeout));
+    (0, _messages.sendShutdownMessage)(worker);
+  }
+
+  shouldRetry(test) {
+    return test.retries < this.maxRetries && !this.forcedStop;
+  }
+
+  handleTestResult(worker, test, result) {
+    const shouldRetry = result.status == 'failed' && this.shouldRetry(test);
+
+    if (shouldRetry) {
+      test.retries += 1;
+      this.queue[this.failFast ? 'unshift' : 'push'](test);
+    }
+
+    this.sendStatus({
+      id: test.id,
+      status: shouldRetry ? 'retrying' : result.status,
+      result
+    });
+    worker.isRunning = false;
+    setImmediate(() => this.process());
+  }
+
+  subscribe(worker, test) {
+    const subscriptions = [(0, _messages.subscribeOnWorker)(worker, 'worker', message => {
+      if (message.type != 'error') return;
+      subscriptions.forEach(unsubscribe => unsubscribe());
+      this.gracefullyKill(worker);
+      this.handleTestResult(worker, test, {
+        status: 'failed',
+        ...message.payload
+      });
+    }), (0, _messages.subscribeOnWorker)(worker, 'test', message => {
+      if (message.type != 'end') return;
+      subscriptions.forEach(unsubscribe => unsubscribe());
+      this.handleTestResult(worker, test, message.payload);
+    })];
+  }
+
+}
+
+exports.default = Pool;