@elastic/synthetics 1.0.0-beta.3 → 1.0.0-beta.30

package/src/reporters/base.ts

@@ -25,7 +25,6 @@
 
 import SonicBoom from 'sonic-boom';
 import { green, red, cyan } from 'kleur/colors';
-import Runner from '../core/runner';
 import {
   symbols,
   indent,
@@ -33,7 +32,13 @@ import {
   findPWLogsIndexes,
   rewriteErrorStack,
 } from '../helpers';
-import { ReporterOptions } from './reporter';
+import { Reporter, ReporterOptions } from '.';
+import {
+  JourneyEndResult,
+  JourneyStartResult,
+  StepEndResult,
+} from '../common_types';
+import { Journey, Step } from '../dsl';
 
 function renderError(error) {
   let output = '';
@@ -58,68 +63,74 @@ function renderDuration(durationMs) {
   return parseInt(durationMs);
 }
 
-export default class BaseReporter {
+export default class BaseReporter implements Reporter {
   stream: SonicBoom;
   fd: number;
+  metrics = {
+    succeeded: 0,
+    failed: 0,
+    skipped: 0,
+  };
 
-  constructor(public runner: Runner, options: ReporterOptions = {}) {
+  constructor(options: ReporterOptions = {}) {
     this.fd = options.fd || process.stdout.fd;
-    this.stream = new SonicBoom({ fd: this.fd, sync: true });
-    this._registerListeners();
-    this.runner.on('end', () => this.stream.flush());
+    /**
+     * minLength is set to 1 byte to make sure we flush the
+     * content even if its the last byte on the stream buffer
+     * before destroying the pipe with underlying file descriptor
+     */
+    this.stream = new SonicBoom({ fd: this.fd, sync: true, minLength: 1 });
   }
 
-  _registerListeners() {
-    const result = {
-      succeeded: 0,
-      failed: 0,
-      skipped: 0,
-    };
-
-    this.runner.on('journey:start', ({ journey }) => {
-      this.write(`\nJourney: ${journey.name}`);
-    });
-
-    this.runner.on('step:end', ({ step, start, end, error, status }) => {
-      const message = `${symbols[status]}  Step: '${
-        step.name
-      }' ${status} (${renderDuration((end - start) * 1000)} ms)`;
-      this.write(indent(message));
-      error && this.write(renderError(error));
-      result[status]++;
-    });
-
-    this.runner.on('journey:end', ({ error }) => {
-      const { failed, succeeded, skipped } = result;
-      const total = failed + succeeded + skipped;
+  onJourneyStart(journey: Journey, {}: JourneyStartResult) {
+    this.write(`\nJourney: ${journey.name}`);
+  }
 
-      /**
-       * Render the error on the terminal only when no steps could
-       * be executed which means the error happened in one of the hooks
-       */
-      if (total === 0 && error) {
-        this.write(renderError(error));
-      }
-    });
+  onStepEnd(journey: Journey, step: Step, result: StepEndResult) {
+    const { status, end, start, error } = result;
+    const message = `${symbols[status]}  Step: '${
+      step.name
+    }' ${status} (${renderDuration((end - start) * 1000)} ms)`;
+    this.write(indent(message));
+    error && this.write(renderError(error));
+    this.metrics[status]++;
+  }
 
-    this.runner.on('end', () => {
-      const { failed, succeeded, skipped } = result;
-      const total = failed + succeeded + skipped;
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  onJourneyEnd(journey: Journey, { error }: JourneyEndResult) {
+    const { failed, succeeded, skipped } = this.metrics;
+    const total = failed + succeeded + skipped;
+    /**
+     * Render the error on the terminal only when no steps could
+     * be executed which means the error happened in one of the hooks
+     */
+    if (total === 0 && error) {
+      this.write(renderError(error));
+    }
+  }
 
-      let message = '\n';
-      if (total === 0) {
-        message = 'No tests found!';
-        message += ` (${renderDuration(now())} ms) \n`;
-        this.write(message);
-        return;
-      }
+  onEnd() {
+    const { failed, succeeded, skipped } = this.metrics;
+    const total = failed + succeeded + skipped;
 
-      message += succeeded > 0 ? green(` ${succeeded} passed`) : '';
-      message += failed > 0 ? red(` ${failed} failed`) : '';
-      message += skipped > 0 ? cyan(` ${skipped} skipped`) : '';
+    let message = '\n';
+    if (total === 0) {
+      message = 'No tests found!';
       message += ` (${renderDuration(now())} ms) \n`;
       this.write(message);
-    });
+      return;
+    }
+
+    message += succeeded > 0 ? green(` ${succeeded} passed`) : '';
+    message += failed > 0 ? red(` ${failed} failed`) : '';
+    message += skipped > 0 ? cyan(` ${skipped} skipped`) : '';
+    message += ` (${renderDuration(now())} ms) \n`;
+    this.write(message);
+
+    // flushSync is used here to make sure all the data from the underlying
+    // SonicBoom stream buffer is completely written to the fd before closing
+    // the process
+    this.stream.flushSync();
   }
 
   write(message) {

package/src/reporters/index.ts

@@ -26,11 +26,34 @@
 import BaseReporter from './base';
 import JSONReporter from './json';
 import JUnitReporter from './junit';
-import Reporter, { ReporterOptions } from './reporter';
+import { Journey, Step } from '../dsl';
+import {
+  StartEvent,
+  JourneyEndResult,
+  JourneyStartResult,
+  StepEndResult,
+} from '../common_types';
 
-export { Reporter, ReporterOptions };
-export const reporters = {
+export type ReporterOptions = { fd?: number; colors?: boolean };
+export type BuiltInReporterName = 'default' | 'json' | 'junit';
+export type ReporterInstance = new (opts: ReporterOptions) => Reporter;
+export const reporters: {
+  [key in BuiltInReporterName]: ReporterInstance;
+} = {
   default: BaseReporter,
   json: JSONReporter,
   junit: JUnitReporter,
 };
+
+export interface Reporter {
+  onStart?(params: StartEvent): void;
+  onJourneyRegister?(journey: Journey): void;
+  onJourneyStart?(journey: Journey, result: JourneyStartResult): void;
+  onStepStart?(journey: Journey, step: Step): void;
+  onStepEnd?(journey: Journey, step: Step, result: StepEndResult): void;
+  onJourneyEnd?(
+    journey: Journey,
+    result: JourneyEndResult
+  ): void | Promise<void>;
+  onEnd?(): void | Promise<void>;
+}