feat: add testplane support

Author: KuznetsovRoman

.eslintignore

@@ -10,5 +10,6 @@ hot
 /test/func/**/reports
 /test/func/packages/*/plugin.js
 /hermione-report
+/testplane-report
 tmp
 **/playwright-report

.gitignore

@@ -24,6 +24,7 @@ tmp
 
 **/playwright-report
 hermione-report
+testplane-report
 test/func/**/report
 test/func/**/report-backup
 test/func/**/reports

.npmignore

@@ -5,4 +5,6 @@ lib/static/js/
 lib/static/report.css
 
 hermione-report
+testplane-report
 .hermione.conf.js
+.testplane.conf.js

gemini.js

@@ -1,131 +1,3 @@
-import os from 'os';
-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 pluginHandler from './testplane';
 
-import {cliCommands} from './lib/cli-commands';
-import {parseConfig} from './lib/config';
-import {ToolName} from './lib/constants';
-import {HtmlReporter} from './lib/plugin-api';
-import {StaticReportBuilder} from './lib/report-builder/static';
-import {formatTestResult, logPathToHtmlReport, logError, getExpectedCacheKey} from './lib/server-utils';
-import {SqliteClient} from './lib/sqlite-client';
-import {HtmlReporterApi, ReporterOptions, TestSpecByPath} from './lib/types';
-import {createWorkers, CreateWorkersRunner} from './lib/workers/create-workers';
-import {SqliteImageStore} from './lib/image-store';
-import {Cache} from './lib/cache';
-import {ImagesInfoSaver} from './lib/images-info-saver';
-import {getStatus} from './lib/test-adapter/hermione';
-
-export = (hermione: Hermione, opts: Partial<ReporterOptions>): void => {
-    if (hermione.isWorker()) {
-        return;
-    }
-
-    const config = parseConfig(opts);
-
-    if (!config.enabled) {
-        return;
-    }
-
-    const htmlReporter = HtmlReporter.create(config, {toolName: ToolName.Hermione});
-
-    (hermione as Hermione & HtmlReporterApi).htmlReporter = htmlReporter;
-
-    let isCliCommandLaunched = false;
-    let handlingTestResults: Promise<void>;
-    let staticReportBuilder: StaticReportBuilder;
-
-    const withMiddleware = <T extends (...args: unknown[]) => unknown>(fn: T):
-        (...args: Parameters<T>) => ReturnType<T> | undefined => {
-        return (...args: unknown[]) => {
-            // If any CLI command was launched, e.g. merge-reports, we need to interrupt regular flow
-            if (isCliCommandLaunched) {
-                return;
-            }
-
-            return fn.call(undefined, ...args) as ReturnType<T>;
-        };
-    };
-
-    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, withMiddleware(async () => {
-        const dbClient = await SqliteClient.create({htmlReporter, reportPath: config.path});
-        const imageStore = new SqliteImageStore(dbClient);
-        const expectedPathsCache = new Cache<[TestSpecByPath, string | undefined], string>(getExpectedCacheKey);
-
-        const imagesInfoSaver = new ImagesInfoSaver({
-            imageFileSaver: htmlReporter.imagesSaver,
-            expectedPathsCache,
-            imageStore,
-            reportPath: htmlReporter.config.path
-        });
-
-        staticReportBuilder = StaticReportBuilder.create(htmlReporter, config, {dbClient, imagesInfoSaver});
-
-        handlingTestResults = Promise.all([
-            staticReportBuilder.saveStaticFiles(),
-            handleTestResults(hermione, staticReportBuilder)
-        ]).then(async () => {
-            await staticReportBuilder.finalize();
-        }).then(async () => {
-            await htmlReporter.emitAsync(htmlReporter.events.REPORT_SAVED, {reportPath: config.path});
-        });
-
-        htmlReporter.emit(htmlReporter.events.DATABASE_CREATED, dbClient.getRawConnection());
-    }));
-
-    hermione.on(hermione.events.RUNNER_START, withMiddleware((runner) => {
-        staticReportBuilder.registerWorkers(createWorkers(runner as unknown as CreateWorkersRunner));
-    }));
-
-    hermione.on(hermione.events.RUNNER_END, withMiddleware(async () => {
-        try {
-            await handlingTestResults;
-
-            logPathToHtmlReport(config);
-        } catch (e: unknown) {
-            logError(e as Error);
-        }
-    }));
-};
-
-async function handleTestResults(hermione: Hermione, reportBuilder: StaticReportBuilder): Promise<void> {
-    return new Promise((resolve, reject) => {
-        const queue = new PQueue({concurrency: os.cpus().length});
-        const promises: Promise<unknown>[] = [];
-
-        [
-            {eventName: hermione.events.TEST_PASS},
-            {eventName: hermione.events.RETRY},
-            {eventName: hermione.events.TEST_FAIL},
-            {eventName: hermione.events.TEST_PENDING}
-        ].forEach(({eventName}) => {
-            type AnyHermioneTestEvent = typeof hermione.events.TEST_PASS;
-
-            hermione.on(eventName as AnyHermioneTestEvent, (testResult: HermioneTestResult) => {
-                promises.push(queue.add(async () => {
-                    const formattedResult = formatTestResult(testResult, getStatus(eventName, hermione.events, testResult));
-
-                    await reportBuilder.addTestResult(formattedResult);
-                }).catch(reject));
-            });
-        });
-
-        hermione.on(hermione.events.RUNNER_END, () => {
-            return Promise.all(promises).then(() => resolve(), reject);
-        });
-    });
-}
+export = pluginHandler;

