joshuakgoldberg

automutate-tests

import { IMutationsProviderFactory } from "./mutationsProviderFactory";

 * File names and settings for test cases.

     * Whether to override the expected file content's with the actual results, instead of checking equality.

     * File name for the mutation result.

     * File name for what the mutation result should be.

     * Endlines to normalize \r\n|\n to, if anything.

     * File name for the original file contents.

 * @param settings   Settings for the test case.

 * @param autoMutatorFactory   Creates mutation providers for files.

 * @returns A Promise for running the test.

export declare const runTestCase: (settings: ITestCaseSettings, mutationsProviderFactory: IMutationsProviderFactory) => Promise<void>;

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {

    return new (P || (P = Promise))(function (resolve, reject) {

        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }

        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }

        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }

        step((generator = generator.apply(thisArg, _arguments || [])).next());

var __generator = (this && this.__generator) || function (thisArg, body) {

    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;

    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;

    function verb(n) { return function (v) { return step([n, v]); }; }

        if (f) throw new TypeError("Generator is already executing.");

            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;

            if (y = 0, t) op = [0, t.value];

                case 0: case 1: t = op; break;

                case 4: _.label++; return { value: op[1], done: false };

                case 5: _.label++; y = op[1]; op = [0]; continue;

                case 7: op = _.ops.pop(); _.trys.pop(); continue;

                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }

                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }

                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }

                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }

                    if (t[2]) _.ops.pop();

                    _.trys.pop(); continue;

        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }

        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };

var automutate_1 = require("automutate");

