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

package/src/reporters/progress-append-only-reporter.ts

@@ -0,0 +1,36 @@
+import os from 'os';
+
+import { MutationTestingPlanReadyEvent } from '@stryker-mutator/api/report';
+
+import { ProgressKeeper } from './progress-keeper.js';
+
+export class ProgressAppendOnlyReporter extends ProgressKeeper {
+  private intervalReference?: NodeJS.Timeout;
+
+  public onMutationTestingPlanReady(
+    event: MutationTestingPlanReadyEvent,
+  ): void {
+    super.onMutationTestingPlanReady(event);
+    if (event.mutantPlans.length) {
+      this.intervalReference = setInterval(() => this.render(), 10000);
+    }
+  }
+
+  public onMutationTestReportReady(): void {
+    if (this.intervalReference) {
+      clearInterval(this.intervalReference);
+    }
+  }
+
+  private render() {
+    process.stdout.write(
+      `Mutation testing ${this.getPercentDone()} (elapsed: ${this.getElapsedTime()}, remaining: ${this.getEtc()}) ` +
+        `${this.progress.tested}/${this.progress.mutants} tested (${this.progress.survived} survived, ${this.progress.timedOut} timed out)` +
+        os.EOL,
+    );
+  }
+
+  private getPercentDone() {
+    return `${Math.floor((this.progress.ticks / this.progress.total) * 100)}%`;
+  }
+}

package/src/reporters/progress-bar.ts

@@ -0,0 +1,6 @@
+import ProgressBar from 'progress';
+
+/**
+ * Wrapper around the progress bar for unit testing purposes
+ */
+export const progressBarWrapper = { ProgressBar };

package/src/reporters/progress-keeper.ts

@@ -0,0 +1,113 @@
+import {
+  MutantResult,
+  MutantRunPlan,
+  MutantTestPlan,
+  PlanKind,
+} from '@stryker-mutator/api/core';
+import {
+  DryRunCompletedEvent,
+  MutationTestingPlanReadyEvent,
+  Reporter,
+  RunTiming,
+} from '@stryker-mutator/api/report';
+import { TestRunnerCapabilities } from '@stryker-mutator/api/test-runner';
+
+import { Timer } from '../utils/timer.js';
+
+export abstract class ProgressKeeper implements Reporter {
+  private timer!: Timer;
+  private timing!: RunTiming;
+  private capabilities!: TestRunnerCapabilities;
+  private ticksByMutantId!: Map<string, number>;
+  protected progress = {
+    survived: 0,
+    timedOut: 0,
+    tested: 0,
+    mutants: 0,
+    total: 0,
+    ticks: 0,
+  };
+
+  public onDryRunCompleted({
+    timing,
+    capabilities,
+  }: DryRunCompletedEvent): void {
+    this.timing = timing;
+    this.capabilities = capabilities;
+  }
+
+  /**
+   * An event emitted when the mutant test plan is calculated.
+   * @param event The mutant test plan ready event
+   */
+  public onMutationTestingPlanReady({
+    mutantPlans,
+  }: MutationTestingPlanReadyEvent): void {
+    this.timer = new Timer();
+    this.ticksByMutantId = new Map(
+      mutantPlans.filter(isRunPlan).map(({ netTime, mutant, runOptions }) => {
+        let ticks = netTime;
+        if (
+          !this.capabilities.reloadEnvironment &&
+          runOptions.reloadEnvironment
+        ) {
+          ticks += this.timing.overhead;
+        }
+        return [mutant.id, ticks];
+      }),
+    );
+    this.progress.mutants = this.ticksByMutantId.size;
+    this.progress.total = [...this.ticksByMutantId.values()].reduce(
+      (acc, n) => acc + n,
+      0,
+    );
+  }
+
+  public onMutantTested(result: MutantResult): number {
+    const ticks = this.ticksByMutantId.get(result.id);
+    if (ticks !== undefined) {
+      this.progress.tested++;
+      this.progress.ticks += this.ticksByMutantId.get(result.id) ?? 0;
+      if (result.status === 'Survived') {
+        this.progress.survived++;
+      }
+      if (result.status === 'Timeout') {
+        this.progress.timedOut++;
+      }
+    }
+    return ticks ?? 0;
+  }
+
+  protected getElapsedTime(): string {
+    return this.formatTime(this.timer.elapsedSeconds());
+  }
+
+  protected getEtc(): string {
+    const totalSecondsLeft = Math.floor(
+      (this.timer.elapsedSeconds() / this.progress.ticks) *
+        (this.progress.total - this.progress.ticks),
+    );
+
+    if (isFinite(totalSecondsLeft) && totalSecondsLeft > 0) {
+      return this.formatTime(totalSecondsLeft);
+    } else {
+      return 'n/a';
+    }
+  }
+
+  private formatTime(timeInSeconds: number) {
+    const hours = Math.floor(timeInSeconds / 3600);
+
+    const minutes = Math.floor((timeInSeconds % 3600) / 60);
+
+    return hours > 0 // conditional time formatting
+      ? `~${hours}h ${minutes}m`
+      : minutes > 0
+        ? `~${minutes}m`
+        : '<1m';
+  }
+}
+
+function isRunPlan(mutantPlan: MutantTestPlan): mutantPlan is MutantRunPlan {
+  return mutantPlan.plan === PlanKind.Run;
+}

