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

package/src/checker/checker-child-process-proxy.ts

@@ -0,0 +1,67 @@
+import { URL } from 'url';
+
+import {
+  FileDescriptions,
+  Mutant,
+  StrykerOptions,
+} from '@stryker-mutator/api/core';
+import { Disposable } from 'typed-inject';
+
+import { ChildProcessProxy } from '../child-proxy/child-process-proxy.js';
+import { Resource } from '../concurrent/pool.js';
+import { IdGenerator } from '../child-proxy/id-generator.js';
+
+import { CheckerWorker } from './checker-worker.js';
+import { CheckerResource } from './checker-resource.js';
+import { LoggingServerAddress } from '../logging/index.js';
+import { LoggerFactoryMethod } from '@stryker-mutator/api/logging';
+
+export class CheckerChildProcessProxy
+  implements CheckerResource, Disposable, Resource
+{
+  private readonly childProcess: ChildProcessProxy<CheckerWorker>;
+
+  constructor(
+    options: StrykerOptions,
+    fileDescriptions: FileDescriptions,
+    pluginModulePaths: readonly string[],
+    loggingServerAddress: LoggingServerAddress,
+    getLogger: LoggerFactoryMethod,
+    idGenerator: IdGenerator,
+  ) {
+    this.childProcess = ChildProcessProxy.create(
+      new URL('./checker-worker.js', import.meta.url).toString(),
+      loggingServerAddress,
+      options,
+      fileDescriptions,
+      pluginModulePaths,
+      process.cwd(),
+      CheckerWorker,
+      options.checkerNodeArgs,
+      getLogger,
+      idGenerator,
+    );
+  }
+
+  public async dispose(): Promise<void> {
+    await this.childProcess.dispose();
+  }
+
+  public async init(): Promise<void> {
+    await this.childProcess.proxy.init();
+  }
+
+  public async check(
+    checkerName: string,
+    mutants: Mutant[],
+  ): ReturnType<CheckerResource['check']> {
+    return this.childProcess.proxy.check(checkerName, mutants);
+  }
+
+  public async group(
+    checkerName: string,
+    mutants: Mutant[],
+  ): ReturnType<CheckerResource['group']> {
+    return this.childProcess.proxy.group(checkerName, mutants);
+  }
+}

package/src/checker/checker-facade.ts

