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

package/src/reporters/clear-text-score-table.ts

@@ -0,0 +1,305 @@
+import os from 'os';
+
+import {
+  MutationScoreThresholds,
+  StrykerOptions,
+} from '@stryker-mutator/api/core';
+
+import { MetricsResult } from 'mutation-testing-metrics';
+
+import chalk from 'chalk';
+
+import { stringWidth } from '../utils/string-utils.js';
+
+const FILES_ROOT_NAME = 'All files';
+
+type TableCellValueFactory = (
+  row: MetricsResult,
+  ancestorCount: number,
+) => string;
+
+const repeat = (char: string, nTimes: number) =>
+  new Array(nTimes > -1 ? nTimes + 1 : 0).join(char);
+const spaces = (n: number) => repeat(' ', n);
+
+const determineContentWidth = (
+  row: MetricsResult,
+  valueFactory: TableCellValueFactory,
+  ancestorCount = 0,
+): number => {
+  return Math.max(
+    valueFactory(row, ancestorCount).length,
+    ...row.childResults.map((child) =>
+      determineContentWidth(child, valueFactory, ancestorCount + 1),
+    ),
+  );
+};
+
+/**
+ * A base class for single columns and grouped columns
+ */
+abstract class Column {
+  /**
+   * @param header The title of the column
+   * @param netWidth The width of the column (excl 2 spaces padding)
+   * @param isFirstColumn Whether or not this is the first column in the table. If it is the first column, it should not have a space in front of it.
+   */
+  constructor(
+    protected readonly header: string,
+    public netWidth: number,
+    public readonly isFirstColumn: boolean,
+  ) {}
+
+  /**
+   * Adds padding (spaces) to the front and end of a value
+   * @param input The string input
+   */
+  protected pad(input = ''): string {
+    return `${spaces(this.netWidth - stringWidth(input))}${this.isFirstColumn ? '' : ' '}${input} `;
+  }
+
+  public drawLine(): string {
+    return repeat('-', this.width);
+  }
+
+  public drawHeader() {
+    return this.pad(this.header);
+  }
+
+  abstract drawTableCell(score: MetricsResult, ancestorCount: number): string;
+
+  /**
+   * The gross width of the column (including padding)
+   */
+  get width() {
+    return this.netWidth + (this.isFirstColumn ? 1 : 2);
+  }
+}
+
+/**
+ * Represents a single column in the clear text table (no group)
+ */
+class SingleColumn extends Column {
+  constructor(
+    header: string,
+    isFirstColumn: boolean,
+    public valueFactory: TableCellValueFactory,
+    public rows: MetricsResult,
+  ) {
+    const maxContentSize = determineContentWidth(rows, valueFactory);
+    super(header, Math.max(maxContentSize, stringWidth(header)), isFirstColumn);
+  }
+
+  public drawTableCell(score: MetricsResult, ancestorCount: number): string {
+    return this.color(score)(this.pad(this.valueFactory(score, ancestorCount)));
+  }
+
+  protected color(_score: MetricsResult) {
+    return (input: string) => input;
+  }
+}
+
+class MutationScoreColumn extends SingleColumn {
+  constructor(
+    rows: MetricsResult,
+    private readonly thresholds: MutationScoreThresholds,
+    private readonly scoreType: 'total' | 'covered',
+  ) {
+    super(
+      scoreType,
+      false,
+      (row) => {
+        const score =
+          scoreType === 'total'
+            ? row.metrics.mutationScore
+            : row.metrics.mutationScoreBasedOnCoveredCode;
+        return isNaN(score) ? 'n/a' : score.toFixed(2);
+      },
+      rows,
+    );
+  }
+  protected color(metricsResult: MetricsResult) {
+    const {
+      mutationScore: score,
+      mutationScoreBasedOnCoveredCode: coveredScore,
+    } = metricsResult.metrics;
+    const scoreToUse = this.scoreType === 'total' ? score : coveredScore;
+    if (isNaN(scoreToUse)) {
+      return chalk.grey;
+    } else if (scoreToUse >= this.thresholds.high) {
+      return chalk.green;
+    } else if (scoreToUse >= this.thresholds.low) {
+      return chalk.yellow;
+    } else {
+      return chalk.red;
+    }
+  }
+}
+
+class FileColumn extends SingleColumn {
+  constructor(rows: MetricsResult) {
+    super(
+      'File',
+      true,
+      (row, ancestorCount) =>
+        spaces(ancestorCount) +
+        (ancestorCount === 0 ? FILES_ROOT_NAME : row.name),
+      rows,
+    );
+  }
+  protected override pad(input: string): string {
+    // Align left
+    return `${input}${spaces(this.width - stringWidth(input))}`;
+  }
+}
+
+class GroupColumn extends Column {
+  columns: SingleColumn[];
+  constructor(groupName: string, ...columns: SingleColumn[]) {
+    // Calculate the width of the columns, use the `width`, since the gross width is included in this grouped column. Subtract 2 for the padding.
+    const { isFirstColumn } = columns[0];
+    const columnsWidth =
+      columns.reduce((acc, cur) => acc + cur.width, 0) -
+      (isFirstColumn ? 1 : 2);
+    const groupNameWidth = stringWidth(groupName);
+    super(groupName, Math.max(groupNameWidth, columnsWidth), isFirstColumn);
+    this.columns = columns;
+    if (this.netWidth > columnsWidth + 1) {
+      // Resize the first column to fill the gap
+      columns[0].netWidth += this.netWidth - columnsWidth - 1;
+    }
+  }
+
+  drawColumnHeaders() {
+    return this.columns.map((column) => column.drawHeader()).join('|');
+  }
+
+  drawColumnLines() {
+    return this.columns.map((column) => column.drawLine()).join('|');
+  }
+
+  drawTableCell(score: MetricsResult, ancestorCount: number): string {
+    return this.columns
+      .map((column) => column.drawTableCell(score, ancestorCount))
+      .join('|');
+  }
+}
+
+/**
+ * Represents a clear text table for mutation score
+ */
+export class ClearTextScoreTable {
+  private readonly columns: GroupColumn[];
+
+  constructor(
+    private readonly metricsResult: MetricsResult,
+    private readonly options: StrykerOptions,
+  ) {
+    this.columns = [
+      new GroupColumn('', new FileColumn(metricsResult)),
+      new GroupColumn(
+        '% Mutation score',
+        new MutationScoreColumn(metricsResult, options.thresholds, 'total'),
+        new MutationScoreColumn(metricsResult, options.thresholds, 'covered'),
+      ),
+      new GroupColumn(
+        '',
+        new SingleColumn(
+          `${options.clearTextReporter.allowEmojis ? '✅' : '#'} killed`,
+          false,
+          (row) => row.metrics.killed.toString(),
+          metricsResult,
+        ),
+      ),
+      new GroupColumn(
+        '',
+        new SingleColumn(
+          `${options.clearTextReporter.allowEmojis ? '⌛️' : '#'} timeout`,
+          false,
+          (row) => row.metrics.timeout.toString(),
+          metricsResult,
+        ),
+      ),
+      new GroupColumn(
+        '',
+        new SingleColumn(
+          `${options.clearTextReporter.allowEmojis ? '👽' : '#'} survived`,
+          false,
+          (row) => row.metrics.survived.toString(),
+          metricsResult,
+        ),
+      ),
+      new GroupColumn(
+        '',
+        new SingleColumn(
+          `${options.clearTextReporter.allowEmojis ? '🙈' : '#'} no cov`,
+          false,
+          (row) => row.metrics.noCoverage.toString(),
+          metricsResult,
+        ),
+      ),
+      new GroupColumn(
+        '',
+        new SingleColumn(
+          `${options.clearTextReporter.allowEmojis ? '💥' : '#'} errors`,
+          false,
+          (row) =>
+            (row.metrics.runtimeErrors + row.metrics.compileErrors).toString(),
+          metricsResult,
+        ),
+      ),
+    ];
+  }
+
+  private drawGroupHeader() {
+    return this.drawRow((column) => column.drawHeader());
+  }
+
+  private drawGroupLine() {
+    return this.drawRow((column) => column.drawLine());
+  }
+  private drawLine() {
+    return this.drawRow((column) => column.drawColumnLines());
+  }
+
+  private drawColumnHeader() {
+    return this.drawRow((c) => c.drawColumnHeaders());
+  }
+
+  private drawRow(toDraw: (col: GroupColumn) => string) {
+    return this.columns.map(toDraw).join('|') + '|';
+  }
+
+  private drawTableBody(
+    current = this.metricsResult,
+    ancestorCount = 0,
+  ): string[] {
+    const rows: string[] = [];
+    if (
+      !this.options.clearTextReporter.skipFull ||
+      current.metrics.mutationScore !== 100
+    ) {
+      rows.push(this.drawRow((c) => c.drawTableCell(current, ancestorCount)));
+    }
+    rows.push(
+      ...current.childResults.flatMap((child) =>
+        this.drawTableBody(child, ancestorCount + 1),
+      ),
+    );
+    return rows;
+  }
+
+  /**
+   * Returns a string with the score results drawn in a table.
+   */
+  public draw(): string {
+    return [
+      this.drawGroupLine(),
+      this.drawGroupHeader(),
+      this.drawColumnHeader(),
+      this.drawLine(),
+      this.drawTableBody().join(os.EOL),
+      this.drawLine(),
+    ].join(os.EOL);
+  }
+}

