yeoman-test 8.1.1 → 8.3.0

package/README.md

@@ -22,17 +22,16 @@ $ npm install --save-dev yeoman-generator@xxx yeoman-environment@xxx
 
 ## Usage
 
-Usage:
+Usage using the convenience last RunResult instance:
 
 ```js
-import helpers from 'yeoman-test';
+import helpers, { result } from 'yeoman-test';
 
 describe('generator test', () => {
   describe('test', () => {
-    let runResult;
     beforeEach(async () => {
-      runResult = await helpers
-        .create(                   // instantiates RunContext
+      await helpers
+        .run(                   // instantiates RunContext
           'namespace',             // namespace or generator
           {},                      // test options
           {}                       // environment options
@@ -53,47 +52,25 @@ describe('generator test', () => {
         [.withYoRcConfig('generator-foo.bar', { : {} })] // same as above
         [.commitFiles()]            // commit mem-fs files to disk
         [.onGenerator(gen => {})]   // do something with the generator
-        [.onEnvironment(env => {})] // do something with the environment
-        [.build(runContext => {     // instantiates Environment/Generator
-          [runContext.env...]       // does something with the environment
-          [runContext.generator...] // does something with the generator
-        })]
-        .run();                     // runs the environment, promises a RunResult
-      [result.create().run()] // instantiates a new RunContext at the same directory
+        [.onEnvironment(env => {})]; // do something with the environment
+
+      [await result.create('another-generator').run();] // instantiates a new RunContext at the same directory
     );
-    afterEach(() => {
-      if (runResult) {
-        // Optional if context is executed at a temporary folder
-        runResult.restore();
-      }
-    });
+
     it('runs correctly', () => {
       // runs assertions using mem-fs.
-      [runResult.assertFile('file.txt');]
-      [runResult.assertNoFile('file.txt');]
-      [runResult.assertFileContent('file.txt', 'content');]
-      [runResult.assertEqualsFileContent('file.txt', 'content');]
-      [runResult.assertNoFileContent('file.txt', 'content');]
-      [runResult.assertJsonFileContent('file.txt', {});]
-      [runResult.assertNoJsonFileContent('file.txt', {});]
+      [result.assertFile('file.txt');]
+      [result.assertNoFile('file.txt');]
+      [result.assertFileContent('file.txt', 'content');]
+      [result.assertEqualsFileContent('file.txt', 'content');]
+      [result.assertNoFileContent('file.txt', 'content');]
+      [result.assertJsonFileContent('file.txt', {});]
+      [result.assertNoJsonFileContent('file.txt', {});]
     });
   });
 });
 ```
 