@@ -0,0 +1,90 @@
+import { CheckResult } from '@stryker-mutator/api/check';
+import { MutantRunPlan } from '@stryker-mutator/api/core';
+
+import { ResourceDecorator } from '../concurrent/index.js';
+
+import { CheckerResource } from './checker-resource.js';
+
+function toMap(mutantRunPlans: MutantRunPlan[]) {
+  return new Map<string, MutantRunPlan>(
+    mutantRunPlans.map((mutant) => [mutant.mutant.id, mutant]),
+  );
+}
+
+export class CheckerFacade extends ResourceDecorator<CheckerResource> {
+  public async check(
+    checkerName: string,
+    mutantRunPlans: MutantRunPlan[],
+  ): Promise<Array<[MutantRunPlan, CheckResult]>> {
+    const innerCheckerResult = Object.entries(
+      await this.innerResource.check(
+        checkerName,
+        mutantRunPlans.map((mr) => mr.mutant),
+      ),
+    );
+
+    // Check if the checker returned all the mutants that was given
+    // When a mutant is missing this will be found in the map underneath
+    const mutantRunPlanMap = toMap(mutantRunPlans);
+
+    const results = innerCheckerResult.map(([id, res]) => {
+      const mutantRunPlan = mutantRunPlanMap.get(id);
+      if (!mutantRunPlan)
+        throw new Error(
+          `Checker "${checkerName}" returned a check result for mutant id "${id}", but a check wasn't requested for it. Stryker asked to check mutant ids: ${mutantRunPlans
+            .map(({ mutant }) => mutant.id)
+            .join(',')}`,
+        );
+      return [mutantRunPlan, res] as [MutantRunPlan, CheckResult];
+    });
+
+    if (mutantRunPlans.length > results.length) {
+      const resultIds = new Set(results.map(([{ mutant }]) => mutant.id));
+      const missingIds = mutantRunPlans
+        .map(({ mutant }) => mutant.id)
+        .filter((id) => !resultIds.has(id));
+      throw new Error(
+        `Checker "${checkerName}" was missing check results for mutant ids "${missingIds.join(',')}", while Stryker asked to check them`,
+      );
+    }
+
+    return results;
+  }
+
+  public async group(
+    checkerName: string,
+    mutantRunPlans: MutantRunPlan[],
+  ): Promise<MutantRunPlan[][]> {
+    const mutantIdGroups = await this.innerResource.group(
+      checkerName,
+      mutantRunPlans.map((mr) => mr.mutant),
+    );
+
+    // Check if the checker returned all the mutants that was given
+    // When a mutant is missing this will be found in the map underneath
+    const mutantRunPlanMap = toMap(mutantRunPlans);
+    const groupedMutantIds = new Set<string>();
+    const groups = mutantIdGroups.map((group) =>
+      group.map((id) => {
+        const mutantRunPlan = mutantRunPlanMap.get(id);
+        groupedMutantIds.add(id);
+        if (!mutantRunPlan)
+          throw new Error(
+            `Checker "${checkerName}" returned a group result for mutant id "${id}", but a group wasn't requested for it. Stryker asked to group mutant ids: ${mutantRunPlans
+              .map(({ mutant }) => mutant.id)
+              .join(',')}!`,
+          );
+        return mutantRunPlan;
+      }),
+    );
+    if (mutantRunPlans.length > groupedMutantIds.size) {
+      const missingIds = mutantRunPlans
+        .map(({ mutant }) => mutant.id)
+        .filter((id) => !groupedMutantIds.has(id));
+      throw new Error(
+        `Checker "${checkerName}" was missing group results for mutant ids "${missingIds.join(',')}", while Stryker asked to group them!`,
+      );
+    }
+    return groups;
+  }
+}

package/src/checker/checker-factory.ts

@@ -0,0 +1,46 @@
+import { FileDescriptions, StrykerOptions } from '@stryker-mutator/api/core';
+import { LoggerFactoryMethod } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+
+import { IdGenerator } from '../child-proxy/id-generator.js';
+
+import { coreTokens } from '../di/index.js';
+
+import { CheckerChildProcessProxy } from './checker-child-process-proxy.js';
+import { CheckerFacade } from './checker-facade.js';
+import { CheckerRetryDecorator } from './checker-retry-decorator.js';
+import { LoggingServerAddress } from '../logging/index.js';
+
+createCheckerFactory.inject = tokens(
+  commonTokens.options,
+  commonTokens.fileDescriptions,
+  coreTokens.loggingServerAddress,
+  coreTokens.pluginModulePaths,
+  commonTokens.getLogger,
+  coreTokens.workerIdGenerator,
+);
+export function createCheckerFactory(
+  options: StrykerOptions,
+  fileDescriptions: FileDescriptions,
+  loggingServerAddress: LoggingServerAddress,
+  pluginModulePaths: readonly string[],
+  getLogger: LoggerFactoryMethod,
+  idGenerator: IdGenerator,
+): () => CheckerFacade {
+  return () =>
+    new CheckerFacade(
+      () =>
+        new CheckerRetryDecorator(
+          () =>
+            new CheckerChildProcessProxy(
+              options,
+              fileDescriptions,
+              pluginModulePaths,
+              loggingServerAddress,
+              getLogger,
+              idGenerator,
+            ),
+          getLogger(CheckerRetryDecorator.name),
+        ),
+    );
+}

package/src/checker/checker-resource.ts

@@ -0,0 +1,12 @@
+import { CheckResult } from '@stryker-mutator/api/check';
+import { Mutant } from '@stryker-mutator/api/core';
+
+import { Resource } from '../concurrent/index.js';
+
+export interface CheckerResource extends Resource {
+  check(
+    checkerName: string,
+    mutant: Mutant[],
+  ): Promise<Record<string, CheckResult>>;
+  group(checkerName: string, mutants: Mutant[]): Promise<string[][]>;
+}

