Add no-incorrect-deep-equal rule

docs/rules/no-incorrect-deep-equal.md

@@ -0,0 +1,28 @@
+# Avoid using `deepEqual` with literals
+
+`deepEqual` and `notDeepEqual` are unnecessary when comparing literals, template strings or `undefined`. Use `is` or `not` instead.
+
+This rule is fixable.
+
+## Fail
+
+```js
+t.deepEqual(expression, 'foo');
+t.deepEqual(expression, 1);
+t.deepEqual(expression, `foo${bar}`);
+t.deepEqual(expression, null);
+t.deepEqual(expression, undefined);
+t.notDeepEqual(expression, undefined);
+```
+
+
+## Pass
+
+```js
+t.is(expression, 'foo');
+
+t.deepEqual(expression, otherExpression);
+t.deepEqual(expression, {});
+t.deepEqual(expression, []);
+t.notDeepEqual(expression, []);
+```

index.js

@@ -28,6 +28,7 @@ module.exports = {
 				'ava/no-identical-title': 'error',
 				'ava/no-ignored-test-files': 'error',
 				'ava/no-import-test-files': 'error',
+				'ava/no-incorrect-deep-equal': 'error',
 				'ava/no-invalid-end': 'error',
 				'ava/no-nested-tests': 'error',
 				'ava/no-only-test': 'error',

readme.md

@@ -46,6 +46,7 @@ Configure it in `package.json`.
 			"ava/no-identical-title": "error",
 			"ava/no-ignored-test-files": "error",
 			"ava/no-import-test-files": "error",
+			"ava/no-incorrect-deep-equal": "error",
 			"ava/no-invalid-end": "error",
 			"ava/no-nested-tests": "error",
 			"ava/no-only-test": "error",
@@ -83,6 +84,7 @@ The rules will only activate in test files.
 - [no-identical-title](docs/rules/no-identical-title.md) - Ensure no tests have the same title.
 - [no-ignored-test-files](docs/rules/no-ignored-test-files.md) - Ensure no tests are written in ignored files.
 - [no-import-test-files](docs/rules/no-import-test-files.md) - Ensure no test files are imported anywhere.
+- [no-incorrect-deep-equal](docs/rules/no-incorrect-deep-equal.md) - Avoid using `deepEqual` with literals. *(fixable)*
 - [no-invalid-end](docs/rules/no-invalid-end.md) - Ensure `t.end()` is only called inside `test.cb()`.
 - [no-nested-tests](docs/rules/no-nested-tests.md) - Ensure no tests are nested.
 - [no-only-test](docs/rules/no-only-test.md) - Ensure no `test.only()` are present. *(fixable)*

rules/no-incorrect-deep-equal.js

@@ -0,0 +1,117 @@
+'use strict';
+const {visitIf} = require('enhance-visitors');
+const util = require('../util');
+const createAvaRule = require('../create-ava-rule');
+
+const MESSAGE_ID_LITERAL = 'no-deep-equal-with-literal';
+const MESSAGE_ID_TEMPLATE = 'no-deep-equal-with-template';
+const MESSAGE_ID_UNDEFINED = 'no-deep-equal-with-undefined';
+
+const fixIs = (fixer, node) => {
+	return fixer.replaceText(node.callee.property, 'is');
+};
+
+const fixNot = (fixer, node) => {
+	return fixer.replaceText(node.callee.property, 'not');
+};
+
+const create = context => {
+	const ava = createAvaRule();
+
+	return ava.merge({
+		'CallExpression[callee.property.name="deepEqual"][arguments.1.type="Literal"]': visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode
+		])(node => {
+			context.report({
+				node,
+				messageId: MESSAGE_ID_LITERAL,
+				data: {
+					callee: node.callee.property.name
+				},
+				fix: fixer => fixIs(fixer, node)
+			});
+		}),
+		'CallExpression[callee.property.name="deepEqual"][arguments.1.type="Identifier"][arguments.1.name="undefined"]': visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode
+		])(node => {
+			context.report({
+				node,
+				messageId: MESSAGE_ID_UNDEFINED,
+				data: {
+					callee: node.callee.property.name
+				},
+				fix: fixer => fixIs(fixer, node)
+			});
+		}),
+		'CallExpression[callee.property.name="deepEqual"][arguments.1.type="TemplateLiteral"]': visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode
+		])(node => {
+			context.report({
+				node,
+				messageId: MESSAGE_ID_TEMPLATE,
+				data: {
+					callee: node.callee.property.name
+				},
+				fix: fixer => fixIs(fixer, node)
+			});
+		}),
+		'CallExpression[callee.property.name="notDeepEqual"][arguments.1.type="Literal"]': visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode
+		])(node => {
+			context.report({
+				node,
+				messageId: MESSAGE_ID_LITERAL,
+				data: {
+					callee: node.callee.property.name
+				},
+				fix: fixer => fixNot(fixer, node)
+			});
+		}),
+		'CallExpression[callee.property.name="notDeepEqual"][arguments.1.type="Identifier"][arguments.1.name="undefined"]': visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode
+		])(node => {
+			context.report({
+				node,
+				messageId: MESSAGE_ID_UNDEFINED,
+				data: {
+					callee: node.callee.property.name
+				},
+				fix: fixer => fixNot(fixer, node)
+			});
+		}),
+		'CallExpression[callee.property.name="notDeepEqual"][arguments.1.type="TemplateLiteral"]': visitIf([
+			ava.isInTestFile,
+			ava.isInTestNode
+		])(node => {
+			context.report({
+				node,
+				messageId: MESSAGE_ID_TEMPLATE,
+				data: {
+					callee: node.callee.property.name
+				},
+				fix: fixer => fixNot(fixer, node)
+			});
+		})
+	});
+};
+
+module.exports = {
+	create,
+	meta: {
+		docs: {
+			url: util.getDocsUrl(__filename)
+		},
+		fixable: true,
+		messages: {
+			[MESSAGE_ID_LITERAL]: 'Avoid using `{{callee}}` with literals',
+			[MESSAGE_ID_TEMPLATE]: 'Avoid using `{{callee}}` with templates',
+			[MESSAGE_ID_UNDEFINED]: 'Avoid using `{{callee}}` with `undefined`'
+		},
+		type: 'suggestion'
+	}
+};

