creevey 0.10.0-beta.43 → 0.10.0-beta.45

package/src/server/master/master.ts

@@ -1,44 +1,27 @@
-import path from 'path';
-import { Config, TestData, isDefined, ServerTest } from '../../types.js';
-import { loadTestsFromStories, saveTestsJson } from '../stories.js';
+import { Config } from '../../types.js';
+import { loadTestsFromStories } from '../stories.js';
 import Runner from './runner.js';
-import { tryToLoadTestsData } from '../utils.js';
-
-function mergeTests(
-  testsWithReports: Partial<Record<string, TestData>>,
-  testsFromStories: Partial<Record<string, ServerTest>>,
-): Partial<Record<string, ServerTest>> {
-  Object.values(testsFromStories)
-    .filter(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;
-}
+import { TestsManager } from './testsManager.js';
 
 export default async function master(config: Config, gridUrl?: string): Promise<Runner> {
-  const runner = new Runner(config, gridUrl);
-  const reportDataPath = path.join(config.reportDir, 'data.js');
-  const testsFromReport = tryToLoadTestsData(reportDataPath) ?? {};
+  // Create TestsManager instance
+  const testsManager = new TestsManager(config.screenDir, config.reportDir);
+
+  // Create Runner with TestsManager
+  const runner = new Runner(config, testsManager, gridUrl);
 
   await runner.init();
 
+  // Load tests from stories and update TestsManager
   const tests = await loadTestsFromStories(
     Object.keys(config.browsers),
     (listener) => config.storiesProvider(config, listener),
     (testsDiff) => {
       runner.updateTests(testsDiff);
-      saveTestsJson(runner.tests, config.reportDir);
     },
   );
 
-  runner.tests = mergeTests(testsFromReport, tests);
-  saveTestsJson(runner.tests, config.reportDir);
+  testsManager.updateTests(testsManager.loadAndMergeTests(tests));
 
   return runner;
 }

package/src/server/master/runner.ts

@@ -1,5 +1,3 @@
-import path from 'path';
-import { copyFile, mkdir } from 'fs/promises';
 import { EventEmitter } from 'events';
 import {
   Config,
@@ -10,7 +8,6 @@ import {
   CreeveyUpdate,
   TestStatus,
   ServerTest,
-  TestMeta,
   TEST_EVENTS,
   FakeSuite,
   FakeTest,
@@ -19,6 +16,7 @@ import Pool from './pool.js';
 import { WorkerQueue } from './queue.js';
 import { getTestPath } from '../utils.js';
 import { getReporter } from '../reporters/index.js';
+import { TestsManager } from './testsManager.js';
 
 // NOTE: This is workaround to fix parallel tests running with mocha-junit-reporter
 let isJUnit = false;
@@ -33,24 +31,23 @@ class FakeRunner extends EventEmitter {
 
 export default class Runner extends EventEmitter {
   private failFast: boolean;
-  private screenDir: string;
-  private reportDir: string;
   private browsers: string[];
   private scheduler: WorkerQueue;
   private pools: Record<string, Pool> = {};
   private fakeRunner: FakeRunner;
   private config: Config;
-  tests: Partial<Record<string, ServerTest>> = {};
+  public testsManager: TestsManager;
+
   public get isRunning(): boolean {
     return Object.values(this.pools).some((pool) => pool.isRunning);
   }
-  constructor(config: Config, gridUrl?: string) {
+
+  constructor(config: Config, testsManager: TestsManager, gridUrl?: string) {
     super();
 
     this.config = config;
     this.failFast = config.failFast;
-    this.screenDir = config.screenDir;
-    this.reportDir = config.reportDir;
+    this.testsManager = testsManager;
     this.scheduler = new WorkerQueue(config.useWorkerQueue);
     this.browsers = Object.keys(config.browsers);
 
@@ -61,7 +58,7 @@ export default class Runner extends EventEmitter {
       isJUnit = true;
     }
 
-    new Reporter(runner, { reportDir: this.reportDir, reporterOptions: config.reporterOptions });
+    new Reporter(runner, { reportDir: config.reportDir, reporterOptions: config.reporterOptions });
     this.fakeRunner = runner;
 
     this.browsers
@@ -71,10 +68,10 @@ export default class Runner extends EventEmitter {
 
   private handlePoolMessage = (message: { id: string; status: TestStatus; result?: TestResult }): void => {
     const { id, status, result } = message;
-    const test = this.tests[id];
+    const test = this.testsManager.getTest(id);
 
     if (!test) return;
-    const { browser, testName, storyPath, storyId } = test;
+    const { browser, testName } = test;
 
     const fakeSuite: FakeSuite = {
       title: test.storyPath.slice(0, -1).join('/'),
@@ -103,20 +100,14 @@ export default class Runner extends EventEmitter {
 
     fakeSuite.tests.push(fakeTest);
 
-    // TODO Handle 'retrying' status
-    test.status = status == 'retrying' ? 'failed' : status;
+    const update = this.testsManager.updateTestStatus(id, status, result);
+    if (!update) return;
+
     if (!result) {
-      // NOTE: Running status
       this.fakeRunner.emit(TEST_EVENTS.TEST_BEGIN, fakeTest);
-      this.sendUpdate({ tests: { [id]: { id, browser, testName, storyPath, status: test.status, storyId } } });
+      this.sendUpdate(update);
       return;
     }
-    test.results ??= [];
-    test.results.push(result);
-
-    if (status == 'failed') {
-      test.approved = null;
-    }
 
     const { duration, attachments } = result;
 
@@ -146,20 +137,7 @@ export default class Runner extends EventEmitter {
 
     this.fakeRunner.emit(TEST_EVENTS.TEST_END, fakeTest);
 
-    this.sendUpdate({
-      tests: {
-        [id]: {
-          id,
-          browser,
-          testName,
-          storyPath,
-          status: test.status,
-          approved: test.approved,
-          results: [result],
-          storyId,
-        },
-      },
-    });
+    this.sendUpdate(update);
 
     if (this.failFast && status == 'failed') this.stop();
   };
@@ -177,31 +155,8 @@ export default class Runner extends EventEmitter {
   }
 
   public updateTests(testsDiff: Partial<Record<string, ServerTest>>): void {
-    const tests: CreeveyStatus['tests'] = {};
-    const removedTests: TestMeta[] = [];
-    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;
-
-        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 });
-        // TODO Use Map instead
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete this.tests[id];
-      }
-    });
-    this.sendUpdate({ tests, removedTests });
+    const update = this.testsManager.updateTests(testsDiff);
+    if (update) this.sendUpdate(update);
   }
 
   public start(ids: string[]): void {
@@ -209,27 +164,32 @@ export default class Runner extends EventEmitter {
     if (this.isRunning) return;
 
     const testsToStart = ids
-      .map((id) => this.tests[id])
+      .map((id) => this.testsManager.getTest(id))
       .filter(isDefined)
       .filter((test) => !test.skip);
 
     if (testsToStart.length == 0) return;
 
+    const pendingTests: CreeveyUpdate['tests'] = testsToStart.reduce(
+      (update: CreeveyUpdate['tests'], { id, storyId, browser, testName, storyPath }) => ({
+        ...update,
+        [id]: { id, browser, testName, storyPath, status: 'pending', storyId },
+      }),
+      {},
+    );
+
     this.sendUpdate({
       isRunning: true,
-      tests: testsToStart.reduce(
-        (update: CreeveyUpdate['tests'], { id, storyId, browser, testName, storyPath }) => ({
-          ...update,
-          [id]: { id, browser, testName, storyPath, status: 'pending', storyId },
-        }),
-        {},
-      ),
+      tests: pendingTests,
     });
 
     const testsByBrowser: Partial<TestsByBrowser> = testsToStart.reduce((tests: Partial<TestsByBrowser>, test) => {
       const { id, browser, testName, storyPath } = test;
       const restPath = [...storyPath, testName].filter(isDefined);
-      test.status = 'pending';
+
+      // Update status to pending in TestsManager
+      this.testsManager.updateTestStatus(id, 'pending');
+
       return {
         ...tests,
         [browser]: [...(tests[browser] ?? []), { id, path: restPath }],
@@ -255,78 +215,24 @@ export default class Runner extends EventEmitter {
   }
 
   public get status(): CreeveyStatus {
-    const tests: CreeveyStatus['tests'] = {};
-    Object.values(this.tests)
-      .filter(isDefined)
-
-      .forEach(({ story: _, fn: __, ...test }) => (tests[test.id] = test));
     return {
       isRunning: this.isRunning,
-      tests,
+      tests: this.testsManager.getTestsData(),
       browsers: this.browsers,
+      isUpdateMode: false,
     };
   }
 
-  private async copyImage(test: ServerTest, image: string, actual: string): Promise<void> {
-    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, actual);
-    const dstImagePath = path.join(this.screenDir, testPath, `${image}.png`);
-    await mkdir(path.join(this.screenDir, testPath), { recursive: true });
-    await copyFile(srcImagePath, dstImagePath);
-  }
-
   public async approveAll(): Promise<void> {
-    const updatedTests: NonNullable<CreeveyUpdate['tests']> = {};
-    for (const test of Object.values(this.tests)) {
-      if (!test?.results) continue;
-      const retry = test.results.length - 1;
-      const { images, status } = test.results.at(retry) ?? {};
-      if (!images || status != 'failed') continue;
-      for (const [name, image] of Object.entries(images)) {
-        if (!image) continue;
-        await this.copyImage(test, name, image.actual);
-
-        test.approved ??= {};
-        test.approved[name] = retry;
-        test.status = 'approved';
-
-        updatedTests[test.id] = {
-          id: test.id,
-          browser: test.browser,
-          storyPath: test.storyPath,
-          storyId: test.storyId,
-          status: test.status,
-          approved: { [name]: retry },
-        };
-      }
-    }
-    this.sendUpdate({ tests: updatedTests });
+    const update = await this.testsManager.approveAll();
+    this.sendUpdate(update);
   }
 
-  public async approve({ id, retry, image }: ApprovePayload): Promise<void> {
-    const test = this.tests[id];
-    if (!test?.results) return;
-    const result = test.results[retry];
-    if (!result.images) return;
-    const images = result.images[image];
-    if (!images) return;
-    test.approved ??= {};
-    const { browser, testName, storyPath, storyId } = test;
-
-    await this.copyImage(test, image, images.actual);
-
-    test.approved[image] = retry;
-
-    if (Object.keys(result.images).every((name) => typeof test.approved?.[name] == 'number')) {
-      test.status = 'approved';
-    }
-
-    this.sendUpdate({
-      tests: { [id]: { id, browser, testName, storyPath, status: test.status, approved: { [image]: retry }, storyId } },
-    });
+  public async approve(payload: ApprovePayload): Promise<void> {
+    const update = await this.testsManager.approve(payload);
+    if (update) this.sendUpdate(update);
   }
+
   private sendUpdate(data: CreeveyUpdate): void {
     this.emit('update', data);
   }

package/src/server/master/server.ts

@@ -1,125 +1,237 @@
+import fs from 'fs';
+import url from 'url';
 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 { IncomingMessage, ServerResponse, createServer } from 'http';
+import { WebSocketServer, WebSocket, RawData } from 'ws';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { CreeveyApi } from './api.js';
-import { emitStoriesMessage, sendStoriesMessage, subscribeOn, subscribeOnWorker } from '../messages.js';
-import { CaptureOptions, isDefined, noop, StoryInput } from '../../types.js';
+import { shutdownOnException } from '../utils.js';
+import { subscribeOn } from '../messages.js';
+import { noop } from '../../types.js';
 import { logger } from '../logger.js';
-import { deserializeStory } from '../../shared/index.js';
+import { CreeveyApi } from './api.js';
+import { pingHandler, captureHandler, storiesHandler, staticHandler } from './handlers/index.js';
+
+function json<T = unknown>(
+  handler: (data: T) => void,
+  defaultValue: T,
+): (request: IncomingMessage, response: ServerResponse) => void {
+  return (request: IncomingMessage, response: ServerResponse) => {
+    const chunks: Buffer[] = [];
+
+    request.on('data', (chunk: Buffer) => {
+      chunks.push(chunk);
+    });
+
+    request.on('end', () => {
+      try {
+        const body = Buffer.concat(chunks);
+        const value = body.length === 0 ? defaultValue : (JSON.parse(body.toString('utf-8')) as T);
+
+        handler(value);
+        response.end();
+      } catch (error) {
+        logger().error('Failed to parse JSON', error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        response.statusCode = 500;
+        response.setHeader('Content-Type', 'text/plain');
+        response.end(`Failed to parse JSON: ${errorMessage}`);
+      }
+    });
+
+    request.on('error', (error) => {
+      logger().error('Failed to parse JSON', error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      response.statusCode = 500;
+      response.setHeader('Content-Type', 'text/plain');
+      response.end(`Failed to parse JSON: ${errorMessage}`);
+    });
+  };
+}
+
+function file(handler: (requestedPath: string) => string | undefined) {
+  return (request: IncomingMessage, response: ServerResponse) => {
+    const parsedUrl = url.parse(request.url ?? '/', true);
+    const requestedPath = parsedUrl.pathname ?? '/';
+
+    try {
+      const filePath = handler(requestedPath);
+      if (filePath) {
+        const stat = fs.statSync(filePath);
+        // Set appropriate MIME type
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeTypes: Record<string, string> = {
+          '.html': 'text/html',
+          '.js': 'application/javascript',
+          '.css': 'text/css',
+          '.json': 'application/json',
+          '.png': 'image/png',
+          '.jpg': 'image/jpeg',
+          '.jpeg': 'image/jpeg',
+          '.gif': 'image/gif',
+          '.svg': 'image/svg+xml',
+          '.ico': 'image/x-icon',
+        };
+
+        const contentType = mimeTypes[ext] || 'application/octet-stream';
+
+        response.statusCode = 200;
+        response.setHeader('Content-Type', contentType);
+        response.setHeader('Content-Length', stat.size);
+
+        // Stream the file
+        const stream = fs.createReadStream(filePath);
+        stream.pipe(response);
+
+        stream.on('error', (error) => {
+          logger().error('Error streaming file', error);
+          if (!response.headersSent) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.statusCode = 500;
+            response.setHeader('Content-Type', 'text/plain');
+            response.end(`Internal server error: ${errorMessage}`);
+          }
+        });
+      } else {
+        logger().error('File not found', requestedPath);
+        response.statusCode = 404;
+        response.setHeader('Content-Type', 'text/plain');
+        response.end('File not found');
+      }
+    } catch (error) {
+      logger().error('Failed to serve file', error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      response.statusCode = 500;
+      response.setHeader('Content-Type', 'text/plain');
+      response.end(`Failed to serve file: ${errorMessage}`);
+    }
+  };
+}
 
 const importMetaUrl = pathToFileURL(__filename).href;
 
 export function start(reportDir: string, port: number, ui: boolean): (api: CreeveyApi) => void {
+  let wss: WebSocketServer | null = null;
+  let creeveyApi: CreeveyApi | null = null;
   let resolveApi: (api: CreeveyApi) => void = noop;
-  let setStoriesCounter = 0;
-  const creeveyApi = new Promise<CreeveyApi>((resolve) => (resolveApi = resolve));
-  const app = new Koa();
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  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;
+
+  const webDir = path.join(path.dirname(fileURLToPath(importMetaUrl)), '../../client/web');
+  const server = createServer();
+
+  const routes = [
+    {
+      path: '/ping',
+      method: 'GET',
+      handler: pingHandler,
+    },
+    {
+      path: '/stories',
+      method: 'POST',
+      handler: json(storiesHandler, { stories: [] }),
+    },
+    {
+      path: '/capture',
+      method: 'POST',
+      handler: json(captureHandler, { workerId: 0, options: undefined }),
+    },
+    {
+      path: '/report/',
+      method: 'GET',
+      handler: file(staticHandler(reportDir, '/report/')),
+    },
+    {
+      path: '/',
+      method: 'GET',
+      handler: file(staticHandler(webDir)),
+    },
+  ];
+
+  const router = (request: IncomingMessage, response: ServerResponse): void => {
+    const parsedUrl = url.parse(request.url ?? '/', true);
+    const path = parsedUrl.pathname ?? '/';
+    const method = request.method ?? 'GET';
+
+    try {
+      const route = routes.find((route) => path.startsWith(route.path) && route.method === method);
+      if (route) {
+        route.handler(request, response);
+      } else {
+        response.statusCode = 404;
+        response.setHeader('Content-Type', 'text/plain');
+        response.end('Not Found');
+      }
+    } catch (error) {
+      logger().error('Request handling error', error);
+      response.statusCode = 500;
+      response.setHeader('Content-Type', 'text/plain');
+      response.end('Internal Server Error');
     }
-    await next();
-  });
+  };
 
-  if (ui) {
-    app.use(async (_, next) => {
-      await creeveyApi;
-      await next();
-    });
-  }
+  server.on('request', (request: IncomingMessage, response: ServerResponse): void => {
+    response.setHeader('Access-Control-Allow-Origin', '*');
+    response.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    response.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
 
-  app.use(async (ctx, next) => {
-    if (ctx.method == 'POST' && ctx.path == '/stories') {
-      const { setStoriesCounter: counter, stories } = ctx.request.body as {
-        setStoriesCounter: number;
-        stories: [string, StoryInput[]][];
-      };
-      if (setStoriesCounter >= counter) return;
-
-      const deserializedStories = stories.map<[string, StoryInput[]]>(([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 });
-        });
+    if (request.method === 'OPTIONS') {
+      response.statusCode = 200;
+      response.end();
       return;
     }
-    await next();
-  });
 
-  app.use(async (ctx, next) => {
-    if (ctx.method == 'POST' && ctx.path == '/capture') {
-      const { workerId, options } = ctx.request.body as { workerId: number; options?: CaptureOptions };
-      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<void>((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();
+    router(request, response);
   });
 
-  app.use(serve(path.join(path.dirname(fileURLToPath(importMetaUrl)), '../../client/web')));
-  app.use(mount('/report', serve(reportDir)));
+  if (ui) {
+    wss = new WebSocketServer({ server });
+    wss.on('connection', (ws: WebSocket) => {
+      ws.on('message', (message: RawData, isBinary: boolean) => {
+        if (creeveyApi) {
+          // NOTE Text messages are passed as Buffer https://github.com/websockets/ws/releases/tag/8.0.0
+          // eslint-disable-next-line @typescript-eslint/no-base-to-string
+          creeveyApi.handleMessage(ws, isBinary ? message : message.toString('utf-8'));
+          return;
+        }
+      });
 
-  wss.on('error', (error) => {
-    logger().error(error);
-  });
+      ws.on('error', (error) => {
+        logger().error('WebSocket error', error);
+      });
+    });
 
-  server.listen(port);
+    wss.on('error', (error) => {
+      logger().error('WebSocket error', error);
+    });
+  }
 
   subscribeOn('shutdown', () => {
+    if (wss) {
+      wss.clients.forEach((ws) => {
+        ws.close();
+      });
+      wss.close();
+    }
+
     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: WebSocket.RawData, isBinary: boolean) => {
-        // NOTE Text messages are passed as Buffer https://github.com/websockets/ws/releases/tag/8.0.0
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        api.handleMessage(ws, isBinary ? message : message.toString('utf-8'));
-      });
+  server
+    .listen(port, () => {
+      logger().info(`Server starting on port ${port}`);
+    })
+    .on('error', (error: unknown) => {
+      logger().error('Failed to start server', error);
+      process.exit(1);
     });
-  });
 
+  void new Promise<CreeveyApi>((resolve) => (resolveApi = resolve))
+    .then((api) => {
+      creeveyApi = api;
+      if (wss) {
+        creeveyApi.subscribe(wss);
+      }
+    })
+    .catch(shutdownOnException);
+
+  // Return the function to resolve the API
   return resolveApi;
 }