Menu

Asserzioni in selenio utilizzando framework Junit e TestNG

  • Principale
  • Altro
  • Asserzioni in selenio utilizzando framework Junit e TestNG

assertions selenium using junit

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial sul selenio sulle asserzioni spiega cosa sono le asserzioni nel selenio e diversi tipi di asserzioni e metodi di asserzione utilizzando i framework Junit e TestNG:

miglior pulitore per PC per Windows 7 download gratuito

Le asserzioni vengono utilizzate per convalidare uno scenario di test e ci aiutano a capire se un caso di test è stato superato o meno. L'asserzione è considerata soddisfatta se il risultato effettivo di un'applicazione corrisponde a quello del risultato atteso.

Durante l'automazione delle applicazioni Web utilizzando Selenium, dobbiamo convalidare i nostri test per verificare se funzionano come previsto o meno(ovvero, se il risultato di uno scenario di test è superato / fallito).

=> Dai un'occhiata alla guida per principianti al selenio qui.

Un test case è considerato superato solo se tutte le asserzioni sono state soddisfatte. Le asserzioni in Selenium possono essere gestite con metodi predefiniti dei framework Junit e TestNG, che verranno spiegati in dettaglio in questo articolo.

Asserzioni in selenio

Cosa imparerai:

Asserzioni in selenio

Le asserzioni vengono utilizzate per eseguire vari tipi di convalida nei casi di test, il che a sua volta ci aiuta a decidere se il caso di test è stato superato o meno. WConsideriamo un test positivo se viene eseguito senza eccezioni.

Tutorial video sulle asserzioni

Tipi di asserzioni nel selenio

Esistono due tipi di asserzioni in Selenium e la classificazione dipende da come si comporta l'asserzione dopo che una condizione è passata o meno.

Qui, discuteremo due tipi di asserzioni in Selenio :

  • Affermazioni dure
  • Asserzioni soft

Fare clic qui per un campione casi test per testare le asserzioni.

# 1) Asserzioni dure (o semplicemente asserzioni)

Un'asserzione difficile non continua con l'esecuzione finché la condizione di asserzione non viene soddisfatta.

Le asserzioni rigide di solito generano un errore di asserzione ogni volta che una condizione di asserzione non è stata soddisfatta. Lo scenario di test verrà immediatamente contrassegnato come Non riuscito quando una condizione di asserzione effettiva non riesce.

Uno scenario per utilizzare questo tipo di asserzione è che, quando si desidera verificare se si è effettuato l'accesso correttamente e non si supera il test se non si è effettuato un accesso riuscito, poiché non ha senso procedere ulteriormente se la pre-condizione ( login) stesso fallisce.

Prendiamo un altro esempio illustrato qui:

Considera un caso di prova per affermare il titolo di una pagina 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(); }

Affermazioni dure

Nell'esempio, la variabile 'ActualTitle' manterrà il testo del titolo dall'automazione. 'ExpectedTitle' contiene i dati della stringa previsti. Assert.assertEquals () verifica se entrambi i testi sono uguali. Il test case precedente passerà e continuerà alla riga di esecuzione successiva poiché il testo effettivo e il testo previsto sono gli stessi.

Console:
Affermare superato.
SUPERATO: VerifyTitle

Risultato asserzioni rigide 1

Lo stesso test case quando non è riuscito genererà un'eccezione e interromperà l'esecuzione in quell'istanza.

Ora, cambiamo il titolo previsto con quello sbagliato.

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:previsto (Benvenuto in Amazon)matrovato (Amazon.com: acquisti online di elettronica, abbigliamento, computer, libri, DVD e altro)

Risultato asserzioni dure 2

Dalla console, possiamo vedere che l'istruzione print è stata ignorata (System.out.println) poiché si è verificato un errore nell'istruzione Assert e ha generato un'eccezione.

# 2) Asserzioni soft

Un'asserzione soft continua con il passaggio successivo dell'esecuzione del test anche se la condizione di asserzione non è soddisfatta.

