@ohos-ports/web-test-runner 1.0.0-beta.0

package/src/reporter/reportTestsErrors.ts

@@ -0,0 +1,110 @@
+import { type Logger, type TestResultError, type TestSession } from '@web/test-runner-core';
+import * as diff from 'diff';
+import { gray, green, red } from 'nanocolors';
+
+import { getFailedOnBrowsers } from './utils/getFailedOnBrowsers.js';
+import { getFlattenedTestResults } from './utils/getFlattenedTestResults.js';
+
+function renderDiff(actual: string, expected: string) {
+  function cleanUp(line: string) {
+    if (line[0] === '+') {
+      return green(line);
+    }
+    if (line[0] === '-') {
+      return red(line);
+    }
+    if (line.match(/@@/)) {
+      return null;
+    }
+    if (line.match(/\\ No newline/)) {
+      return null;
+    }
+    return line;
+  }
+
+  const diffMsg = diff
+    .createPatch('string', actual, expected)
+    .split('\n')
+    .splice(4)
+    .map(cleanUp)
+    .filter(l => !!l)
+    .join('\n');
+
+  return `${green('+ expected')} ${red('- actual')}\n\n${diffMsg}`;
+}
+
+export function formatError(error: TestResultError) {
+  const strings: string[] = [];
+  const { name, message = 'Unknown error' } = error;
+  const errorMsg = name ? `${name}: ${message}` : message;
+  const showDiff = typeof error.expected === 'string' && typeof error.actual === 'string';
+  strings.push(red(errorMsg));
+
+  if (showDiff) {
+    strings.push(`${renderDiff(error.actual!, error.expected!)}\n`);
+  }
+
+  if (error.stack) {
+    if (showDiff) {
+      const dedented = error.stack
+        .split('\n')
+        .map(s => s.trim())
+        .join('\n');
+      strings.push(gray(dedented));
+    } else {
+      strings.push(gray(error.stack));
+    }
+  }
+
+  if (!error.expected && !error.stack) {
+    strings.push(red(error.message || 'Unknown error'));
+  }
+
+  return strings.join('\n');
+}
+
+export function reportTestsErrors(
+  logger: Logger,
+  allBrowserNames: string[],
+  favoriteBrowser: string,
+  failedSessions: TestSession[],
+) {
+  const testErrorsPerBrowser = new Map<string, Map<string, TestResultError>>();
+
+  for (const session of failedSessions) {
+    if (session.testResults) {
+      const flattenedTests = getFlattenedTestResults(session.testResults);
+      for (const test of flattenedTests) {
+        if (test.error) {
+          let testErrorsForBrowser = testErrorsPerBrowser.get(test.name);
+          if (!testErrorsForBrowser) {
+            testErrorsForBrowser = new Map<string, TestResultError>();
+            testErrorsPerBrowser.set(test.name, testErrorsForBrowser);
+          }
+          if (test.error) {
+            testErrorsForBrowser.set(session.browser.name, test.error);
+          }
+        }
+      }
+    }
+  }
+
+  if (testErrorsPerBrowser.size > 0) {
+    for (const [name, errorsForBrowser] of testErrorsPerBrowser) {
+      const failedBrowsers = Array.from(errorsForBrowser.keys());
+      const error =
+        errorsForBrowser.get(favoriteBrowser) ?? errorsForBrowser.get(failedBrowsers[0])!;
+      const failedOn = getFailedOnBrowsers(allBrowserNames, failedBrowsers);
+
+      logger.log(` ❌ ${name}${failedOn}`);
+      logger.group();
+      logger.group();
+      logger.group();
+      logger.log(formatError(error));
+      logger.groupEnd();
+      logger.groupEnd();
+      logger.groupEnd();
+      logger.log('');
+    }
+  }
+}

package/src/reporter/summaryReporter.ts

