assertions selenium using junit
Ce didacticiel Selenium sur les assertions explique ce que sont les assertions dans Selenium et différents types d'assertions et de méthodes d'assertion utilisant les frameworks Junit et TestNG:
questions sur les fonctions Microsoft Excel et la syntaxe commune
Les assertions sont utilisées pour valider un scénario de test et nous aident à comprendre si un scénario de test a réussi ou échoué. L'assertion est considérée comme satisfaite si le résultat réel d'une application correspond à celui du résultat attendu.
Lors de l'automatisation des applications Web à l'aide de Selenium, nous devons valider nos tests pour vérifier s'ils fonctionnent comme prévu ou non(c'est-à-dire si le résultat d'un scénario de test est réussi / échoue).
=> Jetez un œil au guide du débutant Selenium ici.
Un cas de test est considéré comme réussi uniquement si toutes les assertions ont été satisfaites. Les assertions dans Selenium peuvent être gérées par des méthodes prédéfinies des frameworks Junit et TestNG, qui seront expliquées en détail dans cet article.
Ce que vous apprendrez:
- Assertions dans le sélénium
- Types d'assertions dans le sélénium
- Méthodes Junit Assert
- TestNG Assert Méthodes
- Exemples de programmes pour les assertions
- Conclusion
Assertions dans le sélénium
Les assertions sont utilisées pour effectuer divers types de validations dans les cas de test, ce qui à son tour nous aide à décider si le scénario de test a réussi ou échoué. WNous considérons un test comme réussi s'il s'exécute sans aucune exception.
Tutoriel vidéo sur les assertions
Types d'assertions dans le sélénium
Il existe deux types d'assertions dans Selenium et la catégorisation dépend de la façon dont l'assertion se comporte après qu'une condition est réussie ou échouée.
Ici, nous discuterons de deux types d'assertions dans Sélénium :
- Assertions dures
- Assertions douces
Cliquez ici pour un échantillon cas de test pour tester les assertions.
# 1) Assertions dures (ou simplement assertions)
Une assertion ferme ne continue pas avec l'exécution tant que la condition d'assertion n'est pas remplie.
Les assertions matérielles génèrent généralement une erreur d'assertion chaque fois qu'une condition d'assertion n'est pas remplie. Le scénario de test sera immédiatement marqué comme Échoué lorsqu'une condition d'assertion ferme échoue.
Un scénario pour utiliser ce type d'assertion est que, lorsque vous voulez vérifier si vous vous êtes connecté correctement et échouez au test si vous n'avez pas réussi à vous connecter, car il ne sert à rien de continuer si la condition préalable ( login) lui-même échoue.
Prenons un autre exemple illustré ici:
Prenons un cas de test pour affirmer le titre d'une page Web.
public class LearnAssertions { WebDriver driver; //Store current project workspace location in a string variable ‘path’ String path = System.getProperty('user.dir”); @BeforeTest public void SetDriver(){ //Mention the location of ChromeDriver in localsystem System.setProperty('webdriver.chrome.driver',path+'\Drivers\chromedriver.exe'); driver = new ChromeDriver();// Object is created- Chrome browser is opened driver.manage().window().maximize(); } @Test public void verifyTitle() { driver.get(https://www.amazon.com); String ActualTitle = driver.getTitle(); String ExpectedTitle = “Amazon.com: Online Shopping for Electronics, Apparel, Computers, Books, DVDs & more”; Assert.assertEquals(ActualTitle, ExpectedTitle); System.out.println(“Assert passed”); } @AfterTest public void closedriver(){ //closes the browser instance driver.close(); } 
Dans l'exemple, la variable 'ActualTitle' contiendra le texte du titre issu de l'automatisation. «ExpectedTitle» contient les données de chaîne attendues. Assert.assertEquals () vérifie si les deux textes sont égaux. Le scénario de test ci-dessus passera et passera à la ligne d'exécution suivante car le texte réel et le texte attendu sont identiques.
Console :
Assert passé.
RÉUSSI: VerifyTitle
Le même scénario de test en cas d'échec lèvera une exception et arrêtera l'exécution à cette instance.
Maintenant, changeons le titre attendu pour le mauvais.
public class LearnAssertions { WebDriver driver; //Store current project workspace location in a string variable ‘path’ String path = System.getProperty('user.dir'); @BeforeTest public void SetDriver(){ //Mention the location of chromeDriver in localsystem System.setProperty('webdriver.chrome.driver',path+'\Drivers\chromedriver.exe'); driver = new ChromeDriver();// Object is created- Chrome browser is opened driver.manage().window().maximize(); } @Test public void verifyTitle() { driver.get(https://www.amazon.com); String ActualTitle = driver.getTitle(); String ExpectedTitle = “Welcome to Amazon”; Assert.assertEquals(ActualTitle, ExpectedTitle); System.out.println(“Assert passed”); } @AfterTest public void closedriver(){ //closes the browser instance driver.close(); }Console:
java.lang.AssertionError:attendu (Bienvenue sur Amazon)maisfound (Amazon.com: achats en ligne d'électronique, de vêtements, d'ordinateurs, de livres, de DVD et plus)
Depuis la console, nous pouvons voir que l'instruction d'impression a été ignorée (System.out.println) car un échec a été rencontré dans l'instruction Assert et a levé une exception.
# 2) Assertions douces
Une assertion souple continue avec l'étape suivante de l'exécution du test même si la condition d'assertion n'est pas remplie.
Les assertions souples sont le type d'assertions qui ne lèvent pas automatiquement une exception lorsqu'une assertion échoue, sauf si elle est demandée. Ceci est utile si vous effectuez plusieurs validations dans un formulaire, parmi lesquelles seules quelques validations ont directement un impact sur la décision de l'état du scénario de test.
Ici, nous utilisons une classe appelée SoftAssert et la méthode assertAll () est appelée pour lever toutes les exceptions interceptées lors de l'exécution. Lorsque softAssert est utilisé, il effectue une assertion et si une exception est trouvée, elle n'est pas levée immédiatement, mais continue jusqu'à ce que nous appelions la méthode assertAll () pour lever toutes les exceptions interceptées.
Il est sage d’utiliser différents objets de la classe ‘SoftAssert’ pour chaque cas de test.
Considérez le cas de test pour affirmer le titre de la page
Dans l'exemple ci-dessous, deux objets de la classe «SoftAssert» sont créés pour être utilisés dans deux cas de test différents.
public class LearnAssertionsSoft { WebDriver driver; //Object of Class SoftAssert is created to use its methods SoftAssert softassert = new SoftAssert(); SoftAssert softassert2 = new SoftAssert(); //current project workspace String path = System.getProperty('user.dir'); @BeforeTest public void SetDriver(){ System.setProperty('webdriver.chrome.driver',path+'\Drivers\chromedriver.exe'); driver = new ChromeDriver();// Object is created - Chrome browser is opened driver.manage().window().maximize(); } //Soft Assertion example - with a failure test case example @Test public void verifyTitle(){ driver.get('https://amazon.in'); String ActualTitle = driver.getTitle(); System.out.println('Actual Title :'+ActualTitle); String ExpectedTitle = 'cameras, books, watches, apparel, shoes and e-Gift Cards. Free Shipping & Cash on Delivery Available.'; //Soft assert applied to verify title softassert.assertEquals(ActualTitle, ExpectedTitle); //If failed, this line gets printed and execution is not halted System.out.println('Assertion 1 is executed”); softassert.assertAll(); } //Soft Assertion example - with a positive flow test case example @Test public void verifyElement(){ WebElement AmazonIcon = driver.findElement(By.Xpath(“//div(contains(@id,’amazon_icon’))); softassert2.assertEquals (true, AmazonIcon.isDisplayed()); softassert2.assertAll(); System.out.println('Icon is displayed'); System.out.println('Assertion 2 is executed”); } @AfterTest public void closedriver(){ driver.close(); //Checks for failures if any and throws them at the end of execution } }Console:
Titre actuel: Amazon.com: Achats en ligne pour l'électronique, les vêtements, les ordinateurs, les livres, les DVD et plus
L'assertion 1 est exécutée
L'icône s'affiche
L'assertion 2 est exécutée
java.lang.AssertionError: les assertions suivantes ont échoué:
prévu (Bienvenue sur Amazon) mais trouvé (Amazon.com: achats en ligne d'électronique, de vêtements, d'ordinateurs, de livres, de DVD et plus)
Depuis la console, nous pouvons comprendre que même si l'assertion était un échec dans le premier cas de test (verifyTitle), l'exécution s'est poursuivie jusqu'à la ligne suivante où l'instruction - 'Assertion 1 is executée' a été imprimée et seulement après l'appel de softAssert, l'exception a été lancée.
Quand utiliser une assertion dure et douce?
Si vous devez exécuter toutes les étapes d'un scénario de test à exécuter même après l'échec d'une assertion et que vous souhaitez également signaler une exception d'assertion, optez pour l'utilisation d'assertions logicielles. L'utilisation d'assertions souples dans vos scripts de test est une bonne pratique et un moyen efficace de gérer l'exécution de votre test
Si vous souhaitez que l'exécution de votre scénario de test se poursuive uniquement après qu'une assertion est passée ( Par exemple, Pour vérifier une connexion valide et exécuter ensuite les autres étapes), utilisez les affirmations concrètes.
Méthodes Junit Assert
Les différents types de méthodes Junit Assert sont expliqués ci-dessous en détail.
# 1) AssertEquals
La méthode assertequals compare le résultat attendu avec celui du résultat réel. Il lève une AssertionError si le résultat attendu ne correspond pas à celui du résultat réel et met fin à l'exécution du programme à la méthode assert equals.
Syntaxe:
public static void assertEquals(String expected, String actual)Exemple:
Chaîne attendue = 'https://www.google.com';
String actualURL = 'https://www.google.com';
Assert.assertEquals (attendu, actualURL);
# 2) AssertVrai
La méthode asserttrue affirme qu'une condition spécifiée est vraie.
Il prend en deux paramètres, c'est-à-dire que l'un est le message et l'autre est la condition contre laquelle l'assertion doit être appliquée. Il lève une AssertionError si la condition passée à la méthode asserttrue n'est pas satisfaite.
Syntaxe:
public static void assertTrue(java.lang.String message, boolean condition)message - Message à afficher en cas d'erreur d'assertion.
condition - Condition contre laquelle l'assertion doit être appliquée.
Exemple:
Assert.assertTrue («Message de test Assert True», true);
# 3) AssertFalse
assert false La méthode affirme qu'une condition spécifiée est fausse.
Il prend en deux paramètres, c'est-à-dire que l'un est le message et l'autre est la condition contre laquelle l'assertion doit être appliquée. Il lève une AssertionError si la condition passée à la méthode assertfalse n'est pas satisfaite.
Syntaxe:
public static void assertFalse(java.lang.String message, boolean condition)message - Message à afficher en cas d'erreur d'assertion.
condition - Condition contre laquelle l'assertion doit être appliquée.
Exemple:
Assert.assertFalse («Assert false test message» false);
meilleures pratiques d'automatisation dans les tests logiciels
# 4) assertNull
assert null est utilisé pour vérifier si l'objet fourni contient une valeur nulle. Il prend un objet comme paramètre et lève une AssertionError si l'objet fourni ne contient pas de valeur nulle.
Syntaxe:
public static void assertNull(Object object)Exemple:
DemoClass demo = nouvelle DemoClass ();
Assert.assertNull (démo);
# 5) AssertNotNull
assert not null est utilisé pour vérifier qu'un objet fourni ne contient pas de valeur null. Il prend un objet comme paramètre et lève une AssertionError si l'objet fourni ne contient pas de valeur nulle.
Syntaxe:
public static void assertNotNull(Object object)Exemple:
DemoClass demo = nouvelle DemoClass ();
Assert.assertNotNull (démo);
# 6) Assert
assert same method vérifie si deux objets fournis comme paramètres font référence au même objet. Il lève une AssertionError si les objets fournis ne font pas référence au même objet avec le message fourni.
Veuillez noter que Assert same compare les références des objets uniquement, mais pas les valeurs réelles.
Syntaxe:
public static void assertSame(String message, Object expected,Object actual)Exemple:
DemoClass1 demo1 = nouvelle DemoClass1 ();
DemoClass2 demo2 = nouvelle DemoClass2 ();
Assert.assertSame («Deux objets sont égaux», demo1, demo2);
# 7) AssertNotSame
assert not same vérifie que deux objets ne sont pas égaux. Si deux objets font référence au même objet, une AssertionError sera levée.
Veuillez noter que la méthode assert not same compare les références des objets et non les valeurs présentes dans les objets.
Syntaxe:
public static void assertNotSame(String message, Object expected, Object actual)Exemple:
DemoClass1 demo1 = nouvelle DemoClass1 ();
DemoClass2 demo2 = nouvelle DemoClass2 ();
Assert.assertNotSame («Deux objets ne sont pas égaux», demo1, demo2);
# 8) AssertArrayEquals
assert equals vérifie que deux tableaux d'objets sont égaux. Si les deux tableaux contiennent des valeurs nulles, ils sont considérés comme égaux. Cette méthode lève une AssertionError avec le message fourni si les deux tableaux d'objets ne sont pas considérés comme égaux.
Syntaxe:
public static void assertArrayEquals(String message, Object() expected, Object() actual)message - Message à afficher en cas d'erreur d'assertion.
attendu - Tableau d'objets.
actual - Tableau d'objets.
Exemple:
Chaîne () attendue = {'Mangue', 'Pomme', 'Banane'}
String () actual = {'Mango', 'Apple', 'Banana'}
Assert.assertArrayEquals (attendu, réel);
TestNG Assert Méthodes
Les méthodes TestNG Assert seront les mêmes que les méthodes d'assertion Junit décrites ci-dessus. Le principal différence entre Junit et TestNG les méthodes d'assertion font obstacle au traitement des assertions.
TestNG fournit des techniques de gestion des assertions plus avancées telles que les classes dépendantes, les tests de groupe, les tests paramétrés, etc.
Tutoriels vidéo sur les méthodes d'assertion TestNG
Partie I
Partie II
Partie III
# 1) AssertEquals
Cette méthode est utilisée pour affirmer si deux valeurs de données sont égales. Nous pouvons comparer les valeurs de différents types de données tels que chaîne, booléen, entier. etc. Chaque fois que les valeurs attendues et réelles sont identiques, l'assertion passe sans exception. Si ce n'est pas le cas, une AssertionError est renvoyée.
Usage : Ce type d'assertion est utilisé pour vérifier le cas où les données affichées sur la page Web sont comme prévu ou selon l'exigence spécifiée.
Syntaxe:
Assert.assertEquals(actual,expected)Paramètres:
Actuel - La valeur réelle que nous attendons de l'automatisation.
Attendu –La valeur attendue.
Exemple: Pour vérifier cela, si la page d'accueil d'Amazon a un titre disant: 'Amazon.com: achats en ligne d'électronique, de vêtements, d'ordinateurs, de livres, de DVD et plus »
@Test public void verifyTitle() { WebDriver driver = new FirefoxDriver(); driver.get(https://www.amazon.com); String ActualTitle = driver.getTitle(); String ExpectedTitle = “Amazon.com: Online Shopping for Electronics, Apparel, Computers, Books, DVDs & more”; Assert.assertEquals(ActualTitle, ExpectedTitle); System.out.println(“Assert passed”); } Console :
Assert passé.
RÉUSSI: VerifyTitle
Dans l'exemple ci-dessus, deux chaînes ont été vérifiées pour des valeurs égales. De même, l'égalité d'autres types de données tels que les entiers, les booléens, etc. peut être vérifiée.
# 2) AssertNotEquals
assertNotEquals est utilisé pour vérifier si deux valeurs de données ne sont pas égales. C'est juste l'opposé du fonctionnement de l'assertEquals Assertion. Chaque fois que les valeurs attendues et réelles correspondent, l'assertion échoue avec une exception et marque le scénario de test comme «échoué».
Usage : Ceci est utilisé dans les cas où nous voudrions vérifier que chaque donnée est unique sur une page Web. Par exemple , un annuaire téléphonique, où il n'y a pas 2 numéros de téléphone identiques.
Syntaxe:
Assert.assertNotEquals(actual,expected)Paramètres:
Actuel - La valeur réelle que nous attendons de l'automatisation.
Attendu - La valeur attendue.
Exemple: Pour vérifier que les codes PIN de deux zones différentes sont uniques / différents.
@Test // test case to verify AssertNotEquals public void verifyAssertNotEquals{ WebDriver driver = new FirefoxDriver(); driver.get('http://chennaiiq.com/chennai/pincode-by-name.php'); WebElement Adambakkam = driver.findElement(By.xpath('//table(contains(@class,'TBox'))/tbody/tr(5)/td(3)')); WebElement Aminijikarai = driver.findElement(By.xpath('//table(contains(@class,'TBox'))/tbody/tr(15)/td(3)')); String Pincode1 = Adambakkam.getText(); String Pincode2 = Aminijikarai.getText(); System.out.println('Two Unique pincodes are : ' +Pincode1 +' && '+Pincode2); Assert.assertNotEquals(Pincode1, Pincode2); System.out.println(“Assert passed”); } Console :
Deux codes PIN uniques sont: 600012 && 600001
Assert passé.
PASSÉ: verifyAssertNotEqual
# 3) AssertVrai
assertTrue est utilisé pour vérifier si une condition booléenne donnée est vraie. Cette assertion retourne true si la condition spécifiée réussit, sinon, une erreur d'assertion est levée.
Syntaxe:
Assert.assertTrue(BooleanCondition); Paramètres :
BooleanCondition - Condition pour vérifier que son type de retour est True.
Usage :
Exemple: Pour vérifier, si le bouton SignIn est présent sur la page d'accueil d'Amazon.in (affirmer pour l'affichage du bouton).
Assert.assertTrue(SignIn.isDisplayed());Ici, il vérifie si la condition booléenne - SignIn.IsDisplayed () renvoie TRUE.
Exemple: Pour vérifier si un bouton est présent sur la page Web.
@Test // Test cases for AssertTrue public void verifyAssertTrue(){ WebDriver driver = new FirefoxDriver(); driver.get('https://www.amazon.in');// Open browser and pass URL in address bar WebElement Navigation = driver.findElement(By.xpath('//*(@id='nav-link-yourAccount')')); WebElement SignInButton = driver.findElement(By.xpath('//span(text()='Sign in')')); Actions move = new Actions(driver); move.moveToElement(Navigation).build().perform(); Boolean checkButtonPresence = SignInButton.isDisplayed(); Assert.assertTrue(checkButtonPresence); System.out.println('Button is displayed'); } Console :
Le bouton est affiché
RÉUSSI: verifyAssertTrue
# 4) AssertFalse
assertFalse est utilisé pour vérifier si une condition booléenne donnée est fausse. En d'autres termes, le type de retour de la condition booléenne donnée doit être False. Cette assertion réussit si la condition spécifiée a un type de retour FALSE sinon, une erreur d'assertion est levée.
Syntaxe:
Assert.assertFlase(BooleanCondition); Paramètres :
BooleanCondition - Condition pour vérifier que son type de retour est False.
Usage : Un scénario dans lequel il peut être utilisé consiste à vérifier si un élément n'est pas présent sur une page Web après une certaine action.
Exemple 1: Le bouton de connexion ne doit pas être affiché après la connexion.
Assert.assertFalse(SignIn.isDisplayed());Ceci affirme si la condition booléenne - SignIn.IsDisplayed () renvoie FALSE.
Exemple 2:
Pour vérifier si un div disparaît après une action particulière. Donc, ici nous vérifions que le div n'est pas affiché, ou en d'autres termes, Assert pour une fausse condition sur un div affiché.
@Test // Test case for AssertFalse public void verifyAssertFalse() throws InterruptedException { WebDriver driver = new FirefoxDriver(); driver.get('https://www.irctc.co.in'); WebElement CaptchaDiv = driver.findElement(By.xpath('//div(contains(@id,'ImgContainer'))')); WebElement CheckBox = driver.findElement(By.xpath('//*(@id='otpId')')); CheckBox.click(); Assert.assertFalse(CaptchaDiv.isDisplayed()); System.out.println('Captcha div dimmed out of screen'); } Console :
Captcha div estompé hors de l'écran
RÉUSSI:verifyAssertFalse
# 5) assertNull
Cette assertion est utilisée pour vérifier si un objet a une valeur de retour nulle. En d'autres termes, il vérifie si le résultat est nul. Lorsque l'objet est Null, l'assertion est transmise sans aucune exception.
Syntaxe:
AssertNull(Object) Paramètres :
Objet - Toute valeur de données contenant une valeur nulle.
Usage:
Exemple 1:
Affirmez si une chaîne est nulle.
@Test public void verifyAssertion () throws InterruptedException { WebDriver driver = new FirefoxDriver(); driver.get('https://www.irctc.co.in'); String str1 = null; String str2 = 'hello'; AssertNull(str1); // asserts if str1 holds null value System.out.println('String holds null value – Assert passed'); } Exemple 2:
Vérifiez si la valeur du pilote est nulle avant de lancer le pilote Chrome.
@Test public void verifyAssertion () throws InterruptedException { WebDriver driver; AssertNull(driver); System.out.println('Driver is null – Assert passed'); } Ici, l’objet pilote est nul car il n’est pas lancé. Par conséquent, AssertNull (pilote) sera un succès car il a vérifié si l'objet «pilote» contient une valeur nulle
# 6) AssertNotNull
Cette assertion attend un type de retour valide, autre que la valeur Null. En d'autres termes, il recherche un objet s'il n'est pas nul. Le type de retour peut être Boolean, string, integer, list, etc. Lorsque l'objet n'est pas nul, Assertion est passé, sinon, une AssertionError est levée.
Syntaxe:
AssertNotNull(Object) Paramètres :
Objet - Toute valeur de données contenant n'importe quelle valeur de données.
Usage:
comment ouvrir un fichier .eps
Exemple 1: Assert est une chaîne contenant des données. Autrement dit, ce n'est pas nul.
@Test public void verifyAssertion () throws InterruptedException { WebDriver driver = new FirefoxDriver(); driver.get('https://www.irctc.co.in'); String str1 = null; String str2 = 'hello'; AssertNotNull(str2); // asserts if str2 holds some value System.out.println('String holds null value – Assert passed'); } Exemple 2: Vérifiez que l'objet pilote n'est pas nul, après avoir lancé FirefoxDriver.
@Test public void verifyAssertion () throws InterruptedException { WebDriver driver; WebDriver driver = new FirefoxDriver(); AssertNotNull(driver); System.out.println('Driver is null – Assert passed'); } Ici, l’objet pilote est initié au pilote firefox et par conséquent, l’objet «pilote» a une certaine valeur car il n’est pas lancé. Par conséquent, AssertNotNull (pilote) sera un succès car il a vérifié si l'objet «pilote» ne contient pas de valeur nulle
Cliquez sur ici pour des exemples de cas de test.
Exemples de programmes pour les assertions
Affirmer égal:
package Demo; import org.junit.Assert; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionDemo { public static void main(String() args) throws InterruptedException{ String sValue = 'Assert Equals Test'; Assert.assertEquals('Assert Equals Test', sValue); System.out.println('Test Passed'); } }Explication du code:
Le code ci-dessus illustre l'utilisation de la méthode AssertEquals en termes simples.
- Comme indiqué précédemment, assert equals prend en compte deux paramètres, à savoir le résultat attendu et le résultat réel. Si le résultat attendu ne correspond pas à celui du résultat réel, alors une erreur d'assertion sera générée et l'exécution du programme se terminera à la méthode assert equals.
- Le code ci-dessus compare la valeur de chaîne définie par l'utilisateur à la valeur de chaîne attendue.
- Veuillez noter qu'en temps réel, le résultat réel sera une opération définie par l'utilisateur pour laquelle la valeur sera récupérée au moment de l'exécution et transmise en paramètre à la méthode assert equals.
Affirmer vrai:
package Demo; import org.junit.Assert; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionsDemo1 { public static void main(String() args) throws InterruptedException{ String expectedTitle = 'Google'; System.setProperty('webdriver.gecko.driver','D:\Data_Personal\Demo\geckodriver-v0.23.0-win64\geckodriver.exe'); WebDriver driver = new FirefoxDriver(); driver.get('https://www.google.com'); Assert.assertTrue('Title does not match', expectedTitle.equals(driver.getTitle())); driver.close(); } }Explication du code:
Le code ci-dessus illustre l'utilisation de la méthode assertTrue.
- Nous transmettons initialement le titre de page attendu à une variable. Nous instancions ensuite un objet du pilote Firefox et le naviguons vers la page Web - https://www.google.com
- Plus tard, en utilisant la méthode assertsTrue, nous comparons le titre de la page ouverte avec celui du titre de page attendu. Si le titre de la page ouverte ne correspond pas à celui du titre attendu, une erreur d'assertion sera renvoyée et l'exécution du programme sera interrompue à la méthode assertTrue.
- Le code ci-dessus ne sera exécuté avec succès que lorsque le titre de page réel correspond à celui du titre de page attendu.
Affirmer faux:
package Demo; import org.junit.Assert; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionsDemo1 { public static void main(String() args) throws InterruptedException{ String expectedTitle = 'Google1'; System.setProperty('webdriver.gecko.driver','D:\Data_Personal\Demo\geckodriver-v0.23.0-win64\geckodriver.exe'); WebDriver driver = new FirefoxDriver(); driver.get('https://www.google.com'); Assert.assertFalse('Title does match', expectedTitle.equals(driver.getTitle())); driver.close(); } }Explication du code:
Le code ci-dessus illustre l'utilisation de la méthode assertfalse.
- Nous transmettons initialement le titre de page attendu à une variable, puis instancions un objet du pilote Firefox et naviguons vers la page Web - https://www.google.com
- Plus tard, en utilisant la méthode assertfalse, nous comparons le titre de la page ouverte avec celui du titre de page attendu. Si le titre de la page ouverte correspond à celui du titre attendu, alors une erreur d'assertion sera générée et l'exécution du programme se terminera à la méthode assert false.
- Le code ci-dessus ne sera exécuté avec succès que lorsque le titre réel de la page ne correspond pas à celui du titre de page attendu.
Code de bout en bout pour les assertions
Vous trouverez ci-dessous un exemple de code de bout en bout pour les assertions. Nous avons utilisé le scénario suivant à des fins de simplicité.
Scénario:
- Ouvrez la page Web: https://www.google.com sur le navigateur Firefox.
- Vérifiez si le titre de la page ouverte est équivalent à celui du titre de page attendu à l'aide de la méthode asserttrue.
- Dans la zone de texte de recherche, entrez le mot-clé de recherche: Sélénium.
- Appuyez sur le bouton Entrée du clavier.
- Vérifiez si le titre de la page ouverte sur la page de résultats de recherche est équivalent à celui du titre de page attendu à l'aide de la méthode assertequals et de la méthode assertfalse.
- Fermez le navigateur.
Exemple de code:
packageDemo; import org.junit.Assert; import org.openqa.selenium.By; import org.openqa.selenium.Keys; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionsDemo { public static void main(String args()) throws InterruptedException { String expectedTitle = 'Google'; String expectedText = 'selenium - Google Search'; System.setProperty('webdriver.gecko.driver','D:\Data_Personal\Demo\geckodriver-v0.23.0-win64\geckodriver.exe'); // Open the web page https://www.google.com using firefox browser WebDriver driver = new FirefoxDriver(); driver.get('https://www.google.com'); // Validate if actual web page title matches with that of expected title using assert true method System.out.println('Assert true method validation'); Assert.assertTrue('Title does not match', expectedTitle.equals(driver.getTitle())); // Enter the keyword selenium on the search textbox WebElementsearchBox = driver.findElement(By.xpath('//*(@name='q')')); searchBox.sendKeys('selenium'); searchBox.sendKeys(Keys.ENTER); Thread.sleep(8000); // Validate the actual page title with expected page title using assert equals method System.out.println('Assert equals method validation'); Assert.assertEquals(expectedText, driver.getTitle()); // Page title validation using assert false method System.out.println('Assert false method validation'); Assert.assertFalse('Title does match', expectedTitle.equals(driver.getTitle())); // Close the current browser driver.close(); } }Sortie de code:
Dans un premier temps, la fenêtre du navigateur Firefox sera ouverte avec la page Web: https://www.google.com. La méthode Asserttrue vérifiera si le titre de la page ouverte correspond à celui du titre de la page attendu - Google.
Le script entrera le mot-clé de recherche comme Selenium et appuiera sur le bouton Entrée.
Les méthodes Assertfalse et assertequals comparent si le titre de la page réelle de l'écran des résultats de recherche correspond à celui du titre attendu - 'sélénium - Recherche Google'. Le navigateur sera ensuite fermé via la méthode driver.close.
Sortie de la console:
Le texte ci-dessous sera la sortie de la console sur Eclipse IDE
Évitez les erreurs courantes lors de l'utilisation de la classe Assert
1. Supposons que votre projet ait des bibliothèques JUnit, TestNG et python configurées
deux . Mais dans votre script, vous utilisez l'annotation TestNG et par erreur, vous choisissez Junit Assertion, puis votre classe Assert sera obsolète. Reportez-vous à la capture d'écran ci-dessous
3. Il est donc très important de choisir la classe Assert appropriée, pour TestNg, choisissez la seule classe Assert org.TestNG
Quatre. Pour Junit, choisissez la classe org.junit.Assert et ainsi de suite.
5. Pour effectuer une assertion souple, nous devons appeler obligatoirement la méthode assertAll ()
6. Lorsqu'une assertion échoue, elle lèvera une erreur d'assertion et non l'exception
Conclusion
Nous pouvons conclure cet article sur les affirmations dans Selenium avec les pointeurs ci-dessous:
- Une assertion est utilisée pour comparer le résultat réel d'une application avec le résultat attendu.
- Un cas de test est considéré comme réussi uniquement si toutes les assertions ont été satisfaites.
- La méthode AssertEquals compare le résultat attendu avec celui du résultat réel. Il lève une AssertionError si le résultat attendu ne correspond pas à celui du résultat réel et met fin à l'exécution du programme à la méthode assertequals.
- La méthode AssertTrue affirme qu'une condition spécifiée est vraie. Il lève une AssertionError si la condition passée à la méthode asserttrue n'est pas satisfaite.
- La méthode AssertFalse affirme qu'une condition spécifiée est fausse. Il lève une AssertionError si la condition passée pour affirmer la méthode false n'est pas satisfaite.
- Les méthodes AssertEquals, AssertTrue et AssertFalse sont les assertions les plus couramment utilisées dans Selenium.
Dans le tutoriel à venir , nous allons discuter de divers exemples utilisés dans des scénarios de projet en temps réel et comprendre comment les assertions sont utilisées en fonction de l'objectif.
Nous espérons que cet article a enrichi vos connaissances sur les assertions dans Selenium !!
=> Lisez la série de formations Easy Selenium.
lecture recommandée
- Introduction à JUnit Framework et à son utilisation dans Selenium Script - Tutoriel Selenium # 11
- Comment utiliser le framework TestNG pour créer des scripts Selenium - Tutoriel TestNG Selenium # 12
- Apprenez à utiliser les annotations TestNG dans Selenium (avec des exemples)
- Tutoriel Cucumber Selenium: Intégration Cucumber Java Selenium WebDriver
- Intégration de Selenium avec JMeter
- Introduction à Selenium WebDriver - Tutoriel Selenium # 8
- Les cadres d'automatisation de test les plus populaires avec leurs avantages et leurs inconvénients - Tutoriel Selenium # 20
- 30+ meilleurs tutoriels sur Selenium: Apprenez le sélénium avec de vrais exemples