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

package/src/test-runner/command-test-runner.ts

@@ -0,0 +1,190 @@
+import { exec } from 'child_process';
+import os from 'os';
+
+import {
+  StrykerOptions,
+  CommandRunnerOptions,
+  INSTRUMENTER_CONSTANTS,
+} from '@stryker-mutator/api/core';
+import {
+  TestRunner,
+  TestStatus,
+  MutantRunOptions,
+  DryRunResult,
+  MutantRunResult,
+  DryRunStatus,
+  ErrorDryRunResult,
+  CompleteDryRunResult,
+  toMutantRunResult,
+  TestRunnerCapabilities,
+  DryRunOptions,
+} from '@stryker-mutator/api/test-runner';
+import { errorToString, testFilesProvided } from '@stryker-mutator/util';
+
+import { objectUtils } from '../utils/object-utils.js';
+import { Timer } from '../utils/timer.js';
+
+/**
+ * A test runner that uses a (bash or cmd) command to execute the tests.
+ * Does not know hom many tests are executed or any code coverage results,
+ * instead, it mimics a simple test result based on the exit code.
+ * The command can be configured, but defaults to `npm test`.
+ */
+export class CommandTestRunner implements TestRunner {
+  /**
+   * "command"
+   */
+  public static readonly runnerName = CommandTestRunner.name
+    .replace('TestRunner', '')
+    .toLowerCase();
+
+  /**
+   * Determines whether a given name is "command" (ignore case)
+   * @param name Maybe "command", maybe not
+   */
+  public static is(name: string): name is 'command' {
+    return this.runnerName === name.toLowerCase();
+  }
+
+  private readonly settings: CommandRunnerOptions;
+  private readonly testFilesProvided: boolean;
+
+  private timeoutHandler: (() => Promise<void>) | undefined;
+
+  constructor(
+    private readonly workingDir: string,
+    options: StrykerOptions,
+  ) {
+    this.settings = options.commandRunner;
+    this.testFilesProvided = testFilesProvided(options);
+  }
+
+  public capabilities(): TestRunnerCapabilities {
+    // Can reload, because each call is a new process.
+    return { reloadEnvironment: true };
+  }
+
+  public async init(): Promise<void> {
+    if (this.testFilesProvided) {
+      throw new Error(
+        `The ${CommandTestRunner.runnerName} test runner does not support the --testFiles option.`,
+      );
+    }
+    return Promise.resolve();
+  }
+
+  public async dryRun(_options: DryRunOptions): Promise<DryRunResult> {
+    return this.run({});
+  }
+
+  public async mutantRun({
+    activeMutant,
+  }: Pick<MutantRunOptions, 'activeMutant'>): Promise<MutantRunResult> {
+    const result = await this.run({ activeMutantId: activeMutant.id });
+    return toMutantRunResult(result);
+  }
+
+  private run({
+    activeMutantId,
+  }: {
+    activeMutantId?: string;
+  }): Promise<DryRunResult> {
+    const timerInstance = new Timer();
+    return new Promise((res, rej) => {
+      const output: Array<Buffer | string> = [];
+      const env =
+        activeMutantId === undefined
+          ? process.env
+          : {
+              ...process.env,
+              [INSTRUMENTER_CONSTANTS.ACTIVE_MUTANT_ENV_VARIABLE]:
+                activeMutantId,
+            };
+      const childProcess = exec(this.settings.command, {
+        cwd: this.workingDir,
+        env,
+      });
+      childProcess.on('error', (error) => {
+        objectUtils
+          .kill(childProcess.pid)
+          .then(() => handleResolve(errorResult(error)))
+
+          .catch(rej);
+      });
+      childProcess.on('exit', (code) => {
+        const result = completeResult(code, timerInstance);
+        handleResolve(result);
+      });
+      childProcess.stdout!.on('data', (chunk) => {
+        output.push(chunk as Buffer);
+      });
+      childProcess.stderr!.on('data', (chunk) => {
+        output.push(chunk as Buffer);
+      });
+
+      this.timeoutHandler = async () => {
+        handleResolve({ status: DryRunStatus.Timeout });
+        await objectUtils.kill(childProcess.pid);
+      };
+
+      const handleResolve = (runResult: DryRunResult) => {
+        removeAllListeners();
+        this.timeoutHandler = undefined;
+        res(runResult);
+      };
+
+      function removeAllListeners() {
+        childProcess.stderr!.removeAllListeners();
+        childProcess.stdout!.removeAllListeners();
+        childProcess.removeAllListeners();
+      }
+
+      function errorResult(error: Error): ErrorDryRunResult {
+        return {
+          errorMessage: errorToString(error),
+          status: DryRunStatus.Error,
+        };
+      }
+
+      function completeResult(
+        exitCode: number | null,
+        timer: Timer,
+      ): CompleteDryRunResult {
+        const duration = timer.elapsedMs();
+        if (exitCode === 0) {
+          return {
+            status: DryRunStatus.Complete,
+            tests: [
+              {
+                id: 'all',
+                name: 'All tests',
+                status: TestStatus.Success,
+                timeSpentMs: duration,
+              },
+            ],
+          };
+        } else {
+          return {
+            status: DryRunStatus.Complete,
+            tests: [
+              {
+                id: 'all',
+                failureMessage: output
+                  .map((buf) => buf.toString())
+                  .join(os.EOL),
+                name: 'All tests',
+                status: TestStatus.Failed,
+                timeSpentMs: duration,
+              },
+            ],
+          };
+        }
+      }
+    });
+  }
+  public async dispose(): Promise<void> {
+    if (this.timeoutHandler) {
+      await this.timeoutHandler();
+    }
+  }
+}

