release-it 19.0.0-next.4 → 19.0.0

package/test/npm.js

@@ -9,19 +9,19 @@ import { mkTmpDir, getArgs } from './util/helpers.js';
 describe('npm', async () => {
   test('should return npm package url', async () => {
     const options = { npm: { name: 'my-cool-package' } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     assert.equal(npmClient.getPackageUrl(), 'https://www.npmjs.com/package/my-cool-package');
   });
 
   test('should return npm package url (custom registry)', async () => {
     const options = { npm: { name: 'my-cool-package', publishConfig: { registry: 'https://registry.example.org/' } } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     assert.equal(npmClient.getPackageUrl(), 'https://registry.example.org/package/my-cool-package');
   });
 
   test('should return npm package url (custom publicPath)', async () => {
     const options = { npm: { name: 'my-cool-package', publishConfig: { publicPath: '/custom/public-path' } } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     assert.equal(npmClient.getPackageUrl(), 'https://www.npmjs.com/custom/public-path/my-cool-package');
   });
 
@@ -32,46 +32,46 @@ describe('npm', async () => {
         publishConfig: { registry: 'https://registry.example.org/', publicPath: '/custom/public-path' }
       }
     };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     assert.equal(npmClient.getPackageUrl(), 'https://registry.example.org/custom/public-path/my-cool-package');
   });
 
   test('should return default tag', async () => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const tag = await npmClient.resolveTag();
     assert.equal(tag, 'latest');
   });
 
   test('should resolve default tag for pre-release', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient, 'getRegistryPreReleaseTags', () => []);
     const tag = await npmClient.resolveTag('1.0.0-0');
     assert.equal(tag, 'next');
   });
 
   test('should guess tag from registry for pre-release', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient, 'getRegistryPreReleaseTags', () => ['alpha']);
     const tag = await npmClient.resolveTag('1.0.0-0');
     assert.equal(tag, 'alpha');
   });
 
   test('should derive tag from pre-release version', async () => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const tag = await npmClient.resolveTag('1.0.2-alpha.3');
     assert.equal(tag, 'alpha');
   });
 
   test('should use provided (default) tag even for pre-release', async t => {
     const options = { npm: { tag: 'latest' } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     await npmClient.bump('1.0.0-next.0');
     assert.equal(npmClient.getContext('tag'), 'latest');
   });
 
   test('should throw when `npm version` fails', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient.shell, 'exec', () =>
       Promise.reject(new Error('npm ERR! Version not changed, might want --allow-same-version'))
     );
@@ -79,14 +79,14 @@ describe('npm', async () => {
   });
 
   test('should return first pre-release tag from package in registry when resolving tag without pre-id', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const response = { latest: '1.4.1', alpha: '2.0.0-alpha.1', beta: '2.0.0-beta.3' };
     t.mock.method(npmClient.shell, 'exec', () => Promise.resolve(JSON.stringify(response)));
     assert.equal(await npmClient.resolveTag('2.0.0-5'), 'alpha');
   });
 
   test('should return default pre-release tag when resolving tag without pre-id', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const response = {
       latest: '1.4.1'
     };
@@ -95,19 +95,19 @@ describe('npm', async () => {
   });
 
   test('should handle erroneous output when resolving tag without pre-id', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient.shell, 'exec', () => Promise.resolve(''));
     assert.equal(await npmClient.resolveTag('2.0.0-0'), 'next');
   });
 
   test('should handle errored request when resolving tag without pre-id', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     assert.equal(await npmClient.resolveTag('2.0.0-0'), 'next');
   });
 
   test('should add registry to commands when specified', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     npmClient.setContext({ publishConfig: { registry: 'registry.example.org' } });
     const exec = t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami --registry registry.example.org') return Promise.resolve('john');
@@ -126,7 +126,7 @@ describe('npm', async () => {
   });
 
   test('should not throw when executing tasks', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami') return Promise.resolve('john');
       const re = /npm access (list collaborators --json|ls-collaborators) release-it/;
@@ -137,7 +137,7 @@ describe('npm', async () => {
   });
 
   test('should throw if npm is down', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm ping') return Promise.reject();
       return Promise.resolve();
@@ -146,7 +146,7 @@ describe('npm', async () => {
   });
 
   test('should not throw if npm returns 400/404 for unsupported ping/whoami/access', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     const pingError = "npm ERR! code E404\nnpm ERR! 404 Package '--ping' not found : ping";
     const whoamiError = "npm ERR! code E404\nnpm ERR! 404 Package '--whoami' not found : whoami";
@@ -159,7 +159,7 @@ describe('npm', async () => {
   });
 
   test('should not throw if npm returns 400 for unsupported ping/whoami/access', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     const pingError = 'npm ERR! code E400\nnpm ERR! 400 Bad Request - GET https://npm.example.org/-/ping?write=true';
     const whoamiError = 'npm ERR! code E400\nnpm ERR! 400 Bad Request - GET https://npm.example.org/-/whoami';
@@ -172,14 +172,14 @@ describe('npm', async () => {
   });
 
   test('should throw if user is not authenticated', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     exec.mock.mockImplementationOnce(() => Promise.reject(), 1);
     await assert.rejects(runTasks(npmClient), { message: /^Not authenticated with npm/ });
   });
 
   test('should throw if user is not a collaborator (v9)', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami') return Promise.resolve('ada');
       if (command === 'npm --version') return Promise.resolve('9.2.0');
@@ -191,7 +191,7 @@ describe('npm', async () => {
   });
 
   test('should throw if user is not a collaborator (v8)', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
 
     t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami') return Promise.resolve('ada');
@@ -205,7 +205,7 @@ describe('npm', async () => {
   });
 
   test('should not throw if user is not a collaborator on a new package', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
 
     t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami') return Promise.resolve('ada');
@@ -220,7 +220,7 @@ describe('npm', async () => {
   });
 
   test('should handle 2FA and publish with OTP', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     npmClient.setContext({ name: 'pkg' });
 
     const exec = t.mock.method(npmClient.shell, 'exec');
@@ -247,7 +247,7 @@ describe('npm', async () => {
   });
 
   test('should publish', async t => {
-    const npmClient = factory(npm);
+    const npmClient = await factory(npm);
     const exec = t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami') return Promise.resolve('john');
       const re = /npm access (list collaborators --json|ls-collaborators) release-it/;
@@ -260,7 +260,7 @@ describe('npm', async () => {
 
   test('should use extra publish arguments', async t => {
     const options = { npm: { skipChecks: true, publishArgs: '--registry=http://my-internal-registry.local' } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     await runTasks(npmClient);
     assert.equal(
@@ -271,7 +271,7 @@ describe('npm', async () => {
 
   test('should skip checks', async () => {
     const options = { npm: { skipChecks: true } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     await assert.doesNotReject(npmClient.init());
   });
 
@@ -290,7 +290,7 @@ describe('npm', async () => {
       })
     );
     const options = { npm };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     const exec = t.mock.method(npmClient.shell, 'exec', command => {
       const cmd = 'npm whoami --registry https://gitlab.com/api/v4/projects/my-scope%2Fmy-pkg/packages/npm/';
       if (command === cmd) return Promise.resolve('john');
@@ -316,7 +316,7 @@ describe('npm', async () => {
     process.chdir(tmp);
     writeFileSync(join(tmp, 'package.json'), JSON.stringify({ name: '@my-scope/my-pkg', version: '1.0.0' }));
     const options = { npm };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
 
     const exec = t.mock.method(npmClient.shell, 'exec', command => {
       if (command === 'npm whoami') return Promise.resolve('john');
@@ -340,7 +340,7 @@ describe('npm', async () => {
 
   test('should add allow-same-version argument', async t => {
     const options = { npm: { skipChecks: true, allowSameVersion: true } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
 
     const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
 
@@ -351,7 +351,7 @@ describe('npm', async () => {
 
   test('should add version arguments', async t => {
     const options = { npm: { skipChecks: true, versionArgs: ['--workspaces-update=false', '--allow-same-version'] } };
-    const npmClient = factory(npm, { options });
+    const npmClient = await factory(npm, { options });
     const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
     await runTasks(npmClient);
     const versionArgs = getArgs(exec, 'npm version');

package/test/prompt.js

@@ -17,7 +17,7 @@ test('should not create prompt if disabled', async t => {
   const task = t.mock.fn();
   const promptMock = t.mock.fn(yes);
   const inquirer = { prompt: promptMock };
-  const prompt = factory(Prompt, { container: { inquirer } });
+  const prompt = await factory(Prompt, { container: { inquirer } });
   prompt.register(prompts.git);
   await prompt.show({ enabled: false, prompt: 'push', task });
   assert.equal(promptMock.mock.callCount(), 0);
@@ -27,7 +27,7 @@ test('should not create prompt if disabled', async t => {
 test('should create prompt', async t => {
   const promptMock = t.mock.fn(yes);
   const inquirer = { prompt: promptMock };
-  const prompt = factory(Prompt, { container: { inquirer } });
+  const prompt = await factory(Prompt, { container: { inquirer } });
   prompt.register(prompts.git);
   await prompt.show({ prompt: 'push' });
   assert.equal(promptMock.mock.callCount(), 1);
@@ -57,9 +57,10 @@ test('should create prompt', async t => {
       git: { tagName: 'v${version}' },
       npm: { name: 'my-pkg', tag: 'next' }
     });
+    await config.init();
     config.setContext({ version: '1.0.0', tagName: '1.0.0' });
     const inquirer = { prompt: promptMock };
-    const p = factory(Prompt, { container: { inquirer } });
+    const p = await factory(Prompt, { container: { inquirer } });
     p.register(prompts[namespace], namespace);
     await p.show({ namespace, prompt, context: config.getContext() });
     assert.equal(promptMock.mock.callCount(), 1);
@@ -71,7 +72,7 @@ test('should execute task after positive answer', async t => {
   const task = t.mock.fn();
   const promptMock = t.mock.fn(yes);
   const inquirer = { prompt: promptMock };
-  const prompt = factory(Prompt, { container: { inquirer } });
+  const prompt = await factory(Prompt, { container: { inquirer } });
   prompt.register(prompts.git);
   await prompt.show({ prompt: 'push', task });
   assert.equal(promptMock.mock.callCount(), 1);
@@ -83,7 +84,7 @@ test('should not execute task after negative answer', async t => {
   const task = t.mock.fn();
   const promptMock = t.mock.fn(no);
   const inquirer = { prompt: promptMock };
-  const prompt = factory(Prompt, { container: { inquirer } });
+  const prompt = await factory(Prompt, { container: { inquirer } });
   prompt.register(prompts.git);
   await prompt.show({ prompt: 'push', task });
   assert.equal(promptMock.mock.callCount(), 1);

package/test/shell.js

@@ -4,10 +4,10 @@ import assert from 'node:assert/strict';
 import Shell from '../lib/shell.js';
 import { factory } from './util/index.js';
 
-describe('shell', () => {
+describe('shell', async () => {
   const cwd = childProcess.execSync('pwd', { encoding: 'utf8' }).trim();
 
-  const shell = factory(Shell);
+  const shell = await factory(Shell);
 
   test('exec', async () => {
     assert.equal(await shell.exec('echo bar'), 'bar');
@@ -29,7 +29,7 @@ describe('shell', () => {
   });
 
   test('exec (dry-run/read-only)', async () => {
-    const shell = factory(Shell, { options: { 'dry-run': true } });
+    const shell = await factory(Shell, { options: { 'dry-run': true } });
     {
       const actual = await shell.exec('pwd', { write: false });
       assert.equal(actual, cwd);
@@ -46,7 +46,7 @@ describe('shell', () => {
   });
 
   test('exec (verbose)', async () => {
-    const shell = factory(Shell, { options: { verbose: true } });
+    const shell = await factory(Shell, { options: { verbose: true } });
     const actual = await shell.exec('echo foo');
     assert.equal(shell.log.exec.mock.calls[0].arguments[0], 'echo foo');
     assert.equal(shell.log.exec.mock.callCount(), 1);
@@ -56,7 +56,7 @@ describe('shell', () => {
   });
 
   test('should cache results of command execution', async () => {
-    const shell = factory(Shell);
+    const shell = await factory(Shell);
     const result1 = await shell.exec('echo foo');
     const result2 = await shell.exec('echo foo');
     assert(result1 === result2);

package/test/spinner.js

@@ -3,12 +3,15 @@ import assert from 'node:assert/strict';
 import Spinner from '../lib/spinner.js';
 import Config from '../lib/config.js';
 
-const getConfig = options => {
+const getConfig = async options => {
   const testConfig = {
     ci: false,
     config: false
   };
-  return new Config(Object.assign({}, testConfig, options));
+  const config = new Config(Object.assign({}, testConfig, options));
+  await config.init();
+
+  return config;
 };
 
 test('should not show spinner and not execute task if disabled', async t => {
@@ -24,7 +27,7 @@ test('should show spinner and run task by default', async t => {
   const ora = t.mock.fn();
   const task = t.mock.fn(() => Promise.resolve());
   const label = 'foo';
-  const config = getConfig({ ci: true });
+  const config = await getConfig({ ci: true });
   const spinner = new Spinner({ container: { ora, config } });
   await spinner.show({ task, label });
   assert.equal(task.mock.callCount(), 1);
@@ -36,7 +39,7 @@ test('should show spinner and run task by default', async t => {
 test('should run task, but not show spinner if interactive', async t => {
   const ora = t.mock.fn();
   const task = t.mock.fn(() => Promise.resolve());
-  const config = getConfig({ ci: false });
+  const config = await getConfig({ ci: false });
   const spinner = new Spinner({ container: { ora, config } });
   await spinner.show({ task });
   assert.equal(task.mock.callCount(), 1);
@@ -46,7 +49,7 @@ test('should run task, but not show spinner if interactive', async t => {
 test('should run task and show spinner if interactive, but external', async t => {
   const ora = t.mock.fn();
   const task = t.mock.fn(() => Promise.resolve());
-  const config = getConfig({ ci: false });
+  const config = await getConfig({ ci: false });
   const spinner = new Spinner({ container: { ora, config } });
   await spinner.show({ task, external: true });
   assert.equal(task.mock.callCount(), 1);

package/test/stub/config/remote/.release-it.json

@@ -0,0 +1,5 @@
+{
+  "git": {
+    "commitMessage": "Released version ${version}"
+  }
+}

package/test/stub/config/remote/sub/.release-it.json

@@ -0,0 +1,5 @@
+{
+  "git": {
+    "commitMessage": "Released with version ${version}"
+  }
+}

package/test/tasks.interactive.js

@@ -14,13 +14,10 @@ import { interceptPublish as interceptGitLabPublish } from './stub/gitlab.js';
 import { interceptCreate as interceptGitHubCreate } from './stub/github.js';
 import { factory, LogStub, SpinnerStub } from './util/index.js';
 import { mockFetch } from './util/mock.js';
+import { createTarBlobByRawContents } from './util/fetch.js';
 
 describe('tasks.interactive', () => {
-  const [mocker, github, gitlab, githubusercontent] = mockFetch([
-    'https://api.github.com',
-    'https://gitlab.com/api/v4',
-    'https://raw.githubusercontent.com'
-  ]);
+  const [mocker, github, gitlab] = mockFetch(['https://api.github.com', 'https://gitlab.com/api/v4']);
 
   before(() => {
     mocker.mockGlobal();
@@ -96,18 +93,28 @@ describe('tasks.interactive', () => {
 
     const validationExtendedConfiguration = "echo 'extended_configuration'";
 
-    githubusercontent.get('/release-it/release-it-configuration/HEAD/.release-it.json', {
+    github.head('/repos/release-it/release-it-configuration/tarball/main', {
       status: 200,
-      body: {
-        hooks: {
-          'before:init': validationExtendedConfiguration
-        }
-      }
+      headers: {}
+    });
+
+    github.get('/repos/release-it/release-it-configuration/tarball/main', {
+      status: 200,
+      body: await new Response(
+        createTarBlobByRawContents({
+          '.release-it.json': JSON.stringify({
+            hooks: {
+              'before:init': validationExtendedConfiguration
+            }
+          })
+        })
+      ).arrayBuffer()
     });
 
     const config = {
-      $schema: 'https://unpkg.com/release-it@18/schema/release-it.json',
-      extends: 'github:release-it/release-it-configuration'
+      $schema: 'https://unpkg.com/release-it@19/schema/release-it.json',
+      extends: 'github:release-it/release-it-configuration',
+      config: true
     };
 
     const container = getContainer(config);
@@ -129,7 +136,7 @@ describe('tasks.interactive', () => {
     renameSync('.git', 'foo');
 
     const config = {
-      $schema: 'https://unpkg.com/release-it@18/schema/release-it.json',
+      $schema: 'https://unpkg.com/release-it@19/schema/release-it.json',
       extends: false
     };
 
@@ -213,7 +220,7 @@ describe('tasks.interactive', () => {
     childProcess.execSync('git tag 1.0.0', execOpts);
     const sha = gitAdd('line', 'file', 'More file');
 
-    const git = factory(Git);
+    const git = await factory(Git);
     const ref = (await git.getBranchName()) ?? 'HEAD';
 
     interceptGitHubCreate(github, {

package/test/tasks.js

@@ -243,7 +243,7 @@ describe('tasks', () => {
     childProcess.execSync('git tag v1.0.0', execOpts);
     const sha = gitAdd('line', 'file', 'More file');
     childProcess.execSync('git push --follow-tags', execOpts);
-    const git = factory(Git);
+    const git = await factory(Git);
     const ref = (await git.getBranchName()) ?? 'HEAD';
 
     interceptGitHubAuthentication(github);

package/test/util/fetch.js

@@ -0,0 +1,32 @@
+import { Readable } from 'node:stream';
+import { create as createTar } from 'tar';
+import { appendFile, mkTmpDir } from './helpers.js';
+
+export function createTarBlob(dir) {
+  const stream = new Readable({
+    read() {}
+  });
+
+  createTar(
+    {
+      gzip: true,
+      portable: true,
+      sync: false,
+      cwd: dir
+    },
+    ['.']
+  )
+    .on('data', chunk => stream.push(chunk))
+    .on('end', () => stream.push(null));
+
+  return stream;
+}
+
+export function createTarBlobByRawContents(contents) {
+  const dir = mkTmpDir();
+  for (const [key, value] of Object.entries(contents)) {
+    appendFile(value, key, dir);
+  }
+
+  return createTarBlob(dir);
+}

package/test/util/helpers.js

@@ -12,13 +12,7 @@ const mkTmpDir = () => {
 const readFile = file => promises.readFile(path.resolve(file), 'utf8');
 
 const gitAdd = (content, filePath, message) => {
-  const pathSegments = filePath.split('/').filter(Boolean);
-  pathSegments.pop();
-  if (pathSegments.length) {
-    mkdirSync(path.resolve(pathSegments.join('/')), { mode: parseInt('0777', 8), recursive: true });
-  }
-
-  appendFileSync(filePath, content);
+  appendFile(content, filePath);
   childProcess.execSync(`git add ${filePath}`, execOpts);
   const stdout = childProcess.execSync(`git commit -m "${message}"`, { encoding: 'utf-8' });
   const match = stdout.match(/\[.+([a-z0-9]{7})\]/);
@@ -32,4 +26,15 @@ const getArgs = (fn, prefix) =>
     .filter(cmd => cmd.startsWith(prefix))
     .map(cmd => cmd.trim());
 
-export { mkTmpDir, readFile, gitAdd, getArgs };
+const appendFile = (content, filePath, cwd) => {
+  filePath = path.resolve(cwd ?? '', filePath);
+  const dirPath = path.dirname(filePath);
+
+  if (dirPath) {
+    mkdirSync(dirPath, { mode: parseInt('0777', 8), recursive: true });
+  }
+
+  appendFileSync(filePath, content);
+};
+
+export { mkTmpDir, readFile, gitAdd, getArgs, appendFile };

package/test/util/index.js

@@ -36,11 +36,12 @@ export class SpinnerStub {
   }
 }
 
-export let factory = (Definition, { namespace, options = {}, container = {} } = {}) => {
+export let factory = async (Definition, { namespace, options = {}, container = {} } = {}) => {
   options = Object.assign({}, { ci: true, verbose: false, 'dry-run': false, debug: false }, options);
   const ns = namespace || Definition.name.toLowerCase();
   container.config = container.config || new Config(Object.assign({ config: false }, options));
   container.log = new LogStub();
+  await container.config.init();
 
   container.spinner = new SpinnerStub();
   container.shell = container.shell || new ShellStub({ container });