7 raisons d'utiliser des tests automatisés dans Selenium, JUnit5 et Gauge Framework

Les tests automatisés peuvent être exécutés sur plusieurs environnements, plusieurs navigateurs, plusieurs appareils et plusieurs ensembles de données en parallèle.

Ces tests sont moins sujets aux erreurs humaines que les tests manuels, ce qui peut contribuer à améliorer la précision et la fiabilité du processus de test. De plus, ils sont reproductibles, cohérents et fiables, ce qui aide à réduire les faux positifs et les faux négatifs. Dans cet article, je vais expliquer pourquoi vous devriez utiliser des tests automatisés dans Selenium, JUnit5 et Gauge Framework.

1. Augmente l'efficacité

   

   Les tests automatisés peuvent être exécutés plus rapidement que les tests manuels, ce qui permet d'exécuter davantage de tests dans un laps de temps plus court. Cela peut aider à identifier les problèmes et les bogues plus rapidement, ce qui permet d'économiser du temps et des ressources à long terme. Les tests d'automatisation peuvent s'exécuter sur plusieurs environnements, plusieurs navigateurs, plusieurs appareils et plusieurs ensembles de données en parallèle, ce qui augmente l'efficacité globale du processus de test.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver class AutomationTest { private lateinit var driver: WebDriver @Step("Open the browser and navigate to the website") fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Step("Search for <searchTerm>") fun search(searchTerm: String) { driver.findElement(By.name("q")).sendKeys(searchTerm) driver.findElement(By.name("btnK")).click() } @Step("Close the browser") fun closeBrowser() { driver.quit() } }

   
   

   Ceci est un exemple de script d'automatisation de test simple écrit en Kotlin qui utilise la bibliothèque Selenium pour interagir avec une page Web et le framework Gauge pour organiser et exécuter les tests. Ce script ouvre un navigateur, accède à un site Web, effectue une recherche, puis ferme le navigateur.

   
   

   Étant donné que ce test est automatisé, il peut s'exécuter plus rapidement que s'il était effectué manuellement.

   
   

   Ceci n'est qu'un exemple simple, dans un cas d'utilisation réel, vous pouvez avoir plusieurs scénarios, plusieurs cas de test et plusieurs suites de tests qui peuvent être automatisés et exécutés en parallèle, ce qui augmente l'efficacité globale du processus de test.

   
   

   Il convient de noter que, si vous travaillez avec une application Web, il existe d'autres frameworks et outils qui peuvent être utilisés en conjonction avec ou à la place de Selenium, tels que Cypress, WebDriverIO et TestCafe, chacun ayant ses propres caractéristiques et avantages spécifiques. .

   
   