package/src/test-runner/index.ts

@@ -0,0 +1,74 @@
+import { TestRunner } from '@stryker-mutator/api/test-runner';
+import { FileDescriptions, StrykerOptions } from '@stryker-mutator/api/core';
+import { tokens, commonTokens } from '@stryker-mutator/api/plugin';
+import { LoggerFactoryMethod } from '@stryker-mutator/api/logging';
+
+import { LoggingServerAddress } from '../logging/index.js';
+import { coreTokens } from '../di/index.js';
+import { Sandbox } from '../sandbox/sandbox.js';
+
+import { IdGenerator } from '../child-proxy/id-generator.js';
+
+import { RetryRejectedDecorator } from './retry-rejected-decorator.js';
+import { TimeoutDecorator } from './timeout-decorator.js';
+import { ChildProcessTestRunnerProxy } from './child-process-test-runner-proxy.js';
+import { CommandTestRunner } from './command-test-runner.js';
+import { MaxTestRunnerReuseDecorator } from './max-test-runner-reuse-decorator.js';
+import { ReloadEnvironmentDecorator } from './reload-environment-decorator.js';
+
+createTestRunnerFactory.inject = tokens(
+  commonTokens.options,
+  commonTokens.fileDescriptions,
+  coreTokens.sandbox,
+  coreTokens.loggingServerAddress,
+  commonTokens.getLogger,
+  coreTokens.pluginModulePaths,
+  coreTokens.workerIdGenerator,
+);
+export function createTestRunnerFactory(
+  options: StrykerOptions,
+  fileDescriptions: FileDescriptions,
+  sandbox: Pick<Sandbox, 'workingDirectory'>,
+  loggingServerAddress: LoggingServerAddress,
+  getLogger: LoggerFactoryMethod,
+  pluginModulePaths: readonly string[],
+  idGenerator: IdGenerator,
+): () => TestRunner {
+  if (CommandTestRunner.is(options.testRunner)) {
+    return () =>
+      new RetryRejectedDecorator(
+        getLogger(RetryRejectedDecorator.name),
+        () =>
+          new TimeoutDecorator(
+            getLogger(TimeoutDecorator.name),
+            () => new CommandTestRunner(sandbox.workingDirectory, options),
+          ),
+      );
+  } else {
+    return () =>
+      new RetryRejectedDecorator(
+        getLogger(RetryRejectedDecorator.name),
+        () =>
+          new ReloadEnvironmentDecorator(
+            () =>
+              new MaxTestRunnerReuseDecorator(
+                () =>
+                  new TimeoutDecorator(
+                    getLogger(TimeoutDecorator.name),
+                    () =>
+                      new ChildProcessTestRunnerProxy(
+                        options,
+                        fileDescriptions,
+                        sandbox.workingDirectory,
+                        loggingServerAddress,
+                        pluginModulePaths,
+                        getLogger,
+                        idGenerator,
+                      ),
+                  ),
+                options,
+              ),
+          ),
+      );
+  }
+}