@@ -0,0 +1,123 @@
+import type {
+  BrowserLauncher,
+  Logger,
+  Reporter,
+  ReporterArgs,
+  TestSuiteResult,
+} from '@web/test-runner-core';
+
+import { reportTestFileErrors } from './reportTestFileErrors.js';
+import { reportTestsErrors } from './reportTestsErrors.js';
+
+import { TestRunnerLogger } from '../logger/TestRunnerLogger.js';
+import { reportBrowserLogs } from './reportBrowserLogs.js';
+
+interface Options {
+  flatten?: boolean;
+  reportTestLogs?: boolean;
+  reportTestErrors?: boolean;
+}
+
+const color =
+  ([x, y]: [number, number]) =>
+  (z: string) =>
+    `\x1b[${x}m${z}\x1b[${y}m${reset}`;
+const reset = `\x1b[0m\x1b[0m`;
+const green = color([32, 89]);
+const red = color([31, 89]);
+const dim = color([2, 0]);
+
+/** Test reporter that summarizes all test for a given run */
+export function summaryReporter(opts: Options): Reporter {
+  const { flatten = false, reportTestLogs = true, reportTestErrors = true } = opts ?? {};
+  let args: ReporterArgs;
+  let favoriteBrowser: string;
+
+  const testLogger = new TestRunnerLogger();
+
+  function log(
+    logger: Logger,
+    name: string,
+    passed: boolean,
+    skipped: boolean,
+    prefix = '  ',
+    postfix = '',
+  ) {
+    const sign = skipped ? dim('-') : passed ? green('✓') : red('𐄂');
+    if (flatten) logger.log(`${sign} ${name}${postfix}`);
+    else logger.log(`${prefix}  ${sign} ${name}`);
+  }
+
+  function logResults(
+    logger: Logger,
+    results?: TestSuiteResult,
+    prefix?: string,
+    browser?: BrowserLauncher,
+  ) {
+    const browserName = browser?.name ? ` ${dim(`[${browser.name}]`)}` : '';
+    for (const result of results?.tests ?? []) {
+      log(
+        logger,
+        flatten ? `${prefix ?? ''} ${result.name}` : result.name,
+        result.passed,
+        result.skipped,
+        prefix,
+        browserName,
+      );
+    }
+
+    for (const suite of results?.suites ?? []) {
+      logSuite(logger, suite, prefix, browser);
+    }
+  }
+
+  function logSuite(
+    logger: Logger,
+    suite: TestSuiteResult,
+    parent?: string,
+    browser?: BrowserLauncher,
+  ) {
+    const browserName = browser?.name ? ` ${dim(`[${browser.name}]`)}` : '';
+    let pref = parent ? `${parent} ` : ' ';
+    if (flatten) pref += `${suite.name}`;
+    else logger.log(`${pref}${suite.name}${browserName}`);
+
+    logResults(logger, suite, pref, browser);
+  }
+
+  return {
+    start(_args) {
+      args = _args;
+      favoriteBrowser =
+        args.browserNames.find(name => {
+          const n = name.toLowerCase();
+          return n.includes('chrome') || n.includes('chromium') || n.includes('firefox');
+        }) ?? args.browserNames[0];
+    },
+
+    reportTestFileResults({ logger, sessionsForTestFile }) {
+      for (const session of sessionsForTestFile) {
+        logResults(logger, session.testResults, '', session.browser);
+        logger.log('');
+      }
+      if (reportTestLogs) reportBrowserLogs(logger, sessionsForTestFile);
+    },
+
+    onTestRunFinished({ sessions }) {
+      if (reportTestErrors) {
+        const failedSessions = sessions.filter(s => !s.passed);
+        if (failedSessions.length > 0) {
+          testLogger.log('\n\nErrors Reported in Tests:\n\n');
+          reportTestsErrors(testLogger, args.browserNames, favoriteBrowser, failedSessions);
+          reportTestFileErrors(
+            testLogger,
+            args.browserNames,
+            favoriteBrowser,
+            failedSessions,
+            true,
+          );
+        }
+      }
+    },
+  };
+}

package/src/reporter/utils/getFailedOnBrowsers.ts

@@ -0,0 +1,10 @@
+export function getFailedOnBrowsers(allBrowserNames: string[], failedBrowsers: string[]) {
+  if (allBrowserNames.length === 1 || failedBrowsers.length === allBrowserNames.length) {
+    return '';
+  }
+  const browserString =
+    failedBrowsers.length === 1
+      ? failedBrowsers[0]
+      : failedBrowsers.slice(0, -1).join(', ') + ' and ' + failedBrowsers.slice(-1);
+  return ` (failed on ${browserString})`;
+}

package/src/reporter/utils/getFlattenedTestResults.ts

@@ -0,0 +1,24 @@
+import { type TestResult, type TestSuiteResult } from '@web/test-runner-core';
+
+export function getFlattenedTestResults(testResults: TestSuiteResult) {
+  const flattened: TestResult[] = [];
+
+  function collectTests(prefix: string, tests: TestResult[]) {
+    for (const test of tests) {
+      flattened.push({ ...test, name: `${prefix}${test.name}` });
+    }
+  }
+
+  function collectSuite(prefix: string, suite: TestSuiteResult) {
+    collectTests(prefix, suite.tests);
+
+    for (const childSuite of suite.suites) {
+      const newPrefix = `${prefix}${childSuite.name} > `;
+      collectSuite(newPrefix, childSuite);
+    }
+  }
+
+  collectSuite('', testResults);
+
+  return flattened;
+}

package/src/reporter/utils/getPassedFailedSkippedCount.ts

