@serenity-js/console-reporter 3.0.0-rc.9 → 3.0.1

package/src/stage/crew/console-reporter/ConsoleReporter.ts

@@ -1,5 +1,5 @@
-import { ListensToDomainEvents, Stage, StageCrewMemberBuilder } from '@serenity-js/core';
-import { AssertionError } from '@serenity-js/core/lib';
+import { AssertionError, d, DomainEventQueues, Duration, ListensToDomainEvents, LogicError, Stage, StageCrewMemberBuilder, Timestamp } from '@serenity-js/core';
+import { OutputStream } from '@serenity-js/core/lib/adapter';
 import {
     ActivityRelatedArtifactGenerated,
     DomainEvent,
@@ -10,12 +10,10 @@ import {
     TaskFinished,
     TaskStarts,
     TestRunFinished,
+    TestRunStarts,
 } from '@serenity-js/core/lib/events';
-import { OutputStream } from '@serenity-js/core/lib/io';
 import {
-    AssertionReport,
     CorrelationId,
-    Duration,
     ExecutionCompromised,
     ExecutionFailedWithAssertionError,
     ExecutionFailedWithError,
@@ -27,34 +25,40 @@ import {
     Name,
     Outcome,
     ProblemIndication,
-    Timestamp,
 } from '@serenity-js/core/lib/model';
-import { Instance as ChalkInstance } from 'chalk';  // eslint-disable-line unicorn/import-style
+import { Instance as ChalkInstance } from 'chalk'; // eslint-disable-line unicorn/import-style
 import { ensure, isDefined, match } from 'tiny-types';
 
+import { ConsoleReporterConfig } from './ConsoleReporterConfig';
 import { Printer } from './Printer';
 import { Summary } from './Summary';
 import { SummaryFormatter } from './SummaryFormatter';
 import { TerminalTheme, ThemeForDarkTerminals, ThemeForLightTerminals, ThemeForMonochromaticTerminals } from './themes';
 
 /**
- * @desc
- *  Uses [standard output](https://en.wikipedia.org/wiki/Standard_streams)
- *  to report on progress of your Serenity/JS acceptance tests.
+ * A {@apilink StageCrewMember} that uses [standard output](https://en.wikipedia.org/wiki/Standard_streams)
+ * to report on progress of your Serenity/JS acceptance tests.
  *
- *  `ConsoleReporter` ships with colour themes for both dark and light terminals,
- *  as well as a monochromatic theme for those moments when you're in a noir mood
- *  (or have a terminal that doesn't support colours, like the good old `cmd.exe` on Windows).
+ * `ConsoleReporter` ships with colour themes for both dark and light terminals,
+ * as well as a monochromatic theme for those moments when you're in a noir mood
+ * (or have a terminal that doesn't support colours, like the good old `cmd.exe` on Windows).
  *
- * @example <caption>Registering the reporter programmatically</caption>
+ * ## Registering the reporter programmatically
+ *
+ * ```ts
  *  import { configure } from '@serenity-js/core';
  *  import { ConsoleReporter } from '@serenity-js/console-reporter';
  *
  *  configure({
- *      crew: [ ConsoleReporter.withDefaultColourSupport() ],
+ *    crew: [
+ *      ConsoleReporter.withDefaultColourSupport()
+ *    ],
  *  });
+ * ```
+ *
+ * ## Redirecting output to a file
  *
- * @example <caption>Redirecting output to a file</caption>
+ * ```ts
  *  import { configure } from '@serenity-js/core';
  *  import { ConsoleReporter } from '@serenity-js/console-reporter';
  *  import { createWriteStream } from 'fs';
@@ -63,93 +67,122 @@ import { TerminalTheme, ThemeForDarkTerminals, ThemeForLightTerminals, ThemeForM
  *      outputStream: createWriteStream('./output.log'),
  *      crew: [ ConsoleReporter.withDefaultColourSupport() ],
  *  });
+ *  ```
+ * ## Registering the reporter with WebdriverIO
+ *
+ * ```ts
+ * // wdio.conf.ts
+ * import { ConsoleReporter } from '@serenity-js/console-reporter';
+ * import { WebdriverIOConfig } from '@serenity-js/webdriverio';
+ *
+ * export const config: WebdriverIOConfig = {
+ *
+ *   framework: '@serenity-js/webdriverio',
+ *
+ *   serenity: {
+ *     crew: [
+ *       ConsoleReporter.forDarkTerminals(),
+ *     ]
+ *     // other Serenity/JS config
+ *   },
+ *
+ *  // other WebdriverIO config
+ * }
+ * ```
+ *
+ * ## Registering the reporter with Protractor
  *
- * @example <caption>Registering the reporter using Protractor configuration</caption>
- *  // protractor.conf.js
- *  const { ConsoleReporter } = require('@serenity-js/console-reporter');
+ * ```js
+ * // protractor.conf.js
+ * const { ConsoleReporter } = require('@serenity-js/console-reporter');
  *
- *  exports.config = {
- *    framework:     'custom',
- *    frameworkPath: require.resolve('@serenity-js/protractor/adapter'),
+ * exports.config = {
+ *   framework:     'custom',
+ *   frameworkPath: require.resolve('@serenity-js/protractor/adapter'),
  *
- *    serenity: {
- *      crew: [
- *        ConsoleReporter.withDefaultColourSupport(),
- *      ],
- *      // other Serenity/JS config
- *    },
+ *   serenity: {
+ *     crew: [
+ *       ConsoleReporter.withDefaultColourSupport(),
+ *     ],
+ *     // other Serenity/JS config
+ *   },
  *
- *    // other Protractor config
- *  };
+ *   // other Protractor config
+ * }
+ * ```
  *
  * @public
- * @implements {@serenity-js/core/lib/stage~ListensToDomainEvents}
+ *
+ * @group Stage
  */
 export class ConsoleReporter implements ListensToDomainEvents {
 
     private startTimes = new StartTimes();
     private artifacts = new ActivityRelatedArtifacts();
     private summary = new Summary();
-    private firstError: FirstError = new FirstError();
+    private readonly firstErrors: Map<string, FirstError> = new Map();
     private readonly summaryFormatter: SummaryFormatter;
+    private readonly eventQueues = new DomainEventQueues();
+
+    static fromJSON(config: ConsoleReporterConfig): StageCrewMemberBuilder<ConsoleReporter> {
+        return new ConsoleReporterBuilder(ConsoleReporter.theme(config.theme));
+    }
 
     /**
-     * @desc
-     *  Instantiates a `ConsoleReporter` that auto-detects
-     *  your terminal's support for colours and use a colour theme
-     *  for dark terminals if successful.
-     *
-     *  Please note that spawning your test process from another process
-     *  (by using [npm-failsafe](https://www.npmjs.com/package/npm-failsafe), for example)
-     *  causes the `ConsoleReporter` to use the monochromatic colour scheme,
-     *  as colour support can't be detected in child processes.
-     *
-     *  If the above describes your setup, use {@link ConsoleReporter#forDarkTerminals}
-     *  or {@link ConsoleReporter#forLightTerminals} to make the sub-process produce colour output.
+     * Instantiates a `ConsoleReporter` that auto-detects
+     * your terminal's support for colours and uses a colour theme
+     * for dark terminals if successful.
      *
-     * @returns {@serenity-js/core/lib/stage~StageCrewMemberBuilder}
+     * Please note that spawning your test process from another process
+     * (by using [npm-failsafe](https://www.npmjs.com/package/npm-failsafe), for example)
+     * causes the `ConsoleReporter` to use the monochromatic colour scheme,
+     * as colour support can't be detected in child processes.
      */
     static withDefaultColourSupport(): StageCrewMemberBuilder<ConsoleReporter> {
-        return new ConsoleReporterBuilder(new ThemeForDarkTerminals(new ChalkInstance(/* auto-detect */)));
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('auto'));
     }
 
     /**
-     * @desc
-     *  Instantiates a `ConsoleReporter` with a monochromatic colour theme.
-     *  Good for terminals with no colour support (like the `cmd.exe` on Windows),
-     *  or for when you need to pipe the output to a text file and want
-     *  to avoid printing control characters.
-     *
-     * @returns {@serenity-js/core/lib/stage~StageCrewMemberBuilder}
+     * Instantiates a `ConsoleReporter` with a monochromatic colour theme.
+     * Good for terminals with no colour support (like the `cmd.exe` on Windows),
+     * or for times when you need to pipe the output to a text file and want
+     * to avoid printing control characters.
      */
     static forMonochromaticTerminals(): StageCrewMemberBuilder<ConsoleReporter> {
-        return new ConsoleReporterBuilder(new ThemeForMonochromaticTerminals());
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('mono'));
     }
 
     /**
-     * @desc
-     *  Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with dark backgrounds.
-     *
-     * @returns {@serenity-js/core/lib/stage~StageCrewMemberBuilder}
+     * Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with dark backgrounds.
      */
     static forDarkTerminals(): StageCrewMemberBuilder<ConsoleReporter> {
-        return new ConsoleReporterBuilder(new ThemeForDarkTerminals(new ChalkInstance({ level: 2 })));
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('dark'));
     }
 
     /**
-     * @desc
-     *  Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with light backgrounds.
-     *
-     * @returns {@serenity-js/core/lib/stage~StageCrewMemberBuilder}
+     * Instantiates a `ConsoleReporter` with a colour theme optimised for terminals with light backgrounds.
      */
     static forLightTerminals(): StageCrewMemberBuilder<ConsoleReporter> {
-        return new ConsoleReporterBuilder(new ThemeForLightTerminals(new ChalkInstance({ level: 2 })));
+        return new ConsoleReporterBuilder(ConsoleReporter.theme('light'));
+    }
+
+    private static theme(theme: 'light' | 'dark' | 'mono' | 'auto') {
+        switch (theme) {
+            case 'dark':
+                return new ThemeForDarkTerminals(new ChalkInstance({ level: 2 }));
+            case 'light':
+                return new ThemeForLightTerminals(new ChalkInstance({ level: 2 }));
+            case 'mono':
+                return new ThemeForMonochromaticTerminals();
+            default:
+                return new ThemeForDarkTerminals(new ChalkInstance(/* auto-detect */));
+        }
     }
 
     /**
      * @param {Printer} printer
      * @param {TerminalTheme} theme
-     * @param {@serenity-js/core/lib/stage~Stage} [stage=null]
+     * @param {Stage} [stage=undefined]
      */
     constructor(
         private readonly printer: Printer,
@@ -163,167 +196,190 @@ export class ConsoleReporter implements ListensToDomainEvents {
     }
 
     /**
-     * @desc
-     *  Handles {@link @serenity-js/core/lib/events~DomainEvent} objects emitted by the {@link @serenity-js/core/lib/stage~StageCrewMember}.
+     * Handles {@apilink DomainEvent} objects emitted by the {@apilink Stage}.
      *
-     * @see {@link @serenity-js/core/lib/stage~StageCrewMember}
+     * @see {@apilink StageCrewMember}
      *
-     * @listens {@serenity-js/core/lib/events~DomainEvent}
+     * @listens {DomainEvent}
      *
-     * @param {@serenity-js/core/lib/events~DomainEvent} event
-     * @returns {void}
+     * @param {DomainEvent} event
      */
     notifyOf(event: DomainEvent): void {
-        match(event)
-            .when(SceneStarts, (e: SceneStarts) => {
 
-                this.firstError = new FirstError();
-                this.startTimes.recordStartOf(e);
+        if (event instanceof TestRunStarts) {
+            this.summary.recordTestRunStartedAt(event.timestamp);
+        }
+
+        if (this.isSceneSpecific(event)) {
+            this.eventQueues.enqueue(event);
+        }
+
+        if (event instanceof SceneStarts) {
+            this.firstErrors.set(event.sceneId.value, new FirstError());
+
+            this.startTimes.recordStartOf(event);
+        }
 
-                // Print scenario header
-                this.printer.println(this.theme.separator('-'));
-                this.printer.println(e.details.location.path.value, e.details.location.line ? `:${ e.details.location.line }` : '');
-                this.printer.println();
-                this.printer.println(this.theme.heading(e.details.category.value, ': ', e.details.name.value));
-                this.printer.println();
-            })
+        if (event instanceof SceneFinished) {
+            this.printScene(event.sceneId);
+        }
 
-        // todo: add SceneTagged ...
+        if (event instanceof TestRunFinished) {
+            this.summary.recordTestRunFinishedAt(event.timestamp);
 
-            .when(TaskStarts, (e: TaskStarts) => {
+            this.printSummary(this.summary);
 
-                this.printer.indent();
+            if (event.outcome instanceof ProblemIndication) {
+                this.printTestRunErrorOutcome(event.outcome);
+            }
+        }
+    }
 
-                if (! this.firstError.alreadyRecorded()) {
-                    this.printer.println(e.details.name.value);
-                }
+    private printTestRunErrorOutcome(outcome: ProblemIndication): void {
+        this.printer.println(this.theme.outcome(outcome, outcome.error.stack));
+    }
 
-            })
-            .when(InteractionStarts, (e: InteractionStarts) => {
+    private printScene(sceneId: CorrelationId): void {
+        const events = this.eventQueues.drainQueueFor(sceneId);
 
-                this.startTimes.recordStartOf(e);
+        for (const event of events) {
+            match(event)
+                .when(SceneStarts, (e: SceneStarts) => {
 
-            })
-            .when(InteractionFinished, (e: InteractionFinished) => {
+                    const category = e.details.name.value ? `${ e.details.category.value }: ` : '';
 
-                this.printer.indent();
-                this.printer.println(this.formattedOutcome(e));
+                    // Print scenario header
+                    this.printer.println(this.theme.separator('-'));
+                    this.printer.println(e.details.location.path.value, e.details.location.line ? `:${ e.details.location.line }` : '');
+                    this.printer.println();
+                    this.printer.println(this.theme.heading(category, e.details.name.value));
+                    this.printer.println();
+                })
 
-                this.printer.indent();
+                .when(TaskStarts, (e: TaskStarts) => {
 
-                if (e.outcome instanceof ProblemIndication) {
-                    this.firstError.recordIfNeeded(e.outcome.error);
+                    this.printer.indent();
 
-                    if (! (e.outcome.error instanceof AssertionError)) {
-                        this.printer.println(this.theme.outcome(e.outcome, `${ e.outcome.error }`));
+                    if (! this.firstErrors.get(e.sceneId.value)?.alreadyRecorded()) {
+                        this.printer.println(e.details.name.value);
                     }
-                }
 
-                const artifactGeneratedEvents = this.artifacts.recordedFor(e.activityId);
+                })
+                .when(InteractionStarts, (e: InteractionStarts) => {
 
-                if (artifactGeneratedEvents.some(a => a instanceof AssertionReport || a instanceof LogEntry)) {
-                    this.printer.println();
-                }
-
-                artifactGeneratedEvents.forEach(artifactGenerated => {
-                    if (artifactGenerated.artifact instanceof AssertionReport) {
-                        const details = artifactGenerated.artifact.map(
-                            (artifactContents: { expected: string, actual: string }) =>
-                                this.theme.diff(
-                                    artifactContents.expected,
-                                    artifactContents.actual,
-                                ),
-                        );
+                    this.startTimes.recordStartOf(e);
 
-                        this.printer.println();
+                })
+                .when(InteractionFinished, (e: InteractionFinished) => {
 
-                        this.printer.println(details);
+                    this.printer.indent();
+                    this.printer.println(this.formattedOutcome(e));
 
-                        this.printer.println();
-                    }
+                    this.printer.indent();
 
-                    if (artifactGenerated.artifact instanceof LogEntry) {
-                        const details = artifactGenerated.artifact.map((artifactContents: { data: string }) => artifactContents.data);
+                    if (e.outcome instanceof ProblemIndication) {
+                        this.firstErrors.get(e.sceneId.value)?.recordIfNeeded(e.outcome.error);
 
-                        if (artifactGenerated.name.value !== details) {
-                            this.printer.println(this.theme.log(artifactGenerated.name.value, ':'));
+                        if (! (e.outcome.error instanceof AssertionError)) {
+                            this.printer.println(this.theme.outcome(e.outcome, `${ e.outcome.error }`));
                         }
+                    }
 
-                        this.printer.println(details);
+                    const artifactGeneratedEvents = this.artifacts.recordedFor(e.activityId);
+
+                    if (artifactGeneratedEvents.some(a => a instanceof LogEntry)) {
                         this.printer.println();
                     }
-                });
 
-                this.printer.outdent();
+                    artifactGeneratedEvents.forEach(artifactGenerated => {
+                        if (artifactGenerated.artifact instanceof LogEntry) {
+                            const details = artifactGenerated.artifact.map((artifactContents: { data: string }) => artifactContents.data);
 
-                this.printer.outdent();
+                            if (artifactGenerated.name.value !== details) {
+                                this.printer.println(this.theme.log(artifactGenerated.name.value, ':'));
+                            }
 
-            })
-            .when(ActivityRelatedArtifactGenerated, (e: ActivityRelatedArtifactGenerated) => {
+                            this.printer.println(details);
+                            this.printer.println();
+                        }
+                    });
 
-                this.artifacts.record(e);
+                    this.printer.outdent();
 
-            })
-            .when(TaskFinished, (e: TaskFinished) => {
+                    this.printer.outdent();
 
-                this.printer.outdent();
+                })
+                .when(ActivityRelatedArtifactGenerated, (e: ActivityRelatedArtifactGenerated) => {
 
-                if (e.outcome instanceof ProblemIndication) {
-                    this.printer.indent();
-                    this.printer.indent();
+                    this.artifacts.record(e);
 
-                    if (! this.firstError.alreadyRecorded()) {
-                        this.printer.println(this.theme.outcome(e.outcome, this.iconFrom(e.outcome), `${ e.outcome.error }`));
-                    }
+                })
+                .when(TaskFinished, (e: TaskFinished) => {
 
-                    this.printer.outdent();
                     this.printer.outdent();
 
-                    this.firstError.recordIfNeeded(e.outcome.error);
-                }
+                    if (e.outcome instanceof ProblemIndication) {
+                        this.printer.indent();
+                        this.printer.indent();
 
-                else if (! (e.outcome instanceof ExecutionSuccessful)) {
-                    this.printer.indent();
-                    this.printer.println(this.iconFrom(e.outcome), e.details.name.value);
+                        if (! this.firstErrors.get(e.sceneId.value).alreadyRecorded()) {
+                            this.printer.println(this.theme.outcome(e.outcome, this.iconFrom(e.outcome), `${ e.outcome.error }`));
+                        }
 
-                    this.printer.outdent();
-                }
+                        this.printer.outdent();
+                        this.printer.outdent();
+
+                        this.firstErrors.get(e.sceneId.value).recordIfNeeded(e.outcome.error);
+                    }
 
-            })
-            .when(SceneFinished, (e: SceneFinished) => {
+                    else if (! (e.outcome instanceof ExecutionSuccessful)) {
+                        this.printer.indent();
+                        this.printer.println(this.iconFrom(e.outcome), e.details.name.value);
 
-                this.summary.record(e.details, e.outcome, this.startTimes.eventDurationOf(e));
+                        this.printer.outdent();
+                    }
 
-                this.printer.println();
-                this.printer.println(this.theme.outcome(e.outcome, this.formattedOutcome(e, this.deCamelCased(e.outcome.constructor.name))));
+                })
+                .when(SceneFinished, (e: SceneFinished) => {
 
-                if (e.outcome instanceof ProblemIndication) {
+                    this.summary.record(e.details, e.outcome, this.startTimes.eventDurationOf(e));
 
                     this.printer.println();
+                    this.printer.println(this.theme.outcome(e.outcome, this.formattedOutcome(e, this.deCamelCased(e.outcome.constructor.name))));
 
-                    this.printer.indent();
+                    if (e.outcome instanceof ProblemIndication) {
+
+                        this.printer.println();
 
-                    if (e.outcome instanceof ImplementationPending) {
-                        this.printer.println(`${ e.outcome.error.name }: ${ e.outcome.error.message }`);
-                    } else if (e.outcome.error?.stack) {
-                        this.printer.println(e.outcome.error.stack);
+                        this.printer.indent();
+
+                        if (e.outcome instanceof ImplementationPending) {
+                            this.printer.println(`${ e.outcome.error.name }: ${ e.outcome.error.message }`);
+                        } else if (e.outcome.error?.stack) {
+                            this.printer.println(e.outcome.error.stack);
+                        }
+
+                        this.printer.outdent();
                     }
 
-                    this.printer.outdent();
-                }
+                    this.artifacts.clear();
+                })
+                .else((_: DomainEvent) => {
+                    return void 0;
+                });
+        }
+    }
 
-                this.artifacts.clear();
-            })
-            .when(TestRunFinished, (_: TestRunFinished) => {
-                this.printer.println(this.theme.separator('='));
+    private printSummary(summary: Summary) {
+        this.printer.println(this.theme.separator('='));
 
-                this.printer.print(this.summaryFormatter.format(this.summary.aggregated()));
+        this.printer.print(this.summaryFormatter.format(summary.aggregated()));
+
+        this.printer.println(this.theme.separator('='));
+    }
 
-                this.printer.println(this.theme.separator('='));
-            })
-            .else((_: DomainEvent) => {
-                return void 0;
-            });
+    private isSceneSpecific(event: DomainEvent): event is DomainEvent & { sceneId: CorrelationId } {
+        return Object.prototype.hasOwnProperty.call(event, 'sceneId');
     }
 
     private formattedOutcome(event: IdentifiableEvent & { outcome: Outcome }, description: string = event.details.name.value) {
@@ -377,14 +433,22 @@ interface IdentifiableEvent {
 }
 
 class StartTimes {
-    private times: { [correlationId: string]: Timestamp } = {};
+    private times: { [key: string]: Timestamp } = {};
 
     recordStartOf(event: IdentifiableEvent) {
-        this.times[event.details.toString()] = event.timestamp;
+        this.times[this.keyFor(event)] = event.timestamp;
     }
 
     eventDurationOf(event: IdentifiableEvent & { outcome: Outcome }): Duration {
-        return event.timestamp.diff(this.times[event.details.toString()]);
+        if (! this.times[this.keyFor(event)]) {
+            throw new LogicError(d`StartTime missing for event ${ event }`)
+        }
+
+        return event.timestamp.diff(this.times[this.keyFor(event)]);
+    }
+
+    private keyFor(event: IdentifiableEvent): string {
+        return event.details.toString();
     }
 }
 

package/src/stage/crew/console-reporter/ConsoleReporterConfig.ts

@@ -0,0 +1,12 @@
+/**
+ * Used to configure the {@apilink ConsoleReporter}.
+ *
+ * @group Stage
+ */
+export interface ConsoleReporterConfig {
+    /**
+     * Choose a colour theme optimised for light, dark, or monochromatic terminals.
+     * Or, use 'auto' to automatically pick the most suitable one.
+     */
+    theme: 'light' | 'dark' | 'mono' | 'auto'
+}

package/src/stage/crew/console-reporter/Printer.ts

@@ -1,4 +1,4 @@
-import { OutputStream } from '@serenity-js/core/lib/io';
+import { OutputStream } from '@serenity-js/core/lib/adapter';
 
 /**
  * @desc
@@ -10,9 +10,6 @@ import { OutputStream } from '@serenity-js/core/lib/io';
 export class Printer {
     private indentation = new Indentation(2);
 
-    /**
-     * @param {@serenity-js/core/lib/io~OutputStream} stdout
-     */
     constructor(private readonly stdout: OutputStream = process.stdout) {
     }
 

package/src/stage/crew/console-reporter/Summary.ts

@@ -1,9 +1,11 @@
-import { Duration } from '@serenity-js/core';
+import { Duration, Timestamp } from '@serenity-js/core';
 import {
     ExecutionCompromised,
     ExecutionFailedWithAssertionError,
-    ExecutionFailedWithError, ExecutionIgnored,
-    ExecutionSkipped, ExecutionSuccessful,
+    ExecutionFailedWithError,
+    ExecutionIgnored,
+    ExecutionSkipped,
+    ExecutionSuccessful,
     ImplementationPending,
     Outcome,
     ScenarioDetails,
@@ -15,6 +17,9 @@ import {
 export class Summary {
     private readonly records: SummaryRecord[] = [];
 
+    private testRunStartedAt: Timestamp = new Timestamp();
+    private testRunFinishedAt: Timestamp = new Timestamp();
+
     record(details: ScenarioDetails, outcome: Outcome, duration: Duration): void {
         this.records.push({ details, outcome, duration });
     }
@@ -46,7 +51,20 @@ export class Summary {
             acc.categories[categoryName].totalTime = acc.categories[categoryName].totalTime.plus(record.duration);
 
             return acc;
-        }, { categories: {}, totalTime: Duration.ofMilliseconds(0), numberOfScenarios: this.records.length });
+        }, {
+            categories: {},
+            totalTime: Duration.ofMilliseconds(0),
+            realTime: this.testRunFinishedAt.diff(this.testRunStartedAt),
+            numberOfScenarios: this.records.length
+        });
+    }
+
+    recordTestRunStartedAt(timestamp: Timestamp): void {
+        this.testRunStartedAt = timestamp;
+    }
+
+    recordTestRunFinishedAt(timestamp: Timestamp): void {
+        this.testRunFinishedAt = timestamp;
     }
 }
 
@@ -56,6 +74,7 @@ export class Summary {
 export interface AggregatedCategories {
     categories: {[categoryName: string]: AggregatedCategory};
     totalTime: Duration;
+    realTime: Duration;
     numberOfScenarios: number;
 }