package/src/reporters/progress-reporter.ts

@@ -0,0 +1,62 @@
+import { MutantResult } from '@stryker-mutator/api/core';
+import { MutationTestingPlanReadyEvent } from '@stryker-mutator/api/report';
+
+import { progressBarWrapper } from './progress-bar.js';
+import { ProgressKeeper } from './progress-keeper.js';
+
+export class ProgressBarReporter extends ProgressKeeper {
+  private progressBar?: ProgressBar;
+
+  public onMutationTestingPlanReady(
+    event: MutationTestingPlanReadyEvent,
+  ): void {
+    super.onMutationTestingPlanReady(event);
+    const progressBarContent =
+      'Mutation testing  [:bar] :percent (elapsed: :et, remaining: :etc) :tested/:mutants Mutants tested (:survived survived, :timedOut timed out)';
+
+    this.progressBar = new progressBarWrapper.ProgressBar(progressBarContent, {
+      complete: '=',
+      incomplete: ' ',
+      stream: process.stdout,
+      total: this.progress.total,
+      width: 50,
+    });
+  }
+
+  public onMutantTested(result: MutantResult): number {
+    const ticks = super.onMutantTested(result);
+
+    const progressBarContent = {
+      ...this.progress,
+      et: this.getElapsedTime(),
+      etc: this.getEtc(),
+    };
+    if (ticks) {
+      this.tick(ticks, progressBarContent);
+    } else {
+      this.render(progressBarContent);
+    }
+    return ticks;
+  }
+
+  private tick(ticks: number, tickObj: ProgressState): void {
+    this.progressBar?.tick(ticks, tickObj);
+  }
+
+  private render(renderObj: ProgressState): void {
+    if (this.progressBar?.total) {
+      this.progressBar.render(renderObj);
+    }
+  }
+}
+
+interface ProgressState {
+  et: string;
+  etc: string;
+  survived: number;
+  timedOut: number;
+  tested: number;
+  mutants: number;
+  total: number;
+  ticks: number;
+}

package/src/reporters/reporter-util.ts

@@ -0,0 +1,20 @@
+import path from 'path';
+import { createReadStream, createWriteStream, promises as fs } from 'fs';
+
+export const reporterUtil = {
+  copyFile(fromFilename: string, toFilename: string): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const readStream = createReadStream(fromFilename);
+      const writeStream = createWriteStream(toFilename);
+      readStream.on('error', reject);
+      writeStream.on('error', reject);
+      readStream.pipe(writeStream);
+      readStream.on('end', resolve);
+    });
+  },
+
+  async writeFile(fileName: string, content: string): Promise<void> {
+    await fs.mkdir(path.dirname(fileName), { recursive: true });
+    await fs.writeFile(fileName, content, 'utf8');
+  },
+};