package/src/reporters/dashboard-reporter/dashboard-reporter-client.ts

@@ -0,0 +1,89 @@
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { StrykerError } from '@stryker-mutator/util';
+import { HttpClient } from 'typed-rest-client/HttpClient.js';
+import { StrykerOptions } from '@stryker-mutator/api/core';
+
+import { objectUtils } from '../../utils/object-utils.js';
+
+import { dashboardReporterTokens } from './tokens.js';
+import { Report } from './report.js';
+
+interface ReportResponseBody {
+  href: string;
+}
+
+const STRYKER_DASHBOARD_API_KEY = 'STRYKER_DASHBOARD_API_KEY';
+
+export class DashboardReporterClient {
+  public static inject = tokens(
+    commonTokens.logger,
+    dashboardReporterTokens.httpClient,
+    commonTokens.options,
+  );
+  constructor(
+    private readonly log: Logger,
+    private readonly httpClient: HttpClient,
+    private readonly options: StrykerOptions,
+  ) {}
+
+  public async updateReport({
+    report,
+    projectName,
+    version,
+    moduleName,
+  }: {
+    report: Report;
+    projectName: string;
+    version: string;
+    moduleName: string | undefined;
+  }): Promise<string> {
+    const url = this.getPutUrl(projectName, version, moduleName);
+    const serializedBody = JSON.stringify(report);
+    this.log.info('PUT report to %s (~%s bytes)', url, serializedBody.length);
+    const apiKey = objectUtils.getEnvironmentVariable(
+      STRYKER_DASHBOARD_API_KEY,
+    );
+    if (apiKey) {
+      this.log.debug(
+        'Using configured API key from environment "%s"',
+        STRYKER_DASHBOARD_API_KEY,
+      );
+    }
+    this.log.trace('PUT report %s', serializedBody);
+    const result = await this.httpClient.put(url, serializedBody, {
+      ['X-Api-Key']: apiKey,
+      ['Content-Type']: 'application/json',
+    });
+    const responseBody = await result.readBody();
+    if (isOK(result.message.statusCode ?? 0)) {
+      const response: ReportResponseBody = JSON.parse(responseBody);
+      return response.href;
+    } else if (result.message.statusCode === 401) {
+      throw new StrykerError(
+        `Error HTTP PUT ${url}. Unauthorized. Did you provide the correct api key in the "${STRYKER_DASHBOARD_API_KEY}" environment variable?`,
+      );
+    } else {
+      throw new StrykerError(
+        `Error HTTP PUT ${url}. Response status code: ${result.message.statusCode}. Response body: ${responseBody}`,
+      );
+    }
+  }
+
+  private getPutUrl(
+    repoSlug: string,
+    version: string,
+    moduleName: string | undefined,
+  ) {
+    const base = `${this.options.dashboard.baseUrl}/${repoSlug}/${encodeURIComponent(version)}`;
+    if (moduleName) {
+      return `${base}?module=${encodeURIComponent(moduleName)}`;
+    } else {
+      return base;
+    }
+  }
+}
+
+function isOK(statusCode: number): boolean {
+  return statusCode >= 200 && statusCode < 300;
+}

