creevey 0.8.0-beta.0 → 0.8.0-beta.1

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

@@ -1,5 +1,3 @@
-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; }
-
 import path from 'path';
 import { copyFile, mkdir } from 'fs';
 import { promisify } from 'util';
@@ -9,63 +7,40 @@ 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));
+  }
 
-    _defineProperty(this, "failFast", void 0);
-
-    _defineProperty(this, "screenDir", void 0);
-
-    _defineProperty(this, "reportDir", void 0);
-
-    _defineProperty(this, "browsers", void 0);
-
-    _defineProperty(this, "pools", {});
-
-    _defineProperty(this, "tests", {});
-
-    _defineProperty(this, "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;
-      }
+  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
 
-      if (!test.results) {
-        test.results = [];
-      }
+    test.status = status == 'retrying' ? 'failed' : status;
 
-      test.results.push(result);
+    if (!result) {
       this.sendUpdate({
         tests: {
           [id]: {
@@ -74,29 +49,41 @@ export default class Runner extends EventEmitter {
             testName,
             storyPath,
             status: test.status,
-            results: [result],
             storyId
           }
         }
       });
-      if (this.failFast && status == 'failed') this.stop();
-    });
+      return;
+    }
 
-    _defineProperty(this, "handlePoolStop", () => {
-      if (!this.isRunning) {
-        this.sendUpdate({
-          isRunning: false
-        });
-        this.emit('stop');
+    if (!test.results) {
+      test.results = [];
+    }
+
+    test.results.push(result);
+    this.sendUpdate({
+      tests: {
+        [id]: {
+          id,
+          browser,
+          testName,
+          storyPath,
+          status: test.status,
+          results: [result],
+          storyId
+        }
       }
     });
-
-    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));
-  }
+    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()));

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

@@ -1,22 +1,90 @@
 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 { subscribeOn } from '../messages';
-import { noop } from '../../types';
+import { emitStoriesMessage, sendStoriesMessage, subscribeOn, subscribeOnWorker } from '../messages';
+import { isDefined, noop } from '../../types';
 import { logger } from '../logger';
-export default function server(reportDir, port) {
+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(async (_, next) => {
-    await creeveyApi;
+  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')));
@@ -30,7 +98,9 @@ export default function server(reportDir, port) {
   void creeveyApi.then(api => {
     api.subscribe(wss);
     wss.on('connection', ws => {
-      ws.on('message', message => api.handleMessage(ws, message));
+      ws.on('message', (message, isBinary) => {
+        api.handleMessage(ws, isBinary ? message : message.toString());
+      });
     });
   });
   return resolveApi;

package/lib/esm/server/messages.js

@@ -1,10 +1,10 @@
 import cluster from 'cluster';
 
 function emitMessage(message) {
-  var _process$send, _process$send2, _process;
+  var _process$send, _process;
 
   if (cluster.isWorker && !process.connected) return false;
-  return (_process$send = (_process$send2 = (_process = process).send) === null || _process$send2 === void 0 ? void 0 : _process$send2.call(_process, message)) !== null && _process$send !== void 0 ? _process$send : // @ts-expect-error: wrong typings `process.emit` return boolean
+  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);
 }
 
@@ -14,6 +14,12 @@ export function emitWorkerMessage(message) {
     ...message
   });
 }
+export function emitStoriesMessage(message) {
+  return emitMessage({
+    scope: 'stories',
+    ...message
+  });
+}
 export function emitTestMessage(message) {
   return emitMessage({
     scope: 'test',
@@ -37,19 +43,28 @@ export function emitShutdownMessage() {
     scope: 'shutdown'
   });
 }
-const handlers = Object.assign(Object.create(null), {
-  worker: new Set(),
-  test: new Set(),
-  webpack: new Set(),
-  docker: new Set(),
-  shutdown: new Set()
-});
+
+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));
 
@@ -65,26 +80,34 @@ const handler = message => {
 };
 
 process.on('message', handler);
-export function sendTestMessage(target, message) {
+export function sendStoriesMessage(target, message) {
   var _target$send;
 
   (_target$send = target.send) === null || _target$send === void 0 ? void 0 : _target$send.call(target, {
-    scope: 'test',
+    scope: 'stories',
     ...message
   });
 }
-export function sendDockerMessage(target, message) {
+export function sendTestMessage(target, message) {
   var _target$send2;
 
   (_target$send2 = target.send) === null || _target$send2 === void 0 ? void 0 : _target$send2.call(target, {
-    scope: 'docker',
+    scope: 'test',
     ...message
   });
 }
-export function sendShutdownMessage(target) {
+export 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
+  });
+}
+export function sendShutdownMessage(target) {
+  var _target$send4;
+
+  (_target$send4 = target.send) === null || _target$send4 === void 0 ? void 0 : _target$send4.call(target, {
     scope: 'shutdown'
   });
 }
@@ -97,6 +120,13 @@ export function subscribeOn(scope, handler) {
         return () => handlers.worker.delete(workerHandler);
       }
 
+    case 'stories':
+      {
+        const storiesHandler = handler;
+        handlers.stories.add(storiesHandler);
+        return () => handlers.stories.delete(storiesHandler);
+      }
+
     case 'test':
       {
         const testHandler = handler;
@@ -125,4 +155,78 @@ export function subscribeOn(scope, handler) {
         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);
+      }
+  }
 }