package/src/test-runner/max-test-runner-reuse-decorator.ts

@@ -0,0 +1,41 @@
+import {
+  MutantRunOptions,
+  MutantRunResult,
+  TestRunner,
+} from '@stryker-mutator/api/test-runner';
+
+import { StrykerOptions } from '@stryker-mutator/api/core';
+
+import { TestRunnerDecorator } from './test-runner-decorator.js';
+
+/**
+ * Wraps a test runner and implements the retry functionality.
+ */
+export class MaxTestRunnerReuseDecorator extends TestRunnerDecorator {
+  public runs = 0;
+  private readonly restartAfter;
+
+  constructor(
+    testRunnerProducer: () => TestRunner,
+    options: Pick<StrykerOptions, 'maxTestRunnerReuse'>,
+  ) {
+    super(testRunnerProducer);
+
+    this.restartAfter = options.maxTestRunnerReuse || 0;
+  }
+
+  public async mutantRun(options: MutantRunOptions): Promise<MutantRunResult> {
+    this.runs++;
+    if (this.restartAfter > 0 && this.runs > this.restartAfter) {
+      await this.recover();
+      this.runs = 1;
+    }
+
+    return super.mutantRun(options);
+  }
+
+  public dispose(): Promise<any> {
+    this.runs = 0;
+    return super.dispose();
+  }
+}

package/src/test-runner/reload-environment-decorator.ts

@@ -0,0 +1,72 @@
+import {
+  DryRunOptions,
+  DryRunResult,
+  MutantRunOptions,
+  MutantRunResult,
+  TestRunnerCapabilities,
+} from '@stryker-mutator/api/test-runner';
+
+import { TestRunnerDecorator } from './test-runner-decorator.js';
+
+enum TestEnvironmentState {
+  Pristine,
+  Loaded,
+  LoadedStaticMutant,
+}
+
+export class ReloadEnvironmentDecorator extends TestRunnerDecorator {
+  private _capabilities?: TestRunnerCapabilities;
+  private testEnvironment = TestEnvironmentState.Pristine;
+
+  public override async capabilities(): Promise<TestRunnerCapabilities> {
+    if (!this._capabilities) {
+      this._capabilities = await super.capabilities();
+    }
+    return this._capabilities;
+  }
+
+  public override async dryRun(options: DryRunOptions): Promise<DryRunResult> {
+    this.testEnvironment = TestEnvironmentState.Loaded;
+    return super.dryRun(options);
+  }
+
+  public override async mutantRun(
+    options: MutantRunOptions,
+  ): Promise<MutantRunResult> {
+    let newState: TestEnvironmentState;
+    if (options.reloadEnvironment) {
+      newState = TestEnvironmentState.LoadedStaticMutant;
+
+      // If env is still pristine (first run), no reload is actually needed
+      options.reloadEnvironment =
+        this.testEnvironment !== TestEnvironmentState.Pristine;
+
+      if (
+        options.reloadEnvironment &&
+        !(await this.testRunnerIsCapableOfReload())
+      ) {
+        await this.recover();
+        options.reloadEnvironment = false;
+      }
+    } else {
+      // Reload might still be needed actually, since a static mutant could be loaded
+      newState = TestEnvironmentState.Loaded;
+      if (this.testEnvironment === TestEnvironmentState.LoadedStaticMutant) {
+        // Test env needs reloading
+        if (await this.testRunnerIsCapableOfReload()) {
+          options.reloadEnvironment = true;
+        } else {
+          // loaded a static mutant in previous run, need to reload first
+          await this.recover();
+        }
+      }
+    }
+    const result = await super.mutantRun(options);
+    this.testEnvironment = newState;
+    return result;
+  }
+
+  private async testRunnerIsCapableOfReload() {
+    return (await this.capabilities()).reloadEnvironment;
+  }
+}