package/src/reporters/dashboard-reporter/dashboard-reporter.ts

@@ -0,0 +1,97 @@
+import { StrykerOptions, ReportType, schema } from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { Reporter } from '@stryker-mutator/api/report';
+import { MutationTestMetricsResult } from 'mutation-testing-metrics';
+
+import { CIProvider } from '../ci/provider.js';
+
+import { DashboardReporterClient } from './dashboard-reporter-client.js';
+import { dashboardReporterTokens } from './tokens.js';
+import { Report } from './report.js';
+
+export class DashboardReporter implements Reporter {
+  public static readonly inject = tokens(
+    commonTokens.logger,
+    dashboardReporterTokens.dashboardReporterClient,
+    commonTokens.options,
+    dashboardReporterTokens.ciProvider,
+  );
+
+  constructor(
+    private readonly log: Logger,
+    private readonly dashboardReporterClient: DashboardReporterClient,
+    private readonly options: StrykerOptions,
+    private readonly ciProvider: CIProvider | null,
+  ) {}
+
+  private onGoingWork: Promise<void> | undefined;
+
+  public onMutationTestReportReady(
+    result: schema.MutationTestResult,
+    metrics: MutationTestMetricsResult,
+  ): void {
+    this.onGoingWork = (async () => {
+      const { projectName, version, moduleName } =
+        this.getContextFromEnvironment();
+      if (projectName && version) {
+        await this.update(
+          this.toReport(result, metrics),
+          projectName,
+          version,
+          moduleName,
+        );
+      } else {
+        this.log.info(
+          'The report was not send to the dashboard. The dashboard.project and/or dashboard.version values were missing and not detected to be running on a build server.',
+        );
+      }
+    })();
+  }
+
+  public async wrapUp(): Promise<void> {
+    await this.onGoingWork;
+  }
+
+  private toReport(
+    result: schema.MutationTestResult,
+    metrics: MutationTestMetricsResult,
+  ): Report {
+    if (this.options.dashboard.reportType === ReportType.Full) {
+      return result;
+    } else {
+      return {
+        mutationScore: metrics.systemUnderTestMetrics.metrics.mutationScore,
+      };
+    }
+  }
+
+  private async update(
+    report: Report,
+    projectName: string,
+    version: string,
+    moduleName: string | undefined,
+  ) {
+    try {
+      const href = await this.dashboardReporterClient.updateReport({
+        report,
+        moduleName,
+        projectName,
+        version: version,
+      });
+      this.log.info('Report available at: %s', href);
+    } catch (err) {
+      this.log.error('Could not upload report.', err);
+    }
+  }
+
+  private getContextFromEnvironment() {
+    return {
+      moduleName: this.options.dashboard.module,
+      projectName:
+        this.options.dashboard.project ?? this.ciProvider?.determineProject(),
+      version:
+        this.options.dashboard.version ?? this.ciProvider?.determineVersion(),
+    };
+  }
+}

