yeoman-test 8.0.0-beta.5 → 8.0.0-beta.7

package/dist/adapter.d.ts

@@ -1,22 +1,31 @@
 import type { PromptAnswers, PromptQuestion, Logger, InputOutputAdapter, PromptQuestions } from '@yeoman/types';
 import { type PromptModule } from 'inquirer';
+export type DummyPromptCallback = (answer: any, { question, answers }: {
+    question: PromptQuestion;
+    answers: PromptAnswers;
+}) => any;
 export type DummyPromptOptions = {
-    callback?: (answers: PromptAnswers) => PromptAnswers;
+    mockedAnswers?: PromptAnswers;
+    callback?: DummyPromptCallback;
     throwOnMissingAnswer?: boolean;
 };
+export type TestAdapterOptions = DummyPromptOptions & {
+    log?: any;
+};
 export declare class DummyPrompt {
     answers: PromptAnswers;
     question: PromptQuestion;
-    callback: (answers: PromptAnswers) => PromptAnswers;
+    callback: DummyPromptCallback;
     throwOnMissingAnswer: boolean;
-    constructor(question: PromptQuestion, _rl: any, answers: PromptAnswers, mockedAnswers?: PromptAnswers, options?: ((answers: PromptAnswers) => PromptAnswers) | DummyPromptOptions);
-    run(): Promise<import("inquirer").Answers>;
+    constructor(question: PromptQuestion, _rl: any, answers: PromptAnswers, options?: DummyPromptOptions);
+    run(): Promise<any>;
 }
 export declare class TestAdapter implements InputOutputAdapter {
     promptModule: PromptModule;
     diff: any;
     log: Logger;
-    constructor(mockedAnswers?: PromptAnswers);
+    registerDummyPrompt: (promptName: string, customPromptOptions?: DummyPromptOptions) => PromptModule;
+    constructor(options?: TestAdapterOptions);
     close(): void;
     prompt<A extends PromptAnswers = PromptAnswers>(questions: PromptQuestions<A>, initialAnswers?: Partial<A> | undefined): Promise<A>;
 }

package/dist/adapter.js

@@ -1,6 +1,6 @@
-/* eslint-disable max-params */
 import events from 'node:events';
 import { PassThrough } from 'node:stream';