Le asserzioni soft sono il tipo di asserzioni che non generano automaticamente un'eccezione quando un'asserzione non riesce a meno che non venga richiesta. Ciò è utile se si eseguono più convalide in un modulo, di cui solo poche convalide hanno un impatto diretto sulla decisione dello stato del test case.

Qui, utilizziamo una classe chiamata SoftAssert e il metodo assertAll () viene chiamato per generare tutte le eccezioni rilevate durante l'esecuzione. Quando viene utilizzato softAssert, esegue l'asserzione e se viene trovata un'eccezione, non viene lanciata immediatamente, ma continua fino a quando non chiamiamo il metodo assertAll () per generare tutte le eccezioni catturate.

È consigliabile utilizzare diversi oggetti della classe 'SoftAssert' per ogni caso di test.

Considera il caso di test per affermare il titolo della pagina

Nell'esempio seguente, vengono creati due oggetti della classe 'SoftAssert' per essere utilizzati in due diversi casi di test.

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:

Titolo effettivo: Amazon.com: acquisti online di elettronica, abbigliamento, computer, libri, DVD e altro
L'asserzione 1 viene eseguita
Viene visualizzata l'icona
L'asserzione 2 viene eseguita

Risultato delle asserzioni soft 1

java.lang.AssertionError: le seguenti affermazioni non sono riuscite:

previsto (Benvenuto in Amazon) ma trovato (Amazon.com: acquisti online di elettronica, abbigliamento, computer, libri, DVD e altro)

Risultato delle asserzioni soft 2

Dalla console, possiamo capire che anche se l'asserzione è stata un errore nel primo caso di test (verifyTitle), l'esecuzione è continuata alla riga successiva in cui è stata stampata l'istruzione 'Assertion 1 is execute' e solo dopo che softAssert è stato chiamato, l'eccezione è stata generata.

Quando utilizzare l'asserzione hard e soft?

Se è necessario eseguire tutti i passaggi di uno scenario di test da eseguire anche dopo che un'asserzione ha esito negativo e si desidera anche segnalare un'eccezione di asserzione, optare per l'utilizzo di Soft Assertions. L'utilizzo di Soft Assertions negli script di test è una buona pratica e un modo efficace per gestire l'esecuzione del test

Se desideri che l'esecuzione del test case proceda solo dopo che un'asserzione è stata superata ( Per esempio, Per verificare un accesso valido e solo dopo eseguire gli altri passaggi), quindi utilizzare Asserzioni rigide.

Junit Assert Methods

I vari tipi di metodi Junit Assert sono spiegati di seguito in dettaglio.

# 1) asserisci uguale

Il metodo assertequals confronta il risultato atteso con quello del risultato effettivo. Genera un'eccezione AssertionError se il risultato atteso non corrisponde a quello del risultato effettivo e termina l'esecuzione del programma con il metodo assert equals.

Sintassi:

public static void assertEquals(String expected, String actual)

Esempio:

Stringa prevista = 'https://www.google.com';

String actualURL = 'https://www.google.com';

Assert.assertEquals (expected, actualURL);

# 2) asserisci vero

Il metodo asserttrue afferma che una condizione specificata è vera.

Accetta due parametri, ovvero uno è il messaggio e l'altro è la condizione a cui deve essere applicata l'asserzione. Genera un'eccezione AssertionError se la condizione passata al metodo asserttrue non è soddisfatta.

Sintassi:

public static void assertTrue(java.lang.String message, boolean condition)

messaggio - Messaggio da visualizzare in caso di errore di asserzione.
condizione: condizione rispetto alla quale deve essere applicata l'asserzione.

Esempio:

Assert.assertTrue ('Assert True test message', true);

# 3) asserisci Falso

Il metodo assert false afferma che una condizione specificata è falsa.

Accetta due parametri, ovvero uno è il messaggio e l'altro è la condizione alla quale deve essere applicata l'asserzione. Genera un'eccezione AssertionError se la condizione passata al metodo assertfalse non è soddisfatta.

Sintassi:

public static void assertFalse(java.lang.String message, boolean condition)