package/src/checker/checker-retry-decorator.ts

@@ -0,0 +1,57 @@
+import { Mutant } from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+
+import { ChildProcessCrashedError } from '../child-proxy/child-process-crashed-error.js';
+import { OutOfMemoryError } from '../child-proxy/out-of-memory-error.js';
+import { ResourceDecorator } from '../concurrent/index.js';
+
+import { CheckerResource } from './checker-resource.js';
+
+export class CheckerRetryDecorator
+  extends ResourceDecorator<CheckerResource>
+  implements CheckerResource
+{
+  constructor(
+    producer: () => CheckerResource,
+    private readonly log: Logger,
+  ) {
+    super(producer);
+  }
+
+  public async check(
+    checkerName: string,
+    mutants: Mutant[],
+  ): ReturnType<CheckerResource['check']> {
+    return this.tryAction(() => this.innerResource.check(checkerName, mutants));
+  }
+
+  public async group(
+    checkerName: string,
+    mutants: Mutant[],
+  ): ReturnType<CheckerResource['group']> {
+    return this.tryAction(() => this.innerResource.group(checkerName, mutants));
+  }
+
+  private async tryAction<T>(act: () => Promise<T>): Promise<T> {
+    try {
+      return await act();
+    } catch (error) {
+      if (error instanceof ChildProcessCrashedError) {
+        if (error instanceof OutOfMemoryError) {
+          this.log.warn(
+            `Checker process [${error.pid}] ran out of memory. Retrying in a new process.`,
+          );
+        } else {
+          this.log.warn(
+            `Checker process [${error.pid}] crashed with exit code ${error.exitCode}. Retrying in a new process.`,
+            error,
+          );
+        }
+        await this.recover();
+        return act();
+      } else {
+        throw error; //oops
+      }
+    }
+  }
+}

package/src/checker/checker-worker.ts

@@ -0,0 +1,62 @@
+import { Checker, CheckResult } from '@stryker-mutator/api/check';
+import { StrykerOptions, Mutant } from '@stryker-mutator/api/core';
+import { PluginKind, tokens, commonTokens } from '@stryker-mutator/api/plugin';
+import { StrykerError } from '@stryker-mutator/util';
+
+import { coreTokens, PluginCreator } from '../di/index.js';
+
+import { CheckerResource } from './checker-resource.js';
+
+export class CheckerWorker implements CheckerResource {
+  private readonly innerCheckers: Map<string, Checker>;
+
+  public static inject = tokens(commonTokens.options, coreTokens.pluginCreator);
+  constructor(options: StrykerOptions, pluginCreator: PluginCreator) {
+    this.innerCheckers = new Map(
+      options.checkers.map((name) => [
+        name,
+        pluginCreator.create(PluginKind.Checker, name),
+      ]),
+    );
+  }
+  public async init(): Promise<void> {
+    for (const [name, checker] of this.innerCheckers.entries()) {
+      try {
+        await checker.init();
+      } catch (error: unknown) {
+        throw new StrykerError(
+          `An error occurred during initialization of the "${name}" checker`,
+          error,
+        );
+      }
+    }
+  }
+  public async check(
+    checkerName: string,
+    mutants: Mutant[],
+  ): Promise<Record<string, CheckResult>> {
+    return this.perform(checkerName, (checker) => checker.check(mutants));
+  }
+
+  public async group(
+    checkerName: string,
+    mutants: Mutant[],
+  ): Promise<string[][]> {
+    return this.perform(
+      checkerName,
+      (checker) =>
+        checker.group?.(mutants) ??
+        // Group one by one by default
+        mutants.map(({ id }) => [id]),
+    );
+  }
+
+  private perform<T>(checkerName: string, act: (checker: Checker) => T) {
+    const checker = this.innerCheckers.get(checkerName);
+    if (checker) {
+      return act(checker);
+    } else {
+      throw new Error(`Checker ${checkerName} does not exist!`);
+    }
+  }
+}