exports.runTestCase = function (settings, mutationsProviderFactory) { return __awaiter(_this, void 0, void 0, function () {

    var expectedContents, logger, actualContents;

    return __generator(this, function (_a) {

            return [4 /*yield*/, arrangeFiles(settings.actual, settings.original)];

                return [4 /*yield*/, fs.readFile(settings.expected)];

                expectedContents = (_a.sent()).toString();

                logger = new automutate_1.Logger();

                return [4 /*yield*/, automutate_1.runMutations({

                        mutationsApplier: new automutate_1.FileMutationsApplier({ logger: logger }),

                        mutationsProvider: mutationsProviderFactory(settings.actual, settings.settings)

                return [4 /*yield*/, fs.readFile(settings.actual)];

                actualContents = (_a.sent()).toString();

                if (settings.normalizeEndlines !== undefined) {

                    actualContents = actualContents.replace(/\r\n|\n/g, settings.normalizeEndlines);

                if (!settings.accept) return [3 /*break*/, 6];

                return [4 /*yield*/, fs.writeFile(settings.expected, actualContents)];

                chai_1.expect(actualContents).to.be.equal(expectedContents);

            case 7: return [2 /*return*/];

var arrangeFiles = function (actual, original) { return __awaiter(_this, void 0, void 0, function () {

    return __generator(this, function (_d) {

                _b = (_a = fs).writeFile;

                return [4 /*yield*/, fs.readFile(original)];

            case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([_d.sent()]))];

var describeTests_1 = require("./describeTests");

var hierarchyCrawler_1 = require("./hierarchyCrawler");

 * @deprecated   Use {@link describeMutationTestCases} instead.

var TestsFactory = /** @class */ (function () {

     * Initializes a new instance of the TestsFactory class.

     * @param mutationsProviderFactory   Creates test cases from test case settings.

     * @param extension   File extension of test case files.

    function TestsFactory(mutationsProviderFactory, settings) {

        this.mutationsProviderFactory = mutationsProviderFactory;

        this.hierarchyCrawler = new hierarchyCrawler_1.HierarchyCrawler(this.settings.original);

     * Describes tests for the cases directory.

     * @param casesPath   Path to the test cases.

    TestsFactory.prototype.describe = function (casesPath) {

        if (this.settings.includes !== undefined && this.settings.includes.length !== 0) {

            console.log("Including only tests that match any of:\n - ", chalk_1["default"].cyan(this.settings.includes.join("\n - ")));

        describeTests_1.describeTests(this.hierarchyCrawler.crawl("cases", casesPath), function (hierarchy) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {

            return [2 /*return*/, this.runTest(hierarchy)];

        }); }); }, this.settings.includes);

     * @param hierarchy   The case's hierarchy.

     * @returns A Promise for running the test.

    TestsFactory.prototype.runTest = function (hierarchy) {

        return __awaiter(this, void 0, void 0, function () {

            return __generator(this, function (_a) {

                        caseSettings = createTestCaseSettings(this.settings, hierarchy.directoryPath);

                        if (caseSettings === undefined) {

                            throw new Error("Could not find " + this.settings.original + " under " + hierarchy.directoryPath + ".");

                        return [4 /*yield*/, testCase_1.runTestCase(caseSettings, this.mutationsProviderFactory)];

                        return [2 /*return*/];

        expected: path.join(casePath, settings.expected),

        normalizeEndlines: settings.normalizeEndlines,

        settings: path.join(casePath, settings.settings)

 * @param casesPath   Path to the test cases.

 * @param mutationsProviderFactory   Creates test cases from test case settings.

 * @param settings   Settings to describe test cases, namely file names and CLI flag equivalents.

exports.describeMutationTestCases = function (casesPath, mutationsProviderFactory, settings) {

    // tslint:disable-next-line:deprecation

    var testsFactory = new TestsFactory(mutationsProviderFactory, settings);

  "description": "Test harness for automutators.",

    "url": "git+https://github.com/automutate/automutate-tests.git"

  "author": "joshuakgoldberg@outlook.com",

    "url": "https://github.com/automutate/automutate-tests/issues"

  "homepage": "https://github.com/automutate/automutate-tests#readme",

    "src": "npm run src:tsc && npm run src:tslint",

    "src:tslint": "tslint -c tslint.json -p tsconfig.json -t stylish"

import { FileMutationsApplier, Logger, runMutations } from "automutate";

    mutationsProviderFactory: IMutationsProviderFactory,

    await arrangeFiles(settings.actual, settings.original);

    const expectedContents: string = (await fs.readFile(settings.expected)).toString();

        mutationsApplier: new FileMutationsApplier({ logger }),

        mutationsProvider: mutationsProviderFactory(settings.actual, settings.settings),

    const actualContents: string = (await fs.readFile(settings.actual)).toString();

    let actualContents: string = (await fs.readFile(settings.actual)).toString();

    if (settings.normalizeEndlines !== undefined) {

        actualContents = actualContents.replace(/\r\n|\n/g, settings.normalizeEndlines);

        await fs.writeFile(settings.expected, actualContents);

        expect(actualContents).to.be.equal(expectedContents);

const arrangeFiles = async (actual: string, original: string): Promise<void> => {

    await fs.writeFile(actual, await fs.readFile(original));

import { describeTests } from "./describeTests";

import { HierarchyCrawler, IHierarchy } from "./hierarchyCrawler";

import { ITestCaseSettings, runTestCase } from "./testCase";

 * Settings to describe test cases, namely file names and CLI flag equivalents.

export interface ITestDescriptionSettings extends ITestCaseSettings {

     * Generates a directory-based test hierarchy from the file system.

    private readonly hierarchyCrawler: HierarchyCrawler;

     * Creates test cases from test case settings.

    private readonly mutationsProviderFactory: IMutationsProviderFactory;

    private readonly settings: ITestDescriptionSettings;

    public constructor(mutationsProviderFactory: IMutationsProviderFactory, settings: ITestDescriptionSettings) {

        this.hierarchyCrawler = new HierarchyCrawler(this.settings.original);

    public describe(casesPath: string): void {

                "Including only tests that match any of:\n - ",

                chalk.cyan(this.settings.includes.join("\n - ")),

            this.hierarchyCrawler.crawl("cases", casesPath),

            async (hierarchy: IHierarchy): Promise<void> => this.runTest(hierarchy),

    private async runTest(hierarchy: IHierarchy): Promise<void> {

        const caseSettings = createTestCaseSettings(this.settings, hierarchy.directoryPath);

        if (caseSettings === undefined) {

            throw new Error(`Could not find ${this.settings.original} under ${hierarchy.directoryPath}.`);

        await runTestCase(caseSettings, this.mutationsProviderFactory);

 * @param settings   Settings for test cases.

 * @param casePath   Path to a test case.

const createTestCaseSettings = (settings: ITestDescriptionSettings, casePath: string): ITestCaseSettings | undefined => {

    const matches = glob.sync(path.join(casePath, settings.original));

        settings: path.join(casePath, settings.settings),

export const describeMutationTestCases = (

    const testsFactory = new TestsFactory(mutationsProviderFactory, settings);

		@@ -118,2 +118,3 @@ "use strict";
		expected: path.join(casePath, settings.expected),
		normalizeEndlines: settings.normalizeEndlines,
		original: matches[0],
		@@ -120,0 +121,0 @@ settings: path.join(casePath, settings.settings)

		{
		"name": "automutate-tests",
		"version": "0.3.0",
		"version": "0.3.1",
		"description": "Test harness for automutators.",
		@@ -5,0 +5,0 @@ "main": "lib/index.js",

		@@ -107,2 +107,3 @@ import chalk from "chalk";
		expected: path.join(casePath, settings.expected),
		normalizeEndlines: settings.normalizeEndlines,
		original: matches[0],
		@@ -109,0 +110,0 @@ settings: path.join(casePath, settings.settings),

		@@ -19,2 +19,6 @@ import { IMutationsProviderFactory } from "./mutationsProviderFactory";
		/**
		* Endlines to normalize \r\n\|\n to, if anything.
		*/
		normalizeEndlines?: string;
		/**
		* File name for the original file contents.
		@@ -21,0 +25,0 @@ */

		@@ -75,2 +75,5 @@ "use strict";
		actualContents = (_a.sent()).toString();
		if (settings.normalizeEndlines !== undefined) {
		actualContents = actualContents.replace(/\r\n\|\n/g, settings.normalizeEndlines);
		}
		if (!settings.accept) return [3 /break/, 6];
		@@ -77,0 +80,0 @@ return [4 /yield/, fs.writeFile(settings.expected, actualContents)];

		@@ -27,2 +27,7 @@ import { FileMutationsApplier, Logger, runMutations } from "automutate";
		/**
		* Endlines to normalize \r\n\|\n to, if anything.
		*/
		normalizeEndlines?: string;

		/**
		* File name for the original file contents.
		@@ -62,4 +67,8 @@ */
		// Assert
		const actualContents: string = (await fs.readFile(settings.actual)).toString();
		let actualContents: string = (await fs.readFile(settings.actual)).toString();

		if (settings.normalizeEndlines !== undefined) {
		actualContents = actualContents.replace(/\r\n\|\n/g, settings.normalizeEndlines);
		}

		if (settings.accept) {
		@@ -66,0 +75,0 @@ await fs.writeFile(settings.expected, actualContents);

Improved metrics