package/src/reporters/strict-reporter.ts

@@ -0,0 +1,3 @@
+import { Reporter } from '@stryker-mutator/api/report';
+
+export type StrictReporter = Required<Reporter>;

package/src/sandbox/create-preprocessor.ts

@@ -0,0 +1,27 @@
+import {
+  tokens,
+  Injector,
+  commonTokens,
+  PluginContext,
+} from '@stryker-mutator/api/plugin';
+
+import { disableTypeChecks } from '@stryker-mutator/instrumenter';
+
+import { coreTokens } from '../di/index.js';
+
+import { TSConfigPreprocessor } from './ts-config-preprocessor.js';
+import { FilePreprocessor } from './file-preprocessor.js';
+import { MultiPreprocessor } from './multi-preprocessor.js';
+import { DisableTypeChecksPreprocessor } from './disable-type-checks-preprocessor.js';
+
+createPreprocessor.inject = tokens(commonTokens.injector);
+export function createPreprocessor(
+  injector: Injector<PluginContext>,
+): FilePreprocessor {
+  return new MultiPreprocessor([
+    injector
+      .provideValue(coreTokens.disableTypeChecksHelper, disableTypeChecks)
+      .injectClass(DisableTypeChecksPreprocessor),
+    injector.injectClass(TSConfigPreprocessor),
+  ]);
+}

package/src/sandbox/disable-type-checks-preprocessor.ts

@@ -0,0 +1,70 @@
+import path from 'path';
+
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { StrykerOptions } from '@stryker-mutator/api/core';
+import type { disableTypeChecks } from '@stryker-mutator/instrumenter';
+import { Logger } from '@stryker-mutator/api/logging';
+
+import { optionsPath } from '../utils/index.js';
+import { coreTokens } from '../di/index.js';
+import { objectUtils } from '../utils/object-utils.js';
+import { FileMatcher } from '../config/index.js';
+
+import { Project } from '../fs/project.js';
+
+import { FilePreprocessor } from './file-preprocessor.js';
+
+/**
+ * Disabled type checking by inserting `@ts-nocheck` atop TS/JS files and removing other @ts-xxx directives from comments:
+ * @see https://github.com/stryker-mutator/stryker-js/issues/2438
+ */
+export class DisableTypeChecksPreprocessor implements FilePreprocessor {
+  public static readonly inject = tokens(
+    commonTokens.logger,
+    commonTokens.options,
+    coreTokens.disableTypeChecksHelper,
+  );
+  constructor(
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+    private readonly impl: typeof disableTypeChecks,
+  ) {}
+
+  public async preprocess(project: Project): Promise<void> {
+    const matcher = new FileMatcher(this.options.disableTypeChecks);
+    let warningLogged = false;
+    await Promise.all(
+      objectUtils.map(project.files, async (file, name) => {
+        if (matcher.matches(path.resolve(name))) {
+          try {
+            const { content } = await this.impl(
+              await file.toInstrumenterFile(),
+              { plugins: this.options.mutator.plugins },
+            );
+            file.setContent(content);
+          } catch (err) {
+            if (
+              objectUtils.isWarningEnabled(
+                'preprocessorErrors',
+                this.options.warnings,
+              )
+            ) {
+              warningLogged = true;
+              this.log.warn(
+                `Unable to disable type checking for file "${name}". Shouldn't type checking be disabled for this file? Consider configuring a more restrictive "${optionsPath(
+                  'disableTypeChecks',
+                )}" settings (or turn it completely off with \`false\`)`,
+                err,
+              );
+            }
+          }
+        }
+      }),
+    );
+    if (warningLogged) {
+      this.log.warn(
+        `(disable "${optionsPath('warnings', 'preprocessorErrors')}" to ignore this warning`,
+      );
+    }
+  }
+}

package/src/sandbox/file-preprocessor.ts