messaggio - Messaggio da visualizzare in caso di errore di asserzione.
condizione: condizione rispetto alla quale deve essere applicata l'asserzione.

Esempio:

Assert.assertFalse ('Assert false test message' false);

# 4) asserisciNullo

assert null viene utilizzato per verificare se l'oggetto fornito contiene un valore null. Prende un oggetto come parametro e genera un AssertionError se l'oggetto fornito non contiene un valore nullo.

Sintassi:

public static void assertNull(Object object)

Esempio:

DemoClass demo = nuova DemoClass ();
Assert.assertNull (demo);

# 5) assertNotNull

assert not null viene utilizzato per verificare che un oggetto fornito non contenga un valore null. Accetta un oggetto come parametro e genera un'eccezione AssertionError se l'oggetto fornito non contiene un valore nullo.

Sintassi:

public static void assertNotNull(Object object)

Esempio:

DemoClass demo = nuova DemoClass ();
Assert.assertNotNull (demo);

# 6) asserisci lo stesso

assert stesso metodo controlla se due oggetti forniti come parametri fanno riferimento allo stesso oggetto. Genera un'eccezione AssertionError se gli oggetti forniti non fanno riferimento allo stesso oggetto con il messaggio fornito.

Si noti che Assert stesso confronta solo i riferimenti degli oggetti, ma non i valori effettivi.

Sintassi:

public static void assertSame(String message, Object expected,Object actual)

Esempio:

DemoClass1 demo1 = new DemoClass1 ();
DemoClass2 demo2 = nuova DemoClass2 ();
Assert.assertSame ('Due oggetti sono uguali', demo1, demo2);

# 7) assertNotSame

assert not same verifica che due oggetti non siano uguali. Se due oggetti fanno riferimento allo stesso oggetto, verrà lanciato un AssertionError.

Si noti che il metodo assert non stesso confronta i riferimenti degli oggetti e non i valori presenti negli oggetti.

Sintassi:

public static void assertNotSame(String message, Object expected, Object actual)

Esempio:

DemoClass1 demo1 = new DemoClass1 ();
DemoClass2 demo2 = nuova DemoClass2 ();
Assert.assertNotSame ('Due oggetti non sono uguali', demo1, demo2);

quanto è buono Ubuntu rispetto a Windows

# 8) assertArrayEquals

assert equals verifica che due array di oggetti siano uguali. Se entrambi gli array contengono valori nulli, vengono considerati uguali. Questo metodo genera un'eccezione AssertionError con il messaggio fornito se entrambi gli array di oggetti non sono considerati uguali.

Sintassi:

public static void assertArrayEquals(String message, Object() expected, Object() actual)

messaggio - Messaggio da visualizzare in caso di errore di asserzione.
previsto: array di oggetti.
effettivo: matrice di oggetti.

Esempio:

Stringa () prevista = {'Mango', 'Apple', 'Banana'}

Stringa () effettiva = {'Mango', 'Apple', 'Banana'}

Assert.assertArrayEquals (previsto, effettivo);

Metodi di asserzione TestNG

I metodi di asserzione TestNG saranno gli stessi dei metodi di asserzione Junit discussi sopra. Il sindaco differenza tra Junit e TestNG i metodi di asserzione ostacolano la gestione delle asserzioni.

TestNG fornisce tecniche di gestione delle asserzioni più avanzate come classi dipendenti, test di gruppo, test parametrizzati, ecc.

Esercitazioni video sui metodi di asserzione di TestNG

Parte I

Seconda parte

Parte III

# 1) asserisci uguale

Questo metodo viene utilizzato per affermare se due valori di dati sono uguali. Possiamo confrontare i valori di diversi tipi di dati come string, boolean, integer. ecc. Ogni volta che i valori attesi ed effettivi coincidono, l'asserzione viene accettata senza eccezioni. In caso contrario, viene generata un'eccezione AssertionError.

Utilizzo : Questo tipo di asserzione viene utilizzato per verificare il caso in cui i dati visualizzati nella pagina web siano quelli previsti o secondo il requisito specificato.

