@d-es-ign/stryker-js-core 9.6.0

package/src/reporters/broadcast-reporter.ts

@@ -0,0 +1,129 @@
+import {
+  MutantResult,
+  schema,
+  StrykerOptions,
+} from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, PluginKind } from '@stryker-mutator/api/plugin';
+import {
+  DryRunCompletedEvent,
+  MutationTestingPlanReadyEvent,
+  Reporter,
+} from '@stryker-mutator/api/report';
+import { MutationTestMetricsResult } from 'mutation-testing-metrics';
+import { tokens } from 'typed-inject';
+
+import { coreTokens, PluginCreator } from '../di/index.js';
+
+import { StrictReporter } from './strict-reporter.js';
+
+export class BroadcastReporter implements StrictReporter {
+  public static readonly inject = tokens(
+    commonTokens.options,
+    coreTokens.pluginCreator,
+    commonTokens.logger,
+    coreTokens.reporterOverride,
+  );
+
+  public readonly reporters: Record<string, Reporter>;
+  constructor(
+    private readonly options: StrykerOptions,
+    private readonly pluginCreator: PluginCreator,
+    private readonly log: Logger,
+    private readonly reporterOverride: Reporter | undefined,
+  ) {
+    this.reporters = {};
+    if (this.reporterOverride) {
+      this.reporters['in-memory'] = this.reporterOverride;
+    } else {
+      this.options.reporters.forEach((reporterName) =>
+        this.createReporter(reporterName),
+      );
+    }
+    this.logAboutReporters();
+  }
+
+  private createReporter(reporterName: string): void {
+    if (reporterName === 'progress' && !process.stdout.isTTY) {
+      this.log.info(
+        'Detected that current console does not support the "progress" reporter, downgrading to "progress-append-only" reporter',
+      );
+      reporterName = 'progress-append-only';
+    }
+    this.reporters[reporterName] = this.pluginCreator.create(
+      PluginKind.Reporter,
+      reporterName,
+    );
+  }
+
+  private logAboutReporters(): void {
+    const reporterNames = Object.keys(this.reporters);
+    if (reporterNames.length) {
+      if (this.log.isDebugEnabled()) {
+        this.log.debug(
+          `Broadcasting to reporters ${JSON.stringify(reporterNames)}`,
+        );
+      }
+    } else {
+      this.log.warn(
+        "No reporter configured. Please configure one or more reporters in the (for example: reporters: ['progress'])",
+      );
+    }
+  }
+
+  private broadcast<TMethod extends keyof Reporter>(
+    methodName: TMethod,
+    ...eventArgs: Parameters<Required<Reporter>[TMethod]>
+  ): Promise<void[]> {
+    return Promise.all(
+      Object.entries(this.reporters).map(async ([reporterName, reporter]) => {
+        if (reporter[methodName]) {
+          try {
+            await (
+              reporter[methodName] as (
+                ...args: Parameters<Required<Reporter>[TMethod]>
+              ) => Promise<void> | void
+            )(...eventArgs);
+          } catch (error) {
+            this.handleError(error, methodName, reporterName);
+          }
+        }
+      }),
+    );
+  }
+
+  public onDryRunCompleted(event: DryRunCompletedEvent): void {
+    void this.broadcast('onDryRunCompleted', event);
+  }
+  public onMutationTestingPlanReady(
+    event: MutationTestingPlanReadyEvent,
+  ): void {
+    void this.broadcast('onMutationTestingPlanReady', event);
+  }
+
+  public onMutantTested(result: MutantResult): void {
+    void this.broadcast('onMutantTested', result);
+  }
+
+  public onMutationTestReportReady(
+    report: schema.MutationTestResult,
+    metrics: MutationTestMetricsResult,
+  ): void {
+    void this.broadcast('onMutationTestReportReady', report, metrics);
+  }
+
+  public async wrapUp(): Promise<void> {
+    await this.broadcast('wrapUp');
+  }
+
+  private handleError(
+    error: unknown,
+    methodName: string,
+    reporterName: string,
+  ) {
+    this.log.error(
+      `An error occurred during '${methodName}' on reporter '${reporterName}'.`,
+      error,
+    );
+  }
+}

package/src/reporters/ci/circle-provider.ts