+import { createLogger } from '@yeoman/adapter';
 import { spy as sinonSpy, stub as sinonStub } from 'sinon';
 import { createPromptModule } from 'inquirer';
 export class DummyPrompt {
@@ -8,21 +8,12 @@ export class DummyPrompt {
     question;
     callback;
     throwOnMissingAnswer = false;
-    constructor(question, _rl, answers, mockedAnswers, options) {
+    constructor(question, _rl, answers, options = {}) {
+        const { mockedAnswers, callback, throwOnMissingAnswer } = options;
         this.answers = { ...answers, ...mockedAnswers };
         this.question = question;
-        if (typeof options === 'function') {
-            this.callback = options;
-        }
-        else if (options) {
-            if (options.callback) {
-                this.callback = options.callback;
-            }
-            if (options.throwOnMissingAnswer !== undefined) {
-                this.throwOnMissingAnswer = options.throwOnMissingAnswer;
-            }
-        }
-        this.callback = this.callback || (answers => answers);
+        this.callback = callback ?? (answers => answers);
+        this.throwOnMissingAnswer = throwOnMissingAnswer ?? false;
     }
     async run() {
         let answer = this.answers[this.question.name];
@@ -56,45 +47,40 @@ export class DummyPrompt {
                 answer = true;
             }
         }
-        return this.callback(answer);
+        return this.callback(answer, { question: this.question, answers: this.answers });
     }
 }
 export class TestAdapter {
     promptModule;
     diff;
     log;
-    constructor(mockedAnswers) {
+    registerDummyPrompt;
+    constructor(options = {}) {
+        const { log = createLogger(), ...promptOptions } = options;
         this.promptModule = createPromptModule({
             input: new PassThrough(),
             output: new PassThrough(),
             skipTTYChecks: true,
         });
+        const actualRegisterPrompt = this.promptModule.registerPrompt.bind(this.promptModule);
+        this.registerDummyPrompt = (promptModuleName, customPromptOptions) => actualRegisterPrompt(promptModuleName, class CustomDummyPrompt extends DummyPrompt {
+            constructor(question, rl, answers) {
+                super(question, rl, answers, customPromptOptions ?? promptOptions);
+            }
+        });
+        this.promptModule.registerPrompt = (name) => this.registerDummyPrompt(name);
         for (const promptName of Object.keys(this.promptModule.prompts)) {
-            this.promptModule.registerPrompt(promptName, class CustomDummyPrompt extends DummyPrompt {
-                constructor(question, rl, answers) {
-                    super(question, rl, answers, mockedAnswers);
-                }
-            });
+            this.promptModule.registerPrompt(promptName, undefined);
         }
         this.diff = sinonSpy();
         this.log = sinonSpy();
         Object.assign(this.log, events.EventEmitter.prototype);
+        const descriptors = Object.getOwnPropertyDescriptors(log);
         // Make sure all log methods are defined
-        const adapterMethods = [
-            'write',
-            'writeln',
-            'ok',
-            'error',
-            'skip',
-            'force',
-            'create',
-            'invoke',
-            'conflict',
-            'identical',
-            'info',
-            'table',
-        ];
-        for (const methodName of adapterMethods) {
+        const logMethods = Object.entries(descriptors)
+            .filter(([method, desc]) => typeof desc.value === 'function' && !Object.getOwnPropertyDescriptor(this.log, method))
+            .map(([method]) => method);
+        for (const methodName of logMethods) {
             this.log[methodName] = sinonStub().returns(this.log);
         }
     }

package/dist/default-environment.d.ts

@@ -1 +1 @@
-export function defaultEnvironment(): Promise<any>;
+export function createEnv(options: import('@yeoman/types').BaseEnvironmentOptions): import('@yeoman/types').BaseEnvironment;

package/dist/default-environment.js

@@ -1,4 +1,15 @@
-export const defaultEnvironment = async () => {
-    const dynamicEnv = await import('yeoman-environment');
-    return dynamicEnv.createEnv ?? dynamicEnv.default.createEnv;
+/**
+ * @param {import('@yeoman/types').BaseEnvironmentOptions} options
+ * @returns {import('@yeoman/types').BaseEnvironment}
+ */
+export const createEnv = async (options) => {
+    const DynamicEnv = await import('yeoman-environment');
+    if (typeof DynamicEnv === 'function') {
+        return new DynamicEnv(options);
+    }
+    if (typeof DynamicEnv.default === 'function') {
+        // eslint-disable-next-line new-cap
+        return new DynamicEnv.default(options);
+    }
+    throw new Error(`'yeoman-environment' didn't returned a constructor`);
 };

package/dist/helpers.d.ts

@@ -1,8 +1,9 @@
-import type { BaseEnvironmentOptions, BaseGenerator, BaseGeneratorOptions, GetGeneratorConstructor, GetGeneratorOptions, PromptAnswers } from '@yeoman/types';
+import type { BaseEnvironment, BaseEnvironmentOptions, BaseGenerator, BaseGeneratorOptions, GetGeneratorConstructor, InstantiateOptions, PromptAnswers } from '@yeoman/types';
 import type { SinonSpiedInstance } from 'sinon';
 import type { DefaultEnvironmentApi, DefaultGeneratorApi } from '../types/type-helpers.js';
 import { type DummyPromptOptions } from './adapter.js';
 import RunContext, { BasicRunContext, type RunContextSettings } from './run-context.js';
+export type CreateEnv = (options: BaseEnvironmentOptions) => Promise<BaseEnvironment>;
 /**
  * Dependencies can be path (autodiscovery) or an array [<generator>, <name>]
  */
@@ -89,7 +90,10 @@ export declare class YeomanTest {
      *            ];
      * var angular = createGenerator('angular:app', deps);
      */
-    createGenerator<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(name: string, dependencies: Dependency[], args?: string[], options?: GetGeneratorOptions<GeneratorType>, localConfigOnly?: boolean): Promise<GeneratorType>;
+    createGenerator<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(name: string | GetGeneratorConstructor<GeneratorType>, options?: {
+        dependencies?: Dependency[];
+        localConfigOnly?: boolean;
+    } & InstantiateOptions<GeneratorType>): Promise<GeneratorType>;
     /**
      * Shortcut to the Environment's createEnv.
      *
@@ -105,7 +109,7 @@ export declare class YeomanTest {
      *   createEnv.restore();
      * });
      */
-    createEnv(...args: any[]): Promise<DefaultEnvironmentApi>;
+    createEnv(options: BaseEnvironmentOptions): Promise<DefaultEnvironmentApi>;
     /**
      * Creates a test environment.
      *
@@ -113,7 +117,7 @@ export declare class YeomanTest {
      * @param {Object} - Options to be passed to the environment
      * const env = createTestEnv(require('yeoman-environment').createEnv);
      */
-    createTestEnv(envContructor?: (...args: any[]) => Promise<import("@yeoman/types").BaseEnvironment>, options?: BaseEnvironmentOptions): Promise<import("@yeoman/types").BaseEnvironment>;
+    createTestEnv(envContructor?: CreateEnv, options?: BaseEnvironmentOptions): Promise<BaseEnvironment>;
     /**
      * Get RunContext type
      * @return {RunContext}

package/dist/helpers.js

@@ -1,13 +1,12 @@
-/* eslint-disable max-params */
 import { mkdirSync, existsSync, rmSync } from 'node:fs';
 import { resolve } from 'node:path';
 import process from 'node:process';
 import _ from 'lodash';
 import { spy as sinonSpy, stub as sinonStub } from 'sinon';
-import { DummyPrompt, TestAdapter } from './adapter.js';
+import { TestAdapter } from './adapter.js';
 import RunContext, { BasicRunContext } from './run-context.js';
 import testContext from './test-context.js';
-import { defaultEnvironment } from './default-environment.js';
+import { createEnv } from './default-environment.js';
 let GeneratorImplementation;
 try {
     const GeneratorImport = await import('yeoman-generator');
@@ -84,13 +83,10 @@ export class YeomanTest {
         if (!environment.adapter) {
             throw new Error('environment is not an Environment instance');
         }
-        const { promptModule } = environment.adapter;
+        const testAdapter = environment.adapter;
+        const { promptModule } = testAdapter;
         for (const name of Object.keys(promptModule.prompts)) {
-            promptModule.registerPrompt(name, class CustomDummyPrompt extends DummyPrompt {
-                constructor(question, rl, answers) {
-                    super(question, rl, answers, mockedAnswers, options);
-                }
-            });
+            testAdapter.registerDummyPrompt(name, { ...options, mockedAnswers });
         }
     }
     /**
@@ -170,8 +166,9 @@ export class YeomanTest {
      *            ];
      * var angular = createGenerator('angular:app', deps);
      */
-    async createGenerator(name, dependencies, args, options, localConfigOnly = true) {
-        const env = await this.createEnv([], { sharedOptions: { localConfigOnly } });
+    async createGenerator(name, options = {}) {
+        const { dependencies = [], localConfigOnly = true, ...instantiateOptions } = options;
+        const env = await this.createEnv({ sharedOptions: { localConfigOnly } });
         for (const dependency of dependencies) {
             if (typeof dependency === 'string') {
                 env.register(dependency);
@@ -180,7 +177,7 @@ export class YeomanTest {
                 env.register(...dependency);
             }
         }
-        return env.create(name, { generatorArgs: args, generatorOptions: options });
+        return env.create(name, instantiateOptions);
     }
     /**
      * Shortcut to the Environment's createEnv.
@@ -197,8 +194,8 @@ export class YeomanTest {
      *   createEnv.restore();
      * });
      */
-    async createEnv(...args) {
-        return (await defaultEnvironment())(...args);
+    async createEnv(options) {
+        return createEnv(options);
     }
     /**
      * Creates a test environment.
@@ -231,7 +228,7 @@ export class YeomanTest {
                 ...options,
             };
         }
-        return envContructor([], envOptions, new TestAdapter());
+        return envContructor({ adapter: new TestAdapter(), ...envOptions });
     }
     /**
      * Get RunContext type

package/dist/run-context.d.ts

@@ -5,8 +5,8 @@ import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor, Ge
 import { type MemFsEditorFile, type MemFsEditor } from 'mem-fs-editor';
 import type { DefaultGeneratorApi, DefaultEnvironmentApi } from '../types/type-helpers.js';
 import RunResult, { type RunResultOptions } from './run-result.js';
-import { type Dependency, type YeomanTest } from './helpers.js';
-import { type DummyPromptOptions } from './adapter.js';
+import { type CreateEnv, type Dependency, type YeomanTest } from './helpers.js';
+import { type DummyPromptOptions, type TestAdapterOptions } from './adapter.js';
 /**
  * Provides settings for creating a `RunContext`.
  */
@@ -34,7 +34,7 @@ export type RunContextSettings = {
 type PromiseRunResult<GeneratorType extends BaseGenerator> = Promise<RunResult<GeneratorType>>;
 type MockedGeneratorFactory<GenParameter extends BaseGenerator = DefaultGeneratorApi> = (GeneratorClass?: GetGeneratorConstructor<GenParameter>) => GetGeneratorConstructor<GenParameter>;
 type EnvOptions = BaseEnvironmentOptions & {
-    createEnv?: any;
+    createEnv?: CreateEnv;
 };
 export declare class RunContextBase<GeneratorType extends BaseGenerator = DefaultGeneratorApi> extends EventEmitter {
     readonly mockedGenerators: Record<string, BaseGenerator>;
@@ -51,6 +51,7 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
     private args;
     private options;
     private answers?;
+    private readonly adapterOptions?;
     private keepFsState?;
     private readonly onGeneratorCallbacks;
     private readonly onTargetDirectoryCallbacks;
@@ -136,6 +137,10 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param force - force directory cleanup for not tmpdir
      */
     cleanTestDirectory(force?: boolean): void;
+    /**
+     * TestAdapter options.
+     */
+    withAdapterOptions(options: Omit<TestAdapterOptions, 'mockedAnswers'>): this;
     /**
      * Create an environment
      *
@@ -172,14 +177,14 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param  {Boolean} [options.throwOnMissingAnswer] - Throw if a answer is missing.
      * @return {this}
      */
-    withPrompts(answers: PromptAnswers, options?: DummyPromptOptions): this;
+    withPrompts(answers: PromptAnswers, options?: Omit<DummyPromptOptions, 'mockedAnswers'>): this;
     /**
      * Mock answers for prompts
      * @param  answers - Answers to the prompt questions
      * @param  options - Options or callback.
      * @return {this}
      */
-    withAnswers(answers: PromptAnswers, options?: DummyPromptOptions): this;
+    withAnswers(answers: PromptAnswers, options?: Omit<DummyPromptOptions, 'mockedAnswers'>): this;
     /**
      * Provide dependent generators
      * @param {Array} dependencies - paths to the generators dependencies

package/dist/run-context.js

@@ -12,6 +12,7 @@ import tempDirectory from 'temp-dir';
 import { create as createMemFsEditor } from 'mem-fs-editor';
 import RunResult from './run-result.js';
 import defaultHelpers from './helpers.js';
+import { TestAdapter } from './adapter.js';
 import testContext from './test-context.js';
 const { camelCase, kebabCase, merge: lodashMerge, set: lodashSet } = _;
 export class RunContextBase extends EventEmitter {
@@ -29,6 +30,7 @@ export class RunContextBase extends EventEmitter {
     args = [];
     options = {};
     answers;
+    adapterOptions = {};
     keepFsState;
     onGeneratorCallbacks = [];
     onTargetDirectoryCallbacks = [];
@@ -194,6 +196,13 @@ export class RunContextBase extends EventEmitter {
             rmSync(this.targetDirectory, { recursive: true });
         }
     }
+    /**
+     * TestAdapter options.
+     */
+    withAdapterOptions(options) {
+        Object.assign(this.adapterOptions, options);
+        return this;
+    }
     /**
      * Create an environment
      *
@@ -268,13 +277,9 @@ export class RunContextBase extends EventEmitter {
      * @return {this}
      */
     withAnswers(answers, options) {
-        const callbackSet = Boolean(this.answers);
         this.answers = { ...this.answers, ...answers };
-        if (callbackSet)
-            return this;
-        return this.onEnvironment(env => {
-            this.helpers.mockPrompt(env, this.answers, options);
-        });
+        Object.assign(this.adapterOptions, options);
+        return this;
     }
     /**
      * Provide dependent generators
@@ -485,7 +490,7 @@ export class RunContextBase extends EventEmitter {
             force: true,
             skipCache: true,
             skipInstall: true,
-            ...this.options,
+            adapter: new TestAdapter({ ...this.adapterOptions, mockedAnswers: this.answers }),
             ...this.envOptions,
         });
         this.env = this.envCB ? (await this.envCB(testEnv)) ?? testEnv : testEnv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-test",
-  "version": "8.0.0-beta.5",
+  "version": "8.0.0-beta.7",
   "description": "Test utilities for Yeoman generators",
   "keywords": [
     "yeoman",
@@ -36,11 +36,12 @@
     "doc_path": "../yeoman-test-doc"
   },
   "dependencies": {
+    "@yeoman/adapter": "^1.0.2",
     "inquirer": "^9.2.2",
     "lodash": "^4.17.21",
     "mem-fs": "^3.0.0",
     "mem-fs-editor": "^10.0.2",
-    "sinon": "^14.0.2",
+    "sinon": "^15.1.0",
     "temp-dir": "^3.0.0",
     "type-fest": "^3.10.0"
   },
@@ -52,20 +53,20 @@
     "coveralls": "^3.1.1",
     "esmocha": "^1.0.1",
     "husky": "^8.0.2",
-    "jsdoc": "^3.6.10",
+    "jsdoc": "^4.0.2",
     "lint-staged": "^13.0.3",
     "prettier": "^2.2.1",
     "prettier-plugin-packagejson": "^2.3.0",
     "tui-jsdoc-template": "^1.2.2",
     "typescript": "^5.0.4",
     "xo": "^0.54.2",
-    "yeoman-environment": "^3.18.0",
-    "yeoman-generator": "^5.8.0"
+    "yeoman-environment": "^3.18.3",
+    "yeoman-generator": "^5.9.0"
   },
   "peerDependencies": {
-    "@yeoman/types": "^0.5.0",
-    "yeoman-environment": "^3.18.0 || ^4.0.0-alpha.5",
-    "yeoman-generator": "^5.8.0 || ^6.0.0-beta.3"
+    "@yeoman/types": "^1.0.1",
+    "yeoman-environment": "^3.18.3 || ^4.0.0-alpha.6",
+    "yeoman-generator": "^5.9.0 || ^6.0.0-beta.4"
   },
   "peerDependenciesMeta": {
     "yeoman-environment": {