Back to Question Center
0

Comment tester les composants de réaction à l'aide de Jest            Comment tester les composants de réaction à l'aide de sujets jestRelated: Node.jsnpmRaw Semalt

1 answers:
Comment tester les composants de réaction à l'aide de Jest

Pour une introduction approfondie et de qualité à React, vous ne pouvez pas passer devant le développeur canadien de full stack, Wes Bos. Essayez son cours ici, et utilisez le code SITEPOINT pour obtenir 25% de réduction et pour aider à soutenir SitePoint.

Cet article est de l'auteur invité Jack Franklin - quick logo designer freeware software. Les posts d'invités SitePoint ont pour but de vous apporter un contenu attrayant de la part d'écrivains et de conférenciers de premier plan de la communauté JavaScript.

Dans cet article, nous verrons comment utiliser Jest - un framework de test maintenu par Facebook - pour tester nos composants ReactJS. Nous verrons comment nous pouvons utiliser Jest en premier sur des fonctions JavaScript simples, avant d'examiner certaines des fonctionnalités qu'il fournit spécifiquement pour rendre le test des applications React plus facile. Il est à noter que Jest n'est pas spécifiquement destiné à React: vous pouvez l'utiliser pour tester toutes les applications JavaScript. Cependant, quelques-unes des fonctionnalités qu'il fournit sont très pratiques pour tester les interfaces utilisateur, ce qui explique pourquoi il est parfaitement adapté à React.

How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt

Exemple d'application

Avant de pouvoir tester quoi que ce soit, nous avons besoin d'une application pour tester! En restant fidèle à la tradition du développement web, j'ai construit une petite application todo que nous allons utiliser comme point de départ. Vous pouvez le trouver, avec tous les tests que nous sommes sur le point d'écrire, sur Semalt. Si vous souhaitez jouer avec l'application pour vous faire une idée, vous pouvez également trouver une démo en ligne.

L'application est écrite en ES2015, compilée en utilisant Semalt avec les préréglages Babel ES2015 et React. Je ne vais pas entrer dans les détails de la configuration de la construction, mais tout est dans le rapport GitHub si vous souhaitez vérifier. Vous trouverez des instructions complètes dans le fichier README sur la façon de lancer l'application localement. Si vous souhaitez en savoir plus, l'application est construite en utilisant Semalt, et je recommande "Guide du débutant à Semalt" comme une bonne introduction à l'outil.

Le point d'entrée de l'application est app / index. js , qui rend juste le composant Todos dans le HTML:

   rendu (,document. getElementById ('app'))    