-Convenience last RunResult instance:
-
-```js
-import helpers, { result } from 'yeoman-test';
-
-describe('generator test', () => {
-  before(() => helpers.run('namespace'));
-  it('test', () => {
-    result.assert...;
-  });
-});
-```
-
 Generator compose:
 
 ```js

package/dist/adapter.d.ts

@@ -3,3 +3,7 @@ export declare class TestAdapter extends BaseTestAdapter {
     constructor(options?: TestAdapterOptions);
 }
 export { DummyPrompt, type DummyPromptOptions, type DummyPromptCallback, type TestAdapterOptions } from '@yeoman/adapter/testing';
+export type AskedQuestions = Array<{
+    name: string;
+    answer: any;
+}>;

package/dist/adapter.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line n/file-extension-in-import
 import { TestAdapter as BaseTestAdapter } from '@yeoman/adapter/testing';
 import { spy as sinonSpy, stub as sinonStub } from 'sinon';
 export class TestAdapter extends BaseTestAdapter {
@@ -9,5 +8,4 @@ export class TestAdapter extends BaseTestAdapter {
         });
     }
 }
-// eslint-disable-next-line n/file-extension-in-import
 export { DummyPrompt } from '@yeoman/adapter/testing';

package/dist/run-context.d.ts

@@ -6,7 +6,7 @@ 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 CreateEnv, type Dependency, type YeomanTest } from './helpers.js';
-import { type DummyPromptOptions, type TestAdapterOptions } from './adapter.js';
+import { type AskedQuestions, type DummyPromptOptions, type TestAdapterOptions } from './adapter.js';
 /**
  * Provides settings for creating a `RunContext`.
  */
@@ -48,6 +48,7 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
     memFs: Store<MemFsEditorFile>;
     spawnStub?: any;
     mockedGeneratorFactory: MockedGeneratorFactory;
+    readonly askedQuestions: AskedQuestions;
     protected environmentPromise?: PromiseRunResult<GeneratorType>;
     private args;
     private options;
@@ -203,7 +204,11 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * });
      */
     withGenerators(dependencies: Dependency[]): this;
-    withSpawnMock(stub?: import("sinon").SinonStub<any[], any>): this;
+    withSpawnMock(options?: ((...args: any[]) => any) | {
+        stub?: (...args: any[]) => any;
+        registerSinonDefaults?: boolean;
+        callback?: (stub: any) => void | Promise<void>;
+    }): this;
     withMockedGeneratorFactory(mockedGeneratorFactory: MockedGeneratorFactory): this;
     /**
      * Create mocked generators

package/dist/run-context.js

@@ -5,7 +5,6 @@ import assert from 'node:assert';
 import { EventEmitter } from 'node:events';
 import process from 'node:process';
 import { camelCase, kebabCase, merge as lodashMerge, set as lodashSet } from 'lodash-es';
-// 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';
@@ -27,6 +26,7 @@ export class RunContextBase extends EventEmitter {
     memFs;
     spawnStub;
     mockedGeneratorFactory;
+    askedQuestions = [];
     environmentPromise;
     args = [];
     options = {};
@@ -311,10 +311,30 @@ export class RunContextBase extends EventEmitter {
             }
         });
     }
-    withSpawnMock(stub = sinonStub()) {
+    withSpawnMock(options) {
         if (this.spawnStub) {
             throw new Error('Multiple withSpawnMock calls');
         }
+        const stub = typeof options === 'function' ? options : options?.stub ?? sinonStub();
+        const registerSinonDefaults = typeof options === 'function' ? false : options?.registerSinonDefaults ?? true;
+        const callback = typeof options === 'function' ? undefined : options?.callback;
+        if (registerSinonDefaults) {
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            const defaultChild = { stdout: { on() { } }, stderr: { on() { } } };
+            const defaultReturn = { exitCode: 0, stdout: '', stderr: '' };
+            const stubFn = stub;
+            // eslint-disable-next-line @typescript-eslint/promise-function-async
+            stubFn.withArgs('spawnCommand').callsFake(() => Object.assign(Promise.resolve({ ...defaultReturn }), defaultChild));
+            // eslint-disable-next-line @typescript-eslint/promise-function-async
+            stubFn.withArgs('spawn').callsFake(() => Object.assign(Promise.resolve({ ...defaultReturn }), defaultChild));
+            stubFn.withArgs('spawnCommandSync').callsFake(() => ({ ...defaultReturn }));
+            stubFn.withArgs('spawnSync').callsFake(() => ({ ...defaultReturn }));
+        }
+        if (callback) {
+            this.onBeforePrepare(async () => {
+                await callback(stub);
+            });
+        }
         this.spawnStub = stub;
         return this.onEnvironment(env => {
             env.on('compose', (_namespace, generator) => {
@@ -502,13 +522,21 @@ export class RunContextBase extends EventEmitter {
     // eslint-disable-next-line @typescript-eslint/member-ordering
     async build() {
         await this.prepare();
+        const { askedQuestions, adapterOptions } = this;
+        const promptCallback = function (answer, options) {
+            const { question } = options;
+            if (question.name) {
+                askedQuestions.push({ name: question.name, answer });
+            }
+            return adapterOptions?.callback ? adapterOptions.callback.call(this, answer, options) : answer;
+        };
         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,
-            adapter: this.helpers.createTestAdapter({ ...this.adapterOptions, mockedAnswers: this.answers }),
+            adapter: this.helpers.createTestAdapter({ ...this.adapterOptions, mockedAnswers: this.answers, callback: promptCallback }),
             ...this.envOptions,
         });
         this.env = this.envCB ? (await this.envCB(testEnv)) ?? testEnv : testEnv;
@@ -560,6 +588,7 @@ export class RunContextBase extends EventEmitter {
             envOptions: this.envOptions,
             mockedGenerators: this.mockedGenerators,
             helpers: this.helpers,
+            askedQuestions: this.askedQuestions,
         };
     }
     /**

package/dist/run-result.d.ts

@@ -4,6 +4,7 @@ import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor } f
 import type { DefaultEnvironmentApi, DefaultGeneratorApi } from '../types/type-helpers.js';
 import { type RunContextSettings } from './run-context.js';
 import { type YeomanTest } from './helpers.js';
+import { type AskedQuestions } from './adapter.js';
 /**
  * Provides options for `RunResult`s.
  */
@@ -34,6 +35,7 @@ export type RunResultOptions<GeneratorType extends BaseGenerator> = {
     spawnStub?: any;
     settings: RunContextSettings;
     helpers: YeomanTest;
+    askedQuestions: AskedQuestions;
 };
 /**
  * This class provides utilities for testing generated content.
@@ -48,6 +50,7 @@ export default class RunResult<GeneratorType extends BaseGenerator = BaseGenerat
     mockedGenerators: any;
     options: RunResultOptions<GeneratorType>;
     spawnStub?: any;
+    readonly askedQuestions: AskedQuestions;
     constructor(options: RunResultOptions<GeneratorType>);
     /**
      * Create another RunContext reusing the settings.

package/dist/run-result.js

@@ -24,6 +24,7 @@ export default class RunResult {
     mockedGenerators;
     options;
     spawnStub;
+    askedQuestions;
     constructor(options) {
         if (options.memFs && !options.cwd) {
             throw new Error('CWD option is required for mem-fs tests');
@@ -36,6 +37,7 @@ export default class RunResult {
         this.fs = this.memFs && createMemFsEditor(this.memFs);
         this.mockedGenerators = options.mockedGenerators || {};
         this.spawnStub = options.spawnStub;
+        this.askedQuestions = options.askedQuestions;
         this.options = options;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-test",
-  "version": "8.1.1",
+  "version": "8.3.0",
   "description": "Test utilities for Yeoman generators",
   "keywords": [
     "yeoman",