Add prefer-async-await rule (fixes #123) (#134)

Author: jfmengels

docs/rules/prefer-async-await.md

@@ -0,0 +1,31 @@
+# Prefer using async/await instead of returning a Promise
+
+Translations: [Français](https://github.com/avajs/ava-docs/blob/master/fr_FR/related/eslint-plugin-ava/docs/rules/prefer-async-await.md)
+
+AVA comes with built-in support for [async functions](http://www.2ality.com/2016/02/async-functions.html) (async/await). This allows you to write shorter and clearer tests.
+
+This rule will report an error when it finds a test that returns an expression that looks like a Promise (containing a `.then()` call), which could be simplified by using the async/await syntax.
+
+
+## Fail
+
+```js
+import test from 'ava';
+
+test(t => {
+	return foo().then(res => {
+		t.is(res, 1);
+	});
+});
+```
+
+
+## Pass
+
+```js
+import test from 'ava';
+
+test(async t => {
+	t.is(await foo(), 1);
+});
+```

index.js

@@ -27,6 +27,7 @@ module.exports = {
 				'ava/no-todo-implementation': 'error',
 				'ava/no-todo-test': 'warn',
 				'ava/no-unknown-modifiers': 'error',
+				'ava/prefer-async-await': 'error',
 				'ava/prefer-power-assert': 'off',
 				'ava/test-ended': 'error',
 				'ava/test-title': ['error', 'if-multiple'],

readme.md

@@ -45,6 +45,7 @@ Configure it in `package.json`.
 			"ava/no-todo-implementation": "error",
 			"ava/no-todo-test": "warn",
 			"ava/no-unknown-modifiers": "error",
+			"ava/prefer-async-await": "error",
 			"ava/prefer-power-assert": "off",
 			"ava/test-ended": "error",
 			"ava/test-title": ["error", "if-multiple"],
@@ -76,6 +77,7 @@ The rules will only activate in test files.
 - [no-todo-implementation](docs/rules/no-todo-implementation.md) - Ensure `test.todo()` is not given an implementation function.
 - [no-todo-test](docs/rules/no-todo-test.md) - Ensure no `test.todo()` is used.
 - [no-unknown-modifiers](docs/rules/no-unknown-modifiers.md) - Prevent the use of unknown test modifiers.
+- [prefer-async-await](docs/rules/prefer-async-await.md) - Prefer using async/await instead of returning a Promise.
 - [prefer-power-assert](docs/rules/prefer-power-assert.md) - Allow only use of the asserts that have no [power-assert](https://github.com/power-assert-js/power-assert) alternative.
 - [test-ended](docs/rules/test-ended.md) - Ensure callback tests are explicitly ended.
 - [test-title](docs/rules/test-title.md) - Ensure tests have a title.

rules/prefer-async-await.js

@@ -0,0 +1,53 @@
+'use strict';
+const visitIf = require('enhance-visitors').visitIf;
+const createAvaRule = require('../create-ava-rule');
+
+function containsThen(node) {
+	if (!node ||
+		node.type !== 'CallExpression' ||
+		node.callee.type !== 'MemberExpression'
+	) {
+		return false;
+	}
+
+	const callee = node.callee;
+	if (callee.property.type === 'Identifier' &&
+		callee.property.name === 'then'
+	) {
+		return true;
+	}
+
+	return containsThen(callee.object);
+}
+
+const create = context => {
+	const ava = createAvaRule();
+
+	const check = visitIf([
+		ava.isInTestFile,
+		ava.isInTestNode
+	])(node => {
+		if (node.body.type !== 'BlockStatement') {
+			return;
+		}
+
+		const statements = node.body.body;
+		const returnStatement = statements.find(statement => statement.type === 'ReturnStatement');
+		if (returnStatement && containsThen(returnStatement.argument)) {
+			context.report({
+				node,
+				message: 'Prefer using async/await instead of returning a Promise.'
+			});
+		}
+	});
+
+	return ava.merge({
+		ArrowFunctionExpression: check,
+		FunctionExpression: check
+	});
+};
+
+module.exports = {
+	create,
+	meta: {}
+};

test/prefer-async-await.js

@@ -0,0 +1,52 @@
+import test from 'ava';
+import avaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../rules/prefer-async-await';
+
+const ruleTester = avaRuleTester(test, {
+	env: {
+		es6: true
+	}
+});
+
+const header = `const test = require('ava');\n`;
+const errors = [{
+	ruleId: 'prefer-async-await',
+	message: 'Prefer using async/await instead of returning a Promise.'
+}];
+
+ruleTester.run('prefer-async-await', rule, {
+	valid: [
+		header + 'test(t => { t.is(1, 1); });',
+		header + 'test(t => { foo(); });',
+		header + 'test(t => { return foo(); });',
+		header + 'test(t => { foo().then(fn); });',
+		header + 'test(t => { function foo() { return foo().then(fn); } });',
+		header + 'test(t => foo().then(fn));',
+		// TODO: this should be an error, needs improvement
+		header + 'test(t => { const bar = foo().then(fn); return bar; });',
+		// shouldn't be triggered since it's not a test file
+		'test(t => { return foo().then(fn); });'
+	],
+	invalid: [
+		{
+			code: header + 'test(t => { return foo().then(fn); });',
+			errors
+		},
+		{
+			code: header + 'test(function(t) { return foo().then(fn); });',
+			errors
+		},
+		{
+			code: header + 'test(t => { return foo().then(fn).catch(fn2); });',
+			errors
+		},
+		{
+			code: header + 'test(t => { return foo().catch(fn2).then(fn); });',
+			errors
+		},
+		{
+			code: header + 'test(t => { const bar = foo(); return bar.then(fn); });',
+			errors
+		}
+	]
+});