yeoman-test 6.2.0 → 7.0.0

package/dist/run-result.d.ts

@@ -0,0 +1,214 @@
+import MemFsEditor, { type Editor } from 'mem-fs-editor';
+import type { Store } from 'mem-fs';
+import type Environment from 'yeoman-environment';
+import type Generator from 'yeoman-generator';
+import { type RunContextSettings } from './run-context.js';
+import { type YeomanTest } from './helpers.js';
+/**
+ * Provides options for `RunResult`s.
+ */
+export type RunResultOptions<GeneratorType extends Generator> = {
+    generator: GeneratorType;
+    /**
+     * The environment of the generator.
+     */
+    env: Environment;
+    envOptions: Environment.Options;
+    /**
+     * The working directory after running the generator.
+     */
+    cwd: string;
+    /**
+     * The working directory before on running the generator.
+     */
+    oldCwd: string;
+    /**
+     * The file-system of the generator.
+     */
+    memFs: Store;
+    fs?: MemFsEditor.Editor;
+    /**
+     * The mocked generators of the context.
+     */
+    mockedGenerators: Record<string, Generator>;
+    settings: RunContextSettings;
+    helpers: YeomanTest;
+};
+/**
+ * This class provides utilities for testing generated content.
+ */
+export default class RunResult<GeneratorType extends Generator> {
+    env: any;
+    generator: GeneratorType;
+    cwd: string;
+    oldCwd: string;
+    memFs: Store;
+    fs: Editor;
+    mockedGenerators: any;
+    options: RunResultOptions<GeneratorType>;
+    constructor(options: RunResultOptions<GeneratorType>);
+    /**
+     * Create another RunContext reusing the settings.
+     * See helpers.create api
+     */
+    create(GeneratorOrNamespace: any, settings: any, envOptions: any): import("./run-context.js").default<Generator<Generator.GeneratorOptions>>;
+    /**
+     * Return an object with fs changes.
+     * @param {Function} filter - parameter forwarded to mem-fs-editor#dump
+     */
+    getSnapshot(filter?: any): Record<string, {
+        contents: string;
+        stateCleared: string;
+    }>;
+    /**
+     * Return an object with filenames with state.
+     * @param {Function} filter - parameter forwarded to mem-fs-editor#dump
+     * @returns {Object}
+     */
+    getStateSnapshot(filter?: any): Record<string, {
+        stateCleared: string;
+    }>;
+    /**
+     * Either dumps the contents of the specified files or the name and the contents of each file to the console.
+     */
+    dumpFiles(...files: string[]): this;
+    /**
+     * Dumps the name of each file to the console.
+     */
+    dumpFilenames(): this;
+    /**
+     * Reverts to old cwd.
+     * @returns this
+     */
+    restore(): this;
+    /**
+     * Deletes the test directory recursively.
+     */
+    cleanup(): this;
+    _fileName(filename: any): any;
+    _readFile(filename: any, json?: boolean): any;
+    _exists(filename: any): boolean;
+    /**
+     * Assert that a file exists
+     * @param path     - path to a file
+     * @example
+     * result.assertFile('templates/user.hbs');
+     *
+     * @also
+     *
+     * Assert that each files in the array exists
+     * @param paths    - an array of paths to files
+     * @example
+     * result.assertFile(['templates/user.hbs', 'templates/user/edit.hbs']);
+     */
+    assertFile(path: string | string[]): void;
+    /**
+     * Assert that a file doesn't exist
+     * @param file     - path to a file
+     * @example
+     * result.assertNoFile('templates/user.hbs');
+     *
+     * @also
+     *
+     * Assert that each of an array of files doesn't exist
+     * @param pairs    - an array of paths to files
+     * @example
+     * result.assertNoFile(['templates/user.hbs', 'templates/user/edit.hbs']);
+     */
+    assertNoFile(files: string | string[]): void;
+    /**
+     * Assert that a file's content matches a regex or string
+     * @param file     - path to a file
+     * @param reg      - regex / string that will be used to search the file
+     * @example
+     * result.assertFileContent('models/user.js', /App\.User = DS\.Model\.extend/);
+     * result.assertFileContent('models/user.js', 'App.User = DS.Model.extend');
+     *
+     * @also
+     *
+     * Assert that each file in an array of file-regex pairs matches its corresponding regex
+     * @param pairs    - an array of arrays, where each subarray is a [String, RegExp] pair
+     * @example
+     * var arg = [
+     *   [ 'models/user.js', /App\.User = DS\.Model\.extend/ ],
+     *   [ 'controllers/user.js', /App\.UserController = Ember\.ObjectController\.extend/ ]
+     * ]
+     * result.assertFileContent(arg);
+     */
+    assertFileContent(file: string, reg: string | RegExp): void;
+    assertFileContent(pairs: Array<[string, string | RegExp]>): void;
+    /**
+     * Assert that a file's content is the same as the given string
+     * @param file            - path to a file
+     * @param expectedContent - the expected content of the file
+     * @example
+     * result.assertEqualsFileContent(
+     *   'data.js',
+     *   'const greeting = "Hello";\nexport default { greeting }'
+     * );
+     *
+     * @also
+     *
+     * Assert that each file in an array of file-string pairs equals its corresponding string
+     * @param pairs           - an array of arrays, where each subarray is a [String, String] pair
+     * @example
+     * result.assertEqualsFileContent([
+     *   ['data.js', 'const greeting = "Hello";\nexport default { greeting }'],
+     *   ['user.js', 'export default {\n  name: 'Coleman',\n  age: 0\n}']
+     * ]);
+     */
+    assertEqualsFileContent(file: string, expectedContent: string): void;
+    assertEqualsFileContent(pairs: Array<[string, string]>): void;
+    /**
+     * Assert that a file's content does not match a regex / string
+     * @param file     - path to a file
+     * @param reg      - regex / string that will be used to search the file
+     * @example
+     * result.assertNoFileContent('models/user.js', /App\.User = DS\.Model\.extend/);
+     * result.assertNoFileContent('models/user.js', 'App.User = DS.Model.extend');
+     *
+     * @also
+     *
+     * Assert that each file in an array of file-regex pairs does not match its corresponding regex
+     * @param pairs    - an array of arrays, where each subarray is a [String, RegExp] pair
+     * var arg = [
+     *   [ 'models/user.js', /App\.User \ DS\.Model\.extend/ ],
+     *   [ 'controllers/user.js', /App\.UserController = Ember\.ObjectController\.extend/ ]
+     * ]
+     * result.assertNoFileContent(arg);
+     */
+    assertNoFileContent(file: string, reg: RegExp | string): void;
+    assertNoFileContent(pairs: Array<[string, string | RegExp]>): void;
+    /**
+     * Assert that two strings are equal after standardization of newlines
+     * @param value    - a string
+     * @param expected - the expected value of the string
+     * @example
+     * result.assertTextEqual('I have a yellow cat', 'I have a yellow cat');
+     */
+    assertTextEqual(value: string, expected: string): void;
+    /**
+     * Assert an object contains the provided keys
+     * @param obj      Object that should match the given pattern
+     * @param content  An object of key/values the object should contains
+     */
+    assertObjectContent(object: Record<string, unknown>, content: Record<string, any>): void;
+    /**
+     * Assert an object does not contain the provided keys
+     * @param obj Object that should not match the given pattern
+     * @param content An object of key/values the object should not contain
+     */
+    assertNoObjectContent(object: Record<string, unknown>, content: Record<string, any>): void;
+    /**
+     * Assert a JSON file contains the provided keys
+     * @param filename
+     * @param content An object of key/values the file should contains
+     */
+    assertJsonFileContent(filename: string, content: Record<string, any>): void;
+    /**
+     * Assert a JSON file does not contain the provided keys
+     * @param filename
+     * @param content An object of key/values the file should not contain
+     */
+    assertNoJsonFileContent(filename: string, content: Record<string, any>): void;
+}

