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

package/src/initializer/stryker-initializer.ts

@@ -0,0 +1,278 @@
+import childProcess from 'child_process';
+import { promises as fsPromises } from 'fs';
+
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { Logger } from '@stryker-mutator/api/logging';
+import { notEmpty } from '@stryker-mutator/util';
+
+import { NpmClient } from './npm-client.js';
+import { PackageInfo, PackageSummary } from './package-info.js';
+import { CustomInitializer } from './custom-initializers/custom-initializer.js';
+import { PromptOption } from './prompt-option.js';
+import { StrykerConfigWriter } from './stryker-config-writer.js';
+import { StrykerInquirer } from './stryker-inquirer.js';
+import { GitignoreWriter } from './gitignore-writer.js';
+
+import { initializerTokens } from './index.js';
+
+const enum PackageManager {
+  Npm = 'npm',
+  Yarn = 'yarn',
+  Pnpm = 'pnpm',
+}
+
+export class StrykerInitializer {
+  public static inject = tokens(
+    commonTokens.logger,
+    initializerTokens.out,
+    initializerTokens.npmClient,
+    initializerTokens.customInitializers,
+    initializerTokens.configWriter,
+    initializerTokens.gitignoreWriter,
+    initializerTokens.inquirer,
+  );
+  constructor(
+    private readonly log: Logger,
+    private readonly out: typeof console.log,
+    private readonly client: NpmClient,
+    private readonly customInitializers: CustomInitializer[],
+    private readonly configWriter: StrykerConfigWriter,
+    private readonly gitignoreWriter: GitignoreWriter,
+    private readonly inquirer: StrykerInquirer,
+  ) {}
+
+  /**
+   * Runs the initializer will prompt the user for questions about his setup. After that, install plugins and configure Stryker.
+   * @function
+   */
+  public async initialize(): Promise<void> {
+    await this.configWriter.guardForExistingConfig();
+    this.patchProxies();
+    const selectedPreset = await this.selectCustomInitializer();
+    let configFileName: string;
+    if (selectedPreset) {
+      configFileName = await this.initiateInitializer(
+        this.configWriter,
+        selectedPreset,
+      );
+    } else {
+      configFileName = await this.initiateCustom(this.configWriter);
+    }
+    await this.gitignoreWriter.addStrykerTempFolder();
+    this.out(
+      `Done configuring stryker. Please review "${configFileName}", you might need to configure your test runner correctly.`,
+    );
+    this.out("Let's kill some mutants with this command: `stryker run`");
+  }
+
+  /**
+   * The typed rest client works only with the specific HTTP_PROXY and HTTPS_PROXY env settings.
+   * Let's make sure they are available.
+   */
+  private patchProxies() {
+    const copyEnvVariable = (from: string, to: string) => {
+      if (process.env[from] && !process.env[to]) {
+        process.env[to] = process.env[from];
+      }
+    };
+    copyEnvVariable('http_proxy', 'HTTP_PROXY');
+    copyEnvVariable('https_proxy', 'HTTPS_PROXY');
+  }
+
+  private async selectCustomInitializer(): Promise<
+    CustomInitializer | undefined
+  > {
+    const customInitializer: CustomInitializer[] = this.customInitializers;
+    if (customInitializer.length) {
+      this.log.debug(`Found presets: ${JSON.stringify(customInitializer)}`);
+      return this.inquirer.promptPresets(customInitializer);
+    } else {
+      this.log.debug(
+        'No presets have been configured, reverting to custom configuration',
+      );
+      return undefined;
+    }
+  }
+
+  private async initiateInitializer(
+    configWriter: StrykerConfigWriter,
+    selectedPreset: CustomInitializer,
+  ) {
+    const presetConfig = await selectedPreset.createConfig();
+    const isJsonSelected = await this.selectJsonConfigType();
+    const configFileName = await configWriter.writeCustomInitializer(
+      presetConfig,
+      isJsonSelected,
+    );
+    if (presetConfig.additionalConfigFiles) {
+      await Promise.all(
+        Object.entries(presetConfig.additionalConfigFiles).map(
+          ([name, content]) => fsPromises.writeFile(name, content),
+        ),
+      );
+    }
+    const selectedPackageManager = await this.selectPackageManager();
+    this.installNpmDependencies(
+      this.ensureCoreDependencyIncluded(presetConfig.dependencies),
+      selectedPackageManager,
+    );
+    return configFileName;
+  }
+
+  private async initiateCustom(configWriter: StrykerConfigWriter) {
+    const selectedTestRunner = await this.selectTestRunner();
+    const buildCommand = await this.getBuildCommand(selectedTestRunner);
+    const selectedReporters = await this.selectReporters();
+    const selectedPackageManager = await this.selectPackageManager();
+    const isJsonSelected = await this.selectJsonConfigType();
+    const npmDependencies = this.getSelectedNpmDependencies(
+      [selectedTestRunner].concat(selectedReporters),
+    );
+    const packageInfo = await this.fetchAdditionalConfig(npmDependencies);
+    const pkgInfoOfSelectedTestRunner = packageInfo.find(
+      (pkg) => pkg.name == selectedTestRunner.pkg?.name,
+    );
+    const additionalConfig = packageInfo
+      .map((dep) => dep.initStrykerConfig ?? {})
+      .filter(notEmpty);
+
+    const configFileName = await configWriter.write(
+      selectedTestRunner,
+      buildCommand,
+      selectedReporters,
+      selectedPackageManager,
+      npmDependencies.map((pkg) => pkg.name),
+      additionalConfig,
+      pkgInfoOfSelectedTestRunner?.homepage ??
+        "(missing 'homepage' URL in package.json)",
+      isJsonSelected,
+    );
+    this.installNpmDependencies(
+      this.ensureCoreDependencyIncluded(npmDependencies.map((pkg) => pkg.name)),
+      selectedPackageManager,
+    );
+    return configFileName;
+  }
+
+  private async selectTestRunner(): Promise<PromptOption> {
+    const testRunnerOptions = await this.client.getTestRunnerOptions();
+    this.log.debug(`Found test runners: ${JSON.stringify(testRunnerOptions)}`);
+    return this.inquirer.promptTestRunners(testRunnerOptions);
+  }
+
+  private async getBuildCommand(
+    selectedTestRunner: PromptOption,
+  ): Promise<PromptOption> {
+    if (selectedTestRunner.name !== 'jest') {
+      return this.inquirer.promptBuildCommand();
+    }
+    return { name: '', pkg: null };
+  }
+
+  private async selectReporters(): Promise<PromptOption[]> {
+    const reporterOptions = await this.client.getTestReporterOptions();
+    reporterOptions.push(
+      {
+        name: 'html',
+        pkg: null,
+      },
+      {
+        name: 'clear-text',
+        pkg: null,
+      },
+      {
+        name: 'progress',
+        pkg: null,
+      },
+      {
+        name: 'dashboard',
+        pkg: null,
+      },
+    );
+    return this.inquirer.promptReporters(reporterOptions);
+  }
+
+  private async selectPackageManager(): Promise<PromptOption> {
+    return this.inquirer.promptPackageManager([
+      {
+        name: PackageManager.Npm,
+        pkg: null,
+      },
+      {
+        name: PackageManager.Yarn,
+        pkg: null,
+      },
+      {
+        name: PackageManager.Pnpm,
+        pkg: null,
+      },
+    ]);
+  }
+
+  private async selectJsonConfigType(): Promise<boolean> {
+    return this.inquirer.promptJsonConfigFormat();
+  }
+
+  private getSelectedNpmDependencies(
+    selectedOptions: Array<PromptOption | null>,
+  ): PackageInfo[] {
+    return selectedOptions
+      .filter(notEmpty)
+      .map((option) => option.pkg)
+      .filter(notEmpty);
+  }
+
+  /**
+   * Install the npm packages
+   * @function
+   */
+  private installNpmDependencies(
+    dependencies: string[],
+    selectedOption: PromptOption,
+  ): void {
+    if (dependencies.length === 0) {
+      return;
+    }
+
+    const dependencyArg = dependencies.join(' ');
+    this.out('Installing NPM dependencies...');
+    const cmd = this.getInstallCommand(
+      selectedOption.name as PackageManager,
+      dependencyArg,
+    );
+    this.out(cmd);
+    try {
+      childProcess.execSync(cmd, { stdio: [0, 1, 2] });
+    } catch {
+      this.out(
+        `An error occurred during installation, please try it yourself: "${cmd}"`,
+      );
+    }
+  }
+
+  private getInstallCommand(
+    packageManager: PackageManager,
+    dependencyArg: string,
+  ): string {
+    switch (packageManager) {
+      case PackageManager.Yarn:
+        return `yarn add ${dependencyArg} --dev`;
+      case PackageManager.Pnpm:
+        return `pnpm add -D ${dependencyArg}`;
+      case PackageManager.Npm:
+        return `npm i --save-dev ${dependencyArg}`;
+    }
+  }
+
+  private async fetchAdditionalConfig(
+    dependencies: PackageSummary[],
+  ): Promise<PackageInfo[]> {
+    return await Promise.all(
+      dependencies.map((dep) => this.client.getAdditionalConfig(dep)),
+    );
+  }
+
+  private ensureCoreDependencyIncluded(dependencies: string[]) {
+    return Array.from(new Set(['@stryker-mutator/core', ...dependencies]));
+  }
+}