@@ -0,0 +1,31 @@
+import { type TestResult, type TestSuiteResult } from '@web/test-runner-core';
+
+export function getPassedFailedSkippedCount(testResults: TestSuiteResult) {
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+
+  function collectTests(tests: TestResult[]) {
+    for (const test of tests) {
+      if (test.skipped) {
+        skipped += 1;
+      } else if (test.passed) {
+        passed += 1;
+      } else {
+        failed += 1;
+      }
+    }
+  }
+
+  function collectSuite(suite: TestSuiteResult) {
+    collectTests(suite.tests);
+
+    for (const childSuite of suite.suites) {
+      collectSuite(childSuite);
+    }
+  }
+
+  collectSuite(testResults);
+
+  return { passed, failed, skipped };
+}

package/src/reporter/utils/toBrowserPath.ts

@@ -0,0 +1,5 @@
+import path from 'path';
+
+export function toBrowserPath(filePath: string) {
+  return filePath.split(path.sep).join('/');
+}

package/src/reporter/utils/toFilePath.ts

@@ -0,0 +1,9 @@
+import path from 'path';
+
+/**
+ * Transforms a file system path to a browser URL. For example windows uses `\` on the file system,
+ * but it should use `/` in the browser.
+ */
+export function toFilePath(browserPath: string) {
+  return browserPath.split('/').join(path.sep);
+}

package/src/startTestRunner.ts

@@ -0,0 +1,101 @@
+import { TestRunner, TestRunnerCli } from '@web/test-runner-core';
+import { red } from 'nanocolors';
+
+import { TestRunnerStartError } from './TestRunnerStartError.js';
+import { TestRunnerConfig } from './config/TestRunnerConfig.js';
+import { mergeConfigs } from './config/mergeConfigs.js';
+import { parseConfig } from './config/parseConfig.js';
+import { readCliArgs } from './config/readCliArgs.js';
+import { readFileConfig } from './config/readFileConfig.js';
+
+export interface StartTestRunnerParams {
+  /**
+   * Optional config to merge with the user-defined config.
+   */
+  config?: Partial<TestRunnerConfig>;
+  /**
+   * Whether to read CLI args. Default true.
+   */
+  readCliArgs?: boolean;
+  /**
+   * Whether to read a user config from the file system. Default true.
+   */
+  readFileConfig?: boolean;
+  /**
+   * Name of the configuration to read. Defaults to web-dev-server.config.{mjs,cjs,js}
+   */
+  configName?: string;
+  /**
+   * Whether to automatically exit the process when the server is stopped, killed or an error is thrown.
+   */
+  autoExitProcess?: boolean;
+  /**
+   * Array to read the CLI args from. Defaults to process.argv.
+   */
+  argv?: string[];
+}
+
+/**
+ * Starts the test runner.
+ */
+export async function startTestRunner(options: StartTestRunnerParams = {}) {
+  const {
+    config: extraConfig,
+    readCliArgs: readCliArgsFlag = true,
+    readFileConfig: readFileConfigFlag = true,
+    configName,
+    autoExitProcess = true,
+    argv = process.argv,
+  } = options;
+
+  try {
+    const cliArgs = readCliArgsFlag ? readCliArgs({ argv }) : {};
+    const rawConfig = readFileConfigFlag
+      ? await readFileConfig({ configName, configPath: cliArgs.config })
+      : {};
+    const mergedConfig = mergeConfigs(extraConfig, rawConfig);
+    const { config, groupConfigs } = await parseConfig(mergedConfig, cliArgs);
+
+    const runner = new TestRunner(config, groupConfigs);
+    const cli = new TestRunnerCli(config, runner);
+
+    function stop() {
+      runner.stop();
+    }
+
+    if (autoExitProcess) {
+      (['exit', 'SIGINT'] as NodeJS.Signals[]).forEach(event => {
+        process.on(event, stop);
+      });
+    }
+
+    if (autoExitProcess) {
+      process.on('uncaughtException', error => {
+        console.error(`Uncaught exception, stopping test runner..\n`, error);
+        stop();
+      });
+    }
+
+    runner.on('stopped', passed => {
+      if (autoExitProcess) {
+        process.exit(passed ? 0 : 1);
+      }
+    });
+
+    await runner.start();
+    cli.start();
+
+    return runner;
+  } catch (error) {
+    if (error instanceof TestRunnerStartError) {
+      console.error(`\n${red('Error:')} ${error.message}\n`);
+    } else {
+      console.error(error);
+    }
+
+    setTimeout(() => {
+      // exit after a timeout to allow CLI to flush console output
+      process.exit(1);
+    }, 0);
+  }
+}

package/web-test-runner.config.mjs

@@ -0,0 +1,8 @@
+import { legacyPlugin } from '@web/dev-server-legacy';
+
+export default {
+  rootDir: '../../',
+  preserveSymlinks: true,
+  nodeResolve: true,
+  plugins: [legacyPlugin()],
+};