use-t-well: Suggest AVA equivalents for common assertion names from other test frameworks

Fixes #177

Author: sindresorhus

docs/rules/use-t-well.md

@@ -12,7 +12,7 @@ Translations: [Français](https://github.com/avajs/ava-docs/blob/main/fr_FR/rela
 
 Prevent the use of unknown assertion methods and the access to members other than the assertion methods and `.context`, as well as some known misuses of `t`.
 
-This rule is partly fixable. It can fix most misspelled assertion method names and incorrect usages of `.skip`.
+This rule is partly fixable. It can fix most misspelled assertion method names, suggest AVA equivalents for common assertion names from other test frameworks (tape, Jest, node:assert), and fix incorrect usages of `.skip`.
 
 ## Examples
 
@@ -23,6 +23,8 @@ test('main', t => {
 	// ❌
 	t(value); // `t` is not a function
 	t.depEqual(value, [2]); // Misspelled `.deepEqual` as `.depEqual`, fixable
+	t.ok(value); // Unknown assertion method `.ok`. Did you mean `.truthy`?, fixable
+	t.equal(a, b); // Unknown assertion method `.equal`. Did you mean `.is`?, fixable
 	t.contxt.foo = 100; // Misspelled `.context` as `.contxt`, fixable
 	t.deepEqual.skip.skip(); // Too many chained uses of `.skip`, fixable
 	t.skip.deepEqual(1, 1); // `.skip` modifier should be the last in chain, fixable

rules/use-t-well.js

@@ -7,11 +7,53 @@ const MESSAGE_ID_NOT_FUNCTION = 'not-function';
 const MESSAGE_ID_UNKNOWN_ASSERTION = 'unknown-assertion';
 const MESSAGE_ID_UNKNOWN_MEMBER = 'unknown-member';
 const MESSAGE_ID_MISSPELLED = 'misspelled';
+const MESSAGE_ID_SYNONYM = 'synonym';
 const MESSAGE_ID_CHAINING = 'chaining';
 const MESSAGE_ID_MISSING_ASSERTION = 'missing-assertion';
 const MESSAGE_ID_TOO_MANY_SKIPS = 'too-many-skips';
 const MESSAGE_ID_SKIP_POSITION = 'skip-position';
 
+// Map of common assertion names from other test frameworks (tape, node:assert, Jest) to their AVA equivalents.
+const assertionSynonyms = new Map([
+	// Truthy/Falsy
+	['ok', 'truthy'],
+	['notOk', 'falsy'],
+
+	// Equality
+	['equal', 'is'],
+	['equals', 'is'],
+	['strictEqual', 'is'],
+	['strictEquals', 'is'],
+	['notEqual', 'not'],
+	['notEquals', 'not'],
+	['notStrictEqual', 'not'],
+	['notStrictEquals', 'not'],
+
+	// Deep equality
+	['same', 'deepEqual'],
+	['deepStrictEqual', 'deepEqual'],
+	['notSame', 'notDeepEqual'],
+	['notDeepStrictEqual', 'notDeepEqual'],
+
+	// Throws
+	['catch', 'throws'],
+	['exception', 'throws'],
+	['doesNotThrow', 'notThrows'],
+	['rejects', 'throwsAsync'],
+	['doesNotReject', 'notThrowsAsync'],
+
+	// Regex
+	['match', 'regex'],
+	['doesNotMatch', 'notRegex'],
+
+	// Error
+	['error', 'ifError'],
+	['ifErr', 'ifError'],
+
+	// Snapshot
+	['matchSnapshot', 'snapshot'],
+]);
+
 const properties = new Set([
 	...util.executionMethods,
 	'context',
@@ -65,6 +107,17 @@ const create = context => {
 			for (const [i, member] of members.entries()) {
 				const {name} = member;
 
+				const synonym = assertionSynonyms.get(name);
+				if (synonym) {
+					context.report({
+						node,
+						messageId: MESSAGE_ID_SYNONYM,
+						data: {name, corrected: synonym},
+						fix: fixer => fixer.replaceText(member, synonym),
+					});
+					return;
+				}
+
 				let corrected = correcter.correct(name);
 
 				if (i !== 0 && (corrected === 'context' || corrected === 'title')) { // `context` and `title` can only be first
@@ -172,6 +225,7 @@ export default {
 			[MESSAGE_ID_UNKNOWN_ASSERTION]: 'Unknown assertion method `.{{name}}`.',
 			[MESSAGE_ID_UNKNOWN_MEMBER]: 'Unknown member `.{{name}}`. Use `.context.{{name}}` instead.',
 			[MESSAGE_ID_MISSPELLED]: 'Misspelled `.{{corrected}}` as `.{{name}}`.',
+			[MESSAGE_ID_SYNONYM]: 'Unknown assertion method `.{{name}}`. Did you mean `.{{corrected}}`?',
 			[MESSAGE_ID_CHAINING]: 'Can\'t chain assertion methods.',
 			[MESSAGE_ID_MISSING_ASSERTION]: 'Missing assertion method.',
 			[MESSAGE_ID_TOO_MANY_SKIPS]: 'Too many chained uses of `.skip`.',

test/use-t-well.js

@@ -223,5 +223,138 @@ ruleTester.run('use-t-well', rule, {
 			output: testCase('t_.deepEqual(a, a);'),
 			errors: [error('misspelled')],
 		},
+		// Synonyms from other test frameworks
+		{
+			code: testCase('t.ok(v);'),
+			output: testCase('t.truthy(v);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notOk(v);'),
+			output: testCase('t.falsy(v);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.equal(a, a);'),
+			output: testCase('t.is(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.equals(a, a);'),
+			output: testCase('t.is(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.strictEqual(a, a);'),
+			output: testCase('t.is(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.strictEquals(a, a);'),
+			output: testCase('t.is(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notEqual(a, a);'),
+			output: testCase('t.not(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notEquals(a, a);'),
+			output: testCase('t.not(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notStrictEqual(a, a);'),
+			output: testCase('t.not(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notStrictEquals(a, a);'),
+			output: testCase('t.not(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.same(a, a);'),
+			output: testCase('t.deepEqual(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.deepStrictEqual(a, a);'),
+			output: testCase('t.deepEqual(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notSame(a, a);'),
+			output: testCase('t.notDeepEqual(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.notDeepStrictEqual(a, a);'),
+			output: testCase('t.notDeepEqual(a, a);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.catch(fn);'),
+			output: testCase('t.throws(fn);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.exception(fn);'),
+			output: testCase('t.throws(fn);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.doesNotThrow(fn);'),
+			output: testCase('t.notThrows(fn);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.rejects(fn);'),
+			output: testCase('t.throwsAsync(fn);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.doesNotReject(fn);'),
+			output: testCase('t.notThrowsAsync(fn);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.match(v, /v/);'),
+			output: testCase('t.regex(v, /v/);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.doesNotMatch(v, /v/);'),
+			output: testCase('t.notRegex(v, /v/);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.error(v);'),
+			output: testCase('t.ifError(v);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.ifErr(v);'),
+			output: testCase('t.ifError(v);'),
+			errors: [error('synonym')],
+		},
+		{
+			code: testCase('t.matchSnapshot(v);'),
+			output: testCase('t.snapshot(v);'),
+			errors: [error('synonym')],
+		},
+		// Synonym with .skip modifier
+		{
+			code: testCase('t.ok.skip(v);'),
+			output: testCase('t.truthy.skip(v);'),
+			errors: [error('synonym')],
+		},
+		// Synonym with alternative test object name
+		{
+			code: testCase('tt.equal(a, a);'),
+			output: testCase('tt.is(a, a);'),
+			errors: [error('synonym')],
+		},
 	],
 });