package/src/initializer/stryker-inquirer.ts

@@ -0,0 +1,101 @@
+import { CommandTestRunner } from '../test-runner/command-test-runner.js';
+
+import { CustomInitializer } from './custom-initializers/custom-initializer.js';
+import { PromptOption } from './prompt-option.js';
+import { inquire } from './inquire.js';
+
+export interface PromptResult {
+  additionalNpmDependencies: string[];
+  additionalConfig: Record<string, unknown>;
+}
+
+export class StrykerInquirer {
+  public async promptPresets(
+    options: CustomInitializer[],
+  ): Promise<CustomInitializer | undefined> {
+    const preset = await inquire.select({
+      choices: [
+        ...options.map(({ name }) => ({
+          value: name,
+        })),
+        inquire.separator(),
+        { value: 'None/other' },
+      ],
+      message:
+        'Are you using one of these frameworks? Then select a preset configuration.',
+    });
+    return options.find((_) => _.name === preset);
+  }
+
+  public async promptTestRunners(
+    options: PromptOption[],
+  ): Promise<PromptOption> {
+    if (options.length) {
+      const testRunner = await inquire.select({
+        choices: [
+          ...options.map(({ name }) => ({ value: name })),
+          inquire.separator(),
+          { value: CommandTestRunner.runnerName },
+        ],
+        message:
+          'Which test runner do you want to use? If your test runner isn\'t listed here, you can choose "command" (it uses your `npm test` command, but will come with a big performance penalty)',
+      });
+      return (
+        options.find(({ name }) => name === testRunner) ?? {
+          name: CommandTestRunner.runnerName,
+          pkg: null,
+        }
+      );
+    } else {
+      return { name: CommandTestRunner.runnerName, pkg: null };
+    }
+  }
+
+  public async promptBuildCommand(): Promise<PromptOption> {
+    const buildCommand = await inquire.input({
+      message:
+        'What build command should be executed just before running your tests? For example: "npm run build" or "tsc -b" (leave empty when this is not needed).',
+      default: 'none',
+    });
+
+    return { name: buildCommand !== 'none' ? buildCommand : '', pkg: null };
+  }
+
+  public async promptReporters(
+    options: PromptOption[],
+  ): Promise<PromptOption[]> {
+    const defaults = ['html', 'clear-text', 'progress'];
+    const reporters = await inquire.checkbox({
+      choices: options.map(({ name }) => ({
+        value: name,
+        checked: defaults.includes(name),
+      })),
+      message: 'Which reporter(s) do you want to use?',
+    });
+    return options.filter((option) =>
+      reporters.some((reporterName) => option.name === reporterName),
+    );
+  }
+
+  public async promptPackageManager(
+    options: PromptOption[],
+  ): Promise<PromptOption> {
+    const packageManager = await inquire.select({
+      choices: options.map((_) => ({ value: _.name })),
+      default: 'npm',
+      message: 'Which package manager do you want to use?',
+    });
+    return options.find(({ name }) => name === packageManager)!;
+  }
+
+  public async promptJsonConfigFormat(): Promise<boolean> {
+    const json = 'JSON';
+
+    const configFormat = await inquire.select({
+      choices: [{ value: json }, { value: 'JavaScript' }],
+      default: json,
+      message: 'What file type do you want for your config file?',
+    });
+    return configFormat === json;
+  }
+}

