Points de base
Cet article a été initialement publié sur TestProject.
Si vous souhaitez rédiger des tests fonctionnels en JavaScript, ce tutoriel fournit aux ingénieurs d'automatisation d'interface utilisateur le matériel de référence structuré parfait pour les tests JavaScript à l'aide de Selenium WebDriver 3, Mocha et Nodejs.
JavaScript est aujourd'hui un langage Web omniprésent qui semble surmonter son passé "notoire" et est devenu une plate-forme plus fiable non seulement pour les clients mais aussi les serveurs. Mocha.js (ou Mocha pour faire court) est un framework de test JavaScript riche en fonctionnalités basé sur Node.js.Il fournit une plate-forme et une API pour créer des applications côté serveur autonomes, basées sur le moteur JavaScript V8 de Google.
Remarque: Pour commencer à apprendre ce didacticiel JavaScript, vous devez vous familiariser avec les bases des langages de programmation NodeJS et JavaScript.
Présentation du tutoriel:
Version utilisée:
Comme mentionné précédemment, Mocha est un cadre de test JavaScript qui exécute des tests sur le nœud. Mocha est fourni sous la forme d'un package de nœuds (via NPM), vous permettant de remplacer les fonctions "Assert" standard du nœud par n'importe quelle bibliothèque d'assertion, comme les chaijs. De plus, Mocha a plusieurs composants similaires à Jasmine, un autre cadre d'automatisation des tests populaire que nous avons mentionné dans l'étude tendance de l'automatisation des tests frontaux et unitaires).
Mocha fournit une API qui spécifie un moyen de créer du code de test dans des suites de test et des modules de cas de test pour l'exécution, puis générer des rapports de test. Mocha fournit deux modes de fonctionnement: la ligne de commande (CLI) ou la programmation (API MOCHA).
Si vous souhaitez utiliser Mocha dans la CLI, vous devez l'installer globalement en tant que node.js.
<code>npm install -g mocha</code>
Installation du module d'affirmation Chai
<code>npm install --save chai</code>
–Save est utilisée pour installer des modules dans le cadre du projet, plutôt que dans le monde.
Dans Mocha, la suite de tests est définie par le mot-clé "décrire", qui accepte une fonction de rappel. Les suites de test peuvent contenir des suites de test sub / internes, qui peuvent contenir leurs propres suites de sous-test, etc. Le cas de test est représenté par la fonction "IT", qui accepte une fonction de rappel et contient le code de test.
Mocha prend en charge les paramètres de la suite de tests et les fonctions de paramètres de cas de test. "Avant" signifie les paramètres de la suite de tests, tandis que "AVANTEAH" signifie les paramètres de cas de test. "Avant l'enseignement" est en fait une configuration courante pour chaque cas d'utilisation dans la suite et sera exécuté avant chaque cas d'utilisation.
Comme avec la configuration, Mocha prend en charge les suites de test et les fonctions de détresse de cas de test. «Après», signifie le démontage de la suite de tests et «après l'enseignement» signifie le démontage du cas de test, ces deux fonctions sont exécutées après la suite de test et chaque cas de test, respectivement.
Créez un fichier qui "héberge" la suite de tests, telle que test_suite.js, et écrivez ce qui suit;
describe("Inner Suite 1", function(){
before(function(){
// 在测试套件执行之前执行某些操作
// 无论是否有失败的用例
});
after(function(){
// 测试套件执行完成后执行某些操作
// 无论是否有失败的用例
});
beforeEach(function(){
// 在测试用例执行之前执行某些操作
// 无论是否有失败的用例
});
afterEach(function(){
// 测试用例执行完成后执行某些操作
// 无论是否有失败的用例
});
it("Test-1", function(){
// 测试代码
// 断言
});
it("Test-2", function(){
// 测试代码
// 断言
});
it("Test-3", function(){
// 测试代码
// 断言
});
});Exécutez l'intégralité du fichier de suite de test:
mocha /path/to/test_suite.js
Si un kit est sélectionné, tous les sous-kits et / ou tests seront effectués.
mocha -g “Test-2” /path/to/test_suite.js
mocha --recursive -g “Test-2” /directory/
mocha --help
Dans la fonction de test (IT), vous devez passer la fonction Done dans la chaîne de rappel - cela garantit qu'il est exécuté après votre dernière étape.
L'exemple suivant met l'accent sur la fonction terminée. Dans ce cas, un délai d'expiration de trois secondes se produira à la fin de la fonction de test.
<code>npm install -g mocha</code>
La promesse de retour est une autre façon de s'assurer que Mocha a exécuté toutes les lignes de code lors de l'utilisation d'une fonction asynchrone (dans ce cas, la fonction "terminée" n'est pas requise.)
<code>npm install --save chai</code>
Selenium est une bibliothèque qui contrôle les navigateurs Web et simule le comportement des utilisateurs. Plus précisément, Selenium fournit aux utilisateurs une API de bibliothèque de langage spécifique appelée "liaison". "Binding" agit comme un client pour effectuer des demandes sur les composants intermédiaires et agit comme un serveur pour contrôler finalement le navigateur.
L'API ou la liaison sélénium existe désormais dans toutes les langages de développement populaires. Toutes les implémentations linguistiques acceptent désormais de maintenir la cohérence des conventions de dénomination des fonctions d'API.
Les composants intermédiaires peuvent être le joueur Web réel, le serveur de sélénium-standalone trouvé localement dans chaque ensemble de sélénium, ainsi que les pilotes de contrôle du navigateur indigène du vendeur - tels que Geckodriver de Mozilla, Chromedriver du Chrome, etc. De plus, Selenium WebDriver communique avec les pilotes de navigateur via "JSONWired Protocol" et devient la norme Web W3C.
Nous découvrirons rapidement la mise en œuvre du sélénium et des Nodejs avant de plonger dans l'intégration du sélénium et des mokajs.
Afin d'utiliser l'API Selenium de Javascript (ou la liaison JavaScript Selenium), nous devons installer le module correspondant:
describe("Inner Suite 1", function(){
before(function(){
// 在测试套件执行之前执行某些操作
// 无论是否有失败的用例
});
after(function(){
// 测试套件执行完成后执行某些操作
// 无论是否有失败的用例
});
beforeEach(function(){
// 在测试用例执行之前执行某些操作
// 无论是否有失败的用例
});
afterEach(function(){
// 测试用例执行完成后执行某些操作
// 无论是否有失败的用例
});
it("Test-1", function(){
// 测试代码
// 断言
});
it("Test-2", function(){
// 测试代码
// 断言
});
it("Test-3", function(){
// 测试代码
// 断言
});
});À ce stade, il doit être clair que JavaScript Selenium WebDriver peut également être appelé webdriverjs (mais pas dans NPM). WebDriveJS est différent des autres bibliothèques / modules (tels que WebDriverio, ProTracteur, etc.). Selenium-WebDriver est la bibliothèque officielle de base de base JavaScript Selenium, tandis que d'autres bibliothèques sont des bibliothèques / frameworks en wrapper construits sur l'API WebDriverjs, prétendant améliorer la disponibilité et la maintenance.
Dans le code NodeJS, les modules sont utilisés de la manière suivante:
mocha /path/to/test_suite.js
Pour pouvoir utiliser le sélénium, nous devons créer l'objet "WebDriver" correspondant, qui contrôlera ensuite notre navigateur. Ci-dessous, nous pouvons voir comment nous utilisons le modèle "Builder" pour créer des objets WebDriver en reliant plusieurs fonctions.
mocha -g “Test-2” /path/to/test_suite.js
Dans le code ci-dessus, nous avons réussi à construire un objet WebDriver qui agrége les configurations de plusieurs navigateurs (notez la méthode "Options"), bien que la méthode Forbrowser () définit explicitement Firefox.
L'utilisateur peut définir la variable d'environnement Selenium_Browser à l'exécution pour définir le navigateur souhaité. Il remplacera toutes les options définies par Forbrowser car nous avons définie plusieurs fonctionnalités de navigateur via Set
Les propriétés du navigateur peuvent contenir plusieurs types d'informations, selon le navigateur testé. Par exemple, dans les propriétés de Mozilla, nous pouvons définir la configuration "Profil" requise comme suit:
<code>npm install -g mocha</code>
Ensuite, dans l'extrait de constructeur ci-dessus, nous pouvons ajouter:
<code>npm install --save chai</code>
La documentation de l'API JavaScript Selenium WebDriver décrit plusieurs façons de créer un webdriver. Une autre approche possible consiste à définir toutes les configurations de pilote requises pour fonctionner:
describe("Inner Suite 1", function(){
before(function(){
// 在测试套件执行之前执行某些操作
// 无论是否有失败的用例
});
after(function(){
// 测试套件执行完成后执行某些操作
// 无论是否有失败的用例
});
beforeEach(function(){
// 在测试用例执行之前执行某些操作
// 无论是否有失败的用例
});
afterEach(function(){
// 测试用例执行完成后执行某些操作
// 无论是否有失败的用例
});
it("Test-1", function(){
// 测试代码
// 断言
});
it("Test-2", function(){
// 测试代码
// 断言
});
it("Test-3", function(){
// 测试代码
// 断言
});
});Notez que si les setOptions sont définies après les capacités, la configuration sera écrasée (par exemple, configuration de proxy).
Sélénium WebDriver se comporte de la même manière parce que JavaScript et NodeJ sont basés sur le principe asynchrone. Pour éviter les pyramides de rappel et aider les ingénieurs à tester l'expérience de script et la lisibilité au code et la maintenabilité, l'objet Selenium WebDriver contient un gestionnaire de promesses en utilisant "ControlFlow". "ControlFlow" est une classe responsable de l'exécution de la commande Asynchrone WebDriver.
En fait, chaque commande est exécutée sur l'objet pilote et renvoie une promesse. À moins que vous ne deviez traiter la valeur de promesse analysée, vous n'avez pas besoin de nicher la commande suivante dans "alors" comme indiqué ci-dessous:
mocha /path/to/test_suite.js
Conseils pour les tests JavaScript Selenium WebDriver et Mocha
Cela signifie que nous pouvons faire ce qui suit:
mocha -g “Test-2” /path/to/test_suite.js
mocha --recursive -g “Test-2” /directory/
Remarque: le titre est un objet de promesse, pas la valeur analysée réelle.
D'une manière générale, Selenium WebDriver peut être intégré à Mochajs car il est utilisé pour tout script NodeJS normal. Cependant, comme Mocha ne sait pas quand la fonction asynchrone est terminée avant d'appeler Done () ou de renvoyer une promesse, nous devons le gérer très attentivement.
La commande Selenium est automatiquement enregistrée pour s'assurer que la commande WebDriver est exécutée dans le bon ordre et doit renvoyer une promesse.
Le code suivant montre le (avant, avant l'enseignement, après l'enseignement) ou le corps du boîtier de test.
mocha --help
Les éléments suivants seront effectués:
Pour effectuer des tests JavaScript à l'aide de Selenium WebDriver et Mocha de manière facile, WebDriver favorise l'utilisation de mochajs en emballage des fonctions de test Mochajs (avant, avant l'enseignement, elle, etc.) à l'aide d'objets de test. Cela crée une portée qui fait prendre conscience de l'utilisation de WebDriver. Par conséquent, il n'est pas nécessaire de rendre une promesse.
Tout d'abord, le module correspondant doit être chargé:
<code>npm install -g mocha</code>
Toutes les fonctions Mocha commencent par «test».
<code>npm install --save chai</code>
describe("Inner Suite 1", function(){
before(function(){
// 在测试套件执行之前执行某些操作
// 无论是否有失败的用例
});
after(function(){
// 测试套件执行完成后执行某些操作
// 无论是否有失败的用例
});
beforeEach(function(){
// 在测试用例执行之前执行某些操作
// 无论是否有失败的用例
});
afterEach(function(){
// 测试用例执行完成后执行某些操作
// 无论是否有失败的用例
});
it("Test-1", function(){
// 测试代码
// 断言
});
it("Test-2", function(){
// 测试代码
// 断言
});
it("Test-3", function(){
// 测试代码
// 断言
});
});Conclusion
Dans ce tutoriel, nous avons la possibilité de subir des tests JavaScript à l'aide de Selenium WebDriver et Mochajs. Nous devons nous rappeler qu'il existe des différences majeures en raison de la nature asynchrone des Nodejs, des Mochajs et du Sélénium WebDriver par rapport aux autres liaisons du langage de programmation.Tant que nous continuons à retourner la promesse dans toute fonction qui crée la promesse (fonctions de bibliothèque de test personnalisées ou Hooks / Cas de test Mochajs), Mocha les exécutera dans le bon ordre.
D'autres frameworks tels que WebDriverio, ProTracteur et CodePTJS fournissent des solutions de wrapper qui peuvent masquer certaines configurations pour les utilisateurs et fournir un traitement de promesse amélioré pour une meilleure expérience de script, que de nombreux experts d'automatisation des tests peuvent trouver cela utile.
FAQS (FAQ) sur le test de JavaScript avec Selenium webdriver et moka
Comment configurer Selenium WebDriver pour les tests JavaScript?Qu'est-ce que Mocha et pourquoi l'utiliser avec Selenium WebDriver?
Écriture de cas de test de base à l'aide de Selenium WebDriver et Mocha comprend la création d'un nouveau fichier JavaScript et des cas de test d'écriture dans Mocha décrivent et il bloque. Dans ce bloc, vous pouvez utiliser l'API de Selenium WebDriver pour interagir avec le navigateur, comme la navigation vers une page Web, l'interaction avec les éléments et la vérification de leurs propriétés. Voici un exemple de base:
<code>npm install -g mocha</code>
Vous pouvez utiliser la syntaxe asynchrone / attente de JavaScript pour gérer les opérations asynchrones dans les cas de test. Cela vous permet d'écrire du code asynchrone de manière synchrone, ce qui facilite la lecture et la compréhension. Dans le contexte de Selenium WebDriver, des opérations telles que la navigation vers une page Web, interagissant avec les éléments et les conditions d'attente sont asynchrones et peuvent être traitées à l'aide d'Async / Await.
Pour exécuter des cas de test avec Mocha, vous pouvez utiliser la commande mocha suivie du chemin d'accès au fichier de test. Par exemple, si votre fichier de test est nommé test.js, vous pouvez l'exécuter à l'aide de la commande mocha test.js. Mocha trouvera automatiquement et exécutera tous les cas de test dans ce fichier.
Les affirmations dans les cas de test peuvent être utilisées pour vérifier que certaines conditions sont remplies. Par exemple, vous voudrez peut-être affirmer que le titre de la page Web répond à vos attentes après avoir effectué une recherche. Les affirmations peuvent être écrites à l'aide du module Assert intégré de JavaScript ou des bibliothèques tierces telles que Chai.
La syntaxe JavaScript Try / Catch peut être utilisée pour gérer les erreurs dans les cas de test. Cela vous permet de capturer toutes les erreurs qui se produisent lors de l'exécution du cas de test et de les gérer de manière appropriée, par exemple en enregistrant les erreurs et en échouant le cas de test.
Vous pouvez utiliser l'API de Selenium WebDriver pour interagir avec des éléments sur une page Web. Cela inclut la clic sur un élément, la saisie du champ de saisie et les propriétés de l'élément de lecture. Ces opérations sont effectuées à l'aide de la méthode Driver.FindElement, qui renvoie un objet WebElement avec lequel vous pouvez interagir.
Vous pouvez attendre les conditions de mon cas de test à l'aide de la méthode Driver.Atty.ATT de Selenium WebDriver. Cette méthode prend un temps mort conditionnel et facultatif et attend que la condition soit remplie ou que le délai d'attente soit atteint. Vous pouvez utiliser le module toyal pour créer une condition, tel que jusqu'à.Titleis pour attendre que le titre de la page Web soit une valeur.
Vous pouvez exécuter des cas de test dans différents navigateurs en spécifiant le navigateur lors de la création d'une instance WebDriver. Par exemple, vous pouvez exécuter des cas de test dans Firefox en utilisant un nouveau Builder (). Forbrowser («Firefox») ou les exécuter dans Chrome en utilisant un nouveau constructeur (). Forbrowser («Chrome»). Vous devez installer le pilote de navigateur approprié pour le faire fonctionner.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
touche de raccourci de courbe ps
La visionneuse d'images Windows ne peut pas afficher une mémoire insuffisante
Collection de touches de raccourci informatique
Que sont les bases de données en mémoire ?
Le rôle de Vulkan
Logiciel de trading au comptant
Codes couramment utilisés en langage HTML
La différence entre les fichiers d'en-tête et les fichiers source
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