@@ -0,0 +1,50 @@
+import { objectUtils } from '../../utils/object-utils.js';
+
+import { CIProvider } from './provider.js';
+
+/**
+ * https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables
+ */
+export class CircleProvider implements CIProvider {
+  public determineProject(): string {
+    return `${this.determineProvider()}/${this.determineRepository()}`;
+  }
+  public determineVersion(): string | undefined {
+    return (
+      objectUtils.undefinedEmptyString(
+        objectUtils.getEnvironmentVariable('CIRCLE_PR_NUMBER'),
+      ) ??
+      objectUtils.undefinedEmptyString(
+        objectUtils.getEnvironmentVariable('CIRCLE_BRANCH'),
+      ) ??
+      objectUtils.undefinedEmptyString(
+        objectUtils.getEnvironmentVariable('CIRCLE_TAG'),
+      )
+    );
+  }
+
+  private determineRepository() {
+    const username = objectUtils.getEnvironmentVariableOrThrow(
+      'CIRCLE_PROJECT_USERNAME',
+    );
+    const repoName = objectUtils.getEnvironmentVariableOrThrow(
+      'CIRCLE_PROJECT_REPONAME',
+    );
+    return `${username}/${repoName}`;
+  }
+
+  private determineProvider() {
+    // Repo url can be in 2 forms:
+    // - 'git@github.com:company/repo.git'
+    // - 'https://github.com/company/repo'
+    // See https://discuss.circleci.com/t/circle-repository-url-changed-format-in-v2/15273
+    const repoUrl = objectUtils.getEnvironmentVariableOrThrow(
+      'CIRCLE_REPOSITORY_URL',
+    );
+    if (repoUrl.startsWith('git@')) {
+      return repoUrl.substr(4).split(':')[0];
+    } else {
+      return repoUrl.split('//')[1].split('/')[0];
+    }
+  }
+}

package/src/reporters/ci/github-actions-provider.ts

@@ -0,0 +1,22 @@
+import { objectUtils } from '../../utils/object-utils.js';
+
+import { CIProvider } from './provider.js';
+
+/**
+ * https://help.github.com/en/actions/automating-your-workflow-with-github-actions/using-environment-variables#default-environment-variables
+ */
+export class GithubActionsCIProvider implements CIProvider {
+  public determineProject(): string {
+    return `github.com/${objectUtils.getEnvironmentVariableOrThrow('GITHUB_REPOSITORY')}`;
+  }
+  public determineVersion(): string {
+    const rawRef = objectUtils.getEnvironmentVariableOrThrow('GITHUB_REF');
+    // rawRef will be in the form "refs/pull/:prNumber/merge" or "refs/heads/feat/branch-1"
+    const [, type, ...name] = rawRef.split('/');
+    if (type === 'pull') {
+      return `PR-${name[0]}`;
+    } else {
+      return name.join('/');
+    }
+  }
+}

package/src/reporters/ci/provider.ts

@@ -0,0 +1,42 @@
+import { objectUtils } from '../../utils/object-utils.js';
+
+import { CircleProvider } from './circle-provider.js';
+import { TravisProvider } from './travis-provider.js';
+import { GithubActionsCIProvider } from './github-actions-provider.js';
+
+/**
+ * Represents an object that can provide information about a CI/CD provider.
+ */
+export interface CIProvider {
+  /**
+   * Determine the repository slug, including the git provider. I.E: github.com/stryker-mutator/stryker or bitbucket.org/org/name.
+   */
+  determineProject(): string | undefined;
+  /**
+   * Determine the current version. I.e. branch name, git sha, or tag name
+   */
+  determineVersion(): string | undefined;
+}
+
+/**
+ * Return an appropriate instance of CiProvider.
+ * @returns An instance of CiProvider, or `null` if it appears Stryker is not running in a CI/CD environment.
+ */
+export function determineCIProvider():
+  | CircleProvider
+  | GithubActionsCIProvider
+  | TravisProvider
+  | null {
+  // By far the coolest env. variable from all those listed at
+  // https://docs.travis-ci.com/user/environment-variables/#Default-Environment-Variables
+  if (objectUtils.getEnvironmentVariable('HAS_JOSH_K_SEAL_OF_APPROVAL')) {
+    return new TravisProvider();
+  } else if (objectUtils.getEnvironmentVariable('CIRCLECI')) {
+    return new CircleProvider();
+  } else if (objectUtils.getEnvironmentVariable('GITHUB_ACTION')) {
+    return new GithubActionsCIProvider();
+  }
+  // TODO: Add vsts and gitlab CI
+
+  return null;
+}

package/src/reporters/ci/travis-provider.ts