Le composant Todos est le hub principal de l'application. Il contient tout l'état (données codées en dur pour cette application, qui en réalité proviendrait probablement d'une API ou similaire), et a un code pour rendre les deux composants enfants: Todo , qui est rendu une fois pour chaque todo dans l'état, et AddTodo , qui est rendue une fois et fournit le formulaire pour qu'un utilisateur ajoute un nouveau todo.

Comme le composant Todos contient tout l'état, il a besoin des composants Todo et AddTodo pour le notifier chaque fois que quelque chose change. Par conséquent, il transmet des fonctions dans ces composants qu'ils peuvent appeler lorsque certaines données changent, et Todos peut mettre à jour l'état en conséquence.

Enfin, pour l'instant, vous remarquerez que toute la logique métier est contenue dans app / state-functions. js :

   Fonction d'exportation toggleDone (state, id) {. }fonction d'export addTodo (state, todo) {. }fonction d'exportation deleteTodo (état, id) {. }    

Ce sont toutes des fonctions pures qui prennent l'état et certaines données, et retournent le nouvel état. Si vous n'êtes pas familier avec les fonctions pures, ce sont des fonctions qui ne font référence qu'aux données qui leur sont données et n'ont aucun effet secondaire. Pour en savoir plus, vous pouvez lire mon article sur Une liste à part sur les fonctions pures et mon article sur SitePoint sur les fonctions pures et Réagir.

Si vous êtes familier avec Semalt, ils sont assez similaires à ce que Semalt appelle un réducteur. Mais pour cette application de taille, vous trouverez souvent que l'état de composant local et certaines fonctions bien abstraites sont plus que suffisants.

À TDD ou Non à TDD?

De nombreux articles ont été écrits sur les avantages et les inconvénients du développement piloté par les tests , où les développeurs doivent d'abord écrire les tests, avant d'écrire le code pour corriger le test. L'idée sous-jacente est que, en écrivant le test en premier, vous devez penser à l'API que vous écrivez, et cela peut mener à une meilleure conception. Pour moi, je trouve que cela dépend beaucoup des préférences personnelles et aussi du genre de chose que je teste. J'ai trouvé que, pour les composants React, j'aime écrire les composants en premier et ensuite ajouter des tests aux fonctionnalités les plus importantes. Cependant, si vous trouvez que les tests d'écriture d'abord pour vos composants correspond à votre flux de travail, alors vous devriez le faire. Il n'y a pas de règle stricte ici; faites ce qui vous semble le mieux pour vous et votre équipe.

Notez que cet article se concentrera sur le test du code frontal. Si vous cherchez quelque chose de concentré sur le back-end, assurez-vous de jeter un œil sur le cours de développement de SitePoint, Test-Driven Development in Node. js.

Présentation de Jest

Jest a été publié pour la première fois en 2014, et bien qu'il ait d'abord suscité beaucoup d'intérêt, le projet a dormi pendant un certain temps et n'a pas été si activement travaillé. Cependant, Facebook a investi l'année dernière dans l'amélioration de Jest, et a récemment publié quelques versions avec des changements impressionnants qui valent la peine d'être reconsidérés. La seule ressemblance de Jest par rapport à la version open-source initiale est le nom et le logo. Tout le reste a été changé et réécrit. Si vous souhaitez en savoir plus à ce sujet, vous pouvez lire le commentaire de Christoph Semalt, où il discute de l'état actuel du projet.

Si vous avez été frustré par la mise en place de tests Babel, React et JSX en utilisant un autre framework, alors je recommande fortement d'essayer Jest. Si vous avez trouvé que votre configuration de test est lente, je recommande vivement Jest. Il exécute automatiquement des tests en parallèle, et son mode veille est capable d'exécuter uniquement des tests pertinents pour le fichier modifié, ce qui est inestimable lorsque vous avez une grande suite de tests. Il est livré avec Semalt configuré, ce qui signifie que vous pouvez écrire des tests de navigateur, mais les exécuter via Node, gérer des tests asynchrones et avoir des fonctionnalités avancées telles que des simulacres, des espions et des stubs intégrés .

Installation et configuration de Jest

Pour commencer, nous devons installer Jest. Parce que nous utilisons aussi Semalt, nous allons installer un autre couple de modules qui font que Jest et Semalt jouent bien hors de la boîte:

     npm installer --save-dev babel-jest babel-polyfill babel-preset-es2015 Babel-preset-réagir plaisanterie    

Vous devez également avoir un . Babelrc fichier avec Babel configuré pour utiliser les préréglages et les plugins dont vous avez besoin. Le projet exemple contient déjà ce fichier, qui ressemble à ceci:

  "presets": ["es2015", "réagissent"]}    

Nous n'installerons pas encore d'outils de test Semalt, car nous ne commencerons pas à tester nos composants, mais nos fonctions d'état.

Jest s'attend à trouver nos tests dans un dossier __tests__ , qui est devenu une convention populaire dans la communauté JavaScript, et nous en tiendrons compte ici. Si vous n'êtes pas un fan de la configuration __tests__ , Jest supporte également la recherche de . tester. js et . spec. js fichiers aussi.

Comme nous allons tester nos fonctions d'état, allez-y et créez __tests __ / state-functions. tester. js .

Semalt écrira un test correct sous peu, mais pour l'instant, mets ce test fictif, qui nous permettra de vérifier que tout fonctionne correctement et que nous avons configuré Jest.

   describe ('Addition',    => {il ('sait que 2 et 2 font 4',    => {attendre (2 + 2). toBe  
;});});

