yeoman-test 8.0.0-alpha.0 → 8.0.0-alpha.2

package/dist/adapter.d.ts

@@ -1,24 +1,22 @@
-import inquirer from 'inquirer';
-import type Generator from 'yeoman-generator';
-import type Logger from 'yeoman-environment/lib/util/log.js';
+import type { PromptAnswers, PromptQuestion, Logger, InputOutputAdapter, PromptQuestions } from '@yeoman/types';
+import { type PromptModule } from 'inquirer';
 export type DummyPromptOptions = {
-    callback?: (answers: Generator.Answers) => Generator.Answers;
+    callback?: (answers: PromptAnswers) => PromptAnswers;
     throwOnMissingAnswer?: boolean;
 };
 export declare class DummyPrompt {
-    answers: Generator.Answers;
-    question: inquirer.Question;
-    callback: (answers: Generator.Answers) => Generator.Answers;
+    answers: PromptAnswers;
+    question: PromptQuestion;
+    callback: (answers: PromptAnswers) => PromptAnswers;
     throwOnMissingAnswer: boolean;
-    constructor(question: inquirer.Question, _rl: any, answers: Generator.Answers, mockedAnswers?: Generator.Answers, options?: ((answers: Generator.Answers) => Generator.Answers) | DummyPromptOptions);
-    run(): Promise<inquirer.Answers>;
+    constructor(question: PromptQuestion, _rl: any, answers: PromptAnswers, mockedAnswers?: PromptAnswers, options?: ((answers: PromptAnswers) => PromptAnswers) | DummyPromptOptions);
+    run(): Promise<import("inquirer").Answers>;
 }
