Les tests sont une compétence importante que tout développeur devrait posséder. Cependant, certains hésitent à le faire.
Chacun de nous est tombé sur un développeur qui a affirmé que les tests sont inutiles, ils nécessitent trop d'efforts, et en effet son code est si excellent qu'aucun test n'est nécessaire. Ne le croyez pas. Les tests sont cruciaux.
Les tests rendent votre code plus stable et réduisent le nombre de bugs. Il vous semble que ce n'est pas le cas, car vous connaissez chaque partie de votre code. Après tout, vous l'avez écrit, pourquoi d'autres tests?
Supposons que vous créez une application météo. Vous avez écrit le code pendant plusieurs jours ou semaines, vous connaissez donc le code de et vers.
Imaginez maintenant que vous avez terminé de travailler sur l'application et que vous y reviendrez dans quelques mois. Vous ne vous souviendrez pas de chaque détail de l'ancien code. Vous le changez ... et l'enfer ... quelque chose est cassé. Comment corrigez-vous cela? Regardez chaque fichier que vous créez et configurez-le pour qu'il fonctionne à nouveau? Ça peut marcher. Mais changer ce fichier cassera autre chose.
Prenons un autre exemple. Après plusieurs mois de dur labeur, vous avez enfin obtenu le poste que vous vouliez depuis longtemps! Vous rejoignez l'équipe et commencez à créer quelque chose. Vous travaillez avec du code provenant d'autres développeurs et vice versa. Et en un jour, tout tombe en panne. Si l'équipe n'a pas intégré les tests dans leur application, je ne vous envie pas.
Chaque équipe doit écrire des tests lorsqu'elle crée des logiciels ou des applications. Vous ne voulez pas être une personne qui ne sait pas tester?
Oui, l'écriture des tests prend du temps. Oui, c'est difficile au début. Oui, la création d'applications est plus intéressante. Mais les tests sont importants et permettent de gagner du temps s'ils sont correctement mis en œuvre.
Mon objectif aujourd'hui est d'améliorer les compétences de test. Nous examinerons les tests unitaires et le développement à travers les tests avec Jest (outil de test JavaScript). Bien sûr, il existe d'autres outils de test que vous pouvez utiliser, tels que Mocha et Chai.
Commençons!Tests unitaires
Lorsque vous décidez de tester l'application, vous êtes confronté à différents types de tests: tests unitaires (unit), tests d'intégration et tests fonctionnels. Arrêtons-nous sur les tests unitaires.
Les tests fonctionnels et d'intégration sont tout aussi importants, mais ils sont plus difficiles à configurer et à mettre en œuvre que les tests unitaires. En un mot, le test unitaire consiste à tester de petites parties de votre code: fonctions, méthodes de classe, etc. Vous soumettez des données à l'entrée et confirmez que vous avez reçu le résultat attendu.
Avantages des tests unitaires:- Rend le code plus stable;
- Facilite les changements dans l'implémentation d'une fonction sans changer son comportement;
- Documentez votre code. Vous comprendrez bientĂ´t pourquoi.
- Vous fait faire le bon design. En effet, un code mal conçu est souvent plus difficile à tester.
Développement de tests (TDD)Pour comprendre et utiliser le développement par le biais de tests, n'oubliez pas ces 2 règles:
- Écrivez un test qui échoue avant d'écrire le code.
- Ensuite, Ă©crivez le code qui peut passer le test.
Lorsque nous utilisons TDD, nous parlons d'une boucle «rouge, verte, refactorisée».
Rouge: vous écrivez un test qui a échoué sans écrire de code.
Vert: Ă©crivez le code le plus simple pouvant passer le test. MĂŞme si le code vous semble le plus stupide.
Refactor: refactoring de code, si nécessaire. Ne vous inquiétez pas si vous changez le code et que vos tests unitaires échouent en cas de problème.
Structurer un fichier de test
Jest fournit des fonctions pour structurer les tests:
décrire: utilisé pour regrouper vos tests et décrire le comportement de votre fonction / module / classe. Cela prend deux paramètres. La première est une ligne décrivant votre groupe. La seconde est une fonction de rappel dans laquelle vous avez des cas de test ou des fonctions de hook.
it or test: votre test unitaire. Les paramètres sont les mêmes que ceux décrits. Doit être descriptif. Le choix du test dépend de vous, mais vous pouvez commencer par «Devrait».
beforeAll (afterAll): la fonction hook s'exécute avant (et après) tous les tests. Il prend un paramètre, qui est une fonction que vous exécuterez avant (et après) tous les tests.
beforeEach (afterEach): fonction hook exécutée avant (et après) chaque test. Il prend un paramètre, qui est la fonction que vous exécuterez avant (et après) chaque test.
Avant de passer un test, vous devez savoir ce qui suit:
Vous pouvez ignorer le test en utilisant
.skip sur
describe and
it :
it.skip (...) ou
describe.skip (...) . En utilisant
.skip , vous dites Ă Jest d'ignorer le test ou le groupe.
Vous pouvez choisir exactement les tests que vous souhaitez exécuter en utilisant
.only sur
describe et
it :
it.only (...) ou
describe.only (...) . Ceci est utile si vous avez beaucoup de tests et que vous souhaitez vous concentrer sur une seule chose ou «déboguer» vos tests.
Configuration de Jest
Pour vous montrer les fonctions de test que nous avons examinées ci-dessus, nous devons configurer Jest. C'est très simple.
Vous avez seulement besoin de Node.js et npm ou Yarn. Assurez-vous que vous utilisez la dernière version de Node.js, car nous utiliserons ES6. Créez un nouveau répertoire et initialisez-le.
mkdir test-example && cd test-example npm init -y # OR yarn init -y
-y répond «oui» à toutes les questions npm ou fils. Il devait créer un fichier package.json très simple.
Ajoutez ensuite
Jest à votre environnement de développement.
yarn add jest --dev
Ajoutez ensuite le script suivant Ă votre
package.json :
"scripts": { "test": "jest" }
test de fil exécutera vos fichiers de test dans un répertoire. Par défaut, Jest reconnaît les fichiers dans le répertoire __tests__ ou les fichiers se terminant par .spec.js ou .test.js.
C’est tout. Êtes-vous prêt à passer le premier test.
Matchers (Ă©chantillons)
Lorsque vous vérifiez quelque chose, vous avez besoin d'une entrée et du résultat attendu. C'est pourquoi Jest fournit des échantillons pour tester nos valeurs:
expect(input).matcher(output)
Jest a de nombreux Ă©chantillons, voici le plus important:
toBe: compare l'égalité stricte (===).
expect(1 + 1).toBe(2) let testsAreEssential = true expect(testAreEssential).toBe(true)
toEqual: compare les valeurs entre deux variables, tableaux ou objets.
let arr = [1, 2] arr.push(3) expect(arr).toEqual([1, 2, 3]) let x= 1 x++ expect(x).toEqual(2)
toBeTruthy (toBeFalsy): indique si la valeur est vraie (ou fausse).
expect(null).toBeFalsy() expect(undefined).toBeFalsy() expect(false).toBeFalsy() expect("Hello world").toBeTruthy() expect({foo: 'bar'}).toBeTruthy()
toContain: vérifie si un tableau contient un élément.
expect(['Apple', 'Banana', 'Strawberry']).toContain('Apple')
toThrow: vérifie si une fonction provoque une erreur.
function connect () { throw new ConnectionError() } expect(connect).toThrow(ConnectionError)
Premiers tests
Nous allons maintenant écrire notre premier test et jouer avec nos fonctionnalités. Créez d'abord un fichier example.spec.js dans votre répertoire et collez ce qui suit:
describe('Example', () => { beforeAll(() => { console.log('running before all tests') }) afterAll(() => { console.log('running after all tests') }) beforeEach(() => { console.log('running before each test') }) afterEach(() => { console.log('running after each test') }) it('Should do something', () => { console.log('first test') }) it('Should do something else', () => { console.log('second test') }) })
Veuillez noter que nous n'avons pas besoin d'importer toutes les fonctions que nous utilisons. Ils sont déjà fournis par Jest.
Exécutez le
test de fil :
Comme vous n'avez pas d'instructions dans les tests, elles réussiront. Avez-vous vu différentes instructions console.log? Vous devez mieux comprendre le fonctionnement de vos fonctions et scénarios de test.
Maintenant, supprimez toutes les fonctions de hook et ajoutez
.skip au premier test:
describe('Example', () => { it.skip('Should do something', () => { console.log('first test') }) it('Should do something else', () => { console.log('second test') }) })
Exécutez
Ă nouveau le
test de fil :
Ce n'est pas grave si le premier test ne fonctionne pas.
Ajoutez un troisième test et utilisez
.only :
describe('Example', () => { it('Should do something', () => { console.log('first test') }) it('Should do something else', () => { console.log('second test') }) it.only('Should do that', () => { console.log('third test') }) })
Exécutez à nouveau le test de fil :
Dans la deuxième partie de l'article, nous allons faire une implémentation simple de la pile en JavaScript en utilisant TDD.