Sintassi:

Assert.assertEquals(actual,expected)

Parametri:

attuale - Il valore effettivo che ci aspettiamo dall'automazione.
Previsto –Il valore atteso.

Esempio: Per verificarlo, se la home page di Amazon ha un titolo che dice 'Amazon.com: acquisti online di elettronica, abbigliamento, computer, libri, DVD e altro '

@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:

Affermare superato.
SUPERATO: VerifyTitle

Nell'esempio precedente, due stringhe sono state verificate per valori uguali. Allo stesso modo, è possibile verificare l'uguaglianza di altri tipi di dati come numeri interi, booleani, ecc.

# 2) assertNotEquals

assertNotEquals viene utilizzato per verificare se due valori di dati non sono uguali. È esattamente l'opposto del funzionamento di assertEquals Assertion. Ogni volta che i valori attesi ed effettivi corrispondono, l'asserzione fallisce con un'eccezione e contrassegna lo scenario di test come 'non riuscito'.

Utilizzo : Viene utilizzato nei casi in cui desideriamo verificare che ogni dato sia unico su una pagina web. Per esempio , un elenco telefonico, dove non ci sono 2 numeri di telefono uguali.

Sintassi:

Assert.assertNotEquals(actual,expected)

Parametri:

attuale - Il valore effettivo che ci aspettiamo dall'automazione.
Previsto - Il valore atteso.

Esempio: Verificare che i codici pin di due diverse aree siano univoci / non uguali.

@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:

Due codici PIN Unique sono: 600012 e 600001

Affermare superato.
SUPERATO: verifyAssertNotEqual

# 3) asserisci Vero

assertTrue viene utilizzato per verificare se una determinata condizione booleana è vera. Questa asserzione restituisce true se la condizione specificata viene soddisfatta, in caso contrario viene generato un errore di asserzione.

Sintassi:

Assert.assertTrue(BooleanCondition);

Parametri :
BooleanCondition - Condizione per verificare che il tipo restituito sia True.

Utilizzo :

Esempio: Da verificare, se il pulsante Accedi è presente nella home page di Amazon.in (asserire per la visualizzazione del pulsante).

Assert.assertTrue(SignIn.isDisplayed());

Qui, verifica se la condizione booleana - SignIn.IsDisplayed () restituisce TRUE.

Esempio: Per verificare se un pulsante è presente nella pagina 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:

Viene visualizzato il pulsante
SUPERATO: verifyAssertTrue

# 4) asserisci Falso

assertFalse viene utilizzato per verificare se una determinata condizione booleana è falsa. In altre parole, il tipo di ritorno della condizione booleana data dovrebbe essere False. Questa asserzione viene superata se la condizione specificata ha un tipo restituito FALSE in caso contrario, viene generato un errore di asserzione.

Sintassi:

Assert.assertFlase(BooleanCondition);

Parametri :
BooleanCondition - Condizione per verificare che il tipo restituito sia False.

Utilizzo : Uno scenario in cui può essere utilizzato è verificare se un elemento non è presente in una pagina web dopo una determinata azione.

Esempio 1: Il pulsante di accesso non dovrebbe essere visualizzato dopo il login.

Assert.assertFalse(SignIn.isDisplayed());

Questo afferma se la condizione booleana - SignIn.IsDisplayed () restituisce FALSE.

Esempio 2:

Per verificare se un div scompare dopo una particolare azione. Quindi, qui verifichiamo che il div non sia visualizzato, o in altre parole, Assert per una condizione falsa su un div visualizzato.

@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:

Il div captcha si è oscurato sullo schermo
PASSATO:verificaAssertFalse

# 5) asserisciNullo

Questa asserzione viene utilizzata per verificare se un oggetto ha un valore restituito nullo. In altre parole, controlla se il risultato è nullo. Quando l'oggetto è Null, l'asserzione viene passata senza eccezioni.

Sintassi:

AssertNull(Object)

Parametri :
Oggetto - Qualsiasi valore di dati che contiene un valore nullo.