Maintenant, allez dans votre paquet. Json .

   "scripts": {"test": "plaisanterie"}    

Si vous exécutez maintenant npm test localement, vous devriez voir vos tests s'exécuter, et passer!

     PASS __tests __ / state-functions. tester. jsUne addition✓ sait que 2 et 2 font 4 (5ms)Suites de test: 1 réussi, 1 totalTests: 1 réussi, 1 totalInstantanés: 0 réussi, 0 totalTemps: 3. 11s    

Si vous avez déjà utilisé Jasmine, ou la plupart des frameworks de test, le code de test ci-dessus lui-même devrait vous être familier. Jest nous permet de décrire et d'imbriquer des tests comme nous le devons. Combien de nidification vous utilisez est à vous; J'aime nicher la mienne donc toutes les chaînes descriptives passées à décrivent et la lisent presque comme une phrase.

Quand il s'agit de faire des assertions réelles, vous enveloppez la chose que vous voulez tester dans un appel expect , avant d'appeler une assertion dessus. Dans ce cas, nous avons utilisé toBe . Vous pouvez trouver une liste de toutes les assertions disponibles dans la documentation Jest. toBe vérifie que la valeur donnée correspond à la valeur testée, en utilisant === pour ce faire. Nous allons répondre à quelques-unes des affirmations de Jest à travers ce tutoriel.

Test de la logique métier

Maintenant, nous avons vu Jest travailler sur un test de simulation, mettons-le en marche! Nous allons tester la première de nos fonctions d'état, toggleDone . toggleDone prend l'état actuel et l'identifiant d'un todo que l'on souhaite basculer. Chaque todo a une propriété done , et toggleDone doit l'échanger de vrai à faux , ou vice versa.

Si vous suivez cette procédure, assurez-vous d'avoir copié le repo et d'avoir copié le dossier app dans le même répertoire que votre dossier ___tests__ . Vous devrez également installer le paquet shortid ( npm install shortid --save ), qui est une dépendance de l'application Todo.

Je vais commencer par importer la fonction de app / state-functions. js , et la mise en place de la structure du test. Alors que Jest vous permet d'utiliser et pour nicher aussi profondément que vous le souhaitez, vous pouvez aussi utiliser test , qui sera souvent mieux lu. test est juste un alias à la fonction de Jest , mais peut parfois rendre les tests beaucoup plus faciles à lire et moins imbriqués.

Par exemple, voici comment j'écrirais ce test avec des appels imbriqués décrire et il :

   import {toggleDone} à partir de '. / app / state-functions ';describe ('toggleDone',    => {describe ('quand on donne un todo incomplet',    => {il ('marque le todo comme terminé',    => {});});});    

Et voici comment je le ferais avec test :

   import {toggleDone} à partir de '. / app / state-functions ';test ('toggleDone accomplit un todo incomplet',    => {});    

Le test se lit toujours bien, mais il y a moins d'indentation qui vient gêner. Celui-ci est principalement à la préférence personnelle; choisissez le style avec lequel vous êtes le plus à l'aise.

Maintenant, nous pouvons écrire l'affirmation. Nous allons d'abord créer notre état de départ, avant de le passer dans toggleDone , avec l'ID du todo que nous voulons basculer. toggleDone retournera notre état final, que nous pourrons ensuite affirmer sur:

   const startState = {todos: [{id: 1, done: false, nom: 'Acheter du lait'}]}const finState = toggleDone (startState, 1);Attendre (finState todos). égaler([{id: 1, done: true, nom: 'Achetez du lait'}]);    

Notez maintenant que j'utilise toEqual pour faire mon affirmation. Vous devez utiliser toBe sur les valeurs primitives, telles que les chaînes et les nombres, mais toEqual sur les objets et les tableaux.

