refactor: prepare html-reporter for pwt GUI integration

hermione.ts

@@ -1,39 +1,89 @@
 import os from 'os';
-import PQueue from 'p-queue';
+import path from 'path';
 import Hermione, {TestResult as HermioneTestResult} from 'hermione';
+import _ from 'lodash';
+import PQueue from 'p-queue';
+import {CommanderStatic} from '@gemini-testing/commander';
 
-import {PluginAdapter} from './lib/plugin-adapter';
-import {createWorkers, CreateWorkersRunner} from './lib/workers/create-workers';
-import {FAIL, SUCCESS} from './lib/constants';
+import {cliCommands} from './lib/cli-commands';
 import {hasDiff} from './lib/common-utils';
-import {formatTestResult} from './lib/server-utils';
-import {ReporterConfig, ReporterOptions} from './lib/types';
+import {parseConfig} from './lib/config';
+import {FAIL, SUCCESS, ToolName} from './lib/constants';
+import {HtmlReporter} from './lib/plugin-api';
 import {StaticReportBuilder} from './lib/report-builder/static';
+import {formatTestResult, logPathToHtmlReport, logError} from './lib/server-utils';
+import {SqliteClient} from './lib/sqlite-client';
 import {HermioneTestAdapter, ReporterTestResult} from './lib/test-adapter';