package/dist/run-result.js

@@ -0,0 +1,258 @@
+import assert from 'node:assert';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import MemFsEditor from 'mem-fs-editor';
+const isObject = object => typeof object === 'object' && object !== null && object !== undefined;
+function convertArgs(args) {
+    if (args.length > 1) {
+        return [[...args]];
+    }
+    const arg = args[0];
+    return Array.isArray(arg) ? arg : [arg];
+}
+/**
+ * This class provides utilities for testing generated content.
+ */
+export default class RunResult {
+    env;
+    generator;
+    cwd;
+    oldCwd;
+    memFs;
+    fs;
+    mockedGenerators;
+    options;
+    constructor(options) {
+        if (options.memFs && !options.cwd) {
+            throw new Error('CWD option is required for mem-fs tests');
+        }
+        this.env = options.env;
+        this.generator = options.generator;
+        this.cwd = options.cwd ?? process.cwd();
+        this.oldCwd = options.oldCwd;
+        this.memFs = options.memFs;
+        this.fs = this.memFs && MemFsEditor.create(this.memFs);
+        this.mockedGenerators = options.mockedGenerators || {};
+        this.options = options;
+    }
+    /**
+     * Create another RunContext reusing the settings.
+     * See helpers.create api
+     */
+    create(GeneratorOrNamespace, settings, envOptions) {
+        return this.options.helpers.create(GeneratorOrNamespace, {
+            ...this.options.settings,
+            cwd: this.cwd,
+            oldCwd: this.oldCwd,
+            ...settings,
+            autoCleanup: false,
+        }, { ...this.options.envOptions, memFs: this.memFs, ...envOptions });
+    }
+    /**
+     * Return an object with fs changes.
+     * @param {Function} filter - parameter forwarded to mem-fs-editor#dump
+     */
+    getSnapshot(filter) {
+        return this.fs.dump(this.cwd, filter);
+    }
+    /**
+     * Return an object with filenames with state.
+     * @param {Function} filter - parameter forwarded to mem-fs-editor#dump
+     * @returns {Object}
+     */
+    getStateSnapshot(filter) {
+        const snapshot = this.getSnapshot(filter);
+        for (const dump of Object.values(snapshot)) {
+            delete dump.contents;
+        }
+        return snapshot;
+    }
+    /**
+     * Either dumps the contents of the specified files or the name and the contents of each file to the console.
+     */
+    dumpFiles(...files) {
+        if (files.length === 0) {
+            this.memFs.each(file => {
+                console.log(file.path);
+                if (file.contents) {
+                    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                    console.log(file.contents.toString('utf8'));
+                }
+            });
+            return this;
+        }
+        for (const file of files) {
+            console.log(this.fs.read(this._fileName(file)));
+        }
+        return this;
+    }
+    /**
+     * Dumps the name of each file to the console.
+     */
+    dumpFilenames() {
+        this.memFs.each(file => {
+            console.log(file.path);
+        });
+        return this;
+    }
+    /**
+     * Reverts to old cwd.
+     * @returns this
+     */
+    restore() {
+        process.chdir(this.oldCwd);
+        return this;
+    }
+    /**
+     * Deletes the test directory recursively.
+     */
+    cleanup() {
+        process.chdir(this.oldCwd);
+        rmSync(this.cwd, { recursive: true });
+        return this;
+    }
+    _fileName(filename) {
+        if (path.isAbsolute(filename)) {
+            return filename;
+        }
+        return path.join(this.cwd, filename);
+    }
+    _readFile(filename, json) {
+        filename = this._fileName(filename);
+        const file = this.fs ? this.fs.read(filename) : readFileSync(filename, 'utf8');
+        return json ? JSON.parse(file) : file;
+    }
+    _exists(filename) {
+        filename = this._fileName(filename);
+        if (this.fs) {
+            return this.fs.exists(filename);
+        }
+        return existsSync(filename);
+    }
+    /**
+     * Assert that a file exists
+     * @param path     - path to a file
+     * @example
+     * result.assertFile('templates/user.hbs');
+     *
+     * @also
+     *
+     * Assert that each files in the array exists
+     * @param paths    - an array of paths to files
+     * @example
+     * result.assertFile(['templates/user.hbs', 'templates/user/edit.hbs']);
+     */
+    assertFile(path) {
+        for (const file of convertArgs([path])) {
+            const here = this._exists(file);
+            assert.ok(here, `${file}, no such file or directory`);
+        }
+    }
+    /**
+     * Assert that a file doesn't exist
+     * @param file     - path to a file
+     * @example
+     * result.assertNoFile('templates/user.hbs');
+     *
+     * @also
+     *
+     * Assert that each of an array of files doesn't exist
+     * @param pairs    - an array of paths to files
+     * @example
+     * result.assertNoFile(['templates/user.hbs', 'templates/user/edit.hbs']);
+     */
+    assertNoFile(files) {
+        for (const file of convertArgs([files])) {
+            const here = this._exists(file);
+            assert.ok(!here, `${file} exists`);
+        }
+    }
+    assertFileContent(...args) {
+        for (const pair of convertArgs(args)) {
+            const file = pair[0];
+            const regex = pair[1];
+            this.assertFile(file);
+            const body = this._readFile(file);
+            let match = false;
+            match = typeof regex === 'string' ? body.includes(regex) : regex.test(body);
+            assert(match, `${file} did not match '${regex}'. Contained:\n\n${body}`);
+        }
+    }
+    assertEqualsFileContent(...args) {
+        for (const pair of convertArgs(args)) {
+            const file = pair[0];
+            const expectedContent = pair[1];
+            this.assertFile(file);
+            this.assertTextEqual(this._readFile(file), expectedContent);
+        }
+    }
+    assertNoFileContent(...args) {
+        for (const pair of convertArgs(args)) {
+            const file = pair[0];
+            const regex = pair[1];
+            this.assertFile(file);
+            const body = this._readFile(file);
+            if (typeof regex === 'string') {
+                assert.ok(!body.includes(regex), `${file} matched '${regex}'.`);
+                continue;
+            }
+            assert.ok(!regex.test(body), `${file} matched '${regex}'.`);
+        }
+    }
+    /**
+     * Assert that two strings are equal after standardization of newlines
+     * @param value    - a string
+     * @param expected - the expected value of the string
+     * @example
+     * result.assertTextEqual('I have a yellow cat', 'I have a yellow cat');
+     */
+    assertTextEqual(value, expected) {
+        const eol = string => string.replace(/\r\n/g, '\n');
+        assert.equal(eol(value), eol(expected));
+    }
+    /**
+     * Assert an object contains the provided keys
+     * @param obj      Object that should match the given pattern
+     * @param content  An object of key/values the object should contains
+     */
+    assertObjectContent(object, content) {
+        for (const key of Object.keys(content)) {
+            if (isObject(content[key])) {
+                this.assertObjectContent(object[key], content[key]);
+                continue;
+            }
+            assert.equal(object[key], content[key]);
+        }
+    }
+    /**
+     * Assert an object does not contain the provided keys
+     * @param obj Object that should not match the given pattern
+     * @param content An object of key/values the object should not contain
+     */
+    assertNoObjectContent(object, content) {
+        for (const key of Object.keys(content)) {
+            if (isObject(content[key])) {
+                this.assertNoObjectContent(object[key], content[key]);
+                continue;
+            }
+            assert.notEqual(object[key], content[key]);
+        }
+    }
+    /**
+     * Assert a JSON file contains the provided keys
+     * @param filename
+     * @param content An object of key/values the file should contains
+     */
+    assertJsonFileContent(filename, content) {
+        this.assertObjectContent(this._readFile(filename, true), content);
+    }
+    /**
+     * Assert a JSON file does not contain the provided keys
+     * @param filename
+     * @param content An object of key/values the file should not contain
+     */
+    assertNoJsonFileContent(filename, content) {
+        this.assertNoObjectContent(this._readFile(filename, true), content);
+    }
+}