2. Améliore la précision

   

   Les tests automatisés sont moins sujets aux erreurs humaines que les tests manuels, ce qui peut aider à améliorer la précision et la fiabilité du processus de test. Les tests automatisés sont reproductibles, cohérents et fiables, ce qui aide à réduire les faux positifs et les faux négatifs.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver class AutomationTest { private lateinit var driver: WebDriver @Step("Open the browser and navigate to the website") fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Step("Search for <searchTerm> and verify the result") fun search(searchTerm: String) { driver.findElement(By.name("q")).sendKeys(searchTerm) driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains(searchTerm)) } @Step("Close the browser") fun closeBrowser() { driver.quit() } }

   
   

   Dans cet exemple, le script effectue non seulement une recherche, mais vérifie également les résultats en affirmant que les résultats de recherche renvoyés contiennent le terme de recherche. Cela permet de s'assurer que le test est précis et détectera tous les problèmes pouvant survenir avec la fonctionnalité de recherche.

   
   

   Étant donné que le script est automatisé, il s'exécutera de la même manière à chaque fois qu'il sera exécuté avec les mêmes entrées, garantissant ainsi que le test est reproductible, cohérent et fiable. Cela aide à réduire les faux positifs et les faux négatifs, qui peuvent survenir avec les tests manuels.

   
   

   De plus, vous pouvez utiliser des outils de rapport de test tels que Gauge report, Allure, TestNG, JUnit, etc. pour suivre les résultats des tests, vous permettant de voir si un test a échoué ou réussi. S'il a échoué, il révélera la raison de l'échec, ce qui aide à identifier les problèmes au début du processus de développement et les empêche de devenir des problèmes plus graves plus tard.

   
   

   3. Permet des tests fréquents

   

   Des tests automatisés peuvent être exécutés régulièrement, par exemple à chaque fois que des modifications de code sont apportées, ce qui peut aider à identifier les problèmes au début du processus de développement et à éviter qu'ils ne deviennent des problèmes plus graves par la suite. Cela aide à détecter les bogues tôt dans le cycle de développement et à réduire le coût global de la correction des bogues.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver import org.junit.jupiter.api.Test import org.junit.jupiter.api.BeforeEach class AutomationTest { private lateinit var driver: WebDriver @BeforeEach fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Test fun testSearch() { driver.findElement(By.name("q")).sendKeys("searchTerm") driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains("searchTerm")) } @AfterEach fun closeBrowser() { driver.quit() } }

   
   

   Ce script utilise le framework JUnit5 et l'annotation @Test , qui marque une méthode comme méthode de test. Cela permet au test d'être exécuté automatiquement dans le cadre d'une suite de tests. De plus, le script utilise les annotations @BeforeEach et @AfterEach qui marquent une méthode à exécuter avant ou après chaque méthode de test.

   
   

   Vous pouvez également utiliser un pipeline CI/CD et y intégrer le test d'automatisation, permettant aux tests d'être exécutés automatiquement dans le cadre d'un processus de construction et à chaque changement de code. Cela permet de s'assurer que les modifications de code sont testées et sont de bonne qualité avant d'être déployées en production.
   

   4. Rentable

   

   Les tests automatisés peuvent s'exécuter sans intervention humaine, ce qui réduit le coût des tests au fil du temps. Les tests automatisés peuvent être exécutés sur une base régulière et peuvent être programmés pour s'exécuter à un moment précis, ce qui réduit le besoin en ressources humaines.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver import org.junit.jupiter.api.Test import org.junit.jupiter.api.BeforeEach class AutomationTest { private lateinit var driver: WebDriver @BeforeEach fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Test fun testSearch() { driver.findElement(By.name("q")).sendKeys("searchTerm") driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains("searchTerm")) } @Test fun testSignUp() { driver.findElement(By.linkText("Sign Up")).click() driver.findElement(By.name("username")).sendKeys("myusername") driver.findElement(By.name("password")).sendKeys("mypassword") driver.findElement(By.name("submit")).click() val message = driver.findElement(By.xpath("//div[@class='message']")) assert(message.text.contains("Welcome myusername")) } @AfterEach fun closeBrowser() { driver.quit() } }

   
   

   Dans cet exemple, nous avons deux cas de test. Le premier est pour tester la fonctionnalité de recherche et le second est pour tester la fonctionnalité d'inscription. En ayant plusieurs cas de test dans un seul script, cela augmente l'efficacité globale du processus de test, ce qui peut aider à réduire le coût global des tests.

   
   

   De plus, vous pouvez utiliser le paramétrage de test où vous pouvez exécuter le même scénario de test avec plusieurs entrées et ensembles de données. Cela augmente la couverture globale des tests et aide à trouver plus de bogues, réduisant ainsi le coût global des tests.

   
   

   De plus, vous pouvez utiliser des environnements de test basés sur le cloud tels que SauceLabs, BrowserStack et TestingBot, ce qui vous permet d'exécuter vos tests sur une variété de navigateurs et de systèmes d'exploitation sans avoir à gérer votre propre infrastructure de test. Cela peut réduire les coûts associés à la maintenance et à la mise à l'échelle de l'infrastructure de test.

   
   

   Dans l'ensemble, les tests automatisés peuvent être rentables en réduisant le besoin de ressources humaines, en augmentant l'efficacité du processus de test et en utilisant des environnements de test basés sur le cloud.

   
   

   5. Augmente la couverture

   

   Les tests automatisés peuvent couvrir un large éventail de scénarios, d'entrées et de cas d'utilisation difficiles à couvrir manuellement, augmentant ainsi la couverture globale des tests. Les tests automatisés peuvent couvrir différents navigateurs, différents appareils, différentes versions du système d'exploitation, différents ensembles de données et différents scénarios, ce qui augmente la couverture globale des tests.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver import org.junit.jupiter.api.Test import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.CsvSource class AutomationTest { private lateinit var driver: WebDriver @BeforeEach fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @ParameterizedTest @CsvSource(value = ["searchTerm1, expectedResult1", "searchTerm2, expectedResult2", "searchTerm3, expectedResult3"]) fun testSearch(searchTerm: String, expectedResult: String) { driver.findElement(By.name("q")).sendKeys(searchTerm) driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains(expectedResult)) } @AfterEach fun closeBrowser() { driver.quit() } }

   
   

   Dans cet exemple, nous utilisons l'annotation JUnit5 @ParameterizedTest et @CsvSource pour exécuter le même scénario de test avec plusieurs entrées, ce qui augmente la couverture globale du test. Le test s'exécutera trois fois avec des valeurs d'entrée différentes et vérifiera à chaque fois si la sortie correspond au résultat attendu.

   
   

   De cette façon, vous pouvez tester la même fonctionnalité avec plusieurs ensembles de données, ce qui aide à trouver plus de bogues et augmente la couverture globale des tests. De plus, vous pouvez également utiliser des infrastructures de test basées sur les données telles que TestNG, JUnit5, etc. pour exécuter les cas de test avec plusieurs entrées, augmentant ainsi la couverture globale des tests.

   
   

   6. Améliore la cohérence Les tests automatisés s'exécutent de la même manière à chaque fois, garantissant que les mêmes problèmes ne sont pas manqués à plusieurs reprises. Les tests automatisés sont reproductibles, cohérents et fiables, ce qui réduit les faux positifs et les faux négatifs.

   
   

    import com.thoughtworks.gauge.Step import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.Response class API_AutomationTest { @Step("GET request to <endpoint> and verify the response") fun testAPI(endpoint: String) { val client = OkHttpClient() val request = Request.Builder() .url(endpoint) .get() .build() val response = client.newCall(request).execute() val json = response.body()?.string() assert(json!!.contains("\"userId\": 1")) } }

   
   

   Ce script utilise le framework Gauge et l'annotation @Step , qui marque une méthode comme une étape dans le scénario de test. Cela permet au scénario de test d'être écrit dans un format lisible et compréhensible, ce qui rend le déroulement du test facile à comprendre.

   
   

   Vous pouvez également utiliser le concept de test basé sur les données de la jauge, où vous pouvez exécuter le même scénario de test avec plusieurs entrées, augmentant ainsi la couverture globale des tests et trouvant potentiellement plus de bogues.

   
   

   De plus, vous pouvez utiliser la capacité de rapport de la jauge, qui fournit un rapport clair et concis des scénarios de test, des résultats des tests et du temps d'exécution des tests.

   
   

   7. Permet l'intégration continue et la livraison continue

   

   Les tests automatisés sont un élément clé de l'intégration et de la livraison continues, qui constituent un aspect essentiel du développement de logiciels modernes. Les tests automatisés peuvent être intégrés au pipeline CI/CD et peuvent être exécutés automatiquement à chaque modification de code, garantissant que les modifications de code sont testées et de bonne qualité avant d'être déployées en production.

   
   

   Vous pouvez utiliser un pipeline CI/CD et y intégrer le script, ce qui permet aux tests d'être exécutés automatiquement dans le cadre d'un processus de génération et à chaque changement de code.

   
   

   Par exemple, vous pouvez utiliser Jenkins, Travis, CircleCI, etc. comme outil CI/CD. Ensuite, vous pouvez configurer le travail pour générer le projet, exécuter les scénarios de test et déployer l'application en production si les tests réussissent.

   
   

   Il s'agit d'un aspect essentiel du développement de logiciels modernes, et il aide à obtenir une livraison de logiciels plus rapide et plus fiable.

   
   

 pipeline { agent any stages { stage('Build') { steps { sh './gradlew build' } } stage('Test') { steps { sh 'gauge run specs/' } } stage('Deploy') { steps { sh './deploy.sh' } } } }

