creevey 0.9.0-beta.1 → 0.9.0-non-webpack.0

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

@@ -0,0 +1,281 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = require("fs");
+
+var _util = require("util");
+
+var _events = require("events");
+
+var _types = require("../../types");
+
+var _pool = _interopRequireDefault(require("./pool"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const copyFileAsync = (0, _util.promisify)(_fs.copyFile);
+const mkdirAsync = (0, _util.promisify)(_fs.mkdir);
+
+class Runner extends _events.EventEmitter {
+  pools = {};
+  tests = {};
+
+  get isRunning() {
+    return Object.values(this.pools).some(pool => pool.isRunning);
+  }
+
+  constructor(config) {
+    super();
+    this.failFast = config.failFast;
+    this.screenDir = config.screenDir;
+    this.reportDir = config.reportDir;
+    this.browsers = Object.keys(config.browsers);
+    this.browsers.map(browser => this.pools[browser] = new _pool.default(config, browser)).map(pool => pool.on('test', this.handlePoolMessage));
+  }
+
+  handlePoolMessage = message => {
+    const {
+      id,
+      status,
+      result
+    } = message;
+    const test = this.tests[id];
+    if (!test) return;
+    const {
+      browser,
+      testName,
+      storyPath,
+      storyId
+    } = test; // TODO Handle 'retrying' status
+
+    test.status = status == 'retrying' ? 'failed' : status;
+
+    if (!result) {
+      this.sendUpdate({
+        tests: {
+          [id]: {
+            id,
+            browser,
+            testName,
+            storyPath,
+            status: test.status,
+            storyId
+          }
+        }
+      });
+      return;
+    }
+
+    if (!test.results) {
+      test.results = [];
+    }
+
+    test.results.push(result);
+    this.sendUpdate({
+      tests: {
+        [id]: {
+          id,
+          browser,
+          testName,
+          storyPath,
+          status: test.status,
+          results: [result],
+          storyId
+        }
+      }
+    });
+    if (this.failFast && status == 'failed') this.stop();
+  };
+  handlePoolStop = () => {
+    if (!this.isRunning) {
+      this.sendUpdate({
+        isRunning: false
+      });
+      this.emit('stop');
+    }
+  };
+
+  async init() {
+    await Promise.all(Object.values(this.pools).map(pool => pool.init()));
+  }
+
+  updateTests(testsDiff) {
+    const tests = {};
+    const removedTests = [];
+    Object.entries(testsDiff).forEach(([id, newTest]) => {
+      const oldTest = this.tests[id];
+
+      if (newTest) {
+        if (oldTest) {
+          this.tests[id] = { ...newTest,
+            retries: oldTest.retries,
+            results: oldTest.results,
+            approved: oldTest.approved
+          };
+        } else this.tests[id] = newTest; // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+        const {
+          story,
+          fn,
+          ...restTest
+        } = newTest;
+        tests[id] = { ...restTest,
+          status: 'unknown'
+        };
+      } else if (oldTest) {
+        const {
+          id,
+          browser,
+          testName,
+          storyPath,
+          storyId
+        } = oldTest;
+        removedTests.push({
+          id,
+          browser,
+          testName,
+          storyPath,
+          storyId
+        });
+        delete this.tests[id];
+      }
+    });
+    this.sendUpdate({
+      tests,
+      removedTests
+    });
+  }
+
+  start(ids) {
+    if (this.isRunning) return;
+    const testsToStart = ids.map(id => this.tests[id]).filter(_types.isDefined).filter(test => !test.skip);
+    if (testsToStart.length == 0) return;
+    this.sendUpdate({
+      isRunning: true,
+      tests: testsToStart.reduce((update, {
+        id,
+        storyId,
+        browser,
+        testName,
+        storyPath
+      }) => ({ ...update,
+        [id]: {
+          id,
+          browser,
+          testName,
+          storyPath,
+          status: 'pending',
+          storyId
+        }
+      }), {})
+    });
+    const testsByBrowser = testsToStart.reduce((tests, test) => {
+      const {
+        id,
+        browser,
+        testName,
+        storyPath
+      } = test;
+      const restPath = [...storyPath, testName].filter(_types.isDefined);
+      test.status = 'pending';
+      return { ...tests,
+        [browser]: [...(tests[browser] || []), {
+          id,
+          path: restPath
+        }]
+      };
+    }, {});
+    this.browsers.forEach(browser => {
+      const pool = this.pools[browser];
+      const tests = testsByBrowser[browser];
+
+      if (tests && tests.length > 0 && pool.start(tests)) {
+        pool.once('stop', this.handlePoolStop);
+      }
+    });
+  }
+
+  stop() {
+    if (!this.isRunning) return;
+    this.browsers.forEach(browser => this.pools[browser].stop());
+  }
+
+  get status() {
+    const tests = {};
+    Object.values(this.tests).filter(_types.isDefined) // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    .forEach(({
+      story,
+      fn,
+      ...test
+    }) => tests[test.id] = test);
+    return {
+      isRunning: this.isRunning,
+      tests,
+      browsers: this.browsers
+    };
+  }
+
+  async approve({
+    id,
+    retry,
+    image
+  }) {
+    const test = this.tests[id];
+    if (!test || !test.results) return;
+    const result = test.results[retry];
+    if (!result || !result.images) return;
+    const images = result.images[image];
+    if (!images) return;
+
+    if (!test.approved) {
+      test.approved = {};
+    }
+
+    const {
+      browser,
+      testName,
+      storyPath
+    } = test;
+    const restPath = [...storyPath, testName].filter(_types.isDefined);
+
+    const testPath = _path.default.join(...restPath, image == browser ? '' : browser);
+
+    const srcImagePath = _path.default.join(this.reportDir, testPath, images.actual);
+
+    const dstImagePath = _path.default.join(this.screenDir, testPath, `${image}.png`);
+
+    await mkdirAsync(_path.default.join(this.screenDir, testPath), {
+      recursive: true
+    });
+    await copyFileAsync(srcImagePath, dstImagePath);
+    test.approved[image] = retry;
+    this.sendUpdate({
+      tests: {
+        [id]: {
+          id,
+          browser,
+          testName,
+          storyPath,
+          approved: {
+            [image]: retry
+          },
+          storyId: test.storyId
+        }
+      }
+    });
+  }
+
+  sendUpdate(data) {
+    this.emit('update', data);
+  }
+
+}
+
+exports.default = Runner;

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = server;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _http = _interopRequireDefault(require("http"));
+
+var _cluster = _interopRequireDefault(require("cluster"));
+
+var _koa = _interopRequireDefault(require("koa"));
+
+var _cors = _interopRequireDefault(require("@koa/cors"));
+
+var _koaStatic = _interopRequireDefault(require("koa-static"));
+
+var _koaMount = _interopRequireDefault(require("koa-mount"));
+
+var _koaBodyparser = _interopRequireDefault(require("koa-bodyparser"));
+
+var _ws = _interopRequireDefault(require("ws"));
+
+var _messages = require("../messages");
+
+var _types = require("../../types");
+
+var _logger = require("../logger");
+
+var _shared = require("../../shared");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function server(reportDir, port, ui) {
+  let resolveApi = _types.noop;
+  let setStoriesCounter = 0;
+  const creeveyApi = new Promise(resolve => resolveApi = resolve);
+  const app = new _koa.default();
+
+  const server = _http.default.createServer(app.callback());
+
+  const wss = new _ws.default.Server({
+    server
+  });
+  app.use((0, _cors.default)());
+  app.use((0, _koaBodyparser.default)());
+  app.use(async (ctx, next) => {
+    if (ctx.method == 'GET' && ctx.path == '/ping') {
+      ctx.body = 'pong';
+      return;
+    }
+
+    await next();
+  });
+
+  if (ui) {
+    app.use(async (_, next) => {
+      await creeveyApi;
+      await next();
+    });
+  }
+
+  app.use(async (ctx, next) => {
+    if (ctx.method == 'POST' && ctx.path == '/stories') {
+      const {
+        setStoriesCounter: counter,
+        stories
+      } = ctx.request.body;
+      if (setStoriesCounter >= counter) return;
+      const deserializedStories = stories.map(([file, stories]) => [file, stories.map(_shared.deserializeStory)]);
+      setStoriesCounter = counter;
+      (0, _messages.emitStoriesMessage)({
+        type: 'update',
+        payload: deserializedStories
+      });
+      Object.values(_cluster.default.workers ?? {}).filter(_types.isDefined).filter(worker => worker.isConnected()).forEach(worker => (0, _messages.sendStoriesMessage)(worker, {
+        type: 'update',
+        payload: deserializedStories
+      }));
+      return;
+    }
+
+    await next();
+  });
+  app.use(async (ctx, next) => {
+    if (ctx.method == 'POST' && ctx.path == '/capture') {
+      const {
+        workerId,
+        options
+      } = ctx.request.body;
+      const worker = Object.values(_cluster.default.workers ?? {}).filter(_types.isDefined).find(worker => worker.process.pid == workerId); // NOTE: Hypothetical case when someone send to us capture req and we don't have a worker with browser session for it
+
+      if (!worker) return;
+      await new Promise(resolve => {
+        const unsubscribe = (0, _messages.subscribeOnWorker)(worker, 'stories', message => {
+          if (message.type != 'capture') return;
+          unsubscribe();
+          resolve();
+        });
+        (0, _messages.sendStoriesMessage)(worker, {
+          type: 'capture',
+          payload: options
+        });
+      }); // TODO Pass screenshot result to show it in inspector
+
+      ctx.body = 'Ok';
+      return;
+    }
+
+    await next();
+  });
+  app.use((0, _koaStatic.default)(_path.default.join(__dirname, '../../client/web')));
+  app.use((0, _koaMount.default)('/report', (0, _koaStatic.default)(reportDir)));
+  wss.on('error', error => _logger.logger.error(error));
+  server.listen(port);
+  (0, _messages.subscribeOn)('shutdown', () => {
+    server.close();
+    wss.close();
+  });
+  void creeveyApi.then(api => {
+    api.subscribe(wss);
+    wss.on('connection', ws => {
+      ws.on('message', message => api.handleMessage(ws, message));
+    });
+  });
+  return resolveApi;
+}