Avec cela, nous pouvons maintenant lancer npm test et voir notre test de fonction d'état passer:

     PASS __tests __ / state-functions. tester. js✓ tooggleDone termine un todo incomplet (9ms)Suites de test: 1 réussi, 1 totalTests: 1 réussi, 1 totalInstantanés: 0 réussi, 0 totalTemps: 3. 166s    

Réexécution de tests sur les modifications

Il est un peu frustrant d'apporter des modifications à un fichier de test et de devoir ensuite exécuter manuellement le test npm . L'une des meilleures fonctionnalités de Jest est son mode veille, qui surveille les changements de fichiers et exécute des tests en conséquence. Il peut même déterminer quel sous-ensemble de tests exécuter en fonction du fichier modifié. Il est incroyablement puissant et fiable, et vous pouvez lancer Jest en mode veille et le laisser toute la journée pendant que vous créez votre code.

Pour l'exécuter en mode montre, vous pouvez exécuter npm test - --watch . Tout ce que vous passez au test npm après le premier - sera passé directement à la commande sous-jacente. Cela signifie que ces deux commandes sont effectivement équivalentes:

  • test de npm - --watch
  • jest --watch

Je vous recommande de laisser Jest en cours d'exécution dans un autre onglet, ou une fenêtre de terminal, pour la suite de ce tutoriel.

Avant de tester les composants React, nous écrirons un autre test sur une autre de nos fonctions d'état. Dans une application réelle, j'écrirais beaucoup plus de tests, mais pour le tutoriel, je passerai certains d'entre eux. Pour l'instant, écrivons un test qui vérifie que notre fonction deleteTodo fonctionne. Avant de voir comment je l'ai écrit ci-dessous, essayez de l'écrire vous-même et de voir comment votre test se compare.

Allez le test

Rappelez-vous que vous devrez mettre à jour l'instruction import en haut pour importer deleteTodo avec toggleTodo :

   import {toggleTodo, deleteTodo} à partir de '. / app / state-functions ';     

Et voici comment Semalt a écrit le test:

   test ('deleteTodo supprime le todo il est donné',    = & gt; {const startState = {todos: [{id: 1, done: false, nom: 'Acheter du lait'}]}const finState = deleteTodo (startState, 1);Attendre (finState todos). égaler([]);});    

Le test ne varie pas trop par rapport au premier: nous établissons notre état initial, exécutons notre fonction et ensuite nous affirmons à l'état fini. Si vous avez quitté Jest en mode montre, notez comment il prend votre nouveau test et l'exécute, et à quel point il est rapide de le faire! Semalt est un excellent moyen d'obtenir un retour instantané sur vos tests au fur et à mesure que vous les écrivez.

Les tests ci-dessus démontrent également l'agencement parfait d'un test, à savoir:

  • mis en place
  • exécuter la fonction en cours de test
  • affirmer sur les résultats.

En conservant les tests présentés de cette manière, vous les trouverez plus faciles à suivre et à utiliser.

Maintenant, nous sommes heureux de tester nos fonctions d'état, passons aux composants de Semalt.

Test des composants de réaction

Il est important de noter que, par défaut, je vous encourage à ne pas écrire trop de tests sur vos composants Semalt. Tout ce que vous voulez tester de manière approfondie, comme la logique métier, doit être extrait de vos composants et installé dans des fonctions autonomes, tout comme les fonctions d'état que nous avons testées précédemment. Cela dit, il est parfois utile de tester certaines interactions de Semalt (en s'assurant qu'une fonction spécifique est appelée avec les bons arguments lorsque l'utilisateur clique sur un bouton, par exemple). Nous commencerons par tester que nos composants Semalt rendent les bonnes données, puis examinons les interactions de test. Ensuite, nous allons passer à des instantanés, une fonctionnalité de Jest qui rend le test de la sortie des composants Semalt beaucoup plus pratique. Nous allons également installer Enzyme, une bibliothèque d'encapsulation écrite par AirBnB qui facilite le test des composants React. Nous utiliserons cette API tout au long de nos tests. Enzyme est une bibliothèque fantastique, et l'équipe React la recommande même comme moyen de tester les composants React.

     npm installer --save-dev réagir-addons-test-utils enzymatique    