Utilizzo:

Esempio 1:

Asserisci se una stringa è nulla.

@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'); }

Esempio 2:

Asserisci se il valore del driver è nullo prima di avviare il driver chrome.

@Test public void verifyAssertion () throws InterruptedException { WebDriver driver; AssertNull(driver); System.out.println('Driver is null – Assert passed'); }

Qui, l'oggetto driver è nullo poiché non è stato avviato. Quindi, AssertNull (driver) sarà un successo poiché ha verificato se l'oggetto 'driver' contiene un valore nullo

# 6) assertNotNull

Questa asserzione prevede un tipo restituito valido, diverso dal valore Null. In altre parole, verifica la presenza di un oggetto se non è Null. Il tipo restituito può essere Boolean, string, integer, list, ecc. Quando l'oggetto non è null, viene passato Assertion, in caso contrario, viene generato un AssertionError.

Sintassi:

AssertNotNull(Object)

Parametri :
Oggetto - Qualsiasi valore di dati che contiene qualsiasi valore di dati.

Utilizzo:

Esempio 1: Assert è una stringa che contiene alcuni dati. Cioè, non è Null.

@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'); }

Esempio 2: Verificare che l'oggetto driver non sia nullo, dopo aver avviato FirefoxDriver.

@Test public void verifyAssertion () throws InterruptedException { WebDriver driver; WebDriver driver = new FirefoxDriver(); AssertNotNull(driver); System.out.println('Driver is null – Assert passed'); }

Qui, l'oggetto driver viene avviato su firefox driver e quindi l'oggetto 'driver' ha un certo valore poiché non è avviato. Quindi, AssertNotNull (driver) sarà un successo poiché ha verificato se l'oggetto 'driver' non contiene un valore nullo

Clic Qui per casi di test campione.

Programmi di esempio per le asserzioni

Asserire uguale:

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'); } }

Spiegazione del codice:

Il codice sopra mostra l'uso del metodo AssertEquals in termini semplici.

  • Come discusso in precedenza, asserire uguale accetta due parametri, ovvero il risultato atteso e il risultato effettivo. Se il risultato atteso non corrisponde a quello del risultato effettivo, verrà generato un errore di asserzione e l'esecuzione del programma terminerà con il metodo di asserzione uguale.
  • Il codice precedente confronta il valore di stringa definito dall'utente con il valore di stringa previsto.
  • Si noti che in tempo reale, il risultato effettivo sarà un'operazione definita dall'utente per la quale il valore verrà recuperato in fase di esecuzione e passato come parametro al metodo assert equals.

Asserisci vero:

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(); } }

Spiegazione del codice:

Il codice precedente dimostra l'utilizzo del metodo assertTrue.

  • Inizialmente stiamo passando il titolo della pagina previsto su una variabile. Stiamo quindi creando un'istanza di un oggetto del driver firefox e navigando nella pagina web - https://www.google.com
  • Successivamente, utilizzando il metodo assertsTrue stiamo confrontando il titolo della pagina aperta con quello del titolo della pagina previsto. Se il titolo della pagina aperta non corrisponde a quello del titolo previsto, verrà generato un errore di asserzione e l'esecuzione del programma verrà terminata con il metodo assertTrue.
  • Il codice precedente verrà eseguito correttamente solo quando il titolo della pagina effettivo corrisponde a quello del titolo della pagina previsto.

Afferma falso:

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(); } }

Spiegazione del codice:

Il codice precedente dimostra l'utilizzo del metodo assertfalse.

  • Inizialmente stiamo passando il titolo della pagina previsto su una variabile, quindi creiamo un'istanza di un oggetto del driver Firefox e stiamo navigando alla pagina web - https://www.google.com
  • Successivamente, utilizzando il metodo assertfalse, stiamo confrontando il titolo della pagina aperta con quello del titolo della pagina previsto. Se il titolo della pagina aperta corrisponde a quello del titolo atteso, verrà generato un errore di asserzione e l'esecuzione del programma verrà terminata con il metodo assert false.
  • Il codice precedente verrà eseguito correttamente solo quando il titolo della pagina effettivo non corrisponde a quello del titolo della pagina previsto.