package/src/reporters/dashboard-reporter/index.ts

@@ -0,0 +1,30 @@
+import {
+  commonTokens,
+  Injector,
+  PluginContext,
+  tokens,
+} from '@stryker-mutator/api/plugin';
+import { HttpClient } from 'typed-rest-client/HttpClient.js';
+
+import { determineCIProvider } from '../ci/provider.js';
+
+import { DashboardReporter } from './dashboard-reporter.js';
+import { DashboardReporterClient } from './dashboard-reporter-client.js';
+import { dashboardReporterTokens } from './tokens.js';
+
+export function dashboardReporterFactory(
+  injector: Injector<PluginContext>,
+): DashboardReporter {
+  return injector
+    .provideValue(
+      dashboardReporterTokens.httpClient,
+      new HttpClient('stryker-dashboard-reporter'),
+    )
+    .provideClass(
+      dashboardReporterTokens.dashboardReporterClient,
+      DashboardReporterClient,
+    )
+    .provideFactory(dashboardReporterTokens.ciProvider, determineCIProvider)
+    .injectClass(DashboardReporter);
+}
+dashboardReporterFactory.inject = tokens(commonTokens.injector);

package/src/reporters/dashboard-reporter/report.ts

@@ -0,0 +1,6 @@
+import { schema } from '@stryker-mutator/api/core';
+
+export interface MutationScoreOnlyReport {
+  mutationScore: number;
+}
+export type Report = MutationScoreOnlyReport | schema.MutationTestResult;