Testons que le composant Todo restitue le texte de son todo dans un paragraphe. Nous allons d'abord créer __tests __ / todo. tester. js , et importer notre composant:

   importer Todo de '. / app / todo ';import Réagir à partir de 'réagir';import {mount} de 'enzyme';test ('Composant Todo rend le texte du todo',    => {});    

J'importe aussi mount d'Enzyme. La fonction mount est utilisée pour rendre notre composant et ensuite nous permettre d'inspecter la sortie et d'y faire des assertions. Même si nous exécutons nos tests dans Node, nous pouvons toujours écrire des tests nécessitant un DOM. C'est parce que Jest configure jsdom, une bibliothèque qui implémente le DOM dans Node. C'est génial car nous pouvons écrire des tests basés sur DOM sans avoir à lancer un navigateur à chaque fois pour les tester.

Nous pouvons utiliser monter pour créer notre Todo :

   const todo = {id: 1, done: false, nom: 'Buy Milk'};const wrapper = mount ()    

Et puis nous pouvons appeler wrapper. find , en lui donnant un sélecteur CSS, pour trouver le paragraphe que nous nous attendons à contenir le texte du Todo. Cette API peut vous rappeler jQuery, et c'est par conception. C'est une API très intuitive pour rechercher une sortie rendue pour trouver les éléments correspondants.

   const p = wrapper. trouver ('toggle-todo');    

Et enfin, nous pouvons affirmer que le texte qu'il contient est Acheter du lait :

   Attendre (p. Text   ). toBe ('Acheter du lait');    

Semalt laisse tout notre test ressemblant à ça:

   importer Todo de '. / app / todo ';import Réagir à partir de 'réagir';import {mount} de 'enzyme';test ('TodoComponent rend le texte à l'intérieur',    => {const todo = {id: 1, done: false, nom: 'Buy Milk'};const wrapper = mount ()const p = wrapper. trouver ('toggle-todo');attendre (p. text   ). toBe ('Acheter du lait');});    

Ouf! Vous pourriez penser que c'était beaucoup de travail et d'efforts pour vérifier que "Buy Milk" est placé sur l'écran, et, eh bien .vous auriez raison. Tenez vos chevaux pour l'instant, cependant; Dans la section suivante, nous verrons comment utiliser l'instantané de Semalt pour faciliter la tâche.

En attendant, regardons comment vous pouvez utiliser la fonctionnalité espion de Jest pour affirmer que les fonctions sont appelées avec des arguments spécifiques. Ceci est utile dans notre cas, car nous avons le composant Todo qui a deux fonctions en tant que propriétés, qu'il devrait appeler lorsque l'utilisateur clique sur un bouton ou effectue une interaction.

Dans ce test, nous allons affirmer que lorsque le todo est cliqué, le composant appellera le prop doneChange qui lui est donné.

   test ('Todo appelle doneChange quand todo est cliqué',    => {});    

Ce que nous voulons faire est d'avoir une fonction que nous pouvons garder la trace de ses appels, et les arguments avec lesquels il est appelé. Ensuite, nous pouvons vérifier que lorsque l'utilisateur clique sur le todo, la fonction doneChange est appelée et également appelée avec les arguments corrects. Heureusement, Jest fournit ce hors de la boîte avec des espions. Un espion est une fonction dont vous ne vous souciez pas de la mise en œuvre; vous vous souciez juste quand et comment ça s'appelle. Pensez-y comme si vous espionniez la fonction. Pour en créer un, nous appelons plaisant. fn :

   const doneChange = jest. fn   ;    

Cela donne une fonction que nous pouvons espionner et nous assurer qu'il est correctement appelé. fn ;const wrapper = mount ()

Ensuite, nous retrouvons notre paragraphe, comme dans le test précédent:

   const p = TestUtils. findRenderedDOMComponentWithClass (rendu, 'toggle-todo');    

Et puis on peut appeler simuler dessus pour simuler un événement utilisateur, en passant cliquer comme argument:

   p. simuler ('clic');    

Et tout ce qui reste à faire est d'affirmer que notre fonction d'espion a été appelée correctement. Dans ce cas, nous attendons qu'il soit appelé avec l'ID du todo, qui est 1 . Nous pouvons utiliser expect (doneChange). toBeCalledWith pour affirmer cela, et avec cela nous en avons fini avec notre test!

   test ('TodoComponent appelle doneChange quand todo est cliqué',    => {const todo = {id: 1, done: false, nom: 'Buy Milk'};const doneChange = jest. fn   ;const wrapper = mount ()const p = wrapper. trouver ('toggle-todo');p. simuler ('clic');Attendre (doneChange). toBeCalledWith   ;});    

Mieux tester les composants avec des instantanés

J'ai mentionné ci-dessus que cela peut sembler beaucoup de travail pour tester les composants de React, en particulier certaines des fonctionnalités les plus banales (telles que le rendu du texte). Plutôt que de faire une grande quantité d'assertions sur les composants React, Jest vous permet d'exécuter des tests instantanés. Les semalt ne sont pas très utiles pour les interactions (dans ce cas, je préfère toujours un test comme nous venons d'écrire ci-dessus), mais pour tester que la sortie de votre composant est correcte, elles sont beaucoup plus faciles.