@@ -0,0 +1,10 @@
+import { Project } from '../fs/project.js';
+
+/**
+ * A preprocessor changes files before writing them to the sandbox.
+ * Stuff like rewriting references tsconfig.json files or adding // @ts-nocheck
+ * This is a private api that we might want to open up in the future.
+ */
+export interface FilePreprocessor {
+  preprocess(files: Project): Promise<void>;
+}

package/src/sandbox/index.ts

@@ -0,0 +1,3 @@
+export type { FilePreprocessor } from './file-preprocessor.js';
+export * from './sandbox.js';
+export * from './create-preprocessor.js';

package/src/sandbox/multi-preprocessor.ts

@@ -0,0 +1,13 @@
+import { Project } from '../fs/project.js';
+
+import { FilePreprocessor } from './file-preprocessor.js';
+
+export class MultiPreprocessor implements FilePreprocessor {
+  constructor(private readonly preprocessors: FilePreprocessor[]) {}
+
+  public async preprocess(project: Project): Promise<void> {
+    for (const preprocessor of this.preprocessors) {
+      await preprocessor.preprocess(project);
+    }
+  }
+}

package/src/sandbox/sandbox.ts

@@ -0,0 +1,198 @@
+import path from 'path';
+
+import type { execaCommand } from 'execa';
+import { npmRunPathEnv } from 'npm-run-path';
+import { StrykerOptions } from '@stryker-mutator/api/core';
+import {
+  normalizeWhitespaces,
+  I,
+  isErrnoException,
+} from '@stryker-mutator/util';
+import { Logger } from '@stryker-mutator/api/logging';
+import { tokens, commonTokens, Disposable } from '@stryker-mutator/api/plugin';
+
+import { TemporaryDirectory } from '../utils/temporary-directory.js';
+import { fileUtils } from '../utils/file-utils.js';
+import { coreTokens } from '../di/index.js';
+import { UnexpectedExitHandler } from '../unexpected-exit-handler.js';
+import { ProjectFile } from '../fs/index.js';
+import { Project } from '../fs/project.js';
+import { objectUtils } from '../utils/index.js';
+
+export class Sandbox implements Disposable {
+  private readonly fileMap = new Map<string, string>();
+
+  /**
+   * The working directory for this sandbox
+   * Either an actual sandbox directory, or the cwd when running in --inPlace mode
+   */
+  public readonly workingDirectory: string;
+  /**11
+   * The backup directory when running in --inPlace mode
+   */
+  private readonly backupDirectory: string = '';
+
+  public static readonly inject = tokens(
+    commonTokens.options,
+    commonTokens.logger,
+    coreTokens.temporaryDirectory,
+    coreTokens.project,
+    coreTokens.execa,
+    coreTokens.unexpectedExitRegistry,
+  );
+
+  /**
+   * @param temporaryDirectory The sandbox dir or the backup dir when running in `--inPlace` mode
+   */
+  constructor(
+    private readonly options: StrykerOptions,
+    private readonly log: Logger,
+    temporaryDirectory: I<TemporaryDirectory>,
+    private readonly project: Project,
+    private readonly execCommand: typeof execaCommand,
+    unexpectedExitHandler: I<UnexpectedExitHandler>,
+  ) {
+    if (options.inPlace) {
+      this.workingDirectory = process.cwd();
+      this.backupDirectory = temporaryDirectory.path;
+      this.log.info(
+        'In place mode is enabled, Stryker will be overriding YOUR files. Find your backup at: %s',
+        path.relative(process.cwd(), this.backupDirectory),
+      );
+      unexpectedExitHandler.registerHandler(
+        this.dispose.bind(this, /* unexpected */ true),
+      );
+    } else {
+      this.workingDirectory = temporaryDirectory.path;
+      this.log.debug(
+        'Creating a sandbox for files in %s',
+        this.workingDirectory,
+      );
+    }
+  }
+
+  public async init(): Promise<void> {
+    await this.fillSandbox();
+    await this.runBuildCommand();
+    await this.symlinkNodeModulesIfNeeded();
+  }
+
+  public sandboxFileFor(fileName: string): string {
+    const sandboxFileName = this.fileMap.get(fileName);
+    if (sandboxFileName === undefined) {
+      throw new Error(`Cannot find sandbox file for ${fileName}`);
+    }
+    return sandboxFileName;
+  }
+
+  public originalFileFor(sandboxFileName: string): string {
+    return path
+      .resolve(sandboxFileName)
+      .replace(path.resolve(this.workingDirectory), process.cwd());
+  }
+
+  private async fillSandbox(): Promise<void> {
+    await Promise.all(
+      objectUtils.map(this.project.files, (file, name) =>
+        this.sandboxFile(name, file),
+      ),
+    );
+  }
+
+  private async runBuildCommand() {
+    if (this.options.buildCommand) {
+      const env = npmRunPathEnv();
+      this.log.info(
+        'Running build command "%s" in "%s".',
+        this.options.buildCommand,
+        this.workingDirectory,
+      );
+      this.log.debug('(using PATH: %s)', env.PATH);
+      await this.execCommand(this.options.buildCommand, {
+        cwd: this.workingDirectory,
+        env,
+      });
+    }
+  }
+
+  private async symlinkNodeModulesIfNeeded(): Promise<void> {
+    this.log.debug('Start symlink node_modules');
+    if (this.options.symlinkNodeModules && !this.options.inPlace) {
+      // TODO: Change with this.options.basePath when we have it
+      const basePath = process.cwd();
+      const nodeModulesList = await fileUtils.findNodeModulesList(
+        basePath,
+        this.options.tempDirName,
+      );
+
+      if (nodeModulesList.length > 0) {
+        for (const nodeModules of nodeModulesList) {
+          this.log.debug(
+            `Create symlink from ${path.resolve(nodeModules)} to ${path.join(this.workingDirectory, nodeModules)}`,
+          );
+          await fileUtils
+            .symlinkJunction(
+              path.resolve(nodeModules),
+              path.join(this.workingDirectory, nodeModules),
+            )
+            .catch((error: unknown) => {
+              if (isErrnoException(error) && error.code === 'EEXIST') {
+                this.log.warn(
+                  normalizeWhitespaces(`Could not symlink "${nodeModules}" in sandbox directory,
+              it is already created in the sandbox. Please remove the node_modules from your sandbox files.
+              Alternatively, set \`symlinkNodeModules\` to \`false\` to disable this warning.`),
+                );
+              } else {
+                this.log.warn(
+                  `Unexpected error while trying to symlink "${nodeModules}" in sandbox directory.`,
+                  error,
+                );
+              }
+            });
+        }
+      } else {
+        this.log.debug(
+          `Could not find a node_modules folder to symlink into the sandbox directory. Search "${basePath}" and its parent directories`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Sandboxes a file (writes it to the sandbox). Either in-place, or an actual sandbox directory.
+   * @param name The name of the file
+   * @param file The file reference
+   */
+  private async sandboxFile(name: string, file: ProjectFile): Promise<void> {
+    if (this.options.inPlace) {
+      if (file.hasChanges) {
+        // File is changed (either mutated or by a preprocessor), make a backup and replace in-place
+        const backupFileName = await file.backupTo(this.backupDirectory);
+        this.log.debug('Stored backup file at %s', backupFileName);
+        await file.writeInPlace();
+      }
+      this.fileMap.set(name, name);
+    } else {
+      const targetFileName = await file.writeToSandbox(this.workingDirectory);
+      this.fileMap.set(name, targetFileName);
+    }
+  }
+
+  public dispose(unexpected = false): void {
+    if (this.backupDirectory) {
+      if (unexpected) {
+        console.error(
+          `Detecting unexpected exit, recovering original files from ${path.relative(process.cwd(), this.backupDirectory)}`,
+        );
+      } else {
+        this.log.info(
+          `Resetting your original files from ${path.relative(process.cwd(), this.backupDirectory)}.`,
+        );
+      }
+      fileUtils.moveDirectoryRecursiveSync(
+        this.backupDirectory,
+        this.workingDirectory,
+      );
+    }
+  }
+}