From 07e5f9c8f1dc503a172d085824f99a91b90f88e9 Mon Sep 17 00:00:00 2001 From: Marcelo Shima Date: Wed, 29 Apr 2026 12:16:04 -0300 Subject: [PATCH 1/4] chore: replace assert with expect Co-authored-by: Copilot --- test/command.ts | 51 ++++--- test/environment.ts | 330 +++++++++++++++++++++----------------------- test/plugins.ts | 5 +- test/resolver.ts | 299 ++++++++++++++++++++------------------- test/store.ts | 19 ++- 5 files changed, 351 insertions(+), 353 deletions(-) diff --git a/test/command.ts b/test/command.ts index bc7b6a00..8c45fa78 100644 --- a/test/command.ts +++ b/test/command.ts @@ -1,6 +1,5 @@ /* eslint-disable @typescript-eslint/ban-ts-comment */ // @ts-nocheck -import assert from 'node:assert'; import path, { dirname } from 'node:path'; import { fileURLToPath } from 'node:url'; import { beforeEach, describe, esmocha, expect, it } from 'esmocha'; @@ -66,16 +65,16 @@ describe('environment (command)', () => { beforeEach(async () => { await environment.execute('commands:options'); const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse options correctly', () => { - assert.strictEqual(generator.options.bool, undefined); - assert.strictEqual(generator.options.boolDefault, true); + expect(generator.options.bool).toBe(undefined); + expect(generator.options.boolDefault).toBe(true); - assert.strictEqual(generator.options.string, undefined); - assert.strictEqual(generator.options.stringDefault, 'defaultValue'); + expect(generator.options.string).toBe(undefined); + expect(generator.options.stringDefault).toBe('defaultValue'); }); }); @@ -92,16 +91,16 @@ describe('environment (command)', () => { ]); const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse options correctly', () => { - assert.strictEqual(generator.options.bool, true); - assert.strictEqual(generator.options.boolDefault, false); + expect(generator.options.bool).toBe(true); + expect(generator.options.boolDefault).toBe(false); - assert.strictEqual(generator.options.string, 'customValue'); - assert.strictEqual(generator.options.stringDefault, 'newValue'); + expect(generator.options.string).toBe('customValue'); + expect(generator.options.stringDefault).toBe('newValue'); }); }); @@ -110,13 +109,13 @@ describe('environment (command)', () => { beforeEach(async () => { await environment.execute('commands:options', ['-b', '-s', 'customValue']); const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse options correctly', () => { - assert.strictEqual(generator.options.bool, true); - assert.strictEqual(generator.options.string, 'customValue'); + expect(generator.options.bool).toBe(true); + expect(generator.options.string).toBe('customValue'); }); }); }); @@ -137,12 +136,12 @@ describe('environment (command)', () => { beforeEach(async () => { await environment.execute('commands:arguments'); const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse arguments correctly', () => { - assert.deepStrictEqual(generator._args, []); + expect(generator._args).toEqual([]); }); }); @@ -151,16 +150,16 @@ describe('environment (command)', () => { beforeEach(async () => { await environment.execute('commands:arguments', ['foo']); const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse arguments correctly', () => { - assert.deepStrictEqual(generator._args, ['foo']); + expect(generator._args).toEqual(['foo']); }); it('should load arguments into options', () => { - assert.strictEqual(generator.options.name, 'foo'); + expect(generator.options.name).toBe('foo'); }); }); }); @@ -180,12 +179,12 @@ describe('environment (command)', () => { environment = command.env; const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse arguments correctly', () => { - assert.deepStrictEqual(generator._args, ['bar']); + expect(generator._args).toEqual(['bar']); }); }); }); @@ -211,16 +210,16 @@ describe('environment (command)', () => { environment = command.env; const generators = Object.values(environment.composedStore.getGenerators()) as ParsedGenerator[]; - assert.ok(generators.length === 1); + expect(generators.length).toEqual(1); generator = generators[0]; }); it('should parse options correctly', () => { - assert.strictEqual(generator.options.bool, true); - assert.strictEqual(generator.options.boolDefault, false); + expect(generator.options.bool).toBe(true); + expect(generator.options.boolDefault).toBe(false); - assert.strictEqual(generator.options.string, 'customValue'); - assert.strictEqual(generator.options.stringDefault, 'newValue'); + expect(generator.options.string).toBe('customValue'); + expect(generator.options.stringDefault).toBe('newValue'); }); }); }); diff --git a/test/environment.ts b/test/environment.ts index e3540a76..3a7f8862 100644 --- a/test/environment.ts +++ b/test/environment.ts @@ -9,7 +9,6 @@ import { fileURLToPath } from 'node:url'; import { createRequire } from 'node:module'; import { after, afterEach, before, beforeEach, describe, esmocha, expect, it } from 'esmocha'; import { QueuedAdapter } from '@yeoman/adapter'; -import assert from 'yeoman-assert'; import Environment, { createEnv as createEnvironment } from '../src/index.ts'; import { resolveModulePath } from '../src/util/resolve.ts'; import { allVersions, importGenerator, isGreaterThan6, isLegacyVersion } from './generator-versions.ts'; @@ -65,7 +64,7 @@ for (const generatorVersion of allVersions) { }); it('is an instance of EventEmitter', () => { - assert.ok(new Environment() instanceof events.EventEmitter); + expect(new Environment() instanceof events.EventEmitter).toBeTruthy(); }); describe('constructor', () => { @@ -75,31 +74,31 @@ for (const generatorVersion of allVersions) { }); it('instantiates a QueuedAdapter if none provided', async function () { - assert.ok(env.adapter instanceof QueuedAdapter); + expect(env.adapter instanceof QueuedAdapter).toBeTruthy(); }); it('uses the provided object as adapter if any', () => { const dummyAdapter = {}; const environment = new Environment({ adapter: dummyAdapter }); - assert.equal(environment.adapter, dummyAdapter, 'Not the adapter provided'); + expect(environment.adapter).toEqual(dummyAdapter); }); it('instantiates a mem-fs instance', async function () { - assert.ok(env.sharedFs); + expect(env.sharedFs).toBeTruthy(); }); }); describe('#getVersion()', () => { it('output the version number', async function () { const version = env.getVersion(); - assert.ok(version); - assert.textEqual(version, ENVIRONMENT_VERSION); + expect(version).toBeTruthy(); + expect(version).toEqual(ENVIRONMENT_VERSION); }); it('output the grouped-queue version number', async function () { const version = env.getVersion('grouped-queue'); - assert.ok(version); - assert.textEqual(version, GROUPED_QUEUE_VERSION); + expect(version).toBeTruthy(); + expect(version).toEqual(GROUPED_QUEUE_VERSION); }); }); @@ -115,12 +114,12 @@ for (const generatorVersion of allVersions) { }); it('output the general help', async function () { - assert.textEqual(env.help().trim(), expected); + expect(env.help().trim()).toEqual(expected); }); it('output the help with a custom bin name', async function () { expected = expected.replace('Usage: init', 'Usage: gg'); - assert.textEqual(env.help('gg').trim(), expected); + expect(env.help('gg').trim()).toEqual(expected); }); }); @@ -135,108 +134,107 @@ for (const generatorVersion of allVersions) { it('instantiate a generator', async function () { this.timeout(10_000); - assert.ok((await env.create('stub')) instanceof registeredGenerator); + expect((await env.create('stub')) instanceof registeredGenerator).toBeTruthy(); }); it('instantiate a scoped generator', async function () { - assert.ok((await env.create('@scope/stub')) instanceof registeredGenerator); + expect((await env.create('@scope/stub')) instanceof registeredGenerator).toBeTruthy(); }); it('pass args parameter', async function () { const arguments_ = ['foo', 'bar']; const generator = await env.create('stub', arguments_); - assert.deepEqual(generator.arguments, arguments_); + expect(generator.arguments).toEqual(arguments_); }); it('pass options parameter', async function () { const arguments_ = []; const options = { foo: 'bar' }; const generator = await env.create('stub', arguments_, options); - assert.equal(generator.options.foo, 'bar'); + expect(generator.options.foo).toEqual('bar'); }); it('pass options.arguments', async function () { const arguments_ = ['foo', 'bar']; const generator = await env.create('stub', { arguments: arguments_ }); - assert.deepEqual(generator.arguments, arguments_); + expect(generator.arguments).toEqual(arguments_); }); it('pass options.arguments as string', async function () { const arguments_ = 'foo bar'; const generator = await env.create('stub', { arguments: arguments_ }); - assert.deepEqual(generator.arguments, arguments_.split(' ')); + expect(generator.arguments).toEqual(arguments_.split(' ')); }); it('pass options.args (as `arguments` alias)', async function () { const arguments_ = ['foo', 'bar']; const generator = await env.create('stub', { args: arguments_ }); - assert.deepEqual(generator.arguments, arguments_); + expect(generator.arguments).toEqual(arguments_); }); it('prefer options.arguments over options.args', async function () { const arguments1 = ['yo', 'unicorn']; const arguments_ = ['foo', 'bar']; const generator = await env.create('stub', { arguments: arguments1, args: arguments_ }); - assert.deepEqual(generator.arguments, arguments1); + expect(generator.arguments).toEqual(arguments1); }); it('default arguments to `env.arguments`', async function () { const arguments_ = ['foo', 'bar']; env.arguments = arguments_; const generator = await env.create('stub'); - assert.notEqual(generator.arguments, arguments_, 'expect arguments to not be passed by reference'); + expect(generator.arguments).not.toEqual(arguments_); }); it('pass options.options', async function () { const options = { foo: 'bar' }; const generator = await env.create('stub', { options }); - assert.equal(generator.options.foo, 'bar'); + expect(generator.options.foo).toEqual('bar'); }); it('spread sharedOptions', async function () { const options = { foo: 'bar' }; const generator = await env.create('stub', { options }); const generator2 = await env.create('stub'); - assert.equal(generator.options.foo, 'bar'); - assert.equal(generator.options.sharedData, generator2.options.sharedData); + expect(generator.options.foo).toEqual('bar'); + expect(generator.options.sharedData).toEqual(generator2.options.sharedData); generator.options.sharedData.foo = 'bar'; - assert.equal(generator2.options.sharedData.foo, 'bar'); + expect(generator2.options.sharedData.foo).toEqual('bar'); - assert.equal(generator.options.sharedConstructorData, generator2.options.sharedConstructorData); + expect(generator.options.sharedConstructorData).toEqual(generator2.options.sharedConstructorData); generator.options.sharedConstructorData.bar = 'foo'; - assert.equal(generator2.options.sharedConstructorData.bar, 'foo'); + expect(generator2.options.sharedConstructorData.bar).toEqual('foo'); }); it('throws if Generator is not registered', async function () { - assert.rejects(env.create.bind(env, 'i:do:not:exist')); + expect(() => env.create('i:do:not:exist')).toThrow(); }); it('add the env as property on the generator', async function () { - assert.equal((await env.create('stub')).env, env); + expect((await env.create('stub')).env).toEqual(env); }); it('add the Generator resolved path on the options', async function () { - assert.equal((await env.create('stub')).options.resolved, (await env.get('stub')).resolved); + expect((await env.create('stub')).options.resolved).toEqual((await env.get('stub')).resolved); }); it('adds the namespace on the options', async function () { - assert.equal((await env.create('stub')).options.namespace, 'stub'); + expect((await env.create('stub')).options.namespace).toEqual('stub'); }); it('adds the namespace as called on the options', async function () { - assert.equal((await env.create('stub:foo:bar')).options.namespace, 'stub:foo:bar'); + expect((await env.create('stub:foo:bar')).options.namespace).toEqual('stub:foo:bar'); }); it('adds the namespace from a module generator on the options', async function () { await env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), { namespace: 'fixtures:generator-module' }); - assert.equal((await env.create('fixtures:generator-module')).options.namespace, 'fixtures:generator-module'); + expect((await env.create('fixtures:generator-module')).options.namespace).toEqual('fixtures:generator-module'); }); it('adds the Generator resolved path from a module generator on the options', async function () { await env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), { namespace: 'fixtures:generator-module' }); - assert.equal( - (await env.create('fixtures:generator-module')).options.resolved, + expect((await env.create('fixtures:generator-module')).options.resolved).toEqual( (await env.get('fixtures:generator-module')).resolved, ); }); @@ -258,11 +256,11 @@ for (const generatorVersion of allVersions) { }); it('should instantiate a generator', async function () { - assert.ok((await env.composeWith('stub')) instanceof registeredGenerator); + expect((await env.composeWith('stub')) instanceof registeredGenerator).toBeTruthy(); }); it('should instantiate a genarator and set _meta', async function () { - assert.ok((await env.composeWith('stub'))._meta); + expect((await env.composeWith('stub'))._meta).toBeTruthy(); }); it('should schedule generator queue', async function () { @@ -299,8 +297,8 @@ for (const generatorVersion of allVersions) { it('should emit a compose event', function (done) { env.once('compose', (namespace, generator) => { - assert.ok(namespace === 'stub'); - assert.ok(generator instanceof registeredGenerator); + expect(namespace === 'stub').toBeTruthy(); + expect(generator instanceof registeredGenerator).toBeTruthy(); done(); }); env.composeWith('stub'); @@ -308,7 +306,7 @@ for (const generatorVersion of allVersions) { it('should emit a compose namespace event with scoped generators', function (done) { env.once('compose:@scope/stub', generator => { - assert.ok(generator instanceof registeredGenerator); + expect(generator instanceof registeredGenerator).toBeTruthy(); done(); }); env.composeWith('@scope/stub'); @@ -316,7 +314,7 @@ for (const generatorVersion of allVersions) { it('should emit a compose namespace event', function (done) { env.once('compose:stub', generator => { - assert.ok(generator instanceof registeredGenerator); + expect(generator instanceof registeredGenerator).toBeTruthy(); done(); }); env.composeWith('stub'); @@ -331,8 +329,8 @@ for (const generatorVersion of allVersions) { } env.once('compose', (namespace, generator) => { - assert.ok(namespace === 'stub'); - assert.ok(generator instanceof registeredGenerator); + expect(namespace === 'stub').toBeTruthy(); + expect(generator instanceof registeredGenerator).toBeTruthy(); composed = generator; done(); }); @@ -350,7 +348,7 @@ for (const generatorVersion of allVersions) { }); it('should return already composed instance', async function () { - assert.strictEqual(composed, await env.composeWith('stub')); + expect(composed).toBe(await env.composeWith('stub')); }); }); }); @@ -435,7 +433,7 @@ for (const generatorVersion of allVersions) { throw new Error('should not happen'); }) .catch(error => { - assert.equal(error.message, 'Process aborted by conflict: foo.js'); + expect(error.message).toEqual('Process aborted by conflict: foo.js'); }); }); @@ -444,8 +442,8 @@ for (const generatorVersion of allVersions) { const options = { skipInstall: true }; return env.run(arguments_, options).then(() => { expect(runMethod).toHaveBeenCalledTimes(1); - assert.equal(capturedArgs[0], 'module'); - assert.equal(capturedArgs[1].skipInstall, true); + expect(capturedArgs[0]).toEqual(['module']); + expect(capturedArgs[1].skipInstall).toEqual(true); }); }); @@ -453,7 +451,7 @@ for (const generatorVersion of allVersions) { const arguments_ = 'stub:run module'; return env.run(arguments_).then(() => { expect(runMethod).toHaveBeenCalledTimes(1); - assert.equal(capturedArgs[0], 'module'); + expect(capturedArgs[0]).toEqual(['module']); }); }); @@ -465,14 +463,14 @@ for (const generatorVersion of allVersions) { }, error => { expect(runMethod).not.toHaveBeenCalled(); - assert.ok(error.message.includes('Must provide at least one argument, the generator namespace to invoke.')); + expect(error.message.includes('Must provide at least one argument, the generator namespace to invoke.')).toBeTruthy(); }, ); }); it('launch error if generator is not found', async function () { return env.run('some:unknown:generator').then( - () => assert.fail(), + () => expect.fail('Assertion failed'), error => { expect(error.message).toMatch('“generator-some”'); }, @@ -481,7 +479,9 @@ for (const generatorVersion of allVersions) { it("launch error if generator doesn't have a constructor", async function () { return env.run('no-constructor:app').then( - () => assert.fail(), + () => { + throw new Error('Should throw'); + }, error => { expect(error.message).toMatch('provide a constructor'); }, @@ -491,30 +491,30 @@ for (const generatorVersion of allVersions) { it('generator error event emits error event when no callback passed', function (done) { env.on('error', error => { expect(runMethod).toHaveBeenCalledTimes(1); - assert.ok(error instanceof Error); - assert.equal(error.message, 'some error'); + expect(error instanceof Error).toBeTruthy(); + expect(error.message).toEqual('some error'); done(); }); const generator = env.create('eventfailingstub:run'); - assert.equal(generator.listenerCount('error'), 0); + expect(generator.listenerCount('error')).toEqual(0); env.runGenerator(generator).catch(() => {}); }); it('generator failing task emits error', function (done) { env.on('error', error => { expect(runMethod).toHaveBeenCalledTimes(1); - assert.ok(error instanceof Error); - assert.equal(error.message, 'some error'); + expect(error instanceof Error).toBeTruthy(); + expect(error.message).toEqual('some error'); done(); }); const generator = env.create('promisefailingstub:run'); - assert.equal(generator.listenerCount('error'), 0); + expect(generator.listenerCount('error')).toEqual(0); env.runGenerator(generator).catch(() => {}); }); it('returns the generator', async function () { const runReturnValue = env.run('stub:run'); - assert.ok(runReturnValue instanceof Promise); + expect(runReturnValue instanceof Promise).toBeTruthy(); }); it('correctly rejects promise on generator not found error', function (done) { @@ -531,9 +531,11 @@ for (const generatorVersion of allVersions) { it('correctly append scope in generator hint', async function () { return env.run('@dummyscope/package').then( - () => assert.fail(), + () => { + throw new Error('Should throw'); + }, error => { - assert.ok(error.message.includes('@dummyscope/generator-package')); + expect(error.message.includes('@dummyscope/generator-package')).toBeTruthy(); }, ); }); @@ -548,27 +550,27 @@ for (const generatorVersion of allVersions) { it('importGenerator should return a class', async function () { env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), 'fixtures:generator-module'); const meta = env.getGeneratorMeta('fixtures:generator-module'); - assert.equal(typeof (await meta.importGenerator()), 'function'); + expect(typeof (await meta.importGenerator())).toEqual('function'); }); it('importModule should return the generator module', async function () { env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), 'fixtures:generator-module'); const meta = env.getGeneratorMeta('fixtures:generator-module'); const Generator = await meta.importGenerator(); const module = await meta.importModule(); - assert.strictEqual(Generator, module.default); + expect(Generator).toBe(module.default); }); it('intantiate should return an instance', async function () { env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), 'fixtures:generator-module'); const meta = env.getGeneratorMeta('fixtures:generator-module'); const Generator = await meta.importGenerator(); const generator = await meta.instantiate(); - assert.ok(generator instanceof Generator); + expect(generator instanceof Generator).toBeTruthy(); }); it('intantiateHelp should return an instance with help option', async function () { env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), 'fixtures:generator-module'); const meta = env.getGeneratorMeta('fixtures:generator-module'); const generator = await meta.instantiateHelp(); - assert.strictEqual(generator.options.help, true); + expect(generator.options.help).toBe(true); }); }); @@ -699,14 +701,14 @@ for (const generatorVersion of allVersions) { const specifiedJSON = path.join(__dirname, 'fixtures/generator-scoped/package.json'); const specifiedNode = path.join(__dirname, 'fixtures/generator-scoped/package/nodefile.node'); - assert.equal(specifiedJS, await resolveModulePath(modulePath)); - assert.equal(specifiedJS, await resolveModulePath(specifiedJS)); - assert.equal(specifiedJSON, await resolveModulePath(specifiedJSON)); - assert.equal(specifiedNode, await resolveModulePath(specifiedNode)); + expect(specifiedJS).toEqual(await resolveModulePath(modulePath)); + expect(specifiedJS).toEqual(await resolveModulePath(specifiedJS)); + expect(specifiedJSON).toEqual(await resolveModulePath(specifiedJSON)); + expect(specifiedNode).toEqual(await resolveModulePath(specifiedNode)); const aModulePath = path.join(__dirname, 'fixtures/generator-scoped/app'); const aSpecifiedJS = path.join(__dirname, 'fixtures/generator-scoped/app/index.js'); - assert.equal(aSpecifiedJS, await resolveModulePath(aModulePath)); + expect(aSpecifiedJS).toEqual(await resolveModulePath(aModulePath)); }); }); @@ -714,38 +716,32 @@ for (const generatorVersion of allVersions) { beforeEach(async function () { simplePath = path.join(__dirname, 'fixtures/generator-simple'); extendPath = path.join(__dirname, './fixtures/generator-extend/support'); - assert.equal(env.namespaces().length, 0, 'env should be empty'); + expect(env.namespaces().length).toEqual(0); env.register(simplePath, 'fixtures:generator-simple', simplePath); env.register(extendPath, 'scaffold'); }); it('store registered generators', async function () { - assert.equal(env.namespaces().length, 2); + expect(env.namespaces().length).toEqual(2); }); it('determine registered Generator namespace and resolved path', async function () { const simple = await env.get('fixtures:generator-simple'); - assert.equal(typeof simple, 'function'); - assert.ok(simple.namespace, 'fixtures:generator-simple'); - assert.ok(simple.resolved, path.resolve(simplePath)); - assert.ok(simple.packagePath, simplePath); + expect(typeof simple).toEqual('function'); + expect(simple.namespace).toBeTruthy(); + expect(simple.resolved).toBeTruthy(); + expect(simple.packagePath).toBeTruthy(); const extend = await env.get('scaffold'); - assert.equal(typeof extend, 'function'); - assert.ok(extend.namespace, 'scaffold'); - assert.ok(extend.resolved, path.resolve(extendPath)); + expect(typeof extend).toEqual('function'); + expect(extend.namespace).toBeTruthy(); + expect(extend.resolved).toBeTruthy(); }); it('throw when String is not passed as first parameter', () => { - assert.rejects(function () { - env.register(() => {}, 'blop'); - }); - assert.rejects(function () { - env.register([], 'blop'); - }); - assert.rejects(function () { - env.register(false, 'blop'); - }); + expect(() => env.register(() => {}, 'blop')).not.toThrow(); + expect(() => env.register([], 'blop')).toThrow(); + expect(() => env.register(false, 'blop')).toThrow(); }); }); @@ -754,7 +750,7 @@ for (const generatorVersion of allVersions) { env.alias(/^prefix-(.*)$/, '$1'); simpleDummy = esmocha.fn(); simplePath = path.join(__dirname, 'fixtures/generator-simple'); - assert.equal(env.namespaces().length, 0, 'env should be empty'); + expect(env.namespaces().length).toEqual(0); await env.register(simplePath, { namespace: 'fixtures:generator-simple', packagePath: simplePath }); await env.register(simplePath, { namespace: 'fixtures2', packagePath: simplePath }); env.register(simpleDummy, { namespace: 'fixtures:dummy-simple', resolved: 'dummy/path', packagePath: 'dummy/packagePath' }); @@ -762,14 +758,14 @@ for (const generatorVersion of allVersions) { }); it('determine registered Generator namespace and resolved path', async function () { - assert.equal(await env.getPackagePath('fixtures:generator-simple'), simplePath); - assert.equal(await env.getPackagePath('fixtures'), 'new-path'); - assert.deepEqual(await env.getPackagePaths('fixtures'), ['new-path', join('dummy/packagePath'), simplePath]); + expect(await env.getPackagePath('fixtures:generator-simple')).toEqual(simplePath); + expect(await env.getPackagePath('fixtures')).toEqual('new-path'); + expect(await env.getPackagePaths('fixtures')).toEqual(['new-path', join('dummy/packagePath'), simplePath]); // With alias - assert.equal(await env.getPackagePath('prefix-fixtures:generator-simple'), await env.getPackagePath('fixtures:generator-simple')); - assert.equal(await env.getPackagePath('prefix-fixtures'), await env.getPackagePath('fixtures')); - assert.deepEqual(await env.getPackagePaths('prefix-fixtures'), await env.getPackagePaths('fixtures')); + expect(await env.getPackagePath('prefix-fixtures:generator-simple')).toEqual(await env.getPackagePath('fixtures:generator-simple')); + expect(await env.getPackagePath('prefix-fixtures')).toEqual(await env.getPackagePath('fixtures')); + expect(await env.getPackagePaths('prefix-fixtures')).toEqual(await env.getPackagePaths('fixtures')); }); }); @@ -785,20 +781,20 @@ for (const generatorVersion of allVersions) { }); it('register a function under a namespace', async function () { - assert.equal(completeDummy, await env.get('dummy:complete')); + expect(completeDummy).toEqual(await env.get('dummy:complete')); }); it('registers the resolved path and package path', async function () { - assert.equal(join('dummy/path/index.js'), (await env.get('dummy:resolved')).resolved); - assert.equal(join('dummy/packagePath'), (await env.get('dummy:resolved')).packagePath); + expect(join('dummy/path/index.js')).toEqual((await env.get('dummy:resolved')).resolved); + expect(join('dummy/packagePath')).toEqual((await env.get('dummy:resolved')).packagePath); }); it('throws if invalid generator', async function () { - assert.throws(env.register.bind(env, [], { namespace: 'dummy' }), /stub\sfunction/); + expect(env.register.bind(env, [], { namespace: 'dummy' })).toThrow(/stub\sfunction/); }); it('throws if invalid namespace', async function () { - assert.throws(env.register.bind(env, simpleDummy, {}), /namespace/); + expect(env.register.bind(env, simpleDummy, {})).toThrow(/namespace/); }); }); @@ -810,7 +806,7 @@ for (const generatorVersion of allVersions) { }); it('get the list of namespaces', async function () { - assert.deepEqual(env.namespaces(), ['simple', 'extend:support', 'support:scaffold']); + expect(env.namespaces()).toEqual(['simple', 'extend:support', 'support:scaffold']); }); }); @@ -822,8 +818,8 @@ for (const generatorVersion of allVersions) { it('get the registered Generators metadatas', async function () { const meta = env.getGeneratorsMeta().simple; - assert.deepEqual(meta.resolved, require.resolve(generatorPath)); - assert.deepEqual(meta.namespace, 'simple'); + expect(meta.resolved).toEqual(require.resolve(generatorPath)); + expect(meta.namespace).toEqual('simple'); }); }); @@ -834,84 +830,83 @@ for (const generatorVersion of allVersions) { }); it('get the registered generators names', async function () { - assert.deepEqual(env.getGeneratorNames(), ['simple']); + expect(env.getGeneratorNames()).toEqual(['simple']); }); }); describe('#namespace()', () => { it('create namespace from path', async function () { - assert.equal(env.namespace('backbone/all/index.js'), 'backbone:all'); - assert.equal(env.namespace('backbone/all/main.js'), 'backbone:all'); - assert.equal(env.namespace('backbone/all'), 'backbone:all'); - assert.equal(env.namespace('backbone/all.js'), 'backbone:all'); - assert.equal(env.namespace('backbone/app/index.js'), 'backbone:app'); - assert.equal(env.namespace('backbone.js'), 'backbone'); + expect(env.namespace('backbone/all/index.js')).toEqual('backbone:all'); + expect(env.namespace('backbone/all/main.js')).toEqual('backbone:all'); + expect(env.namespace('backbone/all')).toEqual('backbone:all'); + expect(env.namespace('backbone/all.js')).toEqual('backbone:all'); + expect(env.namespace('backbone/app/index.js')).toEqual('backbone:app'); + expect(env.namespace('backbone.js')).toEqual('backbone'); - assert.equal(env.namespace('generator-backbone/all.js'), 'backbone:all'); - assert.equal(env.namespace('generator-mocha/backbone/model/index.js'), 'mocha:backbone:model'); - assert.equal(env.namespace('generator-mocha/backbone/model.js'), 'mocha:backbone:model'); - assert.equal(env.namespace('node_modules/generator-mocha/backbone/model.js'), 'mocha:backbone:model'); - assert.equal(env.namespace('../node_modules/generator-mocha/backbone/model.js'), 'mocha:backbone:model'); - assert.equal(env.namespace('../generator-mocha/backbone/model.js'), 'mocha:backbone:model'); + expect(env.namespace('generator-backbone/all.js')).toEqual('backbone:all'); + expect(env.namespace('generator-mocha/backbone/model/index.js')).toEqual('mocha:backbone:model'); + expect(env.namespace('generator-mocha/backbone/model.js')).toEqual('mocha:backbone:model'); + expect(env.namespace('node_modules/generator-mocha/backbone/model.js')).toEqual('mocha:backbone:model'); + expect(env.namespace('../node_modules/generator-mocha/backbone/model.js')).toEqual('mocha:backbone:model'); + expect(env.namespace('../generator-mocha/backbone/model.js')).toEqual('mocha:backbone:model'); }); it('create namespace from scoped path', async function () { - assert.equal(env.namespace('@dummyscope/generator-backbone/all.js'), '@dummyscope/backbone:all'); - assert.equal(env.namespace('@dummyscope/generator-mocha/backbone/model/index.js'), '@dummyscope/mocha:backbone:model'); - assert.equal(env.namespace('@dummyscope/generator-mocha/backbone/model.js'), '@dummyscope/mocha:backbone:model'); - assert.equal(env.namespace('/node_modules/@dummyscope/generator-mocha/backbone/model.js'), '@dummyscope/mocha:backbone:model'); + expect(env.namespace('@dummyscope/generator-backbone/all.js')).toEqual('@dummyscope/backbone:all'); + expect(env.namespace('@dummyscope/generator-mocha/backbone/model/index.js')).toEqual('@dummyscope/mocha:backbone:model'); + expect(env.namespace('@dummyscope/generator-mocha/backbone/model.js')).toEqual('@dummyscope/mocha:backbone:model'); + expect(env.namespace('/node_modules/@dummyscope/generator-mocha/backbone/model.js')).toEqual('@dummyscope/mocha:backbone:model'); }); it('handle relative paths', async function () { - assert.equal(env.namespace('../local/stuff'), 'local:stuff'); - assert.equal(env.namespace('./local/stuff'), 'local:stuff'); - assert.equal(env.namespace('././local/stuff'), 'local:stuff'); - assert.equal(env.namespace('../../local/stuff'), 'local:stuff'); + expect(env.namespace('../local/stuff')).toEqual('local:stuff'); + expect(env.namespace('./local/stuff')).toEqual('local:stuff'); + expect(env.namespace('././local/stuff')).toEqual('local:stuff'); + expect(env.namespace('../../local/stuff')).toEqual('local:stuff'); }); it('handles weird paths', async function () { - assert.equal(env.namespace('////gen/all'), 'gen:all'); - assert.equal(env.namespace('generator-backbone///all.js'), 'backbone:all'); - assert.equal(env.namespace('generator-backbone/././all.js'), 'backbone:all'); - assert.equal(env.namespace('generator-backbone/generator-backbone/all.js'), 'backbone:all'); + expect(env.namespace('////gen/all')).toEqual('gen:all'); + expect(env.namespace('generator-backbone///all.js')).toEqual('backbone:all'); + expect(env.namespace('generator-backbone/././all.js')).toEqual('backbone:all'); + expect(env.namespace('generator-backbone/generator-backbone/all.js')).toEqual('backbone:all'); }); it("works with Windows' paths", async function () { - assert.equal(env.namespace('backbone\\all\\main.js'), 'backbone:all'); - assert.equal(env.namespace('backbone\\all'), 'backbone:all'); - assert.equal(env.namespace('backbone\\all.js'), 'backbone:all'); + expect(env.namespace('backbone\\all\\main.js')).toEqual('backbone:all'); + expect(env.namespace('backbone\\all')).toEqual('backbone:all'); + expect(env.namespace('backbone\\all.js')).toEqual('backbone:all'); }); it('remove lookups from namespace', async function () { - assert.equal(env.namespace('backbone/generators/all/index.js'), 'backbone:all'); - assert.equal(env.namespace('backbone/lib/generators/all/index.js'), 'backbone:all'); - assert.equal(env.namespace('some-lib/generators/all/index.js'), 'some-lib:all'); - assert.equal(env.namespace('my.thing/generators/app/index.js'), 'my.thing:app'); - assert.equal(env.namespace('meta/generators/generators-thing/index.js'), 'meta:generators-thing'); + expect(env.namespace('backbone/generators/all/index.js')).toEqual('backbone:all'); + expect(env.namespace('backbone/lib/generators/all/index.js')).toEqual('backbone:all'); + expect(env.namespace('some-lib/generators/all/index.js')).toEqual('some-lib:all'); + expect(env.namespace('my.thing/generators/app/index.js')).toEqual('my.thing:app'); + expect(env.namespace('meta/generators/generators-thing/index.js')).toEqual('meta:generators-thing'); }); it('remove path before the generator name', async function () { - assert.equal(env.namespace('/Users/yeoman/.nvm/v0.10.22/lib/node_modules/generator-backbone/all/index.js'), 'backbone:all'); - assert.equal( - env.namespace('/Users/yeoman with space and ./.nvm/v0.10.22/lib/node_modules/generator-backbone/all/index.js'), + expect(env.namespace('/Users/yeoman/.nvm/v0.10.22/lib/node_modules/generator-backbone/all/index.js')).toEqual('backbone:all'); + expect(env.namespace('/Users/yeoman with space and ./.nvm/v0.10.22/lib/node_modules/generator-backbone/all/index.js')).toEqual( 'backbone:all', ); - assert.equal(env.namespace('/usr/lib/node_modules/generator-backbone/all/index.js'), 'backbone:all'); - assert.equal(env.namespace('c:\\projects\\m. projects\\generators\\generator-example\\generators\\app\\index.js'), 'example:app'); + expect(env.namespace('/usr/lib/node_modules/generator-backbone/all/index.js')).toEqual('backbone:all'); + expect(env.namespace('c:\\projects\\m. projects\\generators\\generator-example\\generators\\app\\index.js')).toEqual('example:app'); }); it('Handles non generator-* packages inside node_modules', async function () { - assert.equal(env.namespace('/Users/yeoman with space and ./.nvm/v0.10.22/lib/node_modules/example/all/index.js'), 'example:all'); - assert.equal(env.namespace('c:\\projects\\node_modules\\example\\generators\\app\\index.js'), 'example:app'); + expect(env.namespace('/Users/yeoman with space and ./.nvm/v0.10.22/lib/node_modules/example/all/index.js')).toEqual('example:all'); + expect(env.namespace('c:\\projects\\node_modules\\example\\generators\\app\\index.js')).toEqual('example:app'); }); it('handle paths when multiples lookups are in it', async function () { - assert.equal(env.namespace('c:\\projects\\yeoman\\generators\\generator-example\\generators\\app\\index.js'), 'example:app'); + expect(env.namespace('c:\\projects\\yeoman\\generators\\generator-example\\generators\\app\\index.js')).toEqual('example:app'); }); it('handles namespaces', async function () { - assert.equal(env.namespace('backbone:app'), 'backbone:app'); - assert.equal(env.namespace('foo'), 'foo'); + expect(env.namespace('backbone:app')).toEqual('backbone:app'); + expect(env.namespace('foo')).toEqual('foo'); }); }); @@ -923,54 +918,54 @@ for (const generatorVersion of allVersions) { }); it('get a specific generator', async function () { - assert.equal(await env.get('mocha:generator'), generator); - assert.equal(await env.get('fixtures:generator-mocha'), generator); + expect(await env.get('mocha:generator')).toEqual(generator); + expect(await env.get('fixtures:generator-mocha')).toEqual(generator); }); it('fallback to requiring generator from a file path', async function () { - assert.equal(await env.get(path.join(__dirname, './fixtures/generator-mocha')), generator); + expect(await env.get(path.join(__dirname, './fixtures/generator-mocha'))).toEqual(generator); }); it('returns undefined if namespace is not found', async function () { - assert.equal(await env.get('not:there'), undefined); - assert.equal(await env.get(), undefined); + expect(await env.get('not:there')).toEqual(undefined); + expect(await env.get()).toEqual(undefined); }); it('works with modules', async function () { const generator = require('./fixtures/generator-module/generators/app/index.js'); await env.register(path.join(__dirname, './fixtures/generator-module/generators/app'), 'fixtures:generator-module'); - assert.equal(await env.get('fixtures:generator-module'), generator.default); + expect(await env.get('fixtures:generator-module')).toEqual(generator.default); }); }); describe('#alias()', () => { it('apply regex and replace with alternative value', async function () { env.alias(/^([^:]+)$/, '$1:app'); - assert.equal(env.alias('foo'), 'foo:app'); + expect(env.alias('foo')).toEqual('foo:app'); }); it('apply multiple regex', async function () { env.alias(/^([\d*:A-Za-z]+)$/, 'generator-$1'); env.alias(/^([^:]+)$/, '$1:app'); - assert.equal(env.alias('foo'), 'generator-foo:app'); + expect(env.alias('foo')).toEqual('generator-foo:app'); }); it('apply latest aliases first', async function () { env.alias(/^([^:]+)$/, '$1:all'); env.alias(/^([^:]+)$/, '$1:app'); - assert.equal(env.alias('foo'), 'foo:app'); + expect(env.alias('foo')).toEqual('foo:app'); }); it('alias empty namespace to `:app` by default', async function () { - assert.equal(env.alias('foo'), 'foo:app'); + expect(env.alias('foo')).toEqual('foo:app'); }); it('alias removing prefix- from namespaces', async function () { env.alias(/^(@.*\/)?prefix-(.*)$/, '$1$2'); - assert.equal(env.alias('prefix-foo'), 'foo:app'); - assert.equal(env.alias('prefix-mocha:generator'), 'mocha:generator'); - assert.equal(env.alias('prefix-fixtures:generator-mocha'), 'fixtures:generator-mocha'); - assert.equal(env.alias('@scoped/prefix-fixtures:generator-mocha'), '@scoped/fixtures:generator-mocha'); + expect(env.alias('prefix-foo')).toEqual('foo:app'); + expect(env.alias('prefix-mocha:generator')).toEqual('mocha:generator'); + expect(env.alias('prefix-fixtures:generator-mocha')).toEqual('fixtures:generator-mocha'); + expect(env.alias('@scoped/prefix-fixtures:generator-mocha')).toEqual('@scoped/fixtures:generator-mocha'); }); }); @@ -983,35 +978,32 @@ for (const generatorVersion of allVersions) { }); it('get a specific generator', async function () { - assert.equal(await env.get('prefix-mocha:generator'), generator); - assert.equal(await env.get('mocha:generator'), generator); - assert.equal(await env.get('prefix-fixtures:generator-mocha'), generator); - assert.equal(await env.get('fixtures:generator-mocha'), generator); + expect(await env.get('prefix-mocha:generator')).toEqual(generator); + expect(await env.get('mocha:generator')).toEqual(generator); + expect(await env.get('prefix-fixtures:generator-mocha')).toEqual(generator); + expect(await env.get('fixtures:generator-mocha')).toEqual(generator); }); }); describe('.createEnv()', () => { it('create an environment', () => { const environment = createEnvironment(); - assert(environment); + expect(environment).toBeTruthy(); }); }); describe('getContextMap', () => { it('creates an context', () => { - assert(env.getContextMap('foo') instanceof Map); + expect(env.getContextMap('foo') instanceof Map).toBeTruthy(); }); it('returns an existing context', () => { - assert.equal(env.getContextMap('foo'), env.getContextMap('foo')); + expect(env.getContextMap('foo')).toEqual(env.getContextMap('foo')); }); it('supports factory', () => { const map = new Map(); - assert.equal( - env.getContextMap('foo', () => map), - map, - ); + expect(env.getContextMap('foo', () => map)).toEqual(map); }); }); }); diff --git a/test/plugins.ts b/test/plugins.ts index ecf181a2..2dc4e8b1 100644 --- a/test/plugins.ts +++ b/test/plugins.ts @@ -1,9 +1,8 @@ -import assert from 'node:assert'; import os from 'node:os'; import path from 'node:path'; import process from 'node:process'; import { mkdirSync, rmSync } from 'node:fs'; -import { afterEach, beforeEach, describe, it } from 'esmocha'; +import { afterEach, beforeEach, describe, expect, it } from 'esmocha'; import Environment from '../src/index.ts'; const tmpdir = path.join(os.tmpdir(), 'yeoman-environment/light'); @@ -62,7 +61,7 @@ describe('Generators plugin', () => { it(`runs generators plugin with requireGenerator value ${extended}`, () => { return env.run('dummy:app').then(() => { - assert.equal(execValue, 'done'); + expect(execValue).toEqual('done'); }); }).timeout(100_000); }); diff --git a/test/resolver.ts b/test/resolver.ts index 0a959fb9..085f4e07 100644 --- a/test/resolver.ts +++ b/test/resolver.ts @@ -1,7 +1,6 @@ /* eslint-disable @typescript-eslint/ban-ts-comment */ // @ts-nocheck import path, { dirname, join, relative } from 'node:path'; -import assert from 'node:assert'; import { fileURLToPath } from 'node:url'; import { createRequire } from 'node:module'; import process from 'node:process'; @@ -138,7 +137,7 @@ describe('Environment Resolver', async function () { beforeEach(async function () { env = new Environment(); - assert.equal(env.namespaces().length, 0, 'ensure env is empty'); + expect(env.namespaces().length).toEqual(0); await env.lookup({ ...lookupOptions, localOnly: true }); }); @@ -146,41 +145,41 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); // Register local generators - assert.ok(await env.get('dummy:app')); - assert.ok(await env.get('dummy:yo')); + expect(await env.get('dummy:app')).toBeTruthy(); + expect(await env.get('dummy:yo')).toBeTruthy(); - assert.ok((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))); - assert.ok((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))); + expect((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))).toBeTruthy(); + expect((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))).toBeTruthy(); // Registers local ts generators - assert.ok(await env.get('ts:app')); + expect(await env.get('ts:app')).toBeTruthy(); // Registers local common js generators with cjs extension - assert.ok(await env.get('common-js:cjs')); + expect(await env.get('common-js:cjs')).toBeTruthy(); // Registers local esm generators with js extension - assert.ok(await env.get('ts:app')); + expect(await env.get('ts:app')).toBeTruthy(); // Registers local esm generators with mjs extension - assert.ok(await env.get('esm:mjs')); + expect(await env.get('esm:mjs')).toBeTruthy(); // Js generators takes precedence // eslint-disable-next-line import-x/extensions - assert.equal(await env.get('ts-js:app'), require('./fixtures/generator-ts-js/generators/app/index.js')); + expect(await env.get('ts-js:app')).toEqual(require('./fixtures/generator-ts-js/generators/app/index.js')); // Register generators in scoped packages - assert.ok(await env.get('@dummyscope/scoped:app')); + expect(await env.get('@dummyscope/scoped:app')).toBeTruthy(); // Register non-dependency local generator - assert.ok(await env.get('jquery:app')); + expect(await env.get('jquery:app')).toBeTruthy(); // Register symlinked generators - assert.ok(await env.get('extend:support')); + expect(await env.get('extend:support')).toBeTruthy(); }); globalLookupTest()('register global generators', async function () { - assert.ok(await env.get('dummytest:app')); - assert.ok(await env.get('dummytest:controller')); + expect(await env.get('dummytest:app')).toBeTruthy(); + expect(await env.get('dummytest:controller')).toBeTruthy(); }); describe("when there's ancestor node_modules/ folder", async () => { @@ -198,7 +197,7 @@ describe('Environment Resolver', async function () { beforeEach(async function () { env = new Environment(); - assert.equal(env.namespaces().length, 0, 'ensure env is empty'); + expect(env.namespaces().length).toEqual(0); await env.lookup({ localOnly: true }); }); @@ -207,12 +206,12 @@ describe('Environment Resolver', async function () { }); it('register generators in ancestor node_modules directory', async function () { - assert.ok(await env.get('jquery:app')); + expect(await env.get('jquery:app')).toBeTruthy(); }); it('local generators are prioritized over ancestor', async function () { const { resolved } = (await env.get('dummy:app')) as any; - assert.ok(resolved.includes('subdir'), `Couldn't find 'subdir' in ${resolved}`); + expect(resolved.includes('subdir')).toBeTruthy(); }); }); @@ -236,36 +235,36 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); // Register local generators - assert.ok(await env.get('dummy:app')); - assert.ok(await env.get('dummy:yo')); + expect(await env.get('dummy:app')).toBeTruthy(); + expect(await env.get('dummy:yo')).toBeTruthy(); - assert.ok((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))); - assert.ok((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))); + expect((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))).toBeTruthy(); + expect((await env.get('dummy:app'))!.packagePath!.endsWith(join('node_modules/generator-dummy'))).toBeTruthy(); // Registers local ts generators - assert.ok(await env.get('ts:app')); + expect(await env.get('ts:app')).toBeTruthy(); // Js generators takes precedence // eslint-disable-next-line import-x/extensions - assert.equal(await env.get('ts-js:app'), require('./fixtures/generator-ts-js/generators/app/index.js')); + expect(await env.get('ts-js:app')).toEqual(require('./fixtures/generator-ts-js/generators/app/index.js')); // Register generators in scoped packages - assert.ok(await env.get('@dummyscope/scoped:app')); + expect(await env.get('@dummyscope/scoped:app')).toBeTruthy(); // Register non-dependency local generator - assert.ok(await env.get('jquery:app')); + expect(await env.get('jquery:app')).toBeTruthy(); // Local generators prioritized over global const { resolved } = (await env.get('dummy:app')) as any; - assert.ok(resolved.includes('lookup-project'), `Couldn't find 'lookup-project' in ${resolved}`); + expect(resolved.includes('lookup-project')).toBeTruthy(); // Register symlinked generators - assert.ok(await env.get('extend:support')); + expect(await env.get('extend:support')).toBeTruthy(); }); globalLookupTest()('register global generators', async function () { - assert.ok(await env.get('dummytest:app')); - assert.ok(await env.get('dummytest:controller')); + expect(await env.get('dummytest:app')).toBeTruthy(); + expect(await env.get('dummytest:controller')).toBeTruthy(); }); }); @@ -291,35 +290,35 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); // Register local generators - assert.ok(await env.get('dummy:app')); - assert.ok(await env.get('dummy:yo')); + expect(await env.get('dummy:app')).toBeTruthy(); + expect(await env.get('dummy:yo')).toBeTruthy(); - assert.ok((await env.get('dummy:app'))!.packagePath!.endsWith(join('/generator-dummy'))); - assert.ok((await env.get('dummy:app'))!.packagePath!.endsWith(join('/generator-dummy'))); + expect((await env.get('dummy:app'))!.packagePath!.endsWith(join('/generator-dummy'))).toBeTruthy(); + expect((await env.get('dummy:app'))!.packagePath!.endsWith(join('/generator-dummy'))).toBeTruthy(); // Registers local ts generators', async function () { - assert.ok(await env.get('ts:app')); + expect(await env.get('ts:app')).toBeTruthy(); // Js generators takes precedence', async function () { // eslint-disable-next-line import-x/extensions - assert.equal(await env.get('ts-js:app'), require('./fixtures/generator-ts-js/generators/app/index.js')); + expect(await env.get('ts-js:app')).toEqual(require('./fixtures/generator-ts-js/generators/app/index.js')); // Register generators in scoped packages', async function () { - assert.ok(await env.get('@dummyscope/scoped:app')); + expect(await env.get('@dummyscope/scoped:app')).toBeTruthy(); // Local generators prioritized over global const { resolved } = (await env.get('dummy:app')) as any; - assert.ok(resolved.includes('orig'), `Couldn't find 'lookup-project' in ${resolved}`); + expect(resolved.includes('orig')).toBeTruthy(); // Register symlinked generators - assert.ok(await env.get('extend:support')); + expect(await env.get('extend:support')).toBeTruthy(); }); }); describe('when localOnly argument is true', async () => { beforeEach(async function () { env = new Environment(); - assert.equal(env.namespaces().length, 0, 'ensure env is empty'); + expect(env.namespaces().length).toEqual(0); await env.lookup({ localOnly: true }); env.alias('dummy-alias', 'dummy'); }); @@ -328,31 +327,31 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); // Register local generators - assert.ok(await env.get('dummy:app')); - assert.ok(await env.get('dummy:yo')); - assert.ok(env.isPackageRegistered('dummy')); - assert.ok(env.isPackageRegistered('dummy-alias')); + expect(await env.get('dummy:app')).toBeTruthy(); + expect(await env.get('dummy:yo')).toBeTruthy(); + expect(env.isPackageRegistered('dummy')).toBeTruthy(); + expect(env.isPackageRegistered('dummy-alias')).toBeTruthy(); // Register generators in scoped packages - assert.ok(await env.get('@dummyscope/scoped:app')); + expect(await env.get('@dummyscope/scoped:app')).toBeTruthy(); // Register non-dependency local generator - assert.ok(await env.get('jquery:app')); + expect(await env.get('jquery:app')).toBeTruthy(); // Register symlinked generators - assert.ok(await env.get('extend:support')); + expect(await env.get('extend:support')).toBeTruthy(); }); globalLookupTest()('does not register global generators', async function () { - assert.ok(!env.get('dummytest:app')); - assert.ok(!env.get('dummytest:controller')); + expect(env.get('dummytest:app')).toBeFalsy(); + expect(env.get('dummytest:controller')).toBeFalsy(); }); }); describe('when options.localOnly argument is true', async () => { beforeEach(async function () { env = new Environment(); - assert.equal(env.namespaces().length, 0, 'ensure env is empty'); + expect(env.namespaces().length).toEqual(0); await env.lookup({ localOnly: true }); }); @@ -360,22 +359,22 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); // Register local generators - assert.ok(await env.get('dummy:app')); - assert.ok(await env.get('dummy:yo')); + expect(await env.get('dummy:app')).toBeTruthy(); + expect(await env.get('dummy:yo')).toBeTruthy(); // Register generators in scoped packages - assert.ok(await env.get('@dummyscope/scoped:app')); + expect(await env.get('@dummyscope/scoped:app')).toBeTruthy(); // Register non-dependency local generator - assert.ok(await env.get('jquery:app')); + expect(await env.get('jquery:app')).toBeTruthy(); // Register symlinked generators - assert.ok(await env.get('extend:support')); + expect(await env.get('extend:support')).toBeTruthy(); }); globalLookupTest()('does not register global generators', async function () { - assert.ok(!env.get('dummytest:app')); - assert.ok(!env.get('dummytest:controller')); + expect(env.get('dummytest:app')).toBeFalsy(); + expect(env.get('dummytest:controller')).toBeFalsy(); }); }); }); @@ -408,8 +407,8 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('module:app')); - assert.ok(env.getRegisteredPackages().length === 1); + expect(await env.get('module:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 1).toBeTruthy(); }); it('with customizeNamespace', async function () { @@ -421,8 +420,8 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('custom:app')); - assert.ok(env.getRegisteredPackages().length === 1); + expect(await env.get('custom:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 1).toBeTruthy(); }); it('with scope and packagePaths', async function () { @@ -434,9 +433,9 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('@test/module:app')); - assert.ok(await env.get('@scoped/scoped:app')); - assert.ok(env.getRegisteredPackages().length === 2); + expect(await env.get('@test/module:app')).toBeTruthy(); + expect(await env.get('@scoped/scoped:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 2).toBeTruthy(); }); it('with 2 packagePaths', async function () { @@ -447,9 +446,9 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('module:app')); - assert.ok(await env.get('module-root:app')); - assert.ok(env.getRegisteredPackages().length === 2); + expect(await env.get('module:app')).toBeTruthy(); + expect(await env.get('module-root:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 2).toBeTruthy(); }); it('with 3 packagePaths', async function () { @@ -460,10 +459,10 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('module:app')); - assert.ok(await env.get('module-root:app')); - assert.ok(await env.get('module-lib-gen:app')); - assert.ok(env.getRegisteredPackages().length === 3); + expect(await env.get('module:app')).toBeTruthy(); + expect(await env.get('module-root:app')).toBeTruthy(); + expect(await env.get('module-lib-gen:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 3).toBeTruthy(); }); it('with scoped packagePaths', async function () { @@ -479,11 +478,11 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('module:app')); - assert.ok(await env.get('module-root:app')); - assert.ok(await env.get('module-lib-gen:app')); - assert.ok(await env.get('@scoped/scoped:app')); - assert.ok(env.getRegisteredPackages().length === 4); + expect(await env.get('module:app')).toBeTruthy(); + expect(await env.get('module-root:app')).toBeTruthy(); + expect(await env.get('module-lib-gen:app')).toBeTruthy(); + expect(await env.get('@scoped/scoped:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 4).toBeTruthy(); }); it('with npmPaths', async function () { @@ -491,11 +490,11 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('module:app')); - assert.ok(await env.get('module-root:app')); - assert.ok(await env.get('module-lib-gen:app')); - assert.ok(await env.get('@scoped/scoped:app')); - assert.ok(env.getRegisteredPackages().length === 4); + expect(await env.get('module:app')).toBeTruthy(); + expect(await env.get('module-root:app')).toBeTruthy(); + expect(await env.get('module-lib-gen:app')).toBeTruthy(); + expect(await env.get('@scoped/scoped:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 4).toBeTruthy(); }); it('with sub-sub-generators filePatterns', async function () { @@ -507,7 +506,7 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('@scoped/scoped:app:scaffold')); + expect(await env.get('@scoped/scoped:app:scaffold')).toBeTruthy(); }); it('with packagePatterns', async function () { @@ -519,9 +518,9 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('module:app')); - assert.ok(await env.get('module-root:app')); - assert.ok(env.getRegisteredPackages().length === 2); + expect(await env.get('module:app')).toBeTruthy(); + expect(await env.get('module-root:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 2).toBeTruthy(); }); it('with sub-sub-generators and packagePaths', async function () { @@ -533,7 +532,7 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('@scoped/scoped:app:scaffold')); + expect(await env.get('@scoped/scoped:app:scaffold')).toBeTruthy(); }); it('with sub-sub-generators and packagePatterns', async function () { @@ -546,7 +545,7 @@ describe('Environment Resolver', async function () { expect(toRelativeMeta(env.getGeneratorsMeta())).toMatchSnapshot(); - assert.ok(await env.get('@scoped/scoped:app:scaffold')); + expect(await env.get('@scoped/scoped:app:scaffold')).toBeTruthy(); }); }); @@ -578,8 +577,8 @@ describe('Environment Resolver', async function () { it('with 1 namespace', async function () { await env.lookupNamespaces('module:app', { localOnly: true, npmPaths: ['node_modules'] }); - assert.ok(await env.get('module:app')); - assert.ok(env.getRegisteredPackages().length === 1); + expect(await env.get('module:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 1).toBeTruthy(); }); it('with 2 namespaces', async function () { @@ -587,9 +586,9 @@ describe('Environment Resolver', async function () { localOnly: true, npmPaths: ['node_modules'], }); - assert.ok(await env.get('module:app')); - assert.ok(await env.get('module-root:app')); - assert.ok(env.getRegisteredPackages().length === 2); + expect(await env.get('module:app')).toBeTruthy(); + expect(await env.get('module-root:app')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 2).toBeTruthy(); }); it('with sub-sub-generators', async function () { @@ -597,8 +596,8 @@ describe('Environment Resolver', async function () { localOnly: true, npmPaths: ['node_modules'], }); - assert.ok(await env.get('@scoped/scoped:app:scaffold')); - assert.ok(env.getRegisteredPackages().length === 1); + expect(await env.get('@scoped/scoped:app:scaffold')).toBeTruthy(); + expect(env.getRegisteredPackages().length === 1).toBeTruthy(); }); }); @@ -616,33 +615,35 @@ describe('Environment Resolver', async function () { it('walk up the CWD lookups dir', async function () { const paths = getNpmPaths({ localOnly: false, filterPaths: false }); - assert.equal(paths[0], path.join(process.cwd(), 'node_modules')); - assert.equal(paths[1], path.join(process.cwd(), '../node_modules')); + expect(paths[0]).toEqual(path.join(process.cwd(), 'node_modules')); + expect(paths[1]).toEqual(path.join(process.cwd(), '../node_modules')); }); it('append NODE_PATH', async function () { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes(process.env.NODE_PATH!)); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).includes(process.env.NODE_PATH!)).toBeTruthy(); }); }); describe('without NODE_PATH', async () => { it('walk up the CWD lookups dir', async function () { const paths = getNpmPaths({ localOnly: false, filterPaths: false }); - assert.equal(paths[0], path.join(process.cwd(), 'node_modules')); + expect(paths[0]).toEqual(path.join(process.cwd(), 'node_modules')); const prevdir = process.cwd().split(path.sep).slice(0, -1).join(path.sep); - assert.equal(paths[1], path.join(prevdir, 'node_modules')); + expect(paths[1]).toEqual(path.join(prevdir, 'node_modules')); }); it('append best bet if NODE_PATH is unset', async function () { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes(bestBet)); - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes(bestBet2)); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).includes(bestBet)).toBeTruthy(); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).includes(bestBet2)).toBeTruthy(); }); it('append default NPM dir depending on your OS', async function () { if (process.platform === 'win32') { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes(path.join(process.env.APPDATA!, 'npm/node_modules'))); + expect( + getNpmPaths({ localOnly: false, filterPaths: false }).includes(path.join(process.env.APPDATA!, 'npm/node_modules')), + ).toBeTruthy(); } else { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes('/usr/lib/node_modules')); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).includes('/usr/lib/node_modules')).toBeTruthy(); } }); }); @@ -654,58 +655,60 @@ describe('Environment Resolver', async function () { it('walk up the CWD lookups dir', async function () { const paths = getNpmPaths({ localOnly: false, filterPaths: false }); - assert.equal(paths[0], path.join(process.cwd(), 'node_modules')); - assert.equal(paths[1], path.join(process.cwd(), '../node_modules')); + expect(paths[0]).toEqual(path.join(process.cwd(), 'node_modules')); + expect(paths[1]).toEqual(path.join(process.cwd(), '../node_modules')); }); it('append NVM_PATH', async function () { - assert.ok( + expect( getNpmPaths({ localOnly: false, filterPaths: false }).includes(path.join(path.dirname(process.env.NVM_PATH!), 'node_modules')), - ); + ).toBeTruthy(); }); }); describe('without NVM_PATH', async () => { it('walk up the CWD lookups dir', async function () { const paths = getNpmPaths({ localOnly: false, filterPaths: false }); - assert.equal(paths[0], path.join(process.cwd(), 'node_modules')); - assert.equal(paths[1], path.join(process.cwd(), '../node_modules')); + expect(paths[0]).toEqual(path.join(process.cwd(), 'node_modules')); + expect(paths[1]).toEqual(path.join(process.cwd(), '../node_modules')); }); it('append best bet if NVM_PATH is unset', async function () { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes(path.join(bestBet, 'node_modules'))); - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).includes(bestBet2)); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).includes(path.join(bestBet, 'node_modules'))).toBeTruthy(); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).includes(bestBet2)).toBeTruthy(); }); }); describe('when localOnly argument is true', async () => { it('walk up the CWD lookups dir', async function () { const paths = getNpmPaths({ localOnly: false, filterPaths: false }); - assert.equal(paths[0], path.join(process.cwd(), 'node_modules')); - assert.equal(paths[1], path.join(process.cwd(), '../node_modules')); + expect(paths[0]).toEqual(path.join(process.cwd(), 'node_modules')); + expect(paths[1]).toEqual(path.join(process.cwd(), '../node_modules')); }); it('does not append NODE_PATH', async function () { process.env.NODE_PATH = '/some/dummy/path'; - assert.ok(!getNpmPaths({ localOnly: true, filterPaths: false }).includes(process.env.NODE_PATH)); + expect(getNpmPaths({ localOnly: true, filterPaths: false }).includes(process.env.NODE_PATH)).toBeFalsy(); }); it('does not append NVM_PATH', async function () { process.env.NVM_PATH = '/some/dummy/path'; - assert.ok( - !getNpmPaths({ localOnly: true, filterPaths: false }).includes(path.join(path.dirname(process.env.NVM_PATH!), 'node_modules')), - ); + expect( + getNpmPaths({ localOnly: true, filterPaths: false }).includes(path.join(path.dirname(process.env.NVM_PATH!), 'node_modules')), + ).toBeFalsy(); }); it('does not append best bet', async function () { - assert.ok(!getNpmPaths({ localOnly: true, filterPaths: false }).includes(bestBet)); + expect(getNpmPaths({ localOnly: true, filterPaths: false }).includes(bestBet)).toBeFalsy(); }); it('does not append default NPM dir depending on your OS', async function () { if (process.platform === 'win32') { - assert.ok(!getNpmPaths({ localOnly: true, filterPaths: false }).includes(path.join(process.env.APPDATA!, 'npm/node_modules'))); + expect( + getNpmPaths({ localOnly: true, filterPaths: false }).includes(path.join(process.env.APPDATA!, 'npm/node_modules')), + ).toBeFalsy(); } else { - assert.ok(!getNpmPaths({ localOnly: true, filterPaths: false }).includes('/usr/lib/node_modules')); + expect(getNpmPaths({ localOnly: true, filterPaths: false }).includes('/usr/lib/node_modules')).toBeFalsy(); } }); }); @@ -714,9 +717,11 @@ describe('Environment Resolver', async function () { it('append npm modules path depending on your OS', async function () { const npmPrefix = execaOutput('npm', ['prefix', '-g'])!; if (process.platform === 'win32') { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).indexOf(path.resolve(npmPrefix, 'node_modules')) > 0); + expect(getNpmPaths({ localOnly: false, filterPaths: false }).indexOf(path.resolve(npmPrefix, 'node_modules')) > 0).toBeTruthy(); } else { - assert.ok(getNpmPaths({ localOnly: false, filterPaths: false }).indexOf(path.resolve(npmPrefix, 'lib/node_modules')) > 0); + expect( + getNpmPaths({ localOnly: false, filterPaths: false }).indexOf(path.resolve(npmPrefix, 'lib/node_modules')) > 0, + ).toBeTruthy(); } }); }); @@ -739,8 +744,8 @@ describe('Environment Resolver', async function () { it('finds it', async function () { const packageToFind = 'generator-dummy'; const actual = findPackagesIn(['node_modules'], [packageToFind]); - assert.equal(actual.length, 1); - assert.ok(actual[0].endsWith(packageToFind)); + expect(actual.length).toEqual(1); + expect(actual[0].endsWith(packageToFind)).toBeTruthy(); }); }); @@ -748,8 +753,8 @@ describe('Environment Resolver', async function () { it('finds it', async function () { const packageToFind = '@dummyscope/generator-scoped'; const actual = findPackagesIn(['node_modules'], [packageToFind]); - assert.equal(actual.length, 1); - assert.ok(actual[0].endsWith(packageToFind)); + expect(actual.length).toEqual(1); + expect(actual[0].endsWith(packageToFind)).toBeTruthy(); }); }); }); @@ -777,13 +782,13 @@ describe('Environment Resolver', async function () { describe('Find generator', async () => { it('Scoped lookup', async () => { const modulePath = lookupGenerator('@dummyscope/scoped:app'); - assert.ok(modulePath.endsWith('node_modules/@dummyscope/generator-scoped/app/index.js')); + expect(modulePath.endsWith('node_modules/@dummyscope/generator-scoped/app/index.js')).toBeTruthy(); const packagePath = lookupGenerator('@dummyscope/scoped:app', { packagePath: true }); - assert.ok(packagePath.endsWith('node_modules/@dummyscope/generator-scoped')); + expect(packagePath.endsWith('node_modules/@dummyscope/generator-scoped')).toBeTruthy(); }); it('Lookup', async () => { const modulePath = lookupGenerator('extend:support'); - assert.ok(modulePath.endsWith('node_modules/generator-extend/support/index.js')); + expect(modulePath.endsWith('node_modules/generator-extend/support/index.js')).toBeTruthy(); const packagePath = lookupGenerator('extend:support', { packagePath: true, @@ -791,22 +796,22 @@ describe('Environment Resolver', async function () { const packagePath3 = lookupGenerator('extend', { packagePath: true, }); - assert.ok(packagePath.endsWith('node_modules/generator-extend')); - assert.ok(packagePath3.endsWith('node_modules/generator-extend')); + expect(packagePath.endsWith('node_modules/generator-extend')).toBeTruthy(); + expect(packagePath3.endsWith('node_modules/generator-extend')).toBeTruthy(); }); it('Module Lookup', async () => { const modulePath = lookupGenerator('module:app'); - assert.ok(modulePath.endsWith('node_modules/generator-module/generators/app/index.js'), modulePath); + expect(modulePath.endsWith('node_modules/generator-module/generators/app/index.js')).toBeTruthy(); const packagePath = lookupGenerator('module:app', { packagePath: true, }); - assert.ok(packagePath.endsWith('node_modules/generator-module'), packagePath); + expect(packagePath.endsWith('node_modules/generator-module')).toBeTruthy(); const generatorPath = lookupGenerator('module:app', { generatorPath: true, }); - assert.ok(generatorPath.endsWith('node_modules/generator-module/generators/'), generatorPath); + expect(generatorPath.endsWith('node_modules/generator-module/generators/')).toBeTruthy(); }); }); }); @@ -837,21 +842,25 @@ describe('Environment Resolver', async function () { describe('Find generator', async () => { it('Module Lookup', async () => { const modulePath = lookupGenerator('module:app'); - assert.ok(modulePath.endsWith('node_modules/generator-module/generators/app/index.js')); + expect(modulePath.endsWith('node_modules/generator-module/generators/app/index.js')).toBeTruthy(); const multiplePath = lookupGenerator('module:app', { singleResult: false, }); - assert.equal(multiplePath.length, 2); - assert.ok(multiplePath[0].endsWith('lookup-custom/node_modules/generator-module/generators/app/index.js')); - assert.ok(multiplePath[1].endsWith('lookup-custom/node_modules/foo/node_modules/generator-module/generators/app/index.js')); + expect(multiplePath.length).toEqual(2); + expect(multiplePath[0].endsWith('lookup-custom/node_modules/generator-module/generators/app/index.js')).toBeTruthy(); + expect( + multiplePath[1].endsWith('lookup-custom/node_modules/foo/node_modules/generator-module/generators/app/index.js'), + ).toBeTruthy(); const multiplePath2 = lookupGenerator('module:app', { singleResult: false, }); - assert.equal(multiplePath2.length, 2); - assert.ok(multiplePath2[0].endsWith('lookup-custom/node_modules/generator-module/generators/app/index.js')); - assert.ok(multiplePath2[1].endsWith('lookup-custom/node_modules/foo/node_modules/generator-module/generators/app/index.js')); + expect(multiplePath2.length).toEqual(2); + expect(multiplePath2[0].endsWith('lookup-custom/node_modules/generator-module/generators/app/index.js')).toBeTruthy(); + expect( + multiplePath2[1].endsWith('lookup-custom/node_modules/foo/node_modules/generator-module/generators/app/index.js'), + ).toBeTruthy(); }); }); }); @@ -868,10 +877,10 @@ describe('Environment Resolver', async function () { describe('Find generator', async () => { it('Generator extended by environment lookup', async () => { env = new Environment(); - assert.equal(env.namespaces().length, 0, 'ensure env is empty'); + expect(env.namespaces().length).toEqual(0); await env.lookup(); - assert.ok(await env.get('environment-extend:app')); - assert.ok(await env.create('environment-extend:app')); + expect(await env.get('environment-extend:app')).toBeTruthy(); + expect(await env.create('environment-extend:app')).toBeTruthy(); }); }); }); diff --git a/test/store.ts b/test/store.ts index a43bec2c..04e192d8 100644 --- a/test/store.ts +++ b/test/store.ts @@ -1,8 +1,7 @@ -import assert from 'node:assert'; import { createRequire } from 'node:module'; import path, { dirname, join } from 'node:path'; import { fileURLToPath } from 'node:url'; -import { beforeEach, describe, it } from 'esmocha'; +import { beforeEach, describe, expect, it } from 'esmocha'; import Store from '../src/store.ts'; const require = createRequire(import.meta.url); @@ -40,12 +39,12 @@ describe('Store', async () => { }); it('store and return the module', async () => { - assert.equal(outcome, module); + expect(outcome).toBe(module); }); it('assign meta data to the module', async () => { - assert.equal(outcome.namespace, 'foo:module'); - assert.equal(outcome.resolved, join('/foo/path/index.js')); + expect(outcome.namespace).toEqual('foo:module'); + expect(outcome.resolved).toEqual(join('/foo/path/index.js')); }); }); @@ -58,13 +57,13 @@ describe('Store', async () => { }); it('store and returns the required module', async () => { - assert.notEqual(outcome, modulePath); - assert.equal(outcome.usage, 'Usage can be used to customize the help output'); + expect(outcome).not.toBe(modulePath); + expect(outcome.usage).toEqual('Usage can be used to customize the help output'); }); it('assign meta data to the module', async () => { - assert.equal(outcome.resolved, join(modulePath, 'index.js')); - assert.equal(outcome.namespace, 'foo:path'); + expect(outcome.resolved).toEqual(join(modulePath, 'index.js')); + expect(outcome.namespace).toEqual('foo:path'); }); }); }); @@ -76,7 +75,7 @@ describe('Store', async () => { }); it('return stored module namespaces', async () => { - assert.deepEqual(store.namespaces(), ['foo', 'lab']); + expect(store.namespaces()).toEqual(['foo', 'lab']); }); }); }); From 243aa39c2174efdaf0dcdb2dbdd498016fccc4d2 Mon Sep 17 00:00:00 2001 From: Marcelo Shima Date: Wed, 29 Apr 2026 12:41:12 -0300 Subject: [PATCH 2/4] chore: drop yeoman-assert --- package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/package.json b/package.json index de087274..e370f856 100644 --- a/package.json +++ b/package.json @@ -94,7 +94,6 @@ "rimraf": "^6.1.3", "strip-ansi": "^7.2.0", "typescript": "6.0.3", - "yeoman-assert": "^3.1.1", "yeoman-environment": "file:./", "yeoman-generator-2": "npm:yeoman-generator@^2.0.5", "yeoman-generator-4": "npm:yeoman-generator@^4.13.0", From c4e7f3ee81c36849f2f2c15fa4789125302f013b Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 29 Apr 2026 16:04:54 +0000 Subject: [PATCH 3/4] fix: normalize line endings in help() tests for Windows compatibility Agent-Logs-Url: https://github.com/yeoman/environment/sessions/39b4a214-ad9b-44c4-9c38-a15ad8ee9e17 Co-authored-by: mshima <1417183+mshima@users.noreply.github.com> --- test/environment.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/environment.ts b/test/environment.ts index 3a7f8862..7bd22ff5 100644 --- a/test/environment.ts +++ b/test/environment.ts @@ -114,12 +114,12 @@ for (const generatorVersion of allVersions) { }); it('output the general help', async function () { - expect(env.help().trim()).toEqual(expected); + expect(env.help().trim().replaceAll('\r\n', '\n')).toEqual(expected.replaceAll('\r\n', '\n')); }); it('output the help with a custom bin name', async function () { expected = expected.replace('Usage: init', 'Usage: gg'); - expect(env.help('gg').trim()).toEqual(expected); + expect(env.help('gg').trim().replaceAll('\r\n', '\n')).toEqual(expected.replaceAll('\r\n', '\n')); }); }); From 1a856f68bd691bf92d85589b5272962e80566635 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 29 Apr 2026 16:07:07 +0000 Subject: [PATCH 4/4] fix: use not.toBe for reference inequality check Agent-Logs-Url: https://github.com/yeoman/environment/sessions/39b4a214-ad9b-44c4-9c38-a15ad8ee9e17 Co-authored-by: mshima <1417183+mshima@users.noreply.github.com> --- test/environment.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/environment.ts b/test/environment.ts index 7bd22ff5..716bc879 100644 --- a/test/environment.ts +++ b/test/environment.ts @@ -183,7 +183,7 @@ for (const generatorVersion of allVersions) { const arguments_ = ['foo', 'bar']; env.arguments = arguments_; const generator = await env.create('stub'); - expect(generator.arguments).not.toEqual(arguments_); + expect(generator.arguments).not.toBe(arguments_); }); it('pass options.options', async function () {