[MUSIQUE]
Dans la conférence précédente et l'exercice qui a suivi la conférence,
nous avons examiné l'utilisation des tests unitaires dans Angular.
Nous avons vu comment les différentes parties de notre application Angular, les composants,
les services, les directives, les tuyaux peuvent tous être testés en utilisant des tests unitaires.
Mais bien sûr, les tests unitaires
ne révèlent pas tout sur l'interaction entre les composants.
C'est là que les stratégies de test de bout en bout nous permettent de
voir l'application entière fonctionner comme une seule unité.
Donc, dans cette conférence, nous allons examiner l'utilisation des tests de bout en bout et
quel rôle ils jouent dans la stratégie globale de test pour nos applications Angular.
Dans l'exercice qui suit, nous allons examiner brièvement comment nous pouvons effectuer des tests
de bout en bout pour notre application Angular, à l'aide d'un outil appelé Protractor.
Comme nous l'avons déjà appris dans la conférence précédente, les tests unitaires
nous offrent une merveilleuse occasion de tester nos unités en isolement.
S'assurer que nos unités exécutent ce qu'elles sont censées effectuer,
leur logique est correcte, et l'interaction entre le composant et
son modèle est bien établie.
Mais bien sûr, les tests unitaires ne complètent pas l'image entière du fonctionnement d'une application Angular typique.
Vous n'avez pas d'unités individuelles travaillant isolément.
Au lieu de cela, vos composants interagissent avec les services.
Les composants peuvent utiliser des types.
Les services, à leur tour, interagiront avec le backend pour récupérer les données.
Et puis le composant lui-même sera responsable du rendu
des vues en utilisant les modèles pour le composant.
Alors, comment tout cet ensemble d'unités fonctionne-t-il ensemble ?
Et comment faire en sorte que le travail ensemble de ces unités
soit complètement exempt de problèmes ?
C'est donc là que les tests de bout en bout et en cours de route, les tests d'intégration
nous aident à couvrir ce genre de scénarios.
Bien sûr, les tests unitaires jouent un rôle important dans la stratégie globale de test.
Mais sans faire de tests de bout en bout,
nous ne pouvons pas être complètement sûrs que notre application fonctionne comme prévu.
Une chose que je dois souligner est que les tests unitaires sont rapides et
très faciles à répéter et peuvent être effectués plusieurs fois.
Les tests d'intégration et les tests de bout en bout sont lents, et ils sont donc utilisés
seulement avec parcimonie pour confirmer que votre application fonctionne comme prévu.
Donc, quand nous regardons notre stratégie globale de test,
, nous pouvons considérer qu'elle est organisée sous la forme d'une pyramide.
Au bas de la pyramide, occupant toute la base et
formant la base de notre stratégie globale de test, sont des tests unitaires.
Comme nous l'avons appris, les tests unitaires nous permettent de tester les unités individuelles en isolement,
en s'assurant que leur logique et
la façon dont ces unités fonctionnent sont correctes.
Et ces tests peuvent être répétés très fréquemment.
Et en effet, devrait être répété fréquemment pour s'assurer que les unités
individuelles fonctionnent comme prévu.
Bien sûr, à un deuxième niveau de cette stratégie, il y aurait des tests d'intégration.
Comment un petit groupe d'unités travaillent ensemble dans
implémentant tout ce qui est nécessaire pour être fait par ces groupes d'unités ?
Alors peut-être que nous pourrions tester un composant avec
ses services pour voir comment le flux d'informations entre eux se produit.
Mais au sommet de cette pyramide se trouve des tests de bout en bout où
nous regardons l'application globale.
Et comment l'application globale est performante et
répond aux exigences attendues.
C'est donc là que nous voyons l'utilisation de tests de bout en bout.
Comme vous pouvez déjà vous y attendre par ce diagramme, les tests de bout en bout sont lents.
Et donc nous n'effectuons pas de tests de bout en bout très fréquemment, au lieu de cela, le test unitaire
constitue la stratégie de base pour nos tests de notre application Angular.
Les tests de bout en bout contribuent à l'image globale, mais ils ne le sont pas souvent
, mais ils sont toujours un élément essentiel de notre stratégie de test.
Alors, comment faire des tests de bout en bout ?
Parlons brièvement des outils disponibles pour nous.
L'environnement de test angulaire pour les tests de bout en bout
est pris en charge par un outil nommé Protractor.
Qui dit que les geeks n'ont pas le sens de l'humour ?
Rapporteur, Angulaire, voilà.
Alors qu'est-ce que c'est exactement Protractor ?
Protractor est, comme vous pouvez vous y attendre, un programme de noeud.
Cela nous permet donc d'effectuer des tests de bout en bout.
Donc, Protractor exécute les tests contre votre application.
Donc Protractor charge votre application dans un navigateur et interagit avec
l'application tout comme un utilisateur réel interagira avec votre application.
Nous cherchons donc à interagir avec votre application,
bien que par programmation, mais en effectuant le genre d'opérations que
un utilisateur typique effectuera comme cliquer sur des liens, remplir des formulaires.
Soumettre des formulaires, naviguer vers différentes parties de votre demande et ainsi de suite.
C'est donc là que Protractor exploite l'utilisation d'un WebDriver pour contrôler les navigateurs
sur lesquels les tests peuvent être effectués.
Un tel framework d'application est appelé le Selenium Framework,
qui est utilisé pour faire des tests automatisés dans les navigateurs.
Si vous utilisez Chrome dans le cadre de votre stratégie de test ou Firefox,
alors vous pouvez utiliser ce qu'on appelle une connexion directe.
qui est disponible via un rapporteur pour se connecter directement à ces navigateurs et
effectuer des tests dans ces navigateurs.
Maintenant, les tests eux-mêmes tirent parti du cadre d'ajustement pour
exprimant le test.
Donc, vous verrez toujours l'utilisateur décrire un int et
avant chacun que vous avez vu avec des tests unitaires.
Sauf que maintenant, nous allons tirer parti du support du rapporteur pour que
puisse générer de vraies interactions de type utilisateur avec notre application
en utilisant du code.
C'est donc ce que nous allons apprendre dans l'exercice qui suit cette conférence
particulière.
Nous ferons usage de Protractor et écrirons nos stratégies de test de bout en bout.
Et bien sûr, tirez parti du support de l'interface de ligne de commande Angular pour
effectuer des tests de bout en bout dans l'exercice qui suit cette conférence.
[MUSIQUE]