package/src/checker/index.ts

@@ -0,0 +1,3 @@
+export * from './checker-factory.js';
+export * from './checker-resource.js';
+export * from './checker-facade.js';

package/src/child-proxy/child-process-crashed-error.ts

@@ -0,0 +1,16 @@
+import { StrykerError } from '@stryker-mutator/util';
+
+export class ChildProcessCrashedError extends StrykerError {
+  constructor(
+    public readonly pid: number | undefined,
+    message: string,
+    public readonly exitCode?: number,
+    public readonly signal?: string,
+    innerError?: Error,
+  ) {
+    super(message, innerError);
+    Error.captureStackTrace(this, ChildProcessCrashedError);
+    // TS recommendation: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+    Object.setPrototypeOf(this, ChildProcessCrashedError.prototype);
+  }
+}

package/src/child-proxy/child-process-proxy-worker.ts

@@ -0,0 +1,203 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { errorToString } from '@stryker-mutator/util';
+import { createInjector } from 'typed-inject';
+import {
+  commonTokens,
+  PluginContext,
+  Injector,
+} from '@stryker-mutator/api/plugin';
+
+import { deserialize, serialize } from '../utils/string-utils.js';
+import { coreTokens, PluginCreator } from '../di/index.js';
+import { PluginLoader } from '../di/plugin-loader.js';
+
+import {
+  CallMessage,
+  ParentMessage,
+  ParentMessageKind,
+  WorkerMessage,
+  WorkerMessageKind,
+  InitMessage,
+} from './message-protocol.js';
+import {
+  provideLogging,
+  provideLoggingClient,
+} from '../logging/provide-logging.js';
+import { Logger } from '@stryker-mutator/api/logging';
+import { minPriority } from '../logging/priority.js';
+
+export interface ChildProcessContext extends PluginContext {
+  [coreTokens.pluginCreator]: PluginCreator;
+}
+
+export class ChildProcessProxyWorker {
+  private log?: Logger;
+  private injector;
+
+  public realSubject: any;
+
+  constructor(private readonly injectorFactory: typeof createInjector) {
+    // Make sure to bind the methods in order to ensure the `this` pointer
+    this.handleMessage = this.handleMessage.bind(this);
+
+    // Start listening before sending the spawned message
+    process.on('message', this.handleMessage);
+    this.send({ kind: ParentMessageKind.Ready });
+    this.injector = this.injectorFactory();
+  }
+
+  private send(value: ParentMessage) {
+    if (process.send) {
+      const str = serialize(value);
+      process.send(str);
+    }
+  }
+  private handleMessage(serializedMessage: unknown) {
+    const message = deserialize<WorkerMessage>(String(serializedMessage));
+    switch (message.kind) {
+      case WorkerMessageKind.Init:
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises -- No handle needed, handleInit has try catch
+        this.handleInit(message);
+        this.removeAnyAdditionalMessageListeners(this.handleMessage);
+        break;
+      case WorkerMessageKind.Call:
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises -- No handle needed, handleCall has try catch
+        this.handleCall(message);
+        this.removeAnyAdditionalMessageListeners(this.handleMessage);
+        break;
+      case WorkerMessageKind.Dispose: {
+        const sendCompleted = () => {
+          this.send({ kind: ParentMessageKind.DisposeCompleted });
+        };
+        this.injector.dispose().then(sendCompleted).catch(sendCompleted);
+        break;
+      }
+    }
+  }
+
+  private async handleInit(message: InitMessage) {
+    try {
+      this.handlePromiseRejections();
+
+      // Load plugins in the child process
+      const pluginInjector = provideLogging(
+        await provideLoggingClient(
+          this.injector,
+          message.loggingServerAddress,
+          minPriority(message.options.logLevel, message.options.fileLogLevel),
+        ),
+      )
+        .provideValue(commonTokens.options, message.options)
+        .provideValue(commonTokens.fileDescriptions, message.fileDescriptions);
+      this.log = pluginInjector.resolve(commonTokens.getLogger)(
+        ChildProcessProxyWorker.name,
+      );
+      const pluginLoader = pluginInjector.injectClass(PluginLoader);
+      const { pluginsByKind } = await pluginLoader.load(
+        message.pluginModulePaths,
+      );
+      const injector: Injector<ChildProcessContext> = pluginInjector
+        .provideValue(coreTokens.pluginsByKind, pluginsByKind)
+        .provideClass(coreTokens.pluginCreator, PluginCreator);
+
+      const childModule = await import(message.modulePath);
+      const RealSubjectClass = childModule[message.namedExport];
+      const workingDir = path.resolve(message.workingDirectory);
+      if (process.cwd() !== workingDir) {
+        this.log.debug(
+          `Changing current working directory for this process to ${workingDir}`,
+        );
+        process.chdir(workingDir);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      this.realSubject = injector.injectClass(RealSubjectClass);
+      this.send({ kind: ParentMessageKind.Initialized });
+    } catch (err) {
+      this.send({
+        error: errorToString(err),
+        kind: ParentMessageKind.InitError,
+      });
+    }
+  }
+
+  private async handleCall(message: CallMessage) {
+    try {
+      const result = await this.doCall(message);
+      this.send({
+        correlationId: message.correlationId,
+        kind: ParentMessageKind.CallResult,
+        result,
+      });
+    } catch (err) {
+      this.send({
+        correlationId: message.correlationId,
+        error: errorToString(err),
+        kind: ParentMessageKind.CallRejection,
+      });
+    }
+  }
+
+  private doCall(
+    message: CallMessage,
+  ):
+    | PromiseLike<Record<string, unknown>>
+    | Record<string, unknown>
+    | undefined {
+    if (typeof this.realSubject[message.methodName] === 'function') {
+      return this.realSubject[message.methodName](...message.args);
+    } else {
+      return this.realSubject[message.methodName];
+    }
+  }
+
+  /**
+   * Remove any addition message listeners that might me eavesdropping.
+   * the @ngtools/webpack plugin listens to messages and throws an error whenever it could not handle a message
+   * @see https://github.com/angular/angular-cli/blob/f776d3cf7982b64734c57fe4407434e9f4ec09f7/packages/%40ngtools/webpack/src/type_checker.ts#L79
+   * @param exceptListener The listener that should remain
+   */
+  private removeAnyAdditionalMessageListeners(
+    exceptListener: NodeJS.MessageListener,
+  ) {
+    process.listeners('message').forEach((listener) => {
+      if (listener !== exceptListener) {
+        this.log?.debug(
+          "Removing an additional message listener, we don't want eavesdropping on our inter-process communication: %s",
+          listener.toString(),
+        );
+        process.removeListener('message', listener);
+      }
+    });
+  }
+
+  /**
+   * During mutation testing, it's to be expected that promise rejections are not handled synchronously anymore (or not at all)
+   * Let's handle those events so future versions of node don't crash
+   * See issue 350: https://github.com/stryker-mutator/stryker-js/issues/350
+   */
+  private handlePromiseRejections() {
+    const unhandledRejections: Array<Promise<unknown>> = [];
+    process.on('unhandledRejection', (reason, promise) => {
+      const unhandledPromiseId = unhandledRejections.push(promise);
+      this.log?.debug(
+        `UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: ${unhandledPromiseId}): ${errorToString(reason)}`,
+      );
+    });
+    process.on('rejectionHandled', (promise) => {
+      const unhandledPromiseId = unhandledRejections.indexOf(promise) + 1;
+      this.log?.debug(
+        `PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: ${unhandledPromiseId})`,
+      );
+    });
+  }
+}
+
+// Prevent side effects for merely importing the file
+// Only actually start the child worker when it is requested
+// Stryker disable all
+if (fileURLToPath(import.meta.url) === process.argv[1]) {
+  new ChildProcessProxyWorker(createInjector);
+}
+// Stryker restore all