package/dist/test-context.d.ts

@@ -0,0 +1,8 @@
+import type RunContext from './run-context.js';
+declare class TestContext {
+    autoCleanup: boolean;
+    private runContext?;
+    startNewContext(runContext: RunContext<any>): void;
+}
+declare const _default: TestContext;
+export default _default;

package/dist/test-context.js

@@ -0,0 +1,9 @@
+class TestContext {
+    autoCleanup = false;
+    runContext;
+    startNewContext(runContext) {
+        this.runContext?.cleanupTemporaryDir();
+        this.runContext = runContext;
+    }
+}
+export default new TestContext();

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "yeoman-test",
-  "version": "6.2.0",
+  "version": "7.0.0",
   "description": "Test utilities for Yeoman generators",
   "homepage": "http://yeoman.io/authoring/testing.html",
   "author": "The Yeoman Team",
+  "type": "module",
   "files": [
-    "lib"
+    "dist"
   ],
-  "main": "lib/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js"
+  },
   "keywords": [
     "yeoman",
     "unit test"
@@ -15,39 +20,50 @@
   "repository": "yeoman/yeoman-test",
   "license": "MIT",
   "engines": {
-    "node": ">=12.10.0"
+    "node": "^14.15.0 || ^16.13.0 || >=18.12.0"
   },
   "config": {
     "doc_path": "../yeoman-test-doc"
   },
   "devDependencies": {
-    "coveralls": "^3.1.0",
-    "husky": "^4.2.5",
-    "jsdoc": "^3.6.6",
-    "lint-staged": "^10.2.11",
-    "mem-fs": "^2.1.0",
-    "mocha": "^8.0.1",
-    "nyc": "^15.1.0",
+    "@esbuild-kit/esm-loader": "^2.5.1",
+    "@types/mocha": "^10.0.0",
+    "@types/sinon": "^10.0.13",
+    "coveralls": "^3.1.1",
+    "husky": "^8.0.2",
+    "jsdoc": "^3.6.10",
+    "lint-staged": "^13.0.3",
+    "mem-fs": "^2.2.1",
+    "mocha": "^10.1.0",
+    "mocha-expect-snapshot": "^7.0.0",
     "prettier": "^2.2.1",
+    "prettier-plugin-packagejson": "^2.3.0",
     "tui-jsdoc-template": "^1.2.2",
-    "xo": "^0.32.1",
-    "yeoman-environment": "^3.3.0",
-    "yeoman-generator": "^5.0.0"
+    "typescript": "^4.9.3",
+    "xo": "^0.53.1",
+    "yeoman-environment": "^3.13.0",
+    "yeoman-generator": "^5.7.0"
   },
   "dependencies": {
-    "inquirer": "^8.0.0",
+    "@types/inquirer": "^8.2.5",
+    "@types/mem-fs-editor": "^7.0.2",
+    "@types/yeoman-environment": "^2.10.8",
+    "@types/yeoman-generator": "^5.2.11",
+    "inquirer": "^8.2.5",
     "lodash": "^4.17.21",
-    "mem-fs-editor": "^9.0.0",
-    "sinon": "^10.0.0",
-    "temp-dir": "^2.0.0"
+    "mem-fs-editor": "^9.5.0",
+    "sinon": "^14.0.2",
+    "temp-dir": "^3.0.0"
   },
   "peerDependencies": {
-    "mem-fs": "^2.1.0",
-    "yeoman-environment": "^3.3.0",
+    "mem-fs": "^2.2.1",
+    "yeoman-environment": "^3.13.0",
     "yeoman-generator": "*"
   },
   "scripts": {
-    "test": "nyc mocha",
+    "test": "mocha",
+    "build": "tsc",
+    "prepare": "npm run build",
     "pretest": "xo",
     "precommit": "lint-staged",
     "doc": "npm run doc:generate && npm run doc:fix && npm run doc:prettier",

package/lib/adapter.js

@@ -1,107 +0,0 @@
-/* eslint-disable max-params */
-'use strict';
-const events = require('events');
-const inquirer = require('inquirer');
-const sinon = require('sinon');
-const {PassThrough} = require('stream');
-
-function DummyPrompt(mockedAnswers, options, question, _rl, answers) {
-  this.answers = {...answers, ...mockedAnswers};
-  this.question = question;
-
-  if (typeof options === 'function') {
-    this.callback = options;
-  } else if (options) {
-    this.callback = options.callback;
-    this.throwOnMissingAnswer = options.throwOnMissingAnswer;
-  }
-
-  this.callback = this.callback || ((answers) => answers);
-}
-
-DummyPrompt.prototype.run = function () {
-  let answer = this.answers[this.question.name];
-  let isSet;
-
-  switch (this.question.type) {
-    case 'list':
-      // List prompt accepts any answer value including null
-      isSet = answer !== undefined;
-      break;
-    case 'confirm':
-      // Ensure that we don't replace `false` with default `true`
-      isSet = answer || answer === false;
-      break;
-    default:
-      // Other prompts treat all falsy values to default
-      isSet = Boolean(answer);
-  }
-
-  if (!isSet) {
-    if (answer === undefined && this.question.default === undefined) {
-      const missingAnswerMessage = `yeoman-test: question ${this.question.name} was asked but answer was not provided`;
-      console.warn(missingAnswerMessage);
-      if (this.throwOnMissingAnswer) {
-        return Promise.reject(new Error(missingAnswerMessage));
-      }
-    }
-
-    answer = this.question.default;
-
-    if (answer === undefined && this.question.type === 'confirm') {
-      answer = true;
-    }
-  }
-
-  return Promise.resolve(this.callback(answer));
-};
-
-function TestAdapter(mockedAnswers) {
-  this.promptModule = inquirer.createPromptModule({
-    input: new PassThrough(),
-    output: new PassThrough(),
-    skipTTYChecks: true
-  });
-
-  Object.keys(this.promptModule.prompts).forEach(function (promptName) {
-    this.promptModule.registerPrompt(
-      promptName,
-      class CustomDummyPrompt extends DummyPrompt {
-        constructor(question, rl, answers) {
-          super(mockedAnswers, undefined, question, rl, answers);
-        }
-      }
-    );
-  }, this);
-
-  this.diff = sinon.spy();
-  this.log = sinon.spy();
-  Object.assign(this.log, events.EventEmitter.prototype);
-
-  // Make sure all log methods are defined
-  [
-    'write',
-    'writeln',
-    'ok',
-    'error',
-    'skip',
-    'force',
-    'create',
-    'invoke',
-    'conflict',
-    'identical',
-    'info',
-    'table'
-  ].forEach(function (methodName) {
-    this.log[methodName] = sinon.stub().returns(this.log);
-  }, this);
-}
-
-TestAdapter.prototype.prompt = function (questions, prefilledAnswers) {
-  return this.promptModule(questions, prefilledAnswers);
-};
-
-module.exports = {
-  DummyPrompt,
-  TestAdapter
-};