package/src/test-runner/retry-rejected-decorator.ts

@@ -0,0 +1,79 @@
+import {
+  DryRunStatus,
+  DryRunResult,
+  DryRunOptions,
+  MutantRunResult,
+  MutantRunOptions,
+  MutantRunStatus,
+  TestRunner,
+} from '@stryker-mutator/api/test-runner';
+import { errorToString } from '@stryker-mutator/util';
+
+import { OutOfMemoryError } from '../child-proxy/out-of-memory-error.js';
+
+import { TestRunnerDecorator } from './test-runner-decorator.js';
+import { Logger } from '@stryker-mutator/api/logging';
+
+const ERROR_MESSAGE =
+  'Test runner crashed. Tried twice to restart it without any luck. Last time the error message was: ';
+export const MAX_RETRIES = 2;
+
+/**
+ * Implements the retry functionality whenever an internal test runner rejects a promise.
+ */
+export class RetryRejectedDecorator extends TestRunnerDecorator {
+  constructor(
+    readonly log: Logger,
+    producer: () => TestRunner,
+  ) {
+    super(producer);
+  }
+
+  public async dryRun(options: DryRunOptions): Promise<DryRunResult> {
+    const result = await this.run(() => super.dryRun(options));
+    if (typeof result === 'string') {
+      return {
+        status: DryRunStatus.Error,
+        errorMessage: result,
+      };
+    } else {
+      return result;
+    }
+  }
+
+  public async mutantRun(options: MutantRunOptions): Promise<MutantRunResult> {
+    const result = await this.run(() => super.mutantRun(options));
+    if (typeof result === 'string') {
+      return {
+        status: MutantRunStatus.Error,
+        errorMessage: result,
+      };
+    } else {
+      return result;
+    }
+  }
+
+  private async run<T extends DryRunResult | MutantRunResult>(
+    actRun: () => Promise<T>,
+    attemptsLeft = MAX_RETRIES,
+    lastError?: unknown,
+  ): Promise<T | string> {
+    if (attemptsLeft > 0) {
+      try {
+        return await actRun();
+      } catch (error) {
+        if (error instanceof OutOfMemoryError) {
+          this.log.info(
+            "Test runner process [%s] ran out of memory. You probably have a memory leak in your tests. Don't worry, Stryker will restart the process, but you might want to investigate this later, because this decreases performance.",
+            error.pid,
+          );
+        }
+        await this.recover();
+        return this.run(actRun, attemptsLeft - 1, error);
+      }
+    } else {
+      await this.recover();
+      return `${ERROR_MESSAGE}${errorToString(lastError)}`;
+    }
+  }
+}

package/src/test-runner/test-runner-decorator.ts