package/src/logging/index.ts

@@ -0,0 +1,5 @@
+export * from './logging-backend.js';
+export type { LoggingServerAddress, LoggingServer } from './logging-server.js';
+export * from './provide-logging.js';
+export * from './logging-sink.js';
+export * from './priority.js';

package/src/logging/logger-impl.ts

@@ -0,0 +1,81 @@
+import { Logger } from '@stryker-mutator/api/logging';
+import { LogLevel } from '@stryker-mutator/api/core';
+import { LoggingEvent } from './logging-event.js';
+import { LoggingSink } from './logging-sink.js';
+
+export class LoggerImpl implements Logger {
+  #categoryName;
+  #loggingBackend;
+
+  constructor(categoryName: string, loggingBackend: LoggingSink) {
+    this.#categoryName = categoryName;
+    this.#loggingBackend = loggingBackend;
+  }
+
+  isTraceEnabled(): boolean {
+    return this.#loggingBackend.isEnabled(LogLevel.Trace);
+  }
+  isDebugEnabled(): boolean {
+    return this.#loggingBackend.isEnabled(LogLevel.Debug);
+  }
+  isInfoEnabled(): boolean {
+    return this.#loggingBackend.isEnabled(LogLevel.Information);
+  }
+  isWarnEnabled(): boolean {
+    return this.#loggingBackend.isEnabled(LogLevel.Warning);
+  }
+  isErrorEnabled(): boolean {
+    return this.#loggingBackend.isEnabled(LogLevel.Error);
+  }
+  isFatalEnabled(): boolean {
+    return this.#loggingBackend.isEnabled(LogLevel.Fatal);
+  }
+  trace(message: string, ...args: any[]): void {
+    this.#loggingBackend.log(
+      LoggingEvent.create(this.#categoryName, LogLevel.Trace, [
+        message,
+        ...args,
+      ]),
+    );
+  }
+  debug(message: string, ...args: any[]): void {
+    this.#loggingBackend.log(
+      LoggingEvent.create(this.#categoryName, LogLevel.Debug, [
+        message,
+        ...args,
+      ]),
+    );
+  }
+  info(message: string, ...args: any[]): void {
+    this.#loggingBackend.log(
+      LoggingEvent.create(this.#categoryName, LogLevel.Information, [
+        message,
+        ...args,
+      ]),
+    );
+  }
+  warn(message: string, ...args: any[]): void {
+    this.#loggingBackend.log(
+      LoggingEvent.create(this.#categoryName, LogLevel.Warning, [
+        message,
+        ...args,
+      ]),
+    );
+  }
+  error(message: string, ...args: any[]): void {
+    this.#loggingBackend.log(
+      LoggingEvent.create(this.#categoryName, LogLevel.Error, [
+        message,
+        ...args,
+      ]),
+    );
+  }
+  fatal(message: string, ...args: any[]): void {
+    this.#loggingBackend.log(
+      LoggingEvent.create(this.#categoryName, LogLevel.Fatal, [
+        message,
+        ...args,
+      ]),
+    );
+  }
+}

