release-it 19.0.0-next.3 → 19.0.0-next.5

package/test/config.js

@@ -1,31 +1,34 @@
 import test, { describe, before, after, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { isCI } from 'ci-info';
-import Config, { getRemoteConfiguration } from '../lib/config.js';
+import Config from '../lib/config.js';
 import { readJSON } from '../lib/util.js';
 import { mockFetch } from './util/mock.js';
+import { createTarBlobByRawContents } from './util/fetch.js';
 
 const defaultConfig = readJSON(new URL('../config/release-it.json', import.meta.url));
 const projectConfig = readJSON(new URL('../.release-it.json', import.meta.url));
 
 const localConfig = { github: { release: true } };
 
-describe('config', () => {
-  test("should read this project's own configuration", () => {
+describe('config', async () => {
+  test("should read this project's own configuration", async () => {
     const config = new Config();
+    await config.init();
     assert.deepEqual(config.constructorConfig, {});
     assert.deepEqual(config.localConfig, projectConfig);
     assert.deepEqual(config.defaultConfig, defaultConfig);
   });
 
-  test('should contain default values', () => {
+  test('should contain default values', async () => {
     const config = new Config({ configDir: './test/stub/config/default' });
+    await config.init();
     assert.deepEqual(config.constructorConfig, { configDir: './test/stub/config/default' });
     assert.deepEqual(config.localConfig, localConfig);
     assert.deepEqual(config.defaultConfig, defaultConfig);
   });
 
-  test('should merge provided options', () => {
+  test('should merge provided options', async () => {
     const config = new Config({
       configDir: './test/stub/config/merge',
       increment: '1.0.0',
@@ -34,6 +37,7 @@ describe('config', () => {
         release: true
       }
     });
+    await config.init();
     const { options } = config;
     assert.equal(config.isVerbose, true);
     assert.equal(config.isDryRun, false);
@@ -42,67 +46,79 @@ describe('config', () => {
     assert.equal(options.github.release, true);
   });
 
-  test('should set CI mode', () => {
+  test('should set CI mode', async () => {
     const config = new Config({ ci: true });
+    await config.init();
     assert.equal(config.isCI, true);
   });
 
-  test('should detect CI mode', () => {
+  test('should detect CI mode', async () => {
     const config = new Config();
+    await config.init();
     assert.equal(config.options.ci, isCI);
     assert.equal(config.isCI, isCI);
   });
 
-  test('should override --no-npm.publish', () => {
+  test('should override --no-npm.publish', async () => {
     const config = new Config({ npm: { publish: false } });
+    await config.init();
     assert.equal(config.options.npm.publish, false);
   });
 
-  test('should read YAML config', () => {
+  test('should read YAML config', async () => {
     const config = new Config({ configDir: './test/stub/config/yaml' });
+    await config.init();
     assert.deepEqual(config.options.foo, { bar: 1 });
   });
 
-  test('should read YML config', () => {
+  test('should read YML config', async () => {
     const config = new Config({ configDir: './test/stub/config/yml' });
+    await config.init();
     assert.deepEqual(config.options.foo, { bar: 1 });
   });
 
-  test('should read TOML config', () => {
+  test('should read TOML config', async () => {
     const config = new Config({ configDir: './test/stub/config/toml' });
+    await config.init();
     assert.deepEqual(config.options.foo, { bar: 1 });
   });
 
-  test('should throw if provided config file is not found', () => {
-    assert.throws(() => new Config({ config: 'nofile' }), /no such file.+nofile/);
+  test('should throw if provided config file is not found', async () => {
+    await assert.rejects(async () => {
+      const config = new Config({ config: 'nofile' });
+      await config.init();
+    }, /no such file.+nofile/);
   });
 
-  test('should throw if provided config file is invalid (cosmiconfig exception)', () => {
-    assert.throws(
-      () => new Config({ config: './test/stub/config/invalid-config-txt' }),
-      /Invalid configuration file at/
-    );
+  test('should throw if provided config file is invalid (cosmiconfig exception)', async () => {
+    await assert.rejects(async () => {
+      const config = new Config({ config: './test/stub/config/invalid-config-txt' });
+      await config.init();
+    }, /Invalid configuration file at/);
   });
 
-  test('should throw if provided config file is invalid (no object)', () => {
-    assert.throws(
-      () => new Config({ config: './test/stub/config/invalid-config-rc' }),
-      /Invalid configuration file at/
-    );
+  test('should throw if provided config file is invalid (no object)', async () => {
+    await assert.rejects(async () => {
+      const config = new Config({ config: './test/stub/config/invalid-config-rc' });
+      await config.init();
+    }, /Invalid configuration file at/);
   });
 
-  test('should not set default increment (for CI mode)', () => {
+  test('should not set default increment (for CI mode)', async () => {
     const config = new Config({ ci: true });
+    await config.init();
     assert.equal(config.options.version.increment, undefined);
   });
 
-  test('should not set default increment (for interactive mode)', () => {
+  test('should not set default increment (for interactive mode)', async () => {
     const config = new Config({ ci: false });
+    await config.init();
     assert.equal(config.options.version.increment, undefined);
   });
 
-  test('should expand pre-release shortcut', () => {
+  test('should expand pre-release shortcut', async () => {
     const config = new Config({ increment: 'major', preRelease: 'beta' });
+    await config.init();
     assert.deepEqual(config.options.version, {
       increment: 'major',
       isPreRelease: true,
@@ -111,8 +127,9 @@ describe('config', () => {
     });
   });
 
-  test('should expand pre-release shortcut (preRelease boolean)', () => {
+  test('should expand pre-release shortcut (preRelease boolean)', async () => {
     const config = new Config({ ci: true, preRelease: true });
+    await config.init();
     assert.deepEqual(config.options.version, {
       increment: undefined,
       isPreRelease: true,
@@ -121,8 +138,9 @@ describe('config', () => {
     });
   });
 
-  test('should expand pre-release shortcut (without increment)', () => {
+  test('should expand pre-release shortcut (without increment)', async () => {
     const config = new Config({ ci: false, preRelease: 'alpha' });
+    await config.init();
     assert.deepEqual(config.options.version, {
       increment: undefined,
       isPreRelease: true,
@@ -131,8 +149,9 @@ describe('config', () => {
     });
   });
 
-  test('should expand pre-release shortcut (including increment and npm.tag)', () => {
+  test('should expand pre-release shortcut (including increment and npm.tag)', async () => {
     const config = new Config({ increment: 'minor', preRelease: 'rc' });
+    await config.init();
     assert.deepEqual(config.options.version, {
       increment: 'minor',
       isPreRelease: true,
@@ -141,8 +160,9 @@ describe('config', () => {
     });
   });
 
-  test('should use pre-release base', () => {
+  test('should use pre-release base', async () => {
     const config = new Config({ increment: 'minor', preRelease: 'next', preReleaseBase: '1' });
+    await config.init();
     assert.deepEqual(config.options.version, {
       increment: 'minor',
       isPreRelease: true,
@@ -151,8 +171,9 @@ describe('config', () => {
     });
   });
 
-  test('should expand pre-release shortcut (snapshot)', () => {
+  test('should expand pre-release shortcut (snapshot)', async () => {
     const config = new Config({ snapshot: 'feat' });
+    await config.init();
     assert.deepEqual(config.options.version, {
       increment: 'prerelease',
       isPreRelease: true,
@@ -165,7 +186,7 @@ describe('config', () => {
 });
 
 describe('fetch extended configuration', () => {
-  const [mocker, server] = mockFetch('https://raw.githubusercontent.com');
+  const [mocker, server] = mockFetch('https://api.github.com');
 
   before(() => {
     mocker.mockGlobal();
@@ -180,86 +201,140 @@ describe('fetch extended configuration', () => {
   });
 
   test('should fetch extended configuration with default file and default branch', async () => {
-    server.get('/release-it/release-it-configuration/HEAD/.release-it.json', {
+    const extendedConfiguration = {
+      git: {
+        commitMessage: 'Released version ${version}'
+      }
+    };
+
+    server.head('/repos/release-it/release-it-configuration/tarball/main', {
+      status: 200,
+      headers: {}
+    });
+
+    server.get('/repos/release-it/release-it-configuration/tarball/main', {
       status: 200,
-      body: { git: { commitMessage: 'Released version ${version}' } }
+      body: await new Response(
+        createTarBlobByRawContents({
+          '.release-it.json': JSON.stringify(extendedConfiguration)
+        })
+      ).arrayBuffer()
     });
 
-    const config = {
+    const config = new Config({
       extends: 'github:release-it/release-it-configuration'
-    };
+    });
+    await config.init();
+
+    assert(mocker.allRoutesCalled());
+
+    assert.equal(config.options.git.commitMessage, extendedConfiguration.git.commitMessage);
+  });
 
+  test('should fetch extended configuration with default file and specific tag', async () => {
     const extendedConfiguration = {
       git: {
         commitMessage: 'Released version ${version}'
       }
     };
 
-    const response = await getRemoteConfiguration(config.extends);
-
-    assert.deepEqual(response, extendedConfiguration);
-  });
+    server.head('/repos/release-it/release-it-configuration/tarball/1.0.0', {
+      status: 200,
+      headers: {}
+    });
 
-  test('should fetch extended configuration with default file and specific tag', async () => {
-    server.get('/release-it/release-it-configuration/refs/tags/1.0.0/.release-it.json', {
+    server.get('/repos/release-it/release-it-configuration/tarball/1.0.0', {
       status: 200,
-      body: { git: { commitMessage: 'Released version ${version}' } }
+      body: await new Response(
+        createTarBlobByRawContents({
+          '.release-it.json': JSON.stringify(extendedConfiguration)
+        })
+      ).arrayBuffer()
     });
 
-    const config = {
+    const config = new Config({
       extends: 'github:release-it/release-it-configuration#1.0.0'
-    };
+    });
+    await config.init();
+
+    assert(mocker.allRoutesCalled());
 
+    assert.equal(config.options.git.commitMessage, extendedConfiguration.git.commitMessage);
+  });
+
+  test('should fetch extended configuration with sub dir and specific tag', async () => {
     const extendedConfiguration = {
       git: {
         commitMessage: 'Released version ${version}'
       }
     };
 
-    const response = await getRemoteConfiguration(config.extends);
+    const extendedSubConfiguration = {
+      git: {
+        commitMessage: 'Released pkg version ${version}'
+      }
+    };
 
-    assert.deepEqual(response, extendedConfiguration);
-  });
+    server.head('/repos/release-it/release-it-configuration/tarball/1.0.0', {
+      status: 200,
+      headers: {}
+    });
 
-  test('should fetch extended configuration with custom file and specific tag', async () => {
-    server.get('/release-it/release-it-configuration/refs/tags/1.0.0/config.json', {
+    server.get('/repos/release-it/release-it-configuration/tarball/1.0.0', {
       status: 200,
-      body: { git: { commitMessage: 'Released version ${version}' } }
+      body: await new Response(
+        createTarBlobByRawContents({
+          '.release-it.json': JSON.stringify(extendedConfiguration),
+          'sub/.release-it.json': JSON.stringify(extendedSubConfiguration)
+        })
+      ).arrayBuffer()
     });
 
-    const config = {
-      extends: 'github:release-it/release-it-configuration:config.json#1.0.0'
-    };
+    const config = new Config({
+      extends: 'github:release-it/release-it-configuration/sub#1.0.0'
+    });
+    await config.init();
+
+    assert(mocker.allRoutesCalled());
+
+    assert.equal(config.options.git.commitMessage, extendedSubConfiguration.git.commitMessage);
+  });
 
+  test('should fetch extended configuration with custom file and default branch', async () => {
     const extendedConfiguration = {
       git: {
         commitMessage: 'Released version ${version}'
       }
     };
 
-    const response = await getRemoteConfiguration(config.extends);
-
-    assert.deepEqual(response, extendedConfiguration);
-  });
+    const extendedSubConfiguration = {
+      git: {
+        commitMessage: 'Released pkg version ${version}'
+      }
+    };
 
-  test('should fetch extended configuration with custom file and default branch', async () => {
-    server.get('/release-it/release-it-configuration/HEAD/config.json', {
+    server.head('/repos/release-it/release-it-configuration/tarball/main', {
       status: 200,
-      body: { git: { commitMessage: 'Released version ${version}' } }
+      headers: {}
     });
 
-    const config = {
-      extends: 'github:release-it/release-it-configuration:config.json'
-    };
+    server.get('/repos/release-it/release-it-configuration/tarball/main', {
+      status: 200,
+      body: await new Response(
+        createTarBlobByRawContents({
+          '.release-it.json': JSON.stringify(extendedConfiguration),
+          'sub/.release-it.json': JSON.stringify(extendedSubConfiguration)
+        })
+      ).arrayBuffer()
+    });
 
-    const extendedConfiguration = {
-      git: {
-        commitMessage: 'Released version ${version}'
-      }
-    };
+    const config = new Config({
+      extends: 'github:release-it/release-it-configuration/sub'
+    });
+    await config.init();
 
-    const response = await getRemoteConfiguration(config.extends);
+    assert(mocker.allRoutesCalled());
 
-    assert.deepEqual(response, extendedConfiguration);
+    assert.equal(config.options.git.commitMessage, extendedSubConfiguration.git.commitMessage);
   });
 });

package/test/git.init.js

@@ -26,59 +26,59 @@ describe('git.init', () => {
 
   test('should throw if on wrong branch', async () => {
     const options = { git: { requireBranch: 'dev' } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     childProcess.execSync('git remote remove origin', execOpts);
     await assert.rejects(gitClient.init(), /Must be on branch dev/);
   });
 
   test('should throw if on negated branch', async () => {
     const options = { git: { requireBranch: '!main' } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     sh.exec('git checkout -b main', execOpts);
     await assert.rejects(gitClient.init(), /Must be on branch !main/);
   });
 
   test('should not throw if required branch matches', async () => {
     const options = { git: { requireBranch: 'ma?*' } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     await assert.doesNotReject(gitClient.init());
   });
 
   test('should not throw if one of required branch matches', async () => {
     const options = { git: { requireBranch: ['release/*', 'hotfix/*'] } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     childProcess.execSync('git checkout -b release/v1', execOpts);
     await assert.doesNotReject(gitClient.init());
   });
 
   test('should throw if there is no remote Git url', async () => {
-    const gitClient = factory(Git, { options: { git } });
+    const gitClient = await factory(Git, { options: { git } });
     childProcess.execSync('git remote remove origin', execOpts);
     await assert.rejects(gitClient.init(), /Could not get remote Git url/);
   });
 
   test('should throw if working dir is not clean', async () => {
-    const gitClient = factory(Git, { options: { git } });
+    const gitClient = await factory(Git, { options: { git } });
     childProcess.execSync('rm file', execOpts);
     await assert.rejects(gitClient.init(), /Working dir must be clean/);
   });
 
   test('should throw if no upstream is configured', async () => {
-    const gitClient = factory(Git, { options: { git } });
+    const gitClient = await factory(Git, { options: { git } });
     childProcess.execSync('git checkout -b foo', execOpts);
     await assert.rejects(gitClient.init(), /No upstream configured for current branch/);
   });
 
   test('should throw if there are no commits', async () => {
     const options = { git: { requireCommits: true } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     childProcess.execSync('git tag 1.0.0', execOpts);
     await assert.rejects(gitClient.init(), /There are no commits since the latest tag/);
   });
 
   test('should not throw if there are commits', async () => {
     const options = { git: { requireCommits: true } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     childProcess.execSync('git tag 1.0.0', execOpts);
     gitAdd('line', 'file', 'Add file');
     await assert.doesNotReject(gitClient.init(), 'There are no commits since the latest tag');
@@ -86,21 +86,21 @@ describe('git.init', () => {
 
   test('should fail (exit code 1) if there are no commits', async () => {
     const options = { git: { requireCommits: true } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     childProcess.execSync('git tag 1.0.0', execOpts);
     await assert.rejects(gitClient.init(), { code: 1 });
   });
 
   test('should not fail (exit code 0) if there are no commits', async () => {
     const options = { git: { requireCommits: true, requireCommitsFail: false } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     childProcess.execSync('git tag 1.0.0', execOpts);
     await assert.rejects(gitClient.init(), { code: 0 });
   });
 
   test('should throw if there are no commits in specified path', async () => {
     const options = { git: { requireCommits: true, commitsPath: 'dir' } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     mkdirSync('dir', { recursive: true });
     sh.exec('git tag 1.0.0', execOpts);
     await assert.rejects(gitClient.init(), { message: /^There are no commits since the latest tag/ });
@@ -108,7 +108,7 @@ describe('git.init', () => {
 
   test('should not throw if there are commits in specified path', async () => {
     const options = { git: { requireCommits: true, commitsPath: 'dir' } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     sh.exec('git tag 1.0.0', execOpts);
     gitAdd('line', 'dir/file', 'Add file');
     await assert.doesNotReject(gitClient.init());
@@ -116,19 +116,19 @@ describe('git.init', () => {
 
   test('should not throw if there are no tags', async () => {
     const options = { git: { requireCommits: true } };
-    const gitClient = factory(Git, { options });
+    const gitClient = await factory(Git, { options });
     gitAdd('line', 'file', 'Add file');
     await assert.doesNotReject(gitClient.init());
   });
 
   test('should not throw if origin remote is renamed', async () => {
     childProcess.execSync('git remote rename origin upstream', execOpts);
-    const gitClient = factory(Git);
+    const gitClient = await factory(Git);
     await assert.doesNotReject(gitClient.init());
   });
 
   test('should detect and include version prefix ("v")', async () => {
-    const gitClient = factory(Git, { options: { git } });
+    const gitClient = await factory(Git, { options: { git } });
     childProcess.execSync('git tag v1.0.0', execOpts);
     await gitClient.init();
     await gitClient.bump('1.0.1');
@@ -136,7 +136,7 @@ describe('git.init', () => {
   });
 
   test('should detect and exclude version prefix', async () => {
-    const gitClient = factory(Git, { options: { git } });
+    const gitClient = await factory(Git, { options: { git } });
     childProcess.execSync('git tag 1.0.0', execOpts);
     await gitClient.init();
     await gitClient.bump('1.0.1');
@@ -144,7 +144,7 @@ describe('git.init', () => {
   });
 
   test('should detect and exclude version prefix (configured)', async () => {
-    const gitClient = factory(Git, { options: { git: { tagName: 'v${version}' } } });
+    const gitClient = await factory(Git, { options: { git: { tagName: 'v${version}' } } });
     childProcess.execSync('git tag 1.0.0', execOpts);
     await gitClient.init();
     await gitClient.bump('1.0.1');
@@ -152,7 +152,7 @@ describe('git.init', () => {
   });
 
   test('should honor custom tagName configuration', async () => {
-    const gitClient = factory(Git, { options: { git: { tagName: 'TAGNAME-${repo.project}-v${version}' } } });
+    const gitClient = await factory(Git, { options: { git: { tagName: 'TAGNAME-${repo.project}-v${version}' } } });
     childProcess.execSync('git tag 1.0.0', execOpts);
     await gitClient.init();
     await gitClient.bump('1.0.1');
@@ -161,8 +161,8 @@ describe('git.init', () => {
   });
 
   test('should get the latest tag after fetch', async () => {
-    const shell = factory(Shell);
-    const gitClient = factory(Git, { container: { shell } });
+    const shell = await factory(Shell);
+    const gitClient = await factory(Git, { container: { shell } });
     const other = mkTmpDir();
     childProcess.execSync('git push', execOpts);
     childProcess.execSync(`git clone ${bare} ${other}`, execOpts);
@@ -176,8 +176,8 @@ describe('git.init', () => {
   });
 
   test('should get the latest custom tag after fetch when tagName is configured', async () => {
-    const shell = factory(Shell);
-    const gitClient = factory(Git, {
+    const shell = await factory(Shell);
+    const gitClient = await factory(Git, {
       options: { git: { tagName: 'TAGNAME-v${version}' } },
       container: { shell }
     });
@@ -195,8 +195,8 @@ describe('git.init', () => {
   });
 
   test('should get the latest tag based on tagMatch', async () => {
-    const shell = factory(Shell);
-    const gitClient = factory(Git, {
+    const shell = await factory(Shell);
+    const gitClient = await factory(Git, {
       options: { git: { tagMatch: '[0-9][0-9]\\.[0-1][0-9]\\.[0-9]*' } },
       container: { shell }
     });
@@ -209,8 +209,8 @@ describe('git.init', () => {
   });
 
   test('should get the latest tag based on tagExclude', async () => {
-    const shell = factory(Shell);
-    const gitClient = factory(Git, {
+    const shell = await factory(Shell);
+    const gitClient = await factory(Git, {
       options: { git: { tagExclude: '*[-]*' } },
       container: { shell }
     });
@@ -226,7 +226,7 @@ describe('git.init', () => {
   });
 
   test('should generate correct changelog', async () => {
-    const gitClient = factory(Git, { options: { git } });
+    const gitClient = await factory(Git, { options: { git } });
     childProcess.execSync('git tag 1.0.0', execOpts);
     gitAdd('line', 'file', 'Add file');
     gitAdd('line', 'file', 'Add file');
@@ -236,8 +236,8 @@ describe('git.init', () => {
   });
 
   test('should get the full changelog since latest major tag', async () => {
-    const shell = factory(Shell);
-    const gitClient = factory(Git, {
+    const shell = await factory(Shell);
+    const gitClient = await factory(Git, {
       options: { git: { tagMatch: '[0-9]\\.[0-9]\\.[0-9]', changelog: git.changelog } },
       container: { shell }
     });