-export declare class TestAdapter {
-    promptModule: inquirer.PromptModule;
+export declare class TestAdapter implements InputOutputAdapter {
+    promptModule: PromptModule;
     diff: any;
-    log: typeof Logger;
-    constructor(mockedAnswers?: any);
-    prompt(questions: any, prefilledAnswers: any): Promise<inquirer.Answers> & {
-        ui: inquirer.ui.Prompt<inquirer.Answers>;
-    };
+    log: Logger;
+    constructor(mockedAnswers?: PromptAnswers);
+    close(): void;
+    prompt<A extends PromptAnswers = PromptAnswers>(questions: PromptQuestions<A>, initialAnswers?: Partial<A> | undefined): Promise<A>;
 }

package/dist/adapter.js

@@ -1,8 +1,8 @@
 /* eslint-disable max-params */
 import events from 'node:events';
 import { PassThrough } from 'node:stream';
-import inquirer from 'inquirer';
 import { spy as sinonSpy, stub as sinonStub } from 'sinon';
+import { createPromptModule } from 'inquirer';
 export class DummyPrompt {
     answers;
     question;
@@ -64,7 +64,7 @@ export class TestAdapter {
     diff;
     log;
     constructor(mockedAnswers) {
-        this.promptModule = inquirer.createPromptModule({
+        this.promptModule = createPromptModule({
             input: new PassThrough(),
             output: new PassThrough(),
             skipTTYChecks: true,
@@ -98,7 +98,10 @@ export class TestAdapter {
             this.log[methodName] = sinonStub().returns(this.log);
         }
     }
-    prompt(questions, prefilledAnswers) {
-        return this.promptModule(questions, prefilledAnswers);
+    close() {
+        // No empty
+    }
+    async prompt(questions, initialAnswers) {
+        return this.promptModule(questions, initialAnswers);
     }
 }

package/dist/helpers.d.ts

@@ -1,24 +1,22 @@
-import YeomanGenerator from 'yeoman-generator';
+import GeneratorImplementation, { type StorageRecord, type BaseOptions as GeneratorOptions } from 'yeoman-generator';
 import Environment from 'yeoman-environment';
-import type { GeneratorOptions } from 'yeoman-generator';
-import type { Options, createEnv } from 'yeoman-environment';
+import type { createEnv } from 'yeoman-environment';
+import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor, PromptAnswers } from '@yeoman/types';
 import type { SinonSpiedInstance } from 'sinon';
 import { type DummyPromptOptions } from './adapter.js';
 import RunContext, { BasicRunContext, type RunContextSettings } from './run-context.js';
 /**
  * Dependencies can be path (autodiscovery) or an array [<generator>, <name>]
  */
-export type Dependency = string | Parameters<Environment['registerStub']> | Parameters<Environment['register']>;
-type GeneratorNew<GenParameter extends YeomanGenerator = YeomanGenerator> = new (...args: ConstructorParameters<typeof YeomanGenerator<GenParameter['options']>>) => GenParameter;
-type GeneratorBuilder<GenParameter extends YeomanGenerator = YeomanGenerator> = (...args: ConstructorParameters<typeof YeomanGenerator<GenParameter['options']>>) => GenParameter;
-export type GeneratorConstructor<GenParameter extends YeomanGenerator = YeomanGenerator> = GeneratorNew<GenParameter> | GeneratorBuilder<GenParameter>;
+export type Dependency = string | Parameters<Environment['registerStub']>;
+export type GeneratorFactory<GenParameter extends BaseGenerator = GeneratorImplementation> = GetGeneratorConstructor<GenParameter> | ((...args: ConstructorParameters<GetGeneratorConstructor<GenParameter>>) => GenParameter);
 /**
  * Collection of unit test helpers. (mostly related to Mocha syntax)
  * @class YeomanTest
  */
 export declare class YeomanTest {
     settings?: RunContextSettings;
-    environmentOptions?: Options;
+    environmentOptions?: BaseEnvironmentOptions;
     generatorOptions?: GeneratorOptions;
     /**
      * @deprecated
@@ -53,28 +51,28 @@ export declare class YeomanTest {
      * @example
      * mockPrompt(angular, {'bootstrap': 'Y', 'compassBoostrap': 'Y'});
      */
-    mockPrompt(envOrGenerator: YeomanGenerator | Environment, mockedAnswers?: YeomanGenerator.Answers, options?: DummyPromptOptions): void;
+    mockPrompt(envOrGenerator: BaseGenerator | Environment, mockedAnswers?: PromptAnswers, options?: DummyPromptOptions): void;
     /**
      * @deprecated
      * Restore defaults prompts on a generator.
      * @param generator or environment
      */
-    restorePrompt(envOrGenerator: YeomanGenerator | Environment): void;
+    restorePrompt(envOrGenerator: BaseGenerator | Environment): void;
     /**
      * @deprecated
      * Provide mocked values to the config
      * @param generator - a Yeoman generator
      * @param localConfig - localConfig - should look just like if called config.getAll()
      */
-    mockLocalConfig(generator: YeomanGenerator, localConfig: any): void;
+    mockLocalConfig(generator: BaseGenerator, localConfig: StorageRecord): void;
     /**
      * Create a mocked generator
      */
-    createMockedGenerator(GeneratorClass?: typeof YeomanGenerator<GeneratorOptions>): SinonSpiedInstance<typeof YeomanGenerator<GeneratorOptions>>;
+    createMockedGenerator(GeneratorClass?: typeof GeneratorImplementation): SinonSpiedInstance<typeof GeneratorImplementation>;
     /**
      * Create a simple, dummy generator
      */
-    createDummyGenerator<GenParameter extends YeomanGenerator = YeomanGenerator>(Generator?: typeof YeomanGenerator): typeof YeomanGenerator<GenParameter['options']>;
+    createDummyGenerator<GenParameter extends BaseGenerator = GeneratorImplementation>(Generator?: GetGeneratorConstructor<GenParameter>, contents?: Record<string, (...args: any[]) => void>): GenParameter;
     /**
      * Create a generator, using the given dependencies and controller arguments
      * Dependecies can be path (autodiscovery) or an array [{generator}, {name}]
@@ -94,7 +92,7 @@ export declare class YeomanTest {
      *            ];
      * var angular = createGenerator('angular:app', deps);
      */
-    createGenerator<GeneratorType extends YeomanGenerator = YeomanGenerator>(name: string, dependencies: Dependency[], args?: string[], options?: YeomanGenerator.GeneratorOptions, localConfigOnly?: boolean): GeneratorType | Promise<GeneratorType>;
+    createGenerator<GeneratorType extends BaseGenerator = GeneratorImplementation>(name: string, dependencies: Dependency[], args?: string[], options?: GeneratorOptions, localConfigOnly?: boolean): Promise<GeneratorType>;
     /**
      * @deprecated
      * Register a list of dependent generators into the provided env.
@@ -122,11 +120,11 @@ export declare class YeomanTest {
     /**
      * Creates a test environment.
      *
-     * @param {Function} envContructor - environment constructor method.
-     * @param {Object} [options] - Options to be passed to the environment
+     * @param {Function} - environment constructor method.
+     * @param {Object} - Options to be passed to the environment
      * const env = createTestEnv(require('yeoman-environment').createEnv);
      */
-    createTestEnv(envContructor?: (args?: string | string[] | undefined, opts?: Environment.Options | undefined, adapter?: import("yeoman-environment/lib/adapter.js") | undefined) => Environment<Environment.Options> | Promise<Environment<Environment.Options>>, options?: Environment.Options): Environment<Environment.Options> | Promise<Environment<Environment.Options>>;
+    createTestEnv(envContructor?: (...args: unknown[]) => any, options?: BaseEnvironmentOptions): any;
     /**
      * Get RunContext type
      * @return {RunContext}
@@ -136,13 +134,13 @@ export declare class YeomanTest {
      * Run the provided Generator
      * @param GeneratorOrNamespace - Generator constructor or namespace
      */
-    run<GeneratorType extends YeomanGenerator = YeomanGenerator>(GeneratorOrNamespace: string | GeneratorConstructor<GeneratorType>, settings?: RunContextSettings, envOptions?: Options): RunContext<GeneratorType>;
+    run<GeneratorType extends BaseGenerator = GeneratorImplementation>(GeneratorOrNamespace: string | GeneratorFactory<GeneratorType>, settings?: RunContextSettings, envOptions?: BaseEnvironmentOptions): RunContext<GeneratorType>;
     /**
      * Prepare a run context
      * @param  {String|Function} GeneratorOrNamespace - Generator constructor or namespace
      * @return {RunContext}
      */
-    create<GeneratorType extends YeomanGenerator = YeomanGenerator>(GeneratorOrNamespace: string | GeneratorConstructor<GeneratorType>, settings?: RunContextSettings, envOptions?: Options): RunContext<GeneratorType>;
+    create<GeneratorType extends BaseGenerator = GeneratorImplementation>(GeneratorOrNamespace: string | GeneratorFactory<GeneratorType>, settings?: RunContextSettings, envOptions?: BaseEnvironmentOptions): RunContext<GeneratorType>;
     /**
      * Prepare temporary dir without generator support.
      * Generator and environment will be undefined.

package/dist/helpers.js

@@ -4,7 +4,7 @@ import { resolve } from 'node:path';
 import process from 'node:process';
 import _ from 'lodash';
 import { spy as sinonSpy, stub as sinonStub } from 'sinon';
-import YeomanGenerator from 'yeoman-generator';
+import GeneratorImplementation from 'yeoman-generator';
 import Environment from 'yeoman-environment';
 import { DummyPrompt, TestAdapter } from './adapter.js';
 import RunContext, { BasicRunContext } from './run-context.js';
@@ -76,6 +76,9 @@ export class YeomanTest {
      */
     mockPrompt(envOrGenerator, mockedAnswers, options) {
         const environment = 'env' in envOrGenerator ? envOrGenerator.env : envOrGenerator;
+        if (!environment.adapter) {
+            throw new Error('environment is not an Environment instance');
+        }
         const { promptModule } = environment.adapter;
         for (const name of Object.keys(promptModule.prompts)) {
             promptModule.registerPrompt(name, class CustomDummyPrompt extends DummyPrompt {
@@ -106,12 +109,12 @@ export class YeomanTest {
     /**
      * Create a mocked generator
      */
-    createMockedGenerator(GeneratorClass = class MockedGenerator extends YeomanGenerator {
+    createMockedGenerator(GeneratorClass = class MockedGenerator extends GeneratorImplementation {
     }) {
         const generator = sinonSpy(GeneratorClass);
         for (const methodName of ['run', 'queueTasks', 'runWithOptions', 'queueOwnTasks']) {
             if (GeneratorClass.prototype[methodName]) {
-                generator.prototype[methodName] = sinonStub();
+                GeneratorClass.prototype[methodName] = sinonStub();
             }
         }
         return generator;
@@ -119,13 +122,24 @@ export class YeomanTest {
     /**
      * Create a simple, dummy generator
      */
-    createDummyGenerator(Generator = YeomanGenerator) {
+    createDummyGenerator(Generator = GeneratorImplementation, contents = {
+        test() {
+            this.shouldRun = true;
+        },
+    }) {
         class DummyGenerator extends Generator {
-            shouldRun;
-            test() {
-                this.shouldRun = true;
+            constructor(...args) {
+                args[1].namespace = args[1].namespace ?? 'dummy';
+                args[1].resolved = args[1].resolved ?? 'dummy';
+                super(...args);
             }
         }
+        for (const [propName, propValue] of Object.entries(contents)) {
+            Object.defineProperty(DummyGenerator.prototype, propName, {
+                value: propValue ?? Object.create(null),
+                writable: true,
+            });
+        }
         return DummyGenerator;
     }
     /**
@@ -147,17 +161,10 @@ export class YeomanTest {
      *            ];
      * var angular = createGenerator('angular:app', deps);
      */
-    createGenerator(name, dependencies, args, options, localConfigOnly = true) {
-        const maybeEnv = this.createEnv([], { sharedOptions: { localConfigOnly } });
-        // TODO convert method to async.
-        if ('then' in maybeEnv) {
-            return maybeEnv.then(env => {
-                this.registerDependencies(env, dependencies);
-                return env.create(name, args, options);
-            });
-        }
-        this.registerDependencies(maybeEnv, dependencies);
-        return maybeEnv.create(name, args, options);
+    async createGenerator(name, dependencies, args, options, localConfigOnly = true) {
+        const env = await this.createEnv([], { sharedOptions: { localConfigOnly } });
+        this.registerDependencies(env, dependencies);
+        return env.create(name, args, options);
     }
     /**
      * @deprecated
@@ -202,14 +209,14 @@ export class YeomanTest {
     /**
      * Creates a test environment.
      *
-     * @param {Function} envContructor - environment constructor method.
-     * @param {Object} [options] - Options to be passed to the environment
+     * @param {Function} - environment constructor method.
+     * @param {Object} - Options to be passed to the environment
      * const env = createTestEnv(require('yeoman-environment').createEnv);
      */
     createTestEnv(envContructor = this.createEnv, options = { localConfigOnly: true }) {
-        const envOptions = cloneDeep(this.environmentOptions ?? {});
+        let envOptions = cloneDeep(this.environmentOptions ?? {});
         if (typeof options === 'boolean') {
-            options = {
+            envOptions = {
                 newErrorHandler: true,
                 ...envOptions,
                 sharedOptions: {
@@ -219,18 +226,18 @@ export class YeomanTest {
             };
         }
         else {
-            options = {
-                newErrorHandler: true,
-                ...envOptions,
-                ...options,
-            };
-            options.sharedOptions = {
+            envOptions.sharedOptions = {
                 localConfigOnly: true,
                 ...envOptions.sharedOptions,
                 ...options.sharedOptions,
             };
+            envOptions = {
+                newErrorHandler: true,
+                ...envOptions,
+                ...options,
+            };
         }
-        return envContructor([], options, new TestAdapter());
+        return envContructor([], envOptions, new TestAdapter());
     }
     /**
      * Get RunContext type
@@ -275,7 +282,7 @@ export class YeomanTest {
 }
 const defaultHelpers = new YeomanTest();
 export default defaultHelpers;
-export const createHelpers = options => {
+export const createHelpers = (options) => {
     const helpers = new YeomanTest();
     Object.assign(helpers, options);
     return helpers;

package/dist/run-context.d.ts

@@ -1,12 +1,14 @@
 /// <reference types="node" resolution-mode="require"/>
 import { EventEmitter } from 'node:events';
-import type Generator from 'yeoman-generator';
+import { type Store } from 'mem-fs';
+import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor, GetGeneratorOptions, PromptAnswers } from '@yeoman/types';
 import type Environment from 'yeoman-environment';
-import { type LookupOptions, type Options } from 'yeoman-environment';
+import { type LookupOptions } from 'yeoman-environment';
+import type GeneratorImplementation from 'yeoman-generator';
+import type { StorageRecord } from 'yeoman-generator';
 import { type MemFsEditor, type VinylMemFsEditorFile } from 'mem-fs-editor';
-import { type Store } from 'mem-fs';
 import RunResult, { type RunResultOptions } from './run-result.js';
-import { type GeneratorConstructor, type Dependency, type YeomanTest } from './helpers.js';
+import { type Dependency, type YeomanTest, type GeneratorFactory } from './helpers.js';
 import { type DummyPromptOptions } from './adapter.js';
 /**
  * Provides settings for creating a `RunContext`.
@@ -32,14 +34,17 @@ export type RunContextSettings = {
      */
     namespace?: string;
 };
-type PromiseRunResult<GeneratorType extends Generator> = Promise<RunResult<GeneratorType>>;
-type MockedGeneratorFactory = (GeneratorClass?: typeof Generator) => typeof Generator;
-export declare class RunContextBase<GeneratorType extends Generator = Generator> extends EventEmitter {
-    readonly mockedGenerators: Record<string, Generator>;
+type PromiseRunResult<GeneratorType extends BaseGenerator> = Promise<RunResult<GeneratorType>>;
+type MockedGeneratorFactory = <GenParameter extends BaseGenerator = GeneratorImplementation>(GeneratorClass?: GetGeneratorConstructor<GenParameter>) => GenParameter;
+type EnvOptions = BaseEnvironmentOptions & {
+    createEnv?: any;
+};
+export declare class RunContextBase<GeneratorType extends BaseGenerator = GeneratorImplementation> extends EventEmitter {
+    readonly mockedGenerators: Record<string, BaseGenerator>;
     env: Environment;
     generator: GeneratorType;
     readonly settings: RunContextSettings;
-    readonly envOptions: Environment.Options;
+    readonly envOptions: EnvOptions;
     completed: boolean;
     targetDirectory?: string;
     editor: MemFsEditor;
@@ -73,7 +78,7 @@ export declare class RunContextBase<GeneratorType extends Generator = Generator>
      * @param settings
      * @return {this}
      */
-    constructor(generatorType?: string | GeneratorConstructor<GeneratorType> | typeof Generator, settings?: RunContextSettings, envOptions?: Options, helpers?: YeomanTest);
+    constructor(generatorType?: string | GeneratorFactory<GeneratorType>, settings?: RunContextSettings, envOptions?: EnvOptions, helpers?: YeomanTest);
     /**
      * Run the generator on the environment and promises a RunResult instance.
      * @return {PromiseRunResult} Promise a RunResult instance.
@@ -159,7 +164,7 @@ export declare class RunContextBase<GeneratorType extends Generator = Generator>
      * @param  {Object} options - command line options (e.g. `--opt-one=foo`)
      * @return {this}
      */
-    withOptions(options: any): this;
+    withOptions(options: Partial<Omit<GetGeneratorOptions<GeneratorType>, 'env' | 'namespace' | 'resolved'>>): this;
     /**
      * @deprecated
      * Mock the prompt with dummy answers
@@ -169,14 +174,14 @@ export declare class RunContextBase<GeneratorType extends Generator = Generator>
      * @param  {Boolean} [options.throwOnMissingAnswer] - Throw if a answer is missing.
      * @return {this}
      */
-    withPrompts(answers: Generator.Answers, options?: DummyPromptOptions): this;
+    withPrompts(answers: PromptAnswers, options?: DummyPromptOptions): this;
     /**
      * Mock answers for prompts
      * @param  answers - Answers to the prompt questions
      * @param  options - Options or callback.
      * @return {this}
      */
-    withAnswers(answers: Generator.Answers, options?: DummyPromptOptions): this;
+    withAnswers(answers: PromptAnswers, options?: DummyPromptOptions): this;
     /**
      * Provide dependent generators
      * @param {Array} dependencies - paths to the generators dependencies
@@ -216,7 +221,7 @@ export declare class RunContextBase<GeneratorType extends Generator = Generator>
      * Mock the local configuration with the provided config
      * @param localConfig - should look just like if called config.getAll()
      */
-    withLocalConfig(localConfig: Record<string, unknown>): this;
+    withLocalConfig(localConfig: StorageRecord): this;
     /**
      * Don't reset mem-fs state cleared to aggregate snapshots from multiple runs.
      */
@@ -269,7 +274,7 @@ export declare class RunContextBase<GeneratorType extends Generator = Generator>
      * Build the generator and the environment.
      * @return {RunContext|false} this
      */
-    protected build(): Promise<void>;
+    build(): Promise<void>;
     /**
      * Return a promise representing the generator run process
      * @return Promise resolved on end or rejected on error
@@ -289,10 +294,10 @@ export declare class RunContextBase<GeneratorType extends Generator = Generator>
      */
     private setDir;
 }
-export default class RunContext<GeneratorType extends Generator = Generator> extends RunContextBase<GeneratorType> implements Promise<RunResult<GeneratorType>> {
-    then<TResult1 = RunResult<GeneratorType>, TResult2 = never>(onfulfilled?: ((value: RunResult<GeneratorType>) => TResult1 | PromiseLike<TResult1>) | undefined | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | undefined): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | undefined): Promise<RunResult<GeneratorType> | TResult>;
-    finally(onfinally?: (() => void) | undefined | undefined): Promise<RunResult<GeneratorType>>;
+export default class RunContext<GeneratorType extends BaseGenerator = GeneratorImplementation> extends RunContextBase<GeneratorType> implements Promise<RunResult<GeneratorType>> {
+    then<TResult1 = RunResult<GeneratorType>, TResult2 = never>(onfulfilled?: ((value: RunResult<GeneratorType>) => TResult1 | PromiseLike<TResult1>) | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined): Promise<RunResult<GeneratorType> | TResult>;
+    finally(onfinally?: (() => void) | undefined): Promise<RunResult<GeneratorType>>;
     get [Symbol.toStringTag](): string;
 }
 export declare class BasicRunContext extends RunContext {

package/dist/run-context.js

@@ -5,11 +5,11 @@ import assert from 'node:assert';
 import { EventEmitter } from 'node:events';
 import process from 'node:process';
 import _ from 'lodash';
-import tempDirectory from 'temp-dir';
-import { create as createMemFsEditor } from 'mem-fs-editor';
 // eslint-disable-next-line n/file-extension-in-import
 import { resetFileCommitStates } from 'mem-fs-editor/state';
 import { create as createMemFs } from 'mem-fs';
+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 testContext from './test-context.js';
@@ -60,11 +60,6 @@ export class RunContextBase extends EventEmitter {
         };
         this.Generator = generatorType;
         this.envOptions = envOptions;
-        this.withOptions({
-            force: true,
-            skipCache: true,
-            skipInstall: true,
-        });
         this.oldCwd = this.settings.oldCwd;
         if (this.settings.cwd) {
             this.cd(this.settings.cwd);
@@ -217,10 +212,11 @@ export class RunContextBase extends EventEmitter {
      * @param lookups - lookup to run.
      */
     withLookups(lookups) {
-        return this.onEnvironment(env => {
+        return this.onEnvironment(async (env) => {
             lookups = Array.isArray(lookups) ? lookups : [lookups];
             for (const lookup of lookups) {
-                env.lookup(lookup);
+                // eslint-disable-next-line no-await-in-loop
+                await env.lookup(lookup);
             }
         });
     }
@@ -301,7 +297,7 @@ export class RunContextBase extends EventEmitter {
             for (const dependency of dependencies) {
                 if (Array.isArray(dependency)) {
                     if (typeof dependency[0] === 'string') {
-                        // eslint-disable-next-line no-await-in-loop, @typescript-eslint/await-thenable
+                        // eslint-disable-next-line no-await-in-loop
                         await env.register(...dependency);
                     }
                     else {
@@ -309,7 +305,7 @@ export class RunContextBase extends EventEmitter {
                     }
                 }
                 else {
-                    // eslint-disable-next-line no-await-in-loop, @typescript-eslint/await-thenable
+                    // eslint-disable-next-line no-await-in-loop
                     await env.register(dependency);
                 }
             }
@@ -470,11 +466,15 @@ export class RunContextBase extends EventEmitter {
      * Build the generator and the environment.
      * @return {RunContext|false} this
      */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
     async build() {
         await this.prepare();
         const testEnv = await this.helpers.createTestEnv(this.envOptions.createEnv, {
             cwd: this.settings.forwardCwd ? this.targetDirectory : undefined,
             sharedFs: this.memFs,
+            force: true,
+            skipCache: true,
+            skipInstall: true,
             ...this.options,
             ...this.envOptions,
         });
@@ -492,8 +492,12 @@ export class RunContextBase extends EventEmitter {
             const { resolved } = this.settings;
             this.env.registerStub(this.Generator, namespace, resolved);
         }
-        // eslint-disable-next-line @typescript-eslint/await-thenable
-        this.generator = (await this.env.create(namespace, this.args, this.options));
+        this.generator = await this.env.create(namespace, this.args, {
+            force: true,
+            skipCache: true,
+            skipInstall: true,
+            ...this.options,
+        });
         for (const onGeneratorCallback of this.onGeneratorCallbacks) {
             // eslint-disable-next-line no-await-in-loop
             await onGeneratorCallback.call(this, this.generator);

package/dist/run-result.d.ts

@@ -1,19 +1,19 @@
-import { type MemFsEditor } from 'mem-fs-editor';
 import type { Store } from 'mem-fs';
-import type Environment from 'yeoman-environment';
-import type Generator from 'yeoman-generator';
+import { type MemFsEditor } from 'mem-fs-editor';
+import type { BaseEnvironment, BaseEnvironmentOptions, BaseGenerator } from '@yeoman/types';
+import type GeneratorImplementation from 'yeoman-generator';
 import { type RunContextSettings } from './run-context.js';
-import { type YeomanTest } from './helpers.js';
+import { type GeneratorFactory, type YeomanTest } from './helpers.js';
 /**
  * Provides options for `RunResult`s.
  */
-export type RunResultOptions<GeneratorType extends Generator> = {
+export type RunResultOptions<GeneratorType extends BaseGenerator> = {
     generator: GeneratorType;
     /**
      * The environment of the generator.
      */
-    env: Environment;
-    envOptions: Environment.Options;
+    env: BaseEnvironment;
+    envOptions: BaseEnvironmentOptions;
     /**
      * The working directory after running the generator.
      */
@@ -30,14 +30,14 @@ export type RunResultOptions<GeneratorType extends Generator> = {
     /**
      * The mocked generators of the context.
      */
-    mockedGenerators: Record<string, Generator>;
+    mockedGenerators: Record<string, BaseGenerator>;
     settings: RunContextSettings;
     helpers: YeomanTest;
 };
 /**
  * This class provides utilities for testing generated content.
  */
-export default class RunResult<GeneratorType extends Generator = Generator> {
+export default class RunResult<GeneratorType extends BaseGenerator = GeneratorImplementation> {
     env: any;
     generator: GeneratorType;
     cwd: string;
@@ -51,7 +51,7 @@ export default class RunResult<GeneratorType extends Generator = Generator> {
      * 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>>;
+    create<GeneratorType extends BaseGenerator = GeneratorImplementation>(GeneratorOrNamespace: string | GeneratorFactory<GeneratorType>, settings?: RunContextSettings, envOptions?: BaseEnvironmentOptions): import("./run-context.js").default<GeneratorType>;
     /**
      * Return an object with fs changes.
      * @param {Function} filter - parameter forwarded to mem-fs-editor#dump

package/dist/test-context.d.ts

@@ -1,7 +1,8 @@
+import type { BaseGenerator } from '@yeoman/types';
 import type RunContext from './run-context.js';
 import type RunResult from './run-result.js';
 declare class TestContext {
-    runResult?: RunResult;
+    runResult?: RunResult<BaseGenerator>;
     private runContext?;
     startNewContext(runContext?: RunContext<any>): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-test",
-  "version": "8.0.0-alpha.0",
+  "version": "8.0.0-alpha.2",
   "description": "Test utilities for Yeoman generators",
   "homepage": "http://yeoman.io/authoring/testing.html",
   "author": "The Yeoman Team",
@@ -37,25 +37,23 @@
     "prettier": "^2.2.1",
     "prettier-plugin-packagejson": "^2.3.0",
     "tui-jsdoc-template": "^1.2.2",
-    "typescript": "^4.9.3",
-    "xo": "^0.53.1",
-    "yeoman-environment": "^3.13.0",
-    "yeoman-generator": "^5.7.0"
+    "typescript": "^5.0.4",
+    "xo": "^0.54.2",
+    "yeoman-environment": "^3.16.1"
   },
   "dependencies": {
-    "@types/inquirer": "^8.2.5",
-    "@types/yeoman-environment": "^2.10.8",
-    "@types/yeoman-generator": "^5.2.11",
-    "inquirer": "^8.2.5",
+    "@types/inquirer": "^9.0.3",
+    "@yeoman/types": "^0.1.2",
+    "inquirer": "^9.2.2",
     "lodash": "^4.17.21",
     "mem-fs": "^3.0.0",
     "mem-fs-editor": "^10.0.1",
     "sinon": "^14.0.2",
-    "temp-dir": "^3.0.0"
+    "temp-dir": "^3.0.0",
+    "yeoman-generator": "^6.0.0-alpha.2"
   },
   "peerDependencies": {
-    "yeoman-environment": "^3.13.0",
-    "yeoman-generator": "*"
+    "yeoman-environment": "^3.13.0 || ^4.0.0-alpha.0"
   },
   "scripts": {
     "test": "c8 esmocha",