package/src/reporters/dashboard-reporter/tokens.ts

@@ -0,0 +1,5 @@
+export const dashboardReporterTokens = Object.freeze({
+  ciProvider: 'ciProvider',
+  dashboardReporterClient: 'dashboardReporterClient',
+  httpClient: 'httpClient',
+} as const);

package/src/reporters/dots-reporter.ts

@@ -0,0 +1,33 @@
+import os from 'os';
+
+import chalk from 'chalk';
+import { Reporter } from '@stryker-mutator/api/report';
+import type { MutantResult } from '@stryker-mutator/api/core';
+
+export class DotsReporter implements Reporter {
+  public onMutantTested(result: MutantResult): void {
+    let toLog: string;
+    switch (result.status) {
+      case 'Killed':
+        toLog = '.';
+        break;
+      case 'Timeout':
+        toLog = chalk.yellow('T');
+        break;
+      case 'Survived':
+        toLog = chalk.bold.red('S');
+        break;
+      case 'RuntimeError':
+        toLog = chalk.yellow('E');
+        break;
+      default:
+        toLog = '';
+        break;
+    }
+    process.stdout.write(toLog);
+  }
+
+  public onMutationTestReportReady(): void {
+    process.stdout.write(os.EOL);
+  }
+}

package/src/reporters/event-recorder-reporter.ts

@@ -0,0 +1,88 @@
+import path from 'path';
+import { promises as fsPromises } from 'fs';
+
+import {
+  MutantResult,
+  schema,
+  StrykerOptions,
+} from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import {
+  DryRunCompletedEvent,
+  MutationTestingPlanReadyEvent,
+  Reporter,
+} from '@stryker-mutator/api/report';
+
+import { fileUtils } from '../utils/file-utils.js';
+
+import { StrictReporter } from './strict-reporter.js';
+
+export class EventRecorderReporter implements StrictReporter {
+  public static readonly inject = tokens(
+    commonTokens.logger,
+    commonTokens.options,
+  );
+
+  private readonly allWork: Array<Promise<void>> = [];
+  private readonly createBaseFolderTask: Promise<string | undefined>;
+  private index = 0;
+
+  constructor(
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+  ) {
+    this.createBaseFolderTask = fileUtils.cleanDir(
+      this.options.eventReporter.baseDir,
+    );
+  }
+
+  private writeToFile(methodName: keyof Reporter, data: any) {
+    const filename = path.join(
+      this.options.eventReporter.baseDir,
+      `${this.format(this.index++)}-${methodName}.json`,
+    );
+    this.log.debug(`Writing event ${methodName} to file ${filename}`);
+    return fsPromises.writeFile(filename, JSON.stringify(data), {
+      encoding: 'utf8',
+    });
+  }
+
+  private format(input: number) {
+    let str = input.toString();
+    for (let i = 10000; i > 1; i = i / 10) {
+      if (i > input) {
+        str = '0' + str;
+      }
+    }
+    return str;
+  }
+
+  private work(eventName: keyof Reporter, data: any) {
+    this.allWork.push(
+      this.createBaseFolderTask.then(() => this.writeToFile(eventName, data)),
+    );
+  }
+
+  public onDryRunCompleted(event: DryRunCompletedEvent): void {
+    this.work('onDryRunCompleted', event);
+  }
+  public onMutationTestingPlanReady(
+    event: MutationTestingPlanReadyEvent,
+  ): void {
+    this.work('onMutationTestingPlanReady', event);
+  }
+
+  public onMutantTested(result: MutantResult): void {
+    this.work('onMutantTested', result);
+  }
+
+  public onMutationTestReportReady(report: schema.MutationTestResult): void {
+    this.work('onMutationTestReportReady', report);
+  }
+
+  public async wrapUp(): Promise<void> {
+    await this.createBaseFolderTask;
+    await Promise.all(this.allWork);
+  }
+}