+import {TestAttemptManager} from './lib/test-attempt-manager';
+import {HtmlReporterApi, ReporterConfig, ReporterOptions} from './lib/types';
+import {createWorkers, CreateWorkersRunner} from './lib/workers/create-workers';
 
 let workers: ReturnType<typeof createWorkers>;
 
 export = (hermione: Hermione, opts: Partial<ReporterOptions>): void => {
     if (hermione.isWorker()) {
         return;
     }
-    const plugin = PluginAdapter.create(hermione, opts);
 
-    if (!plugin.isEnabled()) {
+    const config = parseConfig(opts);
+
+    if (!config.enabled) {
         return;
     }
 
-    plugin
-        .addApi()
-        .addCliCommands()
-        .init(prepare);
+    const htmlReporter = HtmlReporter.create(config, {toolName: ToolName.Hermione});
+
+    (hermione as Hermione & HtmlReporterApi).htmlReporter = htmlReporter;
+
+    let isCliCommandLaunched = false;
+    let handlingTestResults: Promise<void>;
+
+    hermione.on(hermione.events.CLI, (commander: CommanderStatic) => {
+        _.values(cliCommands).forEach((command: string) => {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            require(path.resolve(__dirname, 'lib/cli-commands', command))(commander, config, hermione);
+
+            commander.prependListener(`command:${command}`, () => {
+                isCliCommandLaunched = true;
+            });
+        });
+    });
+
+    hermione.on(hermione.events.INIT, async () => {
+        if (isCliCommandLaunched) {
+            return;
+        }
+
+        const dbClient = await SqliteClient.create({htmlReporter, reportPath: config.path});
+        const testAttemptManager = new TestAttemptManager();
+        const staticReportBuilder = StaticReportBuilder.create(htmlReporter, config, {dbClient, testAttemptManager});
+
+        handlingTestResults = Promise.all([
+            staticReportBuilder.saveStaticFiles(),
+            handleTestResults(hermione, staticReportBuilder, config)
+        ]).then(async () => {
+            await staticReportBuilder.finalize();
+        }).then(async () => {
+            await htmlReporter.emitAsync(htmlReporter.events.REPORT_SAVED, {reportPath: config.path});
+        });
+    });
 
     hermione.on(hermione.events.RUNNER_START, (runner) => {
         workers = createWorkers(runner as unknown as CreateWorkersRunner);
     });
+
+    hermione.on(hermione.events.RUNNER_END, async () => {
+        try {
+            await handlingTestResults;
+
+            logPathToHtmlReport(config);
+        } catch (e: unknown) {
+            logError(e as Error);
+        }
+    });
 };
 
-async function prepare(hermione: Hermione, reportBuilder: StaticReportBuilder, pluginConfig: ReporterConfig): Promise<void> {
+async function handleTestResults(hermione: Hermione, reportBuilder: StaticReportBuilder, pluginConfig: ReporterConfig): Promise<void> {
     const {path: reportPath} = pluginConfig;
     const {imageHandler} = reportBuilder;
 

test/unit/hermione.js

@@ -20,6 +20,8 @@ describe('lib/hermione', () => {
     let hermione;
     let cacheExpectedPaths = new Map(), cacheAllImages = new Map(), cacheDiffImages = new Map();
 
+    let program;
+
     const fs = _.clone(fsOriginal);
     const originalUtils = proxyquire('lib/server-utils', {
         'fs-extra': fs
@@ -49,19 +51,17 @@ describe('lib/hermione', () => {
         '../image-handler': {ImageHandler}
     });
 
-    const {PluginAdapter} = proxyquire('lib/plugin-adapter', {
-        './sqlite-client': {SqliteClient},
-        './server-utils': utils,
-        './report-builder/static': {StaticReportBuilder},
-        './plugin-api': proxyquire('lib/plugin-api', {
-            './local-images-saver': proxyquire('lib/local-images-saver', {
-                './server-utils': utils
-            })
+    const HtmlReporter = proxyquire('lib/plugin-api', {
+        './local-images-saver': proxyquire('lib/local-images-saver', {
+            './server-utils': utils
         })
-    });
+    }).HtmlReporter;
 
-    const HermioneReporter = proxyquire('../../hermione', {
-        './lib/plugin-adapter': {PluginAdapter}
+    const runHtmlReporter = proxyquire('../../hermione', {
+        './lib/sqlite-client': {SqliteClient},
+        './lib/server-utils': utils,
+        './lib/report-builder/static': {StaticReportBuilder},
+        './lib/plugin-api': {HtmlReporter}
     });
 
     const events = {
@@ -103,14 +103,35 @@ describe('lib/hermione', () => {
         }, events, {ImageDiffError, NoRefImageError});
     }
 
+    function mkCommander() {
+        const commander = {};
+        const props = [
+            'command',
+            'allowUnknownOption',
+            'description',
+            'option',
+            'action',
+            'on',
+            'prependListener'
+        ];
+
+        for (const prop of props) {
+            commander[prop] = sinon.stub().returns(commander);
+        }
+
+        return commander;
+    }
+
     function initReporter_(opts) {
         opts = _.defaults(opts, {
             enabled: true,
             path: 'default-path',
             baseHost: ''
         });
 
-        HermioneReporter(hermione, opts);
+        runHtmlReporter(hermione, opts);
+
+        hermione.emit(hermione.events.CLI, program);
 
         return hermione.emitAsync(hermione.events.INIT);
     }
@@ -139,9 +160,9 @@ describe('lib/hermione', () => {
     beforeEach(async () => {
         hermione = mkHermione_();
 
-        sandbox.spy(PluginAdapter.prototype, 'addApi');
-        sandbox.spy(PluginAdapter.prototype, 'addCliCommands');
-        sandbox.spy(PluginAdapter.prototype, 'init');
+        program = mkCommander();
+
+        sandbox.spy(HtmlReporter, 'create');
 
         sandbox.stub(fs, 'ensureDir').resolves();
         sandbox.stub(fs, 'writeFile').resolves();
@@ -178,24 +199,22 @@ describe('lib/hermione', () => {
         sandbox.restore();
     });
 
-    it('should do nothing if plugin is disabled', () => {
-        return initReporter_({enabled: false}).then(() => {
-            assert.notCalled(PluginAdapter.prototype.addCliCommands);
-        });
-    });
+    it('should do nothing if plugin is disabled', async () => {
+        await initReporter_({enabled: false});
 
-    it('should add api', () => {
-        return initReporter_()
-            .then(() => assert.calledOnce(PluginAdapter.prototype.addCliCommands));
+        assert.notCalled(HtmlReporter.create);
     });
 
-    it('should add cli commands', () => {
-        return initReporter_()
-            .then(() => assert.calledOnce(PluginAdapter.prototype.addCliCommands));
+    it('should add api', async () => {
+        await initReporter_();
+
+        assert.isObject(hermione.htmlReporter);
     });
 
-    it('should init plugin', () => {
-        return initReporter_().then(() => assert.calledOnce(PluginAdapter.prototype.init));
+    it('should add cli commands', async () => {
+        await initReporter_();
+
+        assert.called(program.command);
     });
 
     it('should add skipped test to result', async () => {