hermione.ts

@@ -6,10 +6,10 @@ const {Api} = require('../gui/api');
 
 const {GUI: commandName} = cliCommands;
 
-module.exports = (program, pluginConfig, hermione) => {
-    // must be executed here because it adds `gui` field in `gemini` and `hermione tool`,
+module.exports = (program, pluginConfig, testplane) => {
+    // must be executed here because it adds `gui` field in `gemini`, `testplane` and `hermione tool`,
     // which is available to other plugins and is an API for interacting with the current plugin
-    const guiApi = Api.create(hermione);
+    const guiApi = Api.create(testplane);
 
     program
         .command(`${commandName} [paths...]`)
@@ -20,6 +20,6 @@ module.exports = (program, pluginConfig, hermione) => {
         .option('-a, --auto-run', 'auto run immediately')
         .option('-O, --no-open', 'not to open a browser window after starting the server')
         .action((paths, options) => {
-            runGui({paths, hermione, guiApi, configs: {options, program, pluginConfig}});
+            runGui({paths, testplane, guiApi, configs: {options, program, pluginConfig}});
         });
 };

lib/cli-commands/gui.js

@@ -6,7 +6,7 @@ const {logError} = require('../server-utils');
 
 const {MERGE_REPORTS: commandName} = cliCommands;
 
-module.exports = (program, pluginConfig, hermione) => {
+module.exports = (program, pluginConfig, testplane) => {
     program
         .command(`${commandName} [paths...]`)
         .allowUnknownOption()
@@ -17,7 +17,7 @@ module.exports = (program, pluginConfig, hermione) => {
             try {
                 const {destination: destPath, header: headers} = options;
 
-                await mergeReports(pluginConfig, hermione, paths, {destPath, headers});
+                await mergeReports(pluginConfig, testplane, paths, {destPath, headers});
             } catch (err) {
                 logError(err);
                 process.exit(1);

lib/cli-commands/merge-reports.js

@@ -16,7 +16,7 @@ const {logger} = require('../../common-utils');
 const {REMOVE_UNUSED_SCREENS: commandName} = cliCommands;
 
 // TODO: remove hack after add ability to add controllers from plugin in silent mode
-function proxyHermione() {
+function proxyTestplane() {
     const proxyHandler = {
         get(target, prop) {
             return prop in target ? target[prop] : new Proxy(() => {}, this);
@@ -26,31 +26,33 @@ function proxyHermione() {
         }
     };
 
-    global.hermione = new Proxy(global.hermione || {}, proxyHandler);
+    global.hermione = global.testplane = new Proxy(global.testplane || global.hermione || {}, proxyHandler);
 }
 
-module.exports = (program, pluginConfig, hermione) => {
+module.exports = (program, pluginConfig, testplane) => {
+    const toolName = program.name?.() || 'hermione';
+
     program
         .command(commandName)
         .description('remove screenshots which were not used when running tests')
         .option('-p, --pattern <pattern>', 'pattern for searching screenshots on the file system', collect)
         .option('--skip-questions', 'do not ask questions during execution (default values will be used)')
-        .on('--help', () => logger.log(getHelpMessage()))
+        .on('--help', () => logger.log(getHelpMessage(toolName)))
         .action(async (options) => {
             try {
-                proxyHermione();
+                proxyTestplane();
 
                 const {pattern: userPatterns} = options;
 
                 if (_.isEmpty(userPatterns)) {
-                    throw new Error(`option "pattern" is required. See examples of usage: ${chalk.green(`npx hermione ${commandName} --help`)}`);
+                    throw new Error(`option "pattern" is required. See examples of usage: ${chalk.green(`npx ${toolName} ${commandName} --help`)}`);
                 }
 
                 const userScreenPatterns = transformPatternOption(userPatterns);
                 const spinner = ora({spinner: 'point'});
 
-                spinner.start('Reading hermione tests from file system');
-                const fsTests = await getTestsFromFs(hermione);
+                spinner.start(`Reading ${toolName} tests from file system`);
+                const fsTests = await getTestsFromFs(testplane);
                 spinner.succeed();
 
                 logger.log(`${chalk.green(fsTests.count)} uniq tests were read in browsers: ${[...fsTests.browserIds].join(', ')}`);
@@ -80,7 +82,7 @@ module.exports = (program, pluginConfig, hermione) => {
                 }, options);
 
                 if (shouldIdentifyUnused) {
-                    await handleUnusedScreens(foundScreenPaths, fsTests, {hermione, pluginConfig, spinner, cliOpts: options});
+                    await handleUnusedScreens(foundScreenPaths, fsTests, {testplane, pluginConfig, spinner, cliOpts: options});
                 }
             } catch (err) {
                 logger.error(err.stack || err);
@@ -100,7 +102,7 @@ async function handleOutdatedScreens(screenPaths, screenPatterns, opts = {}) {
 }
 
 async function handleUnusedScreens(screenPaths, fsTests, opts = {}) {
-    const {hermione, pluginConfig, spinner, cliOpts} = opts;
+    const {testplane, pluginConfig, spinner, cliOpts} = opts;
     const mainDatabaseUrls = path.resolve(pluginConfig.path, DATABASE_URLS_JSON_NAME);
 
     const isReportPathExists = await fs.pathExists(pluginConfig.path);
@@ -109,7 +111,7 @@ async function handleUnusedScreens(screenPaths, fsTests, opts = {}) {
     }
 
     spinner.start('Loading databases with the test results in order to identify unused screenshots in tests');
-    const dbPaths = await hermione.htmlReporter.downloadDatabases([mainDatabaseUrls], {pluginConfig});
+    const dbPaths = await testplane.htmlReporter.downloadDatabases([mainDatabaseUrls], {pluginConfig});
     spinner.succeed();
 
     if (_.isEmpty(dbPaths)) {
@@ -121,14 +123,14 @@ async function handleUnusedScreens(screenPaths, fsTests, opts = {}) {
 
     if (!_.isEmpty(srcDbPaths)) {
         spinner.start('Merging databases');
-        await hermione.htmlReporter.mergeDatabases(srcDbPaths, pluginConfig.path);
+        await testplane.htmlReporter.mergeDatabases(srcDbPaths, pluginConfig.path);
         spinner.succeed();
 
         logger.log(`${chalk.green(srcDbPaths.length)} databases were merged to ${chalk.green(mergedDbPath)}`);
     }
 
     spinner.start(`Identifying unused reference images (tests passed successfully for them, but they were not used during execution)`);
-    const unusedScreenPaths = identifyUnusedScreens(fsTests, {hermione, mergedDbPath});
+    const unusedScreenPaths = identifyUnusedScreens(fsTests, {testplane, mergedDbPath});
     spinner.succeed();
 
     await handleScreens(screenPaths, {paths: unusedScreenPaths, type: 'unused'}, {spinner, cliOpts});
@@ -204,13 +206,13 @@ function collect(newValue, array = []) {
     return array.concat(newValue);
 }
 
-function getHelpMessage() {
-    const rmUnusedScreens = `npx hermione ${commandName}`;
+function getHelpMessage(toolName) {
+    const rmUnusedScreens = `npx ${toolName} ${commandName}`;
 
     return `
   Example of usage:
     Specify the folder in which all reference screenshots are located:
-    ${chalk.green(`${rmUnusedScreens} -p 'hermione-screens-folder'`)}
+    ${chalk.green(`${rmUnusedScreens} -p '${toolName}-screens-folder'`)}
 
     Specify the mask by which all reference screenshots will be found:
     ${chalk.green(`${rmUnusedScreens} -p 'screens/**/*.png'`)}
@@ -219,7 +221,7 @@ function getHelpMessage() {
     ${chalk.green(`${rmUnusedScreens} -p 'screens/**/chrome/*.png' -p 'screens/**/firefox/*.png'`)}
 
     Don't ask me about anything and just delete unused reference screenshots:
-    ${chalk.green(`${rmUnusedScreens} -p 'hermione-screens-folder' --skip-questions`)}`;
+    ${chalk.green(`${rmUnusedScreens} -p '${toolName}-screens-folder' --skip-questions`)}`;
 }
 
 function transformPatternOption(patterns) {

lib/cli-commands/remove-unused-screens/index.js

@@ -9,7 +9,7 @@ const inquirer = require('inquirer');
 
 const {SUCCESS} = require('../../constants/test-statuses');
 
-exports.getTestsFromFs = async (hermione) => {
+exports.getTestsFromFs = async (testplane) => {
     const tests = {
         byId: {},
         screenPatterns: [],
@@ -18,12 +18,12 @@ exports.getTestsFromFs = async (hermione) => {
     };
     const uniqTests = new Set();
 
-    const testCollection = await hermione.readTests([], {silent: true});
+    const testCollection = await testplane.readTests([], {silent: true});
 
     testCollection.eachTest((test, browserId) => {
         const fullTitle = test.fullTitle();
         const id = `${fullTitle} ${browserId}`;
-        const screenPattern = hermione.config.browsers[browserId].getScreenshotPath(test, '*');
+        const screenPattern = testplane.config.browsers[browserId].getScreenshotPath(test, '*');
 
         tests.byId[id] = {screenPattern, ...test};
         tests.browserIds.add(browserId);
@@ -70,8 +70,8 @@ exports.identifyOutdatedScreens = (screenPaths, screenPatterns) => {
     return outdatedScreens;
 };
 
-exports.identifyUnusedScreens = (fsTests, {hermione, mergedDbPath} = {}) => {
-    const dbTree = hermione.htmlReporter.getTestsTreeFromDatabase(mergedDbPath);
+exports.identifyUnusedScreens = (fsTests, {testplane, mergedDbPath} = {}) => {
+    const dbTree = testplane.htmlReporter.getTestsTreeFromDatabase(mergedDbPath);
     const screenPathsBySuccessTests = getScreenPathsBySuccessTests(dbTree);
     const unusedScreens = [];
 

lib/cli-commands/remove-unused-screens/utils.js

@@ -5,7 +5,7 @@ import axios, {AxiosRequestConfig} from 'axios';
 import {
     ERROR,
     FAIL,
-    HERMIONE_TITLE_DELIMITER,
+    TESTPLANE_TITLE_DELIMITER,
     IDLE, PWT_TITLE_DELIMITER,
     QUEUED,
     RUNNING,
@@ -240,13 +240,7 @@ export const isCheckboxUnchecked = (status: number): boolean => Number(status) =
 export const getToggledCheckboxState = (status: number): number => isCheckboxChecked(status) ? UNCHECKED : CHECKED;
 
 export const getTitleDelimiter = (toolName: ToolName): string => {
-    if (toolName === ToolName.Hermione) {
-        return HERMIONE_TITLE_DELIMITER;
-    } else if (toolName === ToolName.Playwright) {
-        return PWT_TITLE_DELIMITER;
-    } else {
-        return HERMIONE_TITLE_DELIMITER;
-    }
+    return toolName === ToolName.Playwright ? PWT_TITLE_DELIMITER : TESTPLANE_TITLE_DELIMITER;
 };
 
 export function getDetailsFileName(testId: string, browserId: string, attempt: number): string {