Codice end-to-end per asserzioni

Di seguito è riportato un esempio di codice end-to-end per le asserzioni. Abbiamo utilizzato il seguente scenario per motivi di semplicità.

Scenario:

  • Apri la pagina web: https://www.google.com nel browser Firefox.
  • Verificare se il titolo della pagina aperta è equivalente a quello del titolo della pagina previsto utilizzando il metodo asserttrue.
  • Nella casella di testo di ricerca, inserisci la parola chiave di ricerca: Selenio.
  • Premi il pulsante Invio sulla tastiera.
  • Verifica se il titolo della pagina aperta nella pagina dei risultati di ricerca è equivalente a quello del titolo della pagina previsto utilizzando il metodo assertequals e il metodo assertfalse.
  • Chiudi il browser.

Codice di esempio:

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(); } }

Uscita codice:

Inizialmente, verrà aperta la finestra del browser Firefox con la pagina web: https://www.google.com. Il metodo Asserttrue verificherà se il titolo della pagina aperta corrisponde a quello del titolo della pagina previsto: Google.

.net framework intervista domande e risposte

Home page di Google

Lo script inserirà la parola chiave di ricerca come Selenium e premerà il pulsante Invio.

Cerca su Google

I metodi Assertfalse e Assertequals confrontano se il titolo della pagina effettivo della schermata dei risultati di ricerca corrisponde a quello del titolo previsto: 'selenio - Ricerca Google'. Il browser verrà quindi chiuso tramite il metodo driver.close.

Asserzioni Demo

Uscita console:

Il testo fornito di seguito sarà l'output della console su Eclipse IDE

Uscita console

Evita errori comuni durante l'utilizzo di Assert Class

1. Supponiamo che il tuo progetto abbia le librerie JUnit, TestNG e python configurate

Due . Ma nel tuo script, stai usando l'annotazione TestNG e per errore, scegli Junit Assertion, quindi la tua classe Assert sarà deprecata. Fare riferimento alla schermata sottostante

Junit Assertion

La classe Assert sarà deprecata

3. Quindi è molto importante scegliere la classe Assert corretta, poiché TestNg scegliere l'unica classe Assert org.TestNG

Quattro. Per Junit scegli la classe org.junit.Assert e così via.

5. Per eseguire l'asserzione soft dobbiamo chiamare obbligatoriamente il metodo assertAll ()

6. Quando un'asserzione fallisce, verrà generato un errore di asserzione, non un'eccezione

Conclusione

Possiamo concludere questo articolo sulle asserzioni in selenio con i seguenti suggerimenti:

  • Un'asserzione viene utilizzata per confrontare il risultato effettivo di un'applicazione con il risultato previsto.
  • Un test case è considerato superato solo se tutte le asserzioni sono state soddisfatte.
  • Il metodo AssertEquals confronta il risultato atteso con quello del risultato effettivo. Genera un'eccezione AssertionError se il risultato atteso non corrisponde a quello del risultato effettivo e termina l'esecuzione del programma con il metodo assertequals.
  • Il metodo AssertTrue afferma che una condizione specificata è vera. Genera un'eccezione AssertionError se la condizione passata al metodo asserttrue non è soddisfatta.
  • Il metodo AssertFalse afferma che una condizione specificata è falsa. Genera un'eccezione AssertionError se la condizione passata per affermare il metodo falso non è soddisfatta.
  • I metodi AssertEquals, AssertTrue e AssertFalse sono le asserzioni più comunemente utilizzate in Selenium.

Nel prossimo tutorial , discuteremo vari esempi utilizzati in scenari di progetto in tempo reale e capiremo come le asserzioni vengono utilizzate in base allo scopo.

Speriamo che questo articolo abbia arricchito le tue conoscenze sulle asserzioni in selenio !!

=> Leggere attraverso la serie di formazione Easy Selenium.

Lettura consigliata

^