@@ -0,0 +1,24 @@
+import { objectUtils } from '../../utils/object-utils.js';
+
+import { CIProvider } from './provider.js';
+
+/**
+ * See https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
+ */
+export class TravisProvider implements CIProvider {
+  public determineProject(): string | undefined {
+    const slug = objectUtils.getEnvironmentVariable('TRAVIS_REPO_SLUG');
+    if (slug) {
+      return `github.com/${slug}`;
+    } else {
+      return undefined;
+    }
+  }
+  public determineVersion(): string | undefined {
+    return (
+      objectUtils.undefinedEmptyString(
+        objectUtils.getEnvironmentVariable('TRAVIS_PULL_REQUEST_BRANCH'),
+      ) ?? objectUtils.getEnvironmentVariable('TRAVIS_BRANCH')
+    );
+  }
+}

package/src/reporters/clear-text-reporter.ts

@@ -0,0 +1,245 @@
+import os from 'os';
+
+import chalk, { Color } from 'chalk';
+import { schema, Position, StrykerOptions } from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens } from '@stryker-mutator/api/plugin';
+import { Reporter } from '@stryker-mutator/api/report';
+import {
+  MetricsResult,
+  MutantModel,
+  TestModel,
+  MutationTestMetricsResult,
+  TestFileModel,
+  TestMetrics,
+  TestStatus,
+} from 'mutation-testing-metrics';
+import { tokens } from 'typed-inject';
+
+import { getEmojiForStatus, plural } from '../utils/string-utils.js';
+
+import { ClearTextScoreTable } from './clear-text-score-table.js';
+
+export class ClearTextReporter implements Reporter {
+  public static inject = tokens(commonTokens.logger, commonTokens.options);
+  constructor(
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+  ) {
+    this.configConsoleColor();
+  }
+
+  private readonly out: NodeJS.WritableStream = process.stdout;
+
+  private readonly writeLine = (output?: string) => {
+    this.out.write(`${output ?? ''}${os.EOL}`);
+  };
+
+  private readonly writeDebugLine = (input: string) => {
+    this.log.debug(input);
+  };
+
+  private configConsoleColor() {
+    if (!this.options.allowConsoleColors) {
+      chalk.level = 0; // All colors disabled
+    }
+  }
+
+  public onMutationTestReportReady(
+    _report: schema.MutationTestResult,
+    metrics: MutationTestMetricsResult,
+  ): void {
+    this.writeLine();
+
+    if (this.options.clearTextReporter.reportTests) {
+      this.reportTests(metrics);
+    }
+    if (this.options.clearTextReporter.reportMutants) {
+      this.reportMutants(metrics);
+    }
+    if (
+      this.options.clearTextReporter.reportScoreTable &&
+      (!this.options.clearTextReporter.skipFull ||
+        metrics.systemUnderTestMetrics.childResults.some(
+          (x) => x.metrics.mutationScore !== 100,
+        ))
+    ) {
+      this.writeLine(
+        new ClearTextScoreTable(
+          metrics.systemUnderTestMetrics,
+          this.options,
+        ).draw(),
+      );
+    }
+  }
+
+  private reportTests(metrics: MutationTestMetricsResult) {
+    function indent(depth: number) {
+      return new Array(depth).fill('  ').join('');
+    }
+    const formatTestLine = (test: TestModel, state: string): string => {
+      return `${this.color('grey', `${test.name}${test.location ? ` [line ${test.location.start.line}]` : ''}`)} (${state})`;
+    };
+
+    if (metrics.testMetrics) {
+      const reportTests = (
+        currentResult: MetricsResult<TestFileModel, TestMetrics>,
+        depth = 0,
+      ) => {
+        const nameParts: string[] = [currentResult.name];
+        while (!currentResult.file && currentResult.childResults.length === 1) {
+          [currentResult] = currentResult.childResults;
+          nameParts.push(currentResult.name);
+        }
+        this.writeLine(`${indent(depth)}${nameParts.join('/')}`);
+        currentResult.file?.tests.forEach((test) => {
+          switch (test.status) {
+            case TestStatus.Killing:
+              this.writeLine(
+                `${indent(depth + 1)}${this.color('greenBright', '✓')} ${formatTestLine(test, `killed ${test.killedMutants?.length}`)}`,
+              );
+              break;
+            case TestStatus.Covering:
+              this.writeLine(
+                `${indent(depth + 1)}${this.color('blueBright', '~')} ${formatTestLine(test, `covered ${test.coveredMutants?.length}`)}`,
+              );
+              break;
+            case TestStatus.NotCovering:
+              this.writeLine(
+                `${indent(depth + 1)}${this.color('redBright', '✘')} ${formatTestLine(test, 'covered 0')}`,
+              );
+              break;
+          }
+        });
+        currentResult.childResults.forEach((childResult) =>
+          reportTests(childResult, depth + 1),
+        );
+      };
+      reportTests(metrics.testMetrics);
+    }
+  }
+
+  private reportMutants({
+    systemUnderTestMetrics,
+  }: MutationTestMetricsResult): void {
+    this.writeLine();
+    let totalTests = 0;
+
+    const reportMutants = (metrics: MetricsResult[]) => {
+      metrics.forEach((child) => {
+        child.file?.mutants.forEach((result) => {
+          totalTests += result.testsCompleted ?? 0;
+          switch (result.status) {
+            case 'Killed':
+            case 'Timeout':
+            case 'RuntimeError':
+            case 'CompileError':
+              this.reportMutantResult(result, this.writeDebugLine);
+              break;
+            case 'Survived':
+            case 'NoCoverage':
+              this.reportMutantResult(result, this.writeLine);
+              break;
+            default:
+          }
+        });
+        reportMutants(child.childResults);
+      });
+    };
+    reportMutants(systemUnderTestMetrics.childResults);
+    this.writeLine(
+      `Ran ${(totalTests / systemUnderTestMetrics.metrics.totalMutants).toFixed(2)} tests per mutant on average.`,
+    );
+  }
+
+  private statusLabel(mutant: MutantModel): string {
+    const { status } = mutant;
+    return this.options.clearTextReporter.allowEmojis
+      ? `${getEmojiForStatus(status)} ${status}`
+      : status.toString();
+  }
+
+  private reportMutantResult(
+    result: MutantModel,
+    logImplementation: (input: string) => void,
+  ): void {
+    logImplementation(`[${this.statusLabel(result)}] ${result.mutatorName}`);
+    logImplementation(
+      this.colorSourceFileAndLocation(result.fileName, result.location.start),
+    );
+
+    result
+      .getOriginalLines()
+      .split('\n')
+      .filter(Boolean)
+      .forEach((line) => {
+        logImplementation(chalk.red('-   ' + line));
+      });
+    result
+      .getMutatedLines()
+      .split('\n')
+      .filter(Boolean)
+      .forEach((line) => {
+        logImplementation(chalk.green('+   ' + line));
+      });
+    if (result.status === 'Survived') {
+      if (result.static) {
+        logImplementation('Ran all tests for this mutant.');
+      } else if (result.coveredByTests) {
+        this.logExecutedTests(result.coveredByTests, logImplementation);
+      }
+    } else if (result.status === 'Killed' && result.killedByTests?.length) {
+      logImplementation(`Killed by: ${result.killedByTests[0].name}`);
+    } else if (
+      result.status === 'RuntimeError' ||
+      result.status === 'CompileError'
+    ) {
+      logImplementation(`Error message: ${result.statusReason}`);
+    }
+    logImplementation('');
+  }
+
+  private colorSourceFileAndLocation(
+    fileName: string,
+    position: Position,
+  ): string {
+    return [
+      this.color('cyan', fileName),
+      this.color('yellow', position.line),
+      this.color('yellow', position.column),
+    ].join(':');
+  }
+
+  private color(color: Color, ...text: unknown[]) {
+    if (this.options.clearTextReporter.allowColor) {
+      return chalk[color](...text);
+    }
+    return text.join('');
+  }
+
+  private logExecutedTests(
+    tests: TestModel[],
+    logImplementation: (input: string) => void,
+  ) {
+    if (!this.options.clearTextReporter.logTests) {
+      return;
+    }
+
+    const testCount = Math.min(
+      this.options.clearTextReporter.maxTestsToLog,
+      tests.length,
+    );
+
+    if (testCount > 0) {
+      logImplementation('Tests ran:');
+      tests.slice(0, testCount).forEach((test) => {
+        logImplementation(`    ${test.name}`);
+      });
+      const diff = tests.length - this.options.clearTextReporter.maxTestsToLog;
+      if (diff > 0) {
+        logImplementation(`  and ${diff} more test${plural(diff)}!`);
+      }
+      logImplementation('');
+    }
+  }
+}