package/src/logging/logging-backend.ts

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import { LogLevel, PartialStrykerOptions } from '@stryker-mutator/api/core';
+import { LoggingEvent } from './logging-event.js';
+import { Disposable } from 'typed-inject';
+import { promisify } from 'util';
+import { LoggingSink } from './logging-sink.js';
+import { logLevelPriority, minPriority } from './priority.js';
+import { coreTokens } from '../di/index.js';
+
+const LOG_FILE_NAME = 'stryker.log';
+
+/**
+ * The logging backend that handles the actual logging. So to both a file and the stdout, stderr.
+ */
+export class LoggingBackend implements LoggingSink, Disposable {
+  activeStdoutLevel: LogLevel = LogLevel.Information;
+  activeFileLevel: LogLevel = LogLevel.Off;
+  showColors = true;
+  #consoleOut;
+
+  static readonly inject = [coreTokens.loggerConsoleOut] as const;
+
+  constructor(consoleOut: NodeJS.WritableStream) {
+    this.#consoleOut = consoleOut;
+  }
+
+  log(event: LoggingEvent) {
+    const eventPriority = logLevelPriority[event.level];
+    if (eventPriority >= logLevelPriority[this.activeStdoutLevel]) {
+      this.#consoleOut.write(
+        `${this.showColors ? event.formatColorized() : event.format()}\n`,
+      );
+    }
+    if (
+      eventPriority >= logLevelPriority[this.activeFileLevel] &&
+      !this.#fileStream.errored
+    ) {
+      this.#fileStream.write(`${event.format()}\n`);
+    }
+  }
+
+  isEnabled(level: LogLevel) {
+    const priority = logLevelPriority[level];
+    return priority >= this.priority;
+  }
+
+  get activeLogLevel() {
+    return minPriority(this.activeStdoutLevel, this.activeFileLevel);
+  }
+
+  get priority() {
+    return logLevelPriority[this.activeLogLevel];
+  }
+
+  configure({
+    logLevel,
+    fileLogLevel,
+    allowConsoleColors,
+  }: PartialStrykerOptions) {
+    if (logLevel) {
+      this.activeStdoutLevel = logLevel;
+    }
+    if (fileLogLevel) {
+      this.activeFileLevel = fileLogLevel;
+    }
+    if (allowConsoleColors !== undefined) {
+      this.showColors = allowConsoleColors;
+    }
+  }
+
+  #_fileStream?: fs.WriteStream;
+  get #fileStream() {
+    if (!this.#_fileStream) {
+      this.#_fileStream = fs.createWriteStream(LOG_FILE_NAME, { flags: 'a' });
+      this.#_fileStream.on('error', (error) => {
+        console.error(
+          `An error occurred while writing to "${LOG_FILE_NAME}"`,
+          error,
+        );
+      });
+    }
+    return this.#_fileStream;
+  }
+
+  async dispose() {
+    if (this.#_fileStream) {
+      await promisify(this.#_fileStream.end).bind(this.#_fileStream)();
+    }
+  }
+}