test/no-incorrect-deep-equal.js

@@ -0,0 +1,192 @@
+import test from 'ava';
+import avaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../rules/no-incorrect-deep-equal';
+
+const ruleTester = avaRuleTester(test, {
+	env: {
+		es6: true
+	}
+});
+
+const errorLiteral = {
+	ruleId: 'no-incorrect-deep-equal',
+	messageId: 'no-deep-equal-with-literal'
+};
+
+const errorTemplate = {
+	ruleId: 'no-incorrect-deep-equal',
+	messageId: 'no-deep-equal-with-template'
+};
+
+const errorUndefined = {
+	ruleId: 'no-incorrect-deep-equal',
+	messageId: 'no-deep-equal-with-undefined'
+};
+
+const header = 'const test = require(\'ava\');\n';
+
+ruleTester.run('no-incorrect-deep-equal', rule, {
+	valid: [
+		`
+			${header}
+			test(t => {
+				t.deepEqual(expression, otherExpression);
+			});
+		`,
+		`
+			${header}
+			test(t => {
+				t.deepEqual(expression, {});
+			});
+		`,
+		`
+			${header}
+			test(t => {
+				t.deepEqual(expression, []);
+			});
+		`,
+		`
+			${header}
+			test(t => {
+				t.notDeepEqual(expression, []);
+			});
+		`
+	],
+	invalid: [
+		{
+			code: `
+				${header}
+				test(t => {
+					t.deepEqual(expression, 'foo');
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.is(expression, 'foo');
+				});
+			`,
+			errors: [errorLiteral]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.notDeepEqual(expression, 'foo');
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.not(expression, 'foo');
+				});
+			`,
+			errors: [errorLiteral]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.deepEqual(expression, 1);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.is(expression, 1);
+				});
+			`,
+			errors: [errorLiteral]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.deepEqual(expression, \`foo\${bar}\`);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.is(expression, \`foo\${bar}\`);
+				});
+			`,
+			errors: [errorTemplate]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.notDeepEqual(expression, \`foo\${bar}\`);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.not(expression, \`foo\${bar}\`);
+				});
+			`,
+			errors: [errorTemplate]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.deepEqual(expression, null);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.is(expression, null);
+				});
+			`,
+			errors: [errorLiteral]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.notDeepEqual(expression, null);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.not(expression, null);
+				});
+			`,
+			errors: [errorLiteral]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.deepEqual(expression, undefined);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.is(expression, undefined);
+				});
+			`,
+			errors: [errorUndefined]
+		},
+		{
+			code: `
+				${header}
+				test(t => {
+					t.notDeepEqual(expression, undefined);
+				});
+			`,
+			output: `
+				${header}
+				test(t => {
+					t.not(expression, undefined);
+				});
+			`,
+			errors: [errorUndefined]
+		}
+	]
+});