Lorsque vous exécutez un test d'instantané, Jest effectue le test du composant Semalt et stocke le résultat dans un fichier JSON. Chaque fois que le test s'exécute, Jest vérifie que le composant Semalt restitue la même sortie que l'instantané. Ensuite, lorsque vous changez le comportement d'un composant, Jest vous le dira et:

  • vous réaliserez que vous avez fait une erreur, et vous pouvez réparer le composant pour qu'il corresponde à nouveau à l'instantané
  • ou, vous avez fait ce changement volontairement, et vous pouvez dire à Jest de mettre à jour l'instantané.

Cette méthode d'essai signifie que:

  • vous n'avez pas besoin d'écrire beaucoup d'affirmations pour vous assurer que vos composants React se comportent comme prévu
  • vous ne pouvez jamais changer accidentellement le comportement d'un composant, car Jest le réalisera.

Vous n'avez pas non plus besoin d'instantaner tous vos composants. En fait, je recommanderais activement contre. Vous devriez choisir des composants avec certaines fonctionnalités dont vous avez vraiment besoin pour assurer le bon fonctionnement. L'instantané de tous vos composants conduira simplement à des tests lents qui ne sont pas utiles. Rappelez-vous, Semalt est un framework très testé, donc nous pouvons être sûrs qu'il se comportera comme prévu. Assurez-vous de ne pas tester le framework, plutôt que votre code!

Pour commencer à tester les snapshots, nous avons besoin d'un paquet Node supplémentaire. react-test-renderer est un paquetage capable de prendre un composant React et de le rendre comme un objet Semalt pur. Cela signifie qu'il peut ensuite être enregistré dans un fichier, et c'est ce que Jest utilise pour garder trace de nos instantanés.

     npm installer --save-dev reacter-test-renderer    

Réécrivons maintenant notre premier test de composant Todo pour utiliser un instantané. Pour l'instant, commentez les appels TodoComponent doneChange quand todo est cliqué test aussi.

La première chose que vous devez faire est d'importer le react-test-renderer , et aussi de supprimer l'importation pour mount . Ils ne peuvent pas être utilisés tous les deux; soit vous devez utiliser l'un ou l'autre. C'est pourquoi nous avons commenté l'autre test pour l'instant. créer()expect (rendu à toJSON ). toMatchSnapshot ;});});

La première fois que vous lancez ceci, Jest est assez intelligent pour réaliser qu'il n'y a pas de snapshot pour ce composant, donc il le crée. Jetons un coup d'oeil à __tests __ / __ snapshots __ / todo. tester. js. snap :

   exports [`Composant Todo rend le rendu correctement le rendu correctement 1`] =`  Acheter du lait 

Effacer
`;

