08-common-pitfalls.md

---

Note du traducteur

C'est la traduction du fichier 08-common-pitfalls.md. Voici un lien vers les différences avec le master de AVA (Si en cliquant sur le lien, vous ne trouvez pas le fichier 08-common-pitfalls.md parmi les fichiers modifiés, vous pouvez donc en déduire que la traduction est à jour).

---

Pièges classiques

Traductions : English

Si vous utilisez ESLint, vous pouvez installer eslint-plugin-ava. Il vous aidera à utiliser correctement AVA et ainsi vous évitera certains pièges classiques.

AVA dans Docker

Si vous exécutez AVA dans Docker comme faisant partie de votre CI, vous devez ajuster les variables d'environnement adéquates. Plus précisément, en ajoutant -e CI=true dans la commande docker exec. Regardez #751.

AVA utilise is-ci pour décider s'il se trouve ou pas dans un environnement de CI en utilisant ces variables.

AVA et les limites du nombre de clients connectés

Vous utilisez peut-être un service qui permet seulement un nombre de connexions simultanées limitées. Par exemple, de nombreux services de base de données d'entreprises offrent un forfait gratuit avec une limite sur le nombre de clients pouvant être utiliser en même temps. AVA peut atteindre ces limites car il exécute plusieurs processus, mais les services bien écrit doivent émettre une erreur ou créer un goulot d'étranglement dans ces cas. Si celui que vous utilisez ne le fait pas, les tests se bloqueront.

Par défaut, AVA utilisera autant de processus qu'il y a de cœur logique sur votre machine. Ceci est plafonné à deux dans un environnement CI.

Utilisez l'option concurrency pour limiter le nombre de processus exécutés. Par exemple, si votre abonnement au service permet 5 clients, vous devez exécuter AVA avec concurrency=5 ou moins.

Opérations asynchrones

Vous pouvez exécuter une opération asynchrone à l'intérieur d'un test et vous demander pourquoi elle ne se finit pas. Si votre opération asynchrone utilise des promesses, vous devez retourner la promesse :

test('fetches foo', t => {
	return fetch().then(data => {
		t.is(data, 'foo');
	});
});

Mieux encore, l'utilisation de async / await:

test('fetches foo', async t => {
	const data = await fetch();
	t.is(data, 'foo');
});

Si l'on utilise des callbacks, il faut transformer la fonction de rappel en promesse en utilisant quelque chose comme util.promisify() :

import {promisify} from 'util';

test('fetches foo', async t => {
	const data = await promisify(fetch)();
	t.is(data, 'foo');
});

Affectation des exceptions non interceptées par les tests

AVA ne peut pas tracer les exceptions non interceptées par le retour du test qui les déclenche. Les fonctions de prise de callback peuvent conduire à des exceptions non interceptées qui peuvent ensuite être difficiles à déboguer. Utilisez la transformation d'un callback en promesse et l'utilisation de async/await, comme dans l'exemple ci-dessus. Cela devrait permettre à AVA d'attraper l'exception et de l'attribuer au test correctement.

Partage de variables entre tests asynchrones

Par défaut, AVA exécute les tests simultanément. Cela peut poser problème si vos tests sont asynchrones et partagent des variables.

Prenons cet exemple bidon :

import test from 'ava';

let count = 0;
const incr = async () => {
	await true;
	count = count + 1;
};

test.beforeEach('réinitialise le compteur', () => {
	count = 0;
});

test('incrémente une fois', async t => {
	await incr();
	t.is(count, 1);
});

test('incrémente deux fois', async t => {
	await incr();
	await incr();
	t.is(count, 2);
});

Les tests simultanés permettent aux tests asynchrones de s'exécuter plus rapidement, mais s'ils reposent sur un état partagé, cela peut entraîner des échecs de test inattendus. Si l'état partagé ne peut pas être évité, vous pouvez exécuter vos tests en série :

import test from 'ava';

let count = 0;
const incr = async () => {
	await true;
	count = count + 1;
};

test.beforeEach('réinitialise le compteur', () => {
	count = 0;
});

test.serial('incrémente une fois', async t => {
	await incr();
	t.is(count, 1);
});

test.serial('incrémente deux fois', async t => {
	await incr();
	await incr();
	t.is(count, 2);
});

---

Votre problème n'est pas listé ici ? Soumettez un pull request ou commentez sur cette issue.