creevey 0.9.0-beta.20 → 0.9.0-beta.22

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

@@ -1,246 +0,0 @@
-import path from 'path';
-import { copyFile, mkdir } from 'fs';
-import { promisify } from 'util';
-import { EventEmitter } from 'events';
-import { isDefined } from '../../types';
-import Pool from './pool';
-const copyFileAsync = promisify(copyFile);
-const mkdirAsync = promisify(mkdir);
-export default class Runner extends 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(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(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(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(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(isDefined);
-    const testPath = path.join(...restPath, image == browser ? '' : browser);
-    const srcImagePath = path.join(this.reportDir, testPath, images.actual);
-    const dstImagePath = path.join(this.screenDir, testPath, `${image}.png`);
-    await mkdirAsync(path.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);
-  }
-}

package/lib/esm/server/master/server.js

@@ -1,103 +0,0 @@
-import path from 'path';
-import http from 'http';
-import cluster from 'cluster';
-import Koa from 'koa';
-import cors from '@koa/cors';
-import serve from 'koa-static';
-import mount from 'koa-mount';
-import body from 'koa-bodyparser';
-import WebSocket from 'ws';
-import { emitStoriesMessage, sendStoriesMessage, subscribeOn, subscribeOnWorker } from '../messages';
-import { isDefined, noop } from '../../types';
-import { logger } from '../logger';
-import { deserializeStory } from '../../shared';
-export default function server(reportDir, port, ui) {
-  let resolveApi = noop;
-  let setStoriesCounter = 0;
-  const creeveyApi = new Promise(resolve => resolveApi = resolve);
-  const app = new Koa();
-  const server = http.createServer(app.callback());
-  const wss = new WebSocket.Server({
-    server
-  });
-  app.use(cors());
-  app.use(body());
-  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(deserializeStory)]);
-      setStoriesCounter = counter;
-      emitStoriesMessage({
-        type: 'update',
-        payload: deserializedStories
-      });
-      Object.values(cluster.workers ?? {}).filter(isDefined).filter(worker => worker.isConnected()).forEach(worker => 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.workers ?? {}).filter(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 = subscribeOnWorker(worker, 'stories', message => {
-          if (message.type != 'capture') return;
-          unsubscribe();
-          resolve();
-        });
-        sendStoriesMessage(worker, {
-          type: 'capture',
-          payload: options
-        });
-      });
-      // TODO Pass screenshot result to show it in inspector
-      ctx.body = 'Ok';
-      return;
-    }
-    await next();
-  });
-  app.use(serve(path.join(__dirname, '../../client/web')));
-  app.use(mount('/report', serve(reportDir)));
-  wss.on('error', error => logger.error(error));
-  server.listen(port);
-  subscribeOn('shutdown', () => {
-    server.close();
-    wss.close();
-    wss.clients.forEach(ws => ws.close());
-  });
-  void creeveyApi.then(api => {
-    api.subscribe(wss);
-    wss.on('connection', ws => {
-      ws.on('message', (message, isBinary) => {
-        api.handleMessage(ws, isBinary ? message : message.toString());
-      });
-    });
-  });
-  return resolveApi;
-}

package/lib/esm/server/messages.js

@@ -1,200 +0,0 @@
-import cluster from 'cluster';
-function emitMessage(message) {
-  var _process$send, _process;
-  if (cluster.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);
-}
-export function emitWorkerMessage(message) {
-  return emitMessage({
-    scope: 'worker',
-    ...message
-  });
-}
-export function emitStoriesMessage(message) {
-  return emitMessage({
-    scope: 'stories',
-    ...message
-  });
-}
-export function emitTestMessage(message) {
-  return emitMessage({
-    scope: 'test',
-    ...message
-  });
-}
-export function emitWebpackMessage(message) {
-  return emitMessage({
-    scope: 'webpack',
-    ...message
-  });
-}
-export function emitDockerMessage(message) {
-  return emitMessage({
-    scope: 'docker',
-    ...message
-  });
-}
-export 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);
-export function sendStoriesMessage(target, message) {
-  var _target$send;
-  (_target$send = target.send) === null || _target$send === void 0 || _target$send.call(target, {
-    scope: 'stories',
-    ...message
-  });
-}
-export function sendTestMessage(target, message) {
-  var _target$send2;
-  (_target$send2 = target.send) === null || _target$send2 === void 0 || _target$send2.call(target, {
-    scope: 'test',
-    ...message
-  });
-}
-export function sendDockerMessage(target, message) {
-  var _target$send3;
-  (_target$send3 = target.send) === null || _target$send3 === void 0 || _target$send3.call(target, {
-    scope: 'docker',
-    ...message
-  });
-}
-export function sendShutdownMessage(target) {
-  var _target$send4;
-  (_target$send4 = target.send) === null || _target$send4 === void 0 || _target$send4.call(target, {
-    scope: 'shutdown'
-  });
-}
-export 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();
-export 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);
-      }
-  }
-}