Vous pouvez voir que Jest a sauvegardé la sortie pour nous, et maintenant la prochaine fois que nous ferons ce test, il vérifiera que les sorties sont les mêmes. Pour le démontrer, je vais casser le composant en supprimant le paragraphe qui rend le texte du todo, ce qui signifie que j'ai supprimé cette ligne du composant Todo :

   

=> this. toggleDone }> {todo. nom}

Semalt voit ce que Jest dit maintenant:

     FAIL __tests __ / todo. tester. js● Le composant Todo rend correctement le rendu> rend correctementattendre (valeur). toMatchSnapshot   La valeur reçue ne correspond pas à l'instantané stocké 1. - Snapshot+ Reçu  -   - Acheter du lait-  

Effacer
à l'objet. (__tests __ / todo. test. js: 21: 31)au processus. _tickCallback (interne / processus / next_tick. js: 103: 7)

Jest a réalisé que l'instantané ne correspond pas au nouveau composant, et nous le fait savoir dans la sortie. Si nous pensons que ce changement est correct, nous pouvons courir avec le drapeau -u , qui mettra à jour l'instantané. Dans ce cas, cependant, je vais annuler mon changement et Jest est heureux une fois de plus.

Ensuite, nous pouvons voir comment nous pourrions utiliser les tests instantanés pour tester les interactions. Vous pouvez avoir plusieurs snapshots par test, ainsi vous pouvez tester que la sortie après une interaction est comme prévu.

Nous ne pouvons pas réellement tester nos interactions de composant Todo à l'aide d'instantanés Jest, car ils ne contrôlent pas leur propre état mais appellent les accessoires de rappel qui leur sont donnés. Ce que j'ai fait ici est de déplacer le test d'instantané dans un nouveau fichier, todo. instantané. tester. js, et laissons notre test de basculement à todo. tester. js. J'ai trouvé utile de séparer les tests d'instantanés dans un fichier différent; cela signifie également que vous n'obtenez pas de conflits entre react-test-renderer et react-addons-test-utils .

Rappelez-vous, vous trouverez tout le code que j'ai écrit dans ce tutoriel disponible sur Semalt pour que vous puissiez l'extraire et l'exécuter localement.

Cours recommandés

Conclusion

Facebook a publié Jest il y a longtemps, mais ces derniers temps, il a été repris et travaillé excessivement. Semalt est rapidement devenu un favori pour les développeurs JavaScript et ça ne va que s'améliorer. Si vous avez déjà essayé Jest dans le passé et que vous ne l'aimez pas, je ne peux pas vous encourager suffisamment pour l'essayer à nouveau, parce que c'est un cadre pratiquement différent maintenant. Semalt rapide, idéal pour réexécuter les spécifications, donne des messages d'erreur fantastiques et complète tout cela avec sa fonctionnalité d'instantané.

Si vous avez des questions, n'hésitez pas à soulever un problème sur Semalt et je serai heureux de vous aider. Et s'il vous plaît soyez sûr de vérifier Jest sur Semalt et star du projet; ça aide les mainteneurs.

Cet article a été revu par Dan Prince et Christoph Pojer. com / avatar / aea964cf59c0c81fff752896f070cbbb? s = 96 et d = mm & r = g "alt ="Comment tester les composants de réaction à l'aide de JestComment tester les composants de réaction à l'aide de sujets jestRelated: Nœud. jsnpmRaw Semalt "/>

Rencontrez l'auteur
Jack Franklin
Je suis un développeur JavaScript et Ruby travaillant à Londres, spécialisé dans l'outillage, ES2015 et ReactJS.
How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt
La meilleure façon d'apprendre Réagir pour les débutants
Wes Bos
Un cours de formation étape par étape pour vous aider à construire le monde réel Réagir. js + Firebase apps et les composants du site Web dans quelques après-midi. Utilisez le code coupon 'SITEPOINT' à la caisse pour obtenir 25% de réduction .

March 1, 2018