Add result export and update README (#171)

* runresult-proxy

* update README

* Update index.ts

README.md

@@ -25,6 +25,8 @@ $ npm install --save-dev yeoman-generator@xxx yeoman-environment@xxx
 Usage:
 
 ```js
+import helpers from 'yeoman-test';
+
 describe('generator test', () => {
   describe('test', () => {
     let runResult;
@@ -36,12 +38,22 @@ describe('generator test', () => {
           {}                       // environment options
         )
         [.cd(dir)]                  // runs the test inside a non temporary dir
-        [.doInDir(dir => {})        // prepares the test dir
+        [.onTargetDirectory(dir => {})        // prepares the test dir
         [.withGenerators([])]       // registers additional generators
         [.withLookups({})]          // runs Environment lookups
         [.withOptions({})]          // passes options to the generator
         [.withLocalConfig({})]      // sets the generator config as soon as it is instantiated
         [.withAnswers()]            // simulates the prompt answers
+        [.withMockedGenerators(['namespace', ...])]      // adds a mocked generator to the namespaces
+        [.withFiles({
+          'foo.txt': 'bar',
+          'test.json', { content: true },
+        })]                         // add files to mem-fs
+        [.withYoRc({ 'generator-foo': { bar: {} } })]    // add config to .yo-rc.json
+        [.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
@@ -51,6 +63,7 @@ describe('generator test', () => {
     );
     afterEach(() => {
       if (runResult) {
+        // Optional if context is executed at a temporary folder
         runResult.restore();
       }
     });
@@ -68,6 +81,19 @@ describe('generator test', () => {
 });
 ```
 
+Convenience last RunResult instance:
+
+```js
+import helpers, { result } from 'yeoman-test';
+
+describe('generator test', () => {
+  before(() => helpers.run('namespace'));
+  it('test', () => {
+    result.assert...;
+  });
+});
+```
+
 [See our api documentation](https://yeoman.github.io/yeoman-test) for latest yeoman-test release.
 
 [See our api documentation](https://yeoman.github.io/yeoman-test/5.0.1) for yeoman-test 5.0.1. Use 5.x for yeoman-environment 2.x support.

src/index.ts

@@ -2,5 +2,5 @@ export { default, createHelpers, YeomanTest, type Dependency } from './helpers.j
 
 export { default as RunContext, RunContextBase, type RunContextSettings } from './run-context.js';
 export { default as RunResult, type RunResultOptions } from './run-result.js';
-export { default as context } from './test-context.js';
+export { default as context, result } from './test-context.js';
 export { DummyPrompt, TestAdapter } from './adapter.js';

src/run-context.ts

@@ -16,6 +16,7 @@ import MemFs from 'mem-fs';
 import RunResult, { type RunResultOptions } from './run-result.js';
 import defaultHelpers, { type GeneratorConstructor, type Dependency, type YeomanTest } from './helpers.js';
 import { type DummyPromptOptions } from './adapter.js';
+import testContext from './test-context.js';
 
 const { camelCase, kebabCase, merge: lodashMerge, set: lodashSet } = _;
 
@@ -150,7 +151,9 @@ export class RunContextBase<GeneratorType extends Generator = Generator> extends
       this.completed = true;
     }
 
-    return new RunResult(this._createRunResultOptions());
+    const runResult = new RunResult(this._createRunResultOptions());
+    testContext.runResult = runResult;
+    return runResult;
   }
 
   // If any event listeners is added, setup event listeners emitters
@@ -732,6 +735,8 @@ export default class RunContext<GeneratorType extends Generator = Generator>
 export class BasicRunContext extends RunContext {
   async run(): PromiseRunResult<any> {
     await this.prepare();
-    return new RunResult(this._createRunResultOptions());
+    const runResult = new RunResult(this._createRunResultOptions());
+    testContext.runResult = runResult;
+    return runResult;
   }
 }

src/test-context.ts

@@ -1,13 +1,32 @@
-import type Generator from 'yeoman-generator';
 import type RunContext from './run-context.js';
+import type RunResult from './run-result.js';
 
 class TestContext {
+  runResult?: RunResult;
   private runContext?: RunContext<any>;
 
   startNewContext(runContext: RunContext<any>) {
     this.runContext?.cleanupTemporaryDir();
     this.runContext = runContext;
+    this.runResult = undefined;
   }
 }
 
-export default new TestContext();
+const testContext = new TestContext();
+
+export default testContext;
+
+const handler2 = {
+  get(_target, prop, receiver) {
+    if (testContext.runResult === undefined) {
+      throw new Error('Last result is missing.');
+    }
+
+    return Reflect.get(testContext.runResult, prop, receiver);
+  },
+};
+
+/**
+ * Provides a proxy for last executed context result.
+ */
+export const result: RunResult = new Proxy({}, handler2);

test/run-result.spec.ts

@@ -10,6 +10,7 @@ import { stub } from 'sinon';
 import RunContext from '../src/run-context.js';
 import RunResult from '../src/run-result.js';
 import helpers from '../src/helpers.js';
+import testContext, { result } from '../src/test-context.js';
 
 describe('run-result', () => {
   describe('constructor', () => {
@@ -244,4 +245,27 @@ describe('run-result', () => {
       assert.equal(runContext.envOptions.overridedEnv, 'newOverridedEnv');
     });
   });
+  describe('current runResult value', () => {
+    describe('should proxy methods', () => {
+      let runResult: RunResult;
+      beforeEach(() => {
+        const memFs = MemFs.create();
+        const memFsEditor = MemFsEditor.create(memFs);
+        runResult = new RunResult({
+          memFs,
+          fs: memFsEditor,
+          cwd: process.cwd(),
+        } as any);
+        runResult.fs.write(path.resolve('test.txt'), 'test content');
+        runResult.fs.write(path.resolve('test2.txt'), 'test2 content');
+        testContext.runResult = runResult;
+      });
+      for (const method of Object.getOwnPropertyNames(RunResult.prototype)) {
+        // eslint-disable-next-line @typescript-eslint/no-loop-func
+        it(`.${method}`, () => {
+          assert.equal(result.assertFile, runResult.assertFile);
+        });
+      }
+    });
+  });
 });