Internal improvements, add more tests

package.json

@@ -71,16 +71,22 @@
 	},
 	"devDependencies": {
 		"ava": "^5.2.0",
+		"chalk-template": "^1.0.0",
 		"common-tags": "^1.8.2",
 		"esmock": "^2.2.1",
 		"fs-extra": "^11.1.1",
 		"move-file": "^3.1.0",
 		"sinon": "^15.0.3",
+		"strip-ansi": "^7.0.1",
 		"tempy": "^3.0.0",
 		"write-pkg": "^5.1.0",
 		"xo": "^0.53.1"
 	},
 	"ava": {
+		"files": [
+			"!test/fixtures",
+			"!test/_helpers"
+		],
 		"environmentVariables": {
 			"FORCE_HYPERLINK": "1"
 		},

source/git-util.js

@@ -38,6 +38,12 @@ export const readFileFromLastRelease = async file => {
 	return oldFile;
 };
 
+const tagList = async () => {
+	// Returns the list of tags, sorted by creation date in ascending order.
+	const {stdout} = await execa('git', ['tag', '--sort=creatordate']);
+	return stdout.split('\n');
+};
+
 const firstCommit = async () => {
 	const {stdout} = await execa('git', ['rev-list', '--max-parents=0', 'HEAD']);
 	return stdout;
@@ -97,12 +103,6 @@ export const verifyCurrentBranchIsReleaseBranch = async releaseBranch => {
 	}
 };
 
-export const tagList = async () => {
-	// Returns the list of tags, sorted by creation date in ascending order.
-	const {stdout} = await execa('git', ['tag', '--sort=creatordate']);
-	return stdout.split('\n');
-};
-
 export const isHeadDetached = async () => {
 	try {
 		// Command will fail with code 1 if the HEAD is detached.
@@ -113,7 +113,7 @@ export const isHeadDetached = async () => {
 	}
 };
 
-export const isWorkingTreeClean = async () => {
+const isWorkingTreeClean = async () => {
 	try {
 		const {stdout: status} = await execa('git', ['status', '--porcelain']);
 		if (status !== '') {
@@ -182,7 +182,7 @@ export const fetch = async () => {
 	await execa('git', ['fetch']);
 };
 
-export const tagExistsOnRemote = async tagName => {
+const tagExistsOnRemote = async tagName => {
 	try {
 		const {stdout: revInfo} = await execa('git', ['rev-parse', '--quiet', '--verify', `refs/tags/${tagName}`]);
 
@@ -202,14 +202,14 @@ export const tagExistsOnRemote = async tagName => {
 	}
 };
 
-async function hasLocalBranch(branch) {
+const hasLocalBranch = async branch => {
 	try {
 		await execa('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
 		return true;
 	} catch {
 		return false;
 	}
-}
+};
 
 export const defaultBranch = async () => {
 	for (const branch of ['main', 'master', 'gh-pages']) {
@@ -233,6 +233,10 @@ export const commitLogFromRevision = async revision => {
 	return stdout;
 };
 
+const push = async () => {
+	await execa('git', ['push', '--follow-tags']);
+};
+
 export const pushGraceful = async remoteIsOnGitHub => {
 	try {
 		await push();
@@ -247,10 +251,6 @@ export const pushGraceful = async remoteIsOnGitHub => {
 	}
 };
 
-export const push = async () => {
-	await execa('git', ['push', '--follow-tags']);
-};
-
 export const deleteTag = async tagName => {
 	await execa('git', ['tag', '--delete', tagName]);
 };

source/npm/handle-npm-error.js

@@ -27,7 +27,7 @@ const handleNpmError = (error, task, message, executor) => {
 	// Attempting to privately publish a scoped package without the correct npm plan
 	// https://stackoverflow.com/a/44862841/10292952
 	if (error.code === 402 || error.stderr.includes('npm ERR! 402 Payment Required')) {
-		throw new Error('You cannot publish a privately scoped package without a paid plan. Did you mean to publish publicly?');
+		throw new Error('You cannot publish a scoped package privately without a paid plan. Did you mean to publish publicly?');
 	}
 
 	return throwError(() => error);

source/npm/util.js

@@ -33,18 +33,24 @@ export const username = async ({externalRegistry}) => {
 		const {stdout} = await execa('npm', args);
 		return stdout;
 	} catch (error) {
-		throw new Error(/ENEEDAUTH/.test(error.stderr)
+		const message = /ENEEDAUTH/.test(error.stderr)
 			? 'You must be logged in. Use `npm login` and try again.'
-			: 'Authentication error. Use `npm whoami` to troubleshoot.');
+			: 'Authentication error. Use `npm whoami` to troubleshoot.';
+		throw new Error(message);
 	}
 };
 
+export const isExternalRegistry = pkg => typeof pkg.publishConfig === 'object' && typeof pkg.publishConfig.registry === 'string';
+
 export const collaborators = async pkg => {
 	const packageName = pkg.name;
 	ow(packageName, ow.string);
 
 	const npmVersion = await version();
-	const args = semver.satisfies(npmVersion, '>=9.0.0') ? ['access', 'list', 'collaborators', packageName, '--json'] : ['access', 'ls-collaborators', packageName];
+	const args = semver.satisfies(npmVersion, '>=9.0.0')
+		? ['access', 'list', 'collaborators', packageName, '--json']
+		: ['access', 'ls-collaborators', packageName];
+
 	if (isExternalRegistry(pkg)) {
 		args.push('--registry', pkg.publishConfig.registry);
 	}
@@ -116,9 +122,7 @@ export const isPackageNameAvailable = async pkg => {
 	return availability;
 };
 
-export const isExternalRegistry = pkg => typeof pkg.publishConfig === 'object' && typeof pkg.publishConfig.registry === 'string';
-
-export const version = async () => {
+const version = async () => {
 	const {stdout} = await execa('npm', ['--version']);
 	return stdout;
 };

source/pretty-version-diff.js

@@ -1,26 +1,24 @@
-import chalk from 'chalk';
+import chalkTemplate from 'chalk-template';
+import semver from 'semver';
 import Version from './version.js';
 
 const prettyVersionDiff = (oldVersion, inc) => {
-	const newVersion = new Version(oldVersion).getNewVersionFrom(inc).split('.');
-	oldVersion = oldVersion.split('.');
-	let firstVersionChange = false;
-	const output = [];
+	const newVersion = new Version(oldVersion).getNewVersionFrom(inc);
+	const {major, minor, patch, prerelease} = Version.getPartsOf(newVersion);
+	const diff = semver.diff(oldVersion, newVersion);
 
-	for (const [i, element] of newVersion.entries()) {
-		if ((element !== oldVersion[i] && !firstVersionChange)) {
-			output.push(`${chalk.dim.cyan(element)}`);
-			firstVersionChange = true;
-		} else if (element.indexOf('-') >= 1) {
-			let preVersion = [];
-			preVersion = element.split('-');
-			output.push(`${chalk.dim.cyan(`${preVersion[0]}-${preVersion[1]}`)}`);
-		} else {
-			output.push(chalk.reset.dim(element));
-		}
-	}
-
-	return output.join(chalk.reset.dim('.'));
+	/* eslint-disable indent, unicorn/no-nested-ternary, operator-linebreak */
+	return (
+		diff === 'major' ? chalkTemplate`{dim {cyan ${major}}.${minor}.${patch}}` :
+		diff === 'minor' ? chalkTemplate`{dim ${major}.{cyan ${minor}}.${patch}}` :
+		diff === 'patch' ? chalkTemplate`{dim ${major}.${minor}.{cyan ${patch}}}` :
+		diff === 'premajor' ? chalkTemplate`{dim {cyan ${major}}.${minor}.${patch}-{cyan ${prerelease.join('.')}}}` :
+		diff === 'preminor' ? chalkTemplate`{dim ${major}.{cyan ${minor}}.${patch}-{cyan ${prerelease.join('.')}}}` :
+		diff === 'prepatch' ? chalkTemplate`{dim ${major}.${minor}.{cyan ${patch}}-{cyan ${prerelease.join('.')}}}` :
+		diff === 'prerelease' ? chalkTemplate`{dim ${major}.${minor}.${patch}-{cyan ${prerelease.join('.')}}}` : ''
+		// TODO: handle prepatch being the same as prerelease
+	);
+	/* eslint-enable indent, unicorn/no-nested-ternary, operator-linebreak */
 };
 
 export default prettyVersionDiff;

source/util.js

@@ -11,7 +11,7 @@ import * as git from './git-util.js';
 import * as npm from './npm/util.js';
 
 export const readPkg = async packagePath => {
-	packagePath = packagePath ? await packageDirectory(packagePath) : await packageDirectory();
+	packagePath = packagePath ? await packageDirectory({cwd: packagePath}) : await packageDirectory();
 	if (!packagePath) {
 		throw new Error('No `package.json` found. Make sure the current directory is a valid package.');
 	}

source/version.js

@@ -3,6 +3,8 @@ import {readPackageUp} from 'read-pkg-up';
 
 const {packageJson: pkg} = await readPackageUp();
 
+// TODO: make the API cleaner
+
 export default class Version {
 	constructor(version) {
 		this.version = version;
@@ -19,6 +21,7 @@ export default class Version {
 		});
 	}
 
+	/** @returns {string} */
 	getNewVersionFrom(input) {
 		Version.validate(this.version);
 		if (!Version.isValidInput(input)) {
@@ -73,4 +76,8 @@ export default class Version {
 
 		return newVersion;
 	}
+
+	static getPartsOf(version) {
+		return semver.parse(version);
+	}
 }

test/_helpers/integration-test.d.ts

@@ -0,0 +1,24 @@
+import type {Macro, ExecutionContext} from 'ava';
+import type {Execa$} from 'execa';
+
+type CommandsFnParameters = [{
+	t: ExecutionContext;
+	$$: Execa$<string>;
+	temporaryDir: string;
+}];
+
+type AssertionsFnParameters<MockType> = [{
+	t: ExecutionContext;
+	testedModule: MockType;
+	$$: Execa$<string>;
+	temporaryDir: string;
+}];
+
+export type CreateFixtureMacro<MockType> = Macro<[
+	commands: (...arguments_: CommandsFnParameters) => Promise<void>,
+	assertions: (...arguments_: AssertionsFnParameters<MockType>) => Promise<void>,
+], {
+	createFile: (file: string, content?: string) => Promise<void>;
+}>;
+
+export function _createFixture<MockType>(source: string): CreateFixtureMacro<MockType>;

test/_helpers/integration-test.js

@@ -0,0 +1,41 @@
+/* eslint-disable ava/no-ignored-test-files */
+import path from 'node:path';
+import fs from 'fs-extra';
+import test from 'ava';
+import esmock from 'esmock';
+import {$, execa} from 'execa';
+import {temporaryDirectoryTask} from 'tempy';
+
+const createEmptyGitRepo = async ($$, temporaryDir) => {
+	await $$`git init`;
+
+	// `git tag` needs an initial commit
+	await fs.createFile(path.resolve(temporaryDir, 'temp'));
+	await $$`git add temp`;
+	await $$`git commit -m "init1"`;
+	await $$`git rm temp`;
+	await $$`git commit -m "init2"`;
+};
+
+export const createIntegrationTest = async (t, assertions) => {
+	await temporaryDirectoryTask(async temporaryDir => {
+		const $$ = $({cwd: temporaryDir});
+
+		await createEmptyGitRepo($$, temporaryDir);
+
+		t.context.createFile = async (file, content = '') => fs.writeFile(path.resolve(temporaryDir, file), content);
+		await assertions($$, temporaryDir);
+	});
+};
+
+export const _createFixture = source => test.macro(async (t, commands, assertions) => {
+	await createIntegrationTest(t, async ($$, temporaryDir) => {
+		const testedModule = await esmock(source, {}, {
+			'node:process': {cwd: () => temporaryDir},
+			execa: {execa: async (...args) => execa(...args, {cwd: temporaryDir})},
+		});
+
+		await commands({t, $$, temporaryDir});
+		await assertions({t, testedModule, $$, temporaryDir});
+	});
+});

test/_helpers/listr.js

@@ -0,0 +1,20 @@
+import {SilentRenderer} from './listr-renderer.js';
+
+export const run = async listr => {
+	listr.setRenderer(SilentRenderer);
+	await listr.run();
+};
+
+export const assertTaskFailed = (t, taskTitle) => {
+	const task = SilentRenderer.tasks.find(task => task.title === taskTitle);
+	t.true(task.hasFailed(), `Task '${taskTitle}' did not fail!`);
+};
+
+export const assertTaskDisabled = (t, taskTitle) => {
+	const task = SilentRenderer.tasks.find(task => task.title === taskTitle);
+	t.true(!task.isEnabled(), `Task '${taskTitle}' was enabled!`);
+};
+
+export const assertTaskDoesntExist = (t, taskTitle) => {
+	t.true(SilentRenderer.tasks.every(task => task.title !== taskTitle), `Task '${taskTitle}' exists!`);
+};

test/_helpers/stub-execa.d.ts

@@ -0,0 +1,14 @@
+import type {Macro, ExecutionContext} from 'ava';
+import type {ExecaReturnValue} from 'execa';
+
+type AssertionsFnParameters<MockType> = [{
+	t: ExecutionContext;
+	testedModule: MockType;
+}];
+
+export type CreateFixtureMacro<MockType> = Macro<[
+	commands: ExecaReturnValue[],
+	assertions: (...arguments_: AssertionsFnParameters<MockType>) => Promise<void>,
+]>;
+
+export function _createFixture<MockType>(source: string, importMeta: string): CreateFixtureMacro<MockType>;

test/_helpers/stub-execa.js

@@ -0,0 +1,40 @@
+/* eslint-disable ava/no-ignored-test-files */
+import test from 'ava';
+import esmock from 'esmock';
+import sinon from 'sinon';
+import {execa} from 'execa';
+
+const makeExecaStub = commands => {
+	const stub = sinon.stub();
+
+	for (const result of commands) {
+		const [command, ...commandArgs] = result.command.split(' ');
+
+		// Command passes if the exit code is 0, or if there's no exit code and no stderr.
+		const passes = result.exitCode === 0 || (!result.exitCode && !result.stderr);
+
+		if (passes) {
+			stub.withArgs(command, commandArgs).resolves(result);
+		} else {
+			stub.withArgs(command, commandArgs).rejects(Object.assign(new Error(), result)); // eslint-disable-line unicorn/error-message
+		}
+	}
+
+	return stub;
+};
+
+const _stubExeca = (source, importMeta) => async commands => {
+	const execaStub = makeExecaStub(commands);
+
+	return esmock(source, importMeta, {}, {
+		execa: {
+			execa: async (...args) => execaStub.resolves(execa(...args))(...args),
+		},
+	});
+};
+
+export const _createFixture = (source, importMeta) => test.macro(async (t, commands, assertions) => {
+	const stubExeca = _stubExeca(source, importMeta);
+	const testedModule = await stubExeca(commands);
+	await assertions({t, testedModule});
+});

test/_helpers/util.js

@@ -0,0 +1,5 @@
+export const runIfExists = async (func, ...args) => {
+	if (typeof func === 'function') {
+		await func(...args);
+	}
+};