@@ -0,0 +1,22 @@
+import {
+  TestRunner,
+  DryRunOptions,
+  MutantRunOptions,
+  MutantRunResult,
+  DryRunResult,
+  TestRunnerCapabilities,
+} from '@stryker-mutator/api/test-runner';
+
+import { ResourceDecorator } from '../concurrent/index.js';
+
+export class TestRunnerDecorator extends ResourceDecorator<TestRunner> {
+  public async capabilities(): Promise<TestRunnerCapabilities> {
+    return this.innerResource.capabilities();
+  }
+  public dryRun(options: DryRunOptions): Promise<DryRunResult> {
+    return this.innerResource.dryRun(options);
+  }
+  public mutantRun(options: MutantRunOptions): Promise<MutantRunResult> {
+    return this.innerResource.mutantRun(options);
+  }
+}

package/src/test-runner/timeout-decorator.ts

@@ -0,0 +1,71 @@
+import {
+  DryRunStatus,
+  DryRunResult,
+  DryRunOptions,
+  MutantRunOptions,
+  MutantRunResult,
+  MutantRunStatus,
+  TestRunner,
+} from '@stryker-mutator/api/test-runner';
+import { ExpirableTask } from '@stryker-mutator/util';
+
+import { TestRunnerDecorator } from './test-runner-decorator.js';
+import { Logger } from '@stryker-mutator/api/logging';
+
+/**
+ * Wraps a test runner and implements the timeout functionality.
+ */
+export class TimeoutDecorator extends TestRunnerDecorator {
+  constructor(
+    private readonly log: Logger,
+    producer: () => TestRunner,
+  ) {
+    super(producer);
+  }
+
+  public async dryRun(options: DryRunOptions): Promise<DryRunResult> {
+    const result = await this.run(options, () => super.dryRun(options));
+    if (result === ExpirableTask.TimeoutExpired) {
+      return {
+        status: DryRunStatus.Timeout,
+      };
+    } else {
+      return result;
+    }
+  }
+
+  public async mutantRun(options: MutantRunOptions): Promise<MutantRunResult> {
+    const result = await this.run(options, () => super.mutantRun(options));
+    if (result === ExpirableTask.TimeoutExpired) {
+      return {
+        status: MutantRunStatus.Timeout,
+      };
+    } else {
+      return result;
+    }
+  }
+
+  private async run<TResult>(
+    options: { timeout: number },
+    actRun: () => Promise<TResult>,
+  ): Promise<TResult | typeof ExpirableTask.TimeoutExpired> {
+    this.log.debug(
+      'Starting timeout timer (%s ms) for a test run',
+      options.timeout,
+    );
+    const result = await ExpirableTask.timeout(actRun(), options.timeout);
+    if (result === ExpirableTask.TimeoutExpired) {
+      await this.handleTimeout();
+      return result;
+    } else {
+      return result;
+    }
+  }
+
+  private async handleTimeout(): Promise<void> {
+    this.log.debug(
+      'Timeout expired, restarting the process and reporting timeout',
+    );
+    await this.recover();
+  }
+}

package/src/unexpected-exit-handler.ts

@@ -0,0 +1,36 @@
+import { Disposable } from '@stryker-mutator/api/plugin';
+
+import { coreTokens } from './di/index.js';
+
+export type ExitHandler = () => void;
+
+const signals = Object.freeze(['SIGABRT', 'SIGINT', 'SIGHUP', 'SIGTERM']);
+export class UnexpectedExitHandler implements Disposable {
+  private readonly unexpectedExitHandlers: ExitHandler[] = [];
+
+  public static readonly inject = [coreTokens.process] as const;
+  constructor(
+    private readonly process: Pick<NodeJS.Process, 'exit' | 'off' | 'on'>,
+  ) {
+    process.on('exit', this.handleExit);
+    signals.forEach((signal) => process.on(signal, this.processSignal));
+  }
+  private readonly processSignal = (_signal: string, signalNumber: number) => {
+    // Just call 'exit' with correct exitCode.
+    // See https://nodejs.org/api/process.html#process_signal_events, we should exit with 128 + signal number
+    this.process.exit(128 + signalNumber);
+  };
+
+  private readonly handleExit = () => {
+    this.unexpectedExitHandlers.forEach((handler) => handler());
+  };
+
+  public registerHandler(handler: ExitHandler): void {
+    this.unexpectedExitHandlers.push(handler);
+  }
+
+  public dispose(): void {
+    this.process.off('exit', this.handleExit);
+    signals.forEach((signal) => this.process.off(signal, this.processSignal));
+  }
+}

