Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
import { Config, ConfigEditor } from '@stryker-mutator/api/config';
import { tokens } from '@stryker-mutator/api/plugin';
import MochaOptionsLoader from './MochaOptionsLoader';
import { mochaOptionsKey } from './utils';
export default class MochaConfigEditor implements ConfigEditor {
public static inject = tokens('loader');
constructor(private readonly loader: MochaOptionsLoader) {}
public edit(config: Config): void {
config[mochaOptionsKey] = this.loader.load(config);
}
}
import { StrykerOptions } from '@stryker-mutator/api/core';
import { Logger } from '@stryker-mutator/api/logging';
import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
import { childProcessAsPromised, fsAsPromised } from '@stryker-mutator/util';
import PresetConfiguration from './presets/PresetConfiguration';
import PromptOption from './PromptOption';
import { initializerTokens } from '.';
const STRYKER_CONFIG_FILE = 'stryker.conf.js';
export default class StrykerConfigWriter {
public static inject = tokens(commonTokens.logger, initializerTokens.out);
constructor(private readonly log: Logger, private readonly out: typeof console.log) {}
public guardForExistingConfig() {
if (fsAsPromised.existsSync(STRYKER_CONFIG_FILE)) {
const msg = 'Stryker config file "stryker.conf.js" already exists in the current directory. Please remove it and try again.';
this.log.error(msg);
throw new Error(msg);
}
}
/**
* Create stryker.conf.js based on the chosen framework and test runner
* @function
*/
public write(
selectedTestRunner: null | PromptOption,
* A small object that keeps the timing variables of a test run.
*/
interface Timing {
/**
* The time that the test runner was actually executing tests in milliseconds.
*/
net: number;
/**
* the time that was spend not executing tests in milliseconds.
* So the time it took to start the test runner and to report the result.
*/
overhead: number;
}
export default class InitialTestExecutor {
public static inject = tokens(
commonTokens.options,
commonTokens.logger,
coreTokens.inputFiles,
coreTokens.testFramework,
coreTokens.timer,
coreTokens.loggingContext,
coreTokens.transpiler,
coreTokens.temporaryDirectory
);
constructor(
private readonly options: StrykerOptions,
private readonly log: Logger,
private readonly inputFiles: InputFileCollection,
private readonly testFramework: TestFramework | null,
private readonly timer: Timer,
const mapSearchResultToPromptOption = (searchResults: NpmSearchResult): PromptOption[] =>
searchResults.results.map(result => ({
name: getName(result.package.name),
pkg: result.package
}));
const handleResult = (from: string) => (response: IRestResponse): T => {
if (response.statusCode === 200 && response.result) {
return response.result;
} else {
throw new Error(`Path ${from} resulted in http status code: ${response.statusCode}.`);
}
};
export default class NpmClient {
public static inject = tokens(commonTokens.logger, initializerTokens.restClientNpmSearch, initializerTokens.restClientNpm);
constructor(private readonly log: Logger, private readonly searchClient: RestClient, private readonly packageClient: RestClient) {}
public getTestRunnerOptions(): Promise {
return this.search('/v2/search?q=keywords:@stryker-mutator/test-runner-plugin').then(mapSearchResultToPromptOption);
}
public getTestFrameworkOptions(testRunnerFilter: string | null): Promise {
return this.search('/v2/search?q=keywords:@stryker-mutator/test-framework-plugin')
.then(searchResult => {
if (testRunnerFilter) {
searchResult.results = searchResult.results.filter(framework => framework.package.keywords.includes(testRunnerFilter));
}
return searchResult;
})
.then(mapSearchResultToPromptOption);
}
optionsApi?: Partial;
}
export const CONFIG_KEY = 'babel';
export const FILE_KEY: keyof StrykerBabelConfig = 'optionsFile';
export const OPTIONS_KEY: keyof StrykerBabelConfig = 'options';
export const EXTENSIONS_KEY: keyof StrykerBabelConfig = 'extensions';
const DEFAULT_BABEL_CONFIG: Readonly = Object.freeze({
extensions: Object.freeze([]),
options: Object.freeze({}),
optionsFile: '.babelrc'
});
export class BabelConfigReader {
public static inject = tokens(commonTokens.logger);
constructor(private readonly log: Logger) {}
public readConfig(strykerOptions: StrykerOptions): StrykerBabelConfig {
const babelConfig: StrykerBabelConfig = {
...DEFAULT_BABEL_CONFIG,
...strykerOptions[CONFIG_KEY]
};
babelConfig.options = {
...this.readBabelOptionsFromFile(babelConfig.optionsFile, babelConfig.optionsApi),
...babelConfig.options
};
this.log.debug(`Babel config is: ${JSON.stringify(babelConfig, null, 2)}`);
return babelConfig;
}
private readBabelOptionsFromFile(relativeFileName: string | null, optionsApi?: Partial): babel.TransformOptions {
import generate from '@babel/generator';
import { parse, ParserOptions } from '@babel/parser';
import traverse, { NodePath } from '@babel/traverse';
import * as types from '@babel/types';
import { Logger } from '@stryker-mutator/api/logging';
import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
import { MutatorDescriptor } from '@stryker-mutator/api/core';
import { NodeWithParent } from './ParentNode';
export default class BabelParser {
public static inject = tokens(commonTokens.logger, commonTokens.mutatorDescriptor);
private readonly options: ParserOptions;
constructor(private readonly log: Logger, mutatorDescriptor: MutatorDescriptor) {
this.options = this.createOptions(mutatorDescriptor.plugins);
}
public parse(code: string): types.File {
return parse(code, this.options);
}
private createOptions(pluginOverrides: string[] | null): ParserOptions {
const plugins = pluginOverrides || [
'asyncGenerators',
'bigInt',
'classProperties',
'dynamicImport',
import * as ts from 'typescript';
import flatMap = require('lodash.flatmap');
import { getTSConfig, parseFile } from './helpers/tsHelpers';
import { nodeMutators } from './mutator';
import NodeMutator from './mutator/NodeMutator';
export function typescriptMutatorFactory(injector: Injector): TypescriptMutator {
return injector.provideValue(MUTATORS_TOKEN, nodeMutators).injectClass(TypescriptMutator);
}
typescriptMutatorFactory.inject = tokens(commonTokens.injector);
export const MUTATORS_TOKEN = 'mutators';
export class TypescriptMutator {
public static inject = tokens(commonTokens.options, MUTATORS_TOKEN);
constructor(private readonly options: StrykerOptions, public readonly mutators: readonly NodeMutator[]) {}
public mutate(inputFiles: File[]): Mutant[] {
const tsConfig = getTSConfig(this.options);
const mutants = flatMap(inputFiles, inputFile => {
const sourceFile = parseFile(inputFile, tsConfig && tsConfig.options && tsConfig.options.target);
return this.mutateForNode(sourceFile, sourceFile);
});
return mutants;
}
private mutateForNode(node: T, sourceFile: ts.SourceFile): Mutant[] {
if (shouldNodeBeSkipped(node)) {
return [];
} else {
const targetMutators = this.mutators.filter(mutator => mutator.guard(node));