Ce fichier Jenkins définit un pipeline en trois étapes : Build, Test et Deploy.

Dans l' étape Build , le pipeline exécute la commande './gradlew build'. Cette commande générera le projet et générera les artefacts nécessaires.

À l' étape de test , le pipeline exécute la commande "gauge run specs/". Cette commande exécutera tous les cas de test de jauge dans le dossier specs.

À l' étape de déploiement , le pipeline exécute la commande './deploy.sh'. Cette commande déploiera l'application dans l'environnement de production.

Vous pouvez configurer le travail Jenkins pour exécuter ce fichier Jenkins et il construira, testera et déploiera l'application si les tests réussissent.

Avec cet exemple, vous pouvez voir comment vous pouvez utiliser les tests Gauge dans un fichier Jenkins pour permettre l'intégration continue et la livraison continue. Cela vous permet d'automatiser le processus de test.

Dernières pensées

• Augmente l'efficacité en permettant l'exécution de plusieurs cas de test dans un seul script.

• Améliore la précision en réduisant les erreurs humaines et en fournissant des résultats cohérents.

• Permet des tests fréquents en facilitant l'exécution de tests réguliers.

• Est rentable en réduisant le coût global des tests et en augmentant la couverture des tests.

• Augmente la couverture en permettant d'exécuter le même scénario de test avec plusieurs entrées et ensembles de données.

• Améliore la cohérence en garantissant que le logiciel fonctionne comme prévu.

• Permet l'intégration continue et la livraison continue en permettant aux tests d'être exécutés automatiquement dans le cadre d'un processus de construction, et à chaque changement de code, en s'assurant que les changements de code sont testés et sont de bonne qualité avant d'être déployés en production.

  
  

Dans l'ensemble, les tests d'automatisation contribuent à améliorer la qualité globale du logiciel, à réduire le coût global des tests, à augmenter la couverture des tests, à améliorer la cohérence et à permettre une intégration continue et une livraison continue, ce qui se traduit par une livraison logicielle plus rapide et plus fiable.