package/src/utils/file-utils.ts

@@ -0,0 +1,113 @@
+import path from 'path';
+import fs from 'fs';
+
+import { isErrnoException } from '@stryker-mutator/util';
+
+export const fileUtils = {
+  /**
+   * Cleans the dir by creating it.
+   */
+  async cleanDir(dirName: string): Promise<string | undefined> {
+    try {
+      await fs.promises.lstat(dirName);
+      await fs.promises.rm(dirName, { recursive: true, force: true });
+      return fs.promises.mkdir(dirName, { recursive: true });
+    } catch {
+      return fs.promises.mkdir(dirName, { recursive: true });
+    }
+  },
+
+  async exists(fileName: string): Promise<boolean> {
+    try {
+      await fs.promises.access(fileName);
+      return true;
+    } catch (err) {
+      if (isErrnoException(err) && err.code === 'ENOENT') {
+        return false;
+      } else {
+        // Oops, didn't mean to catch this one ⚾
+        throw err;
+      }
+    }
+  },
+
+  /**
+   * Wrapper around the 'import' expression (for testability)
+   */
+  importModule(moduleName: string): Promise<unknown> {
+    return import(moduleName);
+  },
+
+  /**
+   * Recursively walks the from directory and copy the content to the target directory synchronously
+   * @param from The source directory to move from
+   * @param to The target directory to move to
+   */
+  moveDirectoryRecursiveSync(from: string, to: string): void {
+    if (!fs.existsSync(from)) {
+      return;
+    }
+    if (!fs.existsSync(to)) {
+      fs.mkdirSync(to);
+    }
+    const files = fs.readdirSync(from);
+    for (const file of files) {
+      const fromFileName = path.join(from, file);
+      const toFileName = path.join(to, file);
+      const stats = fs.lstatSync(fromFileName);
+      if (stats.isFile()) {
+        fs.renameSync(fromFileName, toFileName);
+      } else {
+        this.moveDirectoryRecursiveSync(fromFileName, toFileName);
+      }
+    }
+    fs.rmdirSync(from);
+  },
+
+  /**
+   * Creates a symlink at `from` that points to `to`
+   * @param to The thing you want to point to
+   * @param from The thing you want to point from
+   */
+  async symlinkJunction(to: string, from: string): Promise<void> {
+    await fs.promises.mkdir(path.dirname(from), { recursive: true });
+    return fs.promises.symlink(to, from, 'junction');
+  },
+
+  /**
+   * Looks for the node_modules folder from basePath up to root.
+   * returns the first occurrence of the node_modules, or null of none could be found.
+   * @param basePath starting point
+   */
+  async findNodeModulesList(
+    basePath: string,
+    tempDirName?: string,
+  ): Promise<string[]> {
+    const nodeModulesList: string[] = [];
+    const dirBfsQueue: string[] = ['.'];
+
+    let dir: string | undefined;
+    while ((dir = dirBfsQueue.pop())) {
+      if (path.basename(dir) === tempDirName) {
+        continue;
+      }
+
+      if (path.basename(dir) === 'node_modules') {
+        nodeModulesList.push(dir);
+        continue;
+      }
+
+      const parentDir = dir;
+      const filesWithType = await fs.promises.readdir(
+        path.join(basePath, dir),
+        { withFileTypes: true },
+      );
+      const dirs = filesWithType
+        .filter((file) => file.isDirectory())
+        .map((childDir) => path.join(parentDir, childDir.name));
+      dirBfsQueue.push(...dirs);
+    }
+
+    return nodeModulesList;
+  },
+};