package/lib/cjs/server/messages.js

@@ -0,0 +1,264 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.emitDockerMessage = emitDockerMessage;
+exports.emitShutdownMessage = emitShutdownMessage;
+exports.emitStoriesMessage = emitStoriesMessage;
+exports.emitTestMessage = emitTestMessage;
+exports.emitWebpackMessage = emitWebpackMessage;
+exports.emitWorkerMessage = emitWorkerMessage;
+exports.sendDockerMessage = sendDockerMessage;
+exports.sendShutdownMessage = sendShutdownMessage;
+exports.sendStoriesMessage = sendStoriesMessage;
+exports.sendTestMessage = sendTestMessage;
+exports.subscribeOn = subscribeOn;
+exports.subscribeOnWorker = subscribeOnWorker;
+
+var _cluster = _interopRequireDefault(require("cluster"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function emitMessage(message) {
+  var _process$send, _process;
+
+  if (_cluster.default.isWorker && !process.connected) return false;
+  return ((_process$send = (_process = process).send) === null || _process$send === void 0 ? void 0 : _process$send.call(_process, message)) ?? // @ts-expect-error: wrong typings `process.emit` return boolean
+  process.emit('message', message);
+}
+
+function emitWorkerMessage(message) {
+  return emitMessage({
+    scope: 'worker',
+    ...message
+  });
+}
+
+function emitStoriesMessage(message) {
+  return emitMessage({
+    scope: 'stories',
+    ...message
+  });
+}
+
+function emitTestMessage(message) {
+  return emitMessage({
+    scope: 'test',
+    ...message
+  });
+}
+
+function emitWebpackMessage(message) {
+  return emitMessage({
+    scope: 'webpack',
+    ...message
+  });
+}
+
+function emitDockerMessage(message) {
+  return emitMessage({
+    scope: 'docker',
+    ...message
+  });
+}
+
+function emitShutdownMessage() {
+  return emitMessage({
+    scope: 'shutdown'
+  });
+}
+
+function createHandlers() {
+  return Object.assign(Object.create(null), {
+    worker: new Set(),
+    stories: new Set(),
+    test: new Set(),
+    webpack: new Set(),
+    docker: new Set(),
+    shutdown: new Set()
+  });
+}
+
+const handlers = createHandlers();
+
+const handler = message => {
+  switch (message.scope) {
+    case 'worker':
+      return handlers.worker.forEach(h => h(message));
+
+    case 'stories':
+      return handlers.stories.forEach(h => h(message));
+
+    case 'test':
+      return handlers.test.forEach(h => h(message));
+
+    case 'webpack':
+      return handlers.webpack.forEach(h => h(message));
+
+    case 'docker':
+      return handlers.docker.forEach(h => h(message));
+
+    case 'shutdown':
+      return handlers.shutdown.forEach(h => h(message));
+  }
+};
+
+process.on('message', handler);
+
+function sendStoriesMessage(target, message) {
+  var _target$send;
+
+  (_target$send = target.send) === null || _target$send === void 0 ? void 0 : _target$send.call(target, {
+    scope: 'stories',
+    ...message
+  });
+}
+
+function sendTestMessage(target, message) {
+  var _target$send2;
+
+  (_target$send2 = target.send) === null || _target$send2 === void 0 ? void 0 : _target$send2.call(target, {
+    scope: 'test',
+    ...message
+  });
+}
+
+function sendDockerMessage(target, message) {
+  var _target$send3;
+
+  (_target$send3 = target.send) === null || _target$send3 === void 0 ? void 0 : _target$send3.call(target, {
+    scope: 'docker',
+    ...message
+  });
+}
+
+function sendShutdownMessage(target) {
+  var _target$send4;
+
+  (_target$send4 = target.send) === null || _target$send4 === void 0 ? void 0 : _target$send4.call(target, {
+    scope: 'shutdown'
+  });
+}
+
+function subscribeOn(scope, handler) {
+  switch (scope) {
+    case 'worker':
+      {
+        const workerHandler = handler;
+        handlers.worker.add(workerHandler);
+        return () => handlers.worker.delete(workerHandler);
+      }
+
+    case 'stories':
+      {
+        const storiesHandler = handler;
+        handlers.stories.add(storiesHandler);
+        return () => handlers.stories.delete(storiesHandler);
+      }
+
+    case 'test':
+      {
+        const testHandler = handler;
+        handlers.test.add(testHandler);
+        return () => handlers.test.delete(testHandler);
+      }
+
+    case 'webpack':
+      {
+        const webpackHandler = handler;
+        handlers.webpack.add(webpackHandler);
+        return () => handlers.webpack.delete(webpackHandler);
+      }
+
+    case 'docker':
+      {
+        const dockerHandler = handler;
+        handlers.docker.add(dockerHandler);
+        return () => handlers.docker.delete(dockerHandler);
+      }
+
+    case 'shutdown':
+      {
+        const shutdownHandler = handler;
+        handlers.shutdown.add(shutdownHandler);
+        return () => handlers.shutdown.delete(shutdownHandler);
+      }
+  }
+}
+
+const workers = new Map();
+
+function subscribeOnWorker(worker, scope, handler) {
+  const workerHandlers = workers.get(worker) ?? createHandlers();
+
+  if (!workers.has(worker)) {
+    workers.set(worker, workerHandlers);
+    worker.once('exit', () => workers.delete(worker));
+    worker.on('message', message => {
+      switch (message.scope) {
+        case 'worker':
+          return workerHandlers.worker.forEach(h => h(message));
+
+        case 'stories':
+          return workerHandlers.stories.forEach(h => h(message));
+
+        case 'test':
+          return workerHandlers.test.forEach(h => h(message));
+
+        case 'webpack':
+          return workerHandlers.webpack.forEach(h => h(message));
+
+        case 'docker':
+          return workerHandlers.docker.forEach(h => h(message));
+
+        case 'shutdown':
+          return workerHandlers.shutdown.forEach(h => h(message));
+      }
+    });
+  }
+
+  switch (scope) {
+    case 'worker':
+      {
+        const workerHandler = handler;
+        workerHandlers.worker.add(workerHandler);
+        return () => workerHandlers.worker.delete(workerHandler);
+      }
+
+    case 'stories':
+      {
+        const storiesHandler = handler;
+        workerHandlers.stories.add(storiesHandler);
+        return () => workerHandlers.stories.delete(storiesHandler);
+      }
+
+    case 'test':
+      {
+        const testHandler = handler;
+        workerHandlers.test.add(testHandler);
+        return () => workerHandlers.test.delete(testHandler);
+      }
+
+    case 'webpack':
+      {
+        const webpackHandler = handler;
+        workerHandlers.webpack.add(webpackHandler);
+        return () => workerHandlers.webpack.delete(webpackHandler);
+      }
+
+    case 'docker':
+      {
+        const dockerHandler = handler;
+        workerHandlers.docker.add(dockerHandler);
+        return () => workerHandlers.docker.delete(dockerHandler);
+      }
+
+    case 'shutdown':
+      {
+        const shutdownHandler = handler;
+        workerHandlers.shutdown.add(shutdownHandler);
+        return () => workerHandlers.shutdown.delete(shutdownHandler);
+      }
+  }
+}