package/src/logging/logging-client.ts

@@ -0,0 +1,56 @@
+import net from 'net';
+import { Disposable } from '@stryker-mutator/api/plugin';
+import { LoggingServerAddress, LoggingSink } from '../logging/index.js';
+import { LogLevel } from '@stryker-mutator/api/core';
+import { LoggingEvent } from './logging-event.js';
+import { promisify } from 'util';
+import { DELIMITER } from './logging-server.js';
+import { logLevelPriority } from './priority.js';
+import { coreTokens } from '../di/index.js';
+
+export class LoggingClient implements LoggingSink, Disposable {
+  #socket?: net.Socket;
+
+  static readonly inject = [
+    coreTokens.loggerActiveLevel,
+    coreTokens.loggingServerAddress,
+  ] as const;
+  constructor(
+    private logLevel: LogLevel,
+    private loggingServerAddress: LoggingServerAddress,
+  ) {}
+
+  openConnection() {
+    return new Promise<void>((res, rej) => {
+      this.#socket = net.createConnection(
+        this.loggingServerAddress.port,
+        'localhost',
+        res,
+      );
+      this.#socket.on('error', (error) => {
+        console.error('Error occurred in logging client', error);
+        rej(error);
+      });
+    });
+  }
+
+  log(event: LoggingEvent): void {
+    if (!this.#socket) {
+      throw new Error(
+        `Cannot use the logging client before it is connected, please call '${LoggingClient.name}.prototype.${LoggingClient.prototype.openConnection.name}' first`,
+      );
+    }
+    if (this.isEnabled(event.level) && this.#socket.writable) {
+      this.#socket.write(JSON.stringify(event.serialize()) + DELIMITER);
+    }
+  }
+  isEnabled(level: LogLevel): boolean {
+    return logLevelPriority[level] >= logLevelPriority[this.logLevel];
+  }
+
+  async dispose(): Promise<void> {
+    if (this.#socket) {
+      await promisify(this.#socket.end).bind(this.#socket)();
+    }
+  }
+}

package/src/logging/logging-event.ts

@@ -0,0 +1,94 @@
+import { LogLevel } from '@stryker-mutator/api/core';
+import util from 'util';
+
+const pattern = [
+  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
+].join('|');
+const ansiRegex = new RegExp(pattern, 'g');
+
+export class LoggingEvent {
+  readonly startTime;
+  readonly categoryName: string;
+  readonly data: Array<unknown>;
+  readonly level: LogLevel;
+  readonly pid: number;
+
+  private constructor(
+    categoryName: string,
+    level: LogLevel,
+    data: Array<unknown>,
+    startTime: Date,
+    pid: number,
+  ) {
+    this.startTime = startTime;
+    this.categoryName = categoryName;
+    this.data = data;
+    this.level = level;
+    this.pid = pid;
+  }
+
+  static create(categoryName: string, level: LogLevel, data: Array<unknown>) {
+    return new LoggingEvent(categoryName, level, data, new Date(), process.pid);
+  }
+
+  format(): string {
+    return `${this.#formatPrefix()} ${this.#formatMessage().replace(ansiRegex, '')}`;
+  }
+
+  formatColorized(): string {
+    return `${this.#colorizedStart()}${this.#formatPrefix()}${this.#colorizedEnd()} ${this.#formatMessage()}`;
+  }
+
+  #formatPrefix(): string {
+    return `${this.startTime.toTimeString().slice(0, 8)} (${this.pid}) ${this.level.toUpperCase()} ${this.categoryName}`;
+  }
+
+  #formatMessage(): string {
+    return util.format(...this.data);
+  }
+  #colorizedStart() {
+    return `\x1B[${styles[this.level]}m`;
+  }
+  #colorizedEnd() {
+    return '\x1B[39m';
+  }
+
+  static deserialize(ser: SerializedLoggingEvent): LoggingEvent {
+    return new LoggingEvent(
+      ser.categoryName,
+      ser.level,
+      [ser.message],
+      new Date(ser.startTime),
+      ser.pid,
+    );
+  }
+
+  serialize(): SerializedLoggingEvent {
+    return {
+      startTime: this.startTime.toJSON(),
+      categoryName: this.categoryName,
+      message: this.#formatMessage(),
+      level: this.level,
+      pid: this.pid,
+    };
+  }
+}
+
+export interface SerializedLoggingEvent {
+  startTime: string;
+  categoryName: string;
+  message: string;
+  level: LogLevel;
+  pid: number;
+}
+
+const styles = Object.freeze({
+  trace: 34, // blue
+  debug: 36, // cyan
+  info: 32, // green
+  warn: 33, // yellow
+  error: 91, // red
+  fatal: 35, // magenta
+  off: 90, // grey
+});