Meny

Topp 10 selenundantag och hur man hanterar dessa (exakt kod)

top 10 selenium exceptions

Prova Vårt Instrument För Att Eliminera Problem

Hantering av Selen WebDriver-undantag med hjälp av ramverk för undantagshantering - Selen-handledning nr 19

Att få ett undantag i automatiseringskod är mycket vanligt. ”Undantag” som ordet antyder är ett speciellt eller ovanligt fall.

Körning av automatiseringskod utförs vanligtvis inte som förväntat på grund av många faktorer som är involverade i körning, såsom nätverksstabilitetsproblem, internetproblem, serverstabilitet etc. Vi kan få undantag på grund av otillräcklig väntetid eller felaktiga syntaxer, parametrar etc.

Undantagshantering i Selen 2

I den senaste WebDriver-självstudien lärde vi oss om tre olika typer av viktiga webbelement som Webbtabeller, ramar och dynamiska element och deras hanteringsmekanismer i selen-skript

Innan du går vidare med Framework-självstudier i detta Selenutbildning här i denna handledning kommer vi att lära oss mer om typer av undantag och hur man hanterar undantag i Java- och Selen-skript . Utvecklare / testare använder ramverk för undantagshantering för att hantera ett undantag i selenskript.

Vad du kommer att lära dig:

Vad är ett undantag?

Undantag är händelser på grund av vilka Java-programmet slutar plötsligt utan att ge förväntat resultat. Java ger ett ramverk där en användare kan hantera undantag.

Processen för hantering av undantag kallas Exception Handling.

Undantag måste hanteras eftersom de bryter det normala genomförandet av ett program. En av de viktiga avsikterna med undantagshantering är att förhindra detta avbrott och fortsätta programkörningen. Ibland kanske du vill utföra några serier av åtgärder om ett visst undantag inträffar.

När ett undantag inträffar skapas ett undantagsobjekt som tekniskt kallas ” Kasta ett undantag ” och vi lägger till Försök fånga block som,

try { // Protected code } catch (ExceptionName e) { // Catch block }

# 1) Den kod som kan kasta ett undantag läggs till i försöksblocket.

#två) Catch-uttalandet fångar undantaget och tar det som en parameter.

# 3) När inget undantag kastas körs försöksuttrycket och inte fångstuttrycket.

Exempel : När selen-skript misslyckas på grund av fel sökare, bör utvecklaren kunna förstå orsaken till misslyckandet och detta kan enkelt uppnås om undantaget hanteras ordentligt i programmet.

Enligt min erfarenhet är det bäst att försöka undvika undantag från WebDriver när det är möjligt och fånga verkligt exceptionella fall. Använd try / catch för att hantera saker som går fel och som ligger utanför min kontroll.

Undvik de jag kan fånga andra!

Det här är den bästa strategin som har fungerat för mig.

Till exempel, överväga en testsida som tar längre tid än vanligt att ladda på en testserver. Vi får frekventa undantag när vi gör åtgärder på den här sidan. Så istället för att bara fånga det här varje gång kan vi

  • Lägg till ett väntkommando och försök att undvika ett undantag
  • Använd “Try / Catch” för att hantera om ett verkligt exceptionellt fall har inträffat

Därmed minskar risken för undantag.

Undantag i selen webdriver

Fördelar och nackdelar med tillvägagångssättet Undvik-hantera

Fördelar

Nackdelar

1) Detta tillvägagångssätt minskar risken för att få undantag.1) Ökar kodraderna eftersom du lägger till extra kod för att undvika undantag
Om ett undantag fortfarande fångas skulle det 2) vara ett verkligt exceptionellt fall som är värt att kontrollera2) Bör ha en bättre förståelse för Web Driver API, kommandon och undantag
Minska felsökningstiden. Automationskoden är avsedd att hitta fel och du vill inte se för många oönskade 3) undantag och hitta orsakerna bakom var och en av dem
4) I Catch-blocket hanterar du mer giltiga fall
5) Minska falska fel
6) Tydligare rapport

I denna handledning kommer vi att diskutera Undvik och hantera metod för de 10 vanligaste undantagen i Selenium WebDriver. Innan det får vi en grundläggande förståelse för Exception Handling och Try / Catch-block.

Typer av undantag i Java och Selen

Nedan har vi beskrivit vilka typer av undantag och olika sätt hur vi kan använda ramar för undantagshantering i selenskript.

Det finns tre typer av undantag:

  1. Kontrollerat undantag
  2. Okontrollerat undantag
  3. Fel

Klasshierarkin för undantag och fel:

Undantagshantering i selen

# 1) Kontrollerat undantag: Kontrollerat undantag hanteras under kompileringstiden och det ger kompileringsfelet om det inte fångas och hanteras under kompileringstiden.

Exempel : FileNotFoundException , IO-undantag etc.

# 2) Okontrollerat undantag: I händelse av det okontrollerade undantaget har en kompilator inte mandat att hantera. Kompilatorn ignorerar under kompileringstiden.

Exempel : ArrayIndexoutOfBoundException

# 3) Fel: När ett scenario är dödligt och programmet inte kan återhämta sig, kastar JVM ett fel. Fel kan inte hanteras av try-catch blocket. Även om användaren försöker hantera felet med Try catch-blocket kan det inte återhämta sig från felet.

Exempel : Påståendefel , OutOfMemoryError etc.

Undantagshantering

Försök och fånga block:

försök fånga block används vanligtvis för att hantera undantag. Typ av undantag anges i fångstblock som förväntas komma. När ett undantag kommer i försöksblock, flyttar kontrollen omedelbart till fångsten.

Exempel :

try { br = new BufferedReader(new FileReader('Data')); } catch(IOException ie) { ie.printStackTrace(); }

Det kan finnas flera fångstycken för ett försöksblock beroende på vilken typ av undantag.

Exempel :

try { br = new BufferedReader(new FileReader('Data')); } catch(IOException ie) { ie.printStackTrace(); } catch(FileNotFoundException file){ file.printStackTrace(); }

kastar Undantag:

kastar nyckelordet i java används för att kasta ett undantag istället för att hantera det. Alla kontrollerade undantag kan kastas med metoder.

Exempel :

public static void main(String() args) throws IOException { BufferedReader br=new BufferedReader(new FileReader('Data')); while ((line = br.readLine()) != null) { System.out.println(line); } }

till sist blockera:

till sist , block exekverar oavsett exekvering av try-catch block och det körs omedelbart efter att try / catch block har slutförts.

I grund och botten kan filstängning, databasanslutning etc. stängas i slutgiltigt block.

Exempel :

try { br = new BufferedReader(new FileReader('Data')); } catch(IOException ie) { ie.printStackTrace(); } Finally { br.close(); }

I exemplet ovan, BufferReader strömmen stängs i slutligen block. br.close () kommer alltid att köras oavsett utförandet av försök och fångstblock.

Notera : slutligen kan block existera utan några fångstblock. Det är inte nödvändigt att ha ett fångstblock alltid.

Det kan finnas många fångstycken men endast ett slutgiltigt block kan användas.

Kastbar : Throwable är en överordnad klass för fel och undantag. Generellt är det svårt att hantera fel i Java. Om en programmerare inte är säker på typen av fel och undantag rekommenderas det att använda Throwable-klassen som kan fånga både fel och undantag.

Exempel :

try { br = new BufferedReader(new FileReader('Data')); } catch (Throwable t) { t.printStackTrace(); }

Vanliga undantag i Selen WebDriver

Selen har sina egna undantag. Medan man utvecklar selen-skript måste en programmerare hantera eller kasta undantagen.

Nedan följer några exempel på undantag i selen:

Alla runtime-undantagsklasser i Selenium WebDriver omfattas av superklassen WebDriverException.

Webdriver undantag

standardgatewayen är inte tillgänglig hela tiden

Även om det finns många undantagsklasser under WebDriverException, ser vi ofta nedanstående.

  • NoSuchElementException
  • NoSuchWindowException
  • NoSuchFrameException
  • NoAlertPresentException
  • InvalidSelectorException
  • ElementNotVisibleException
  • ElementNotSelectableException
  • TimeoutException
  • NoSuchSessionException
  • StaleElementReferenceException

Detaljer :

ElementNotVisibleException : Om selen försöker hitta ett element men elementet inte syns på sidan

NoAlertPresentException : Om en användare försöker hantera en varningsruta men varningen inte finns.

NoSuchAttributeException : Under försök att få attributvärde men attributet är inte tillgängligt i DOM.

NoSuchElementException : Detta undantag beror på åtkomst till ett element som inte är tillgängligt på sidan.

WebDriverException : Undantag kommer när en kod inte kan initiera WebDriver.

Undvika och hantera vanliga undantag

Låt oss diskutera tillvägagångssättet Undvik och hanter för ovan nämnda undantag:

# 1) org.openqa.selenium.NoSuchElementException

Denna vanliga undantagsklass är en underklass av NotFoundException klass. Undantaget inträffar när WebDriver inte kan hitta och hitta element.

Vanligtvis händer detta när testaren skriver fel elementlokaliserare i findElement (By, by) -metoden.

Tänk på att i nedanstående exempel var korrekt id för textfältet 'första fält' men testaren nämnde det felaktigt som 'nävefält'. I det här fallet kan WebDriver inte hitta elementet och org.openqa.selenium.NoSuchElementException kommer att kastas

driver.findElement(By.id('submit')).click(); Exception Handling: try { driver.findElement(By.id('submit')).click(); } catch (NoSuchElementException e)

I detta fall kastas undantaget även om elementet inte är laddat.

Undvik-och-hantering : Försök att vänta.

Exempel: Vänta kommandot nedan väntar 10 sekunder på närvaron av webbelement med id 'skicka'. Sedan försöker den klicka på den. Om elementet är tillgängligt men klicket fortfarande misslyckas fångas ett undantag.

Att använda fördröjd tid är en vanlig praxis i testautomatisering för att skapa en paus mellan stegen. Genom att lägga till en Try / Catch ser vi till att programmet fortsätter även om väntetiden inte kunde hjälpa.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.presenceOfElementLocated(By.id('submit'))); try { driver.findElement(By.id('submit')).click(); } catch (WebDriverException e) { System.out.println(“An exceptional case.”); } } catch (TimeOutException e) { System.out.println(“WebDriver couldn’t locate the element”); }

# 2) org.openqa.selenium.NoSuchWindowException

NoSuchWindowException kommer under NotFoundException klass. Detta kastas när WebDriver försöker växla till ett ogiltigt fönster.

Koden nedan kan kasta org.openqa.selenium.NoSuchWindowException om fönsterhandtaget inte finns eller inte finns att byta.

driver.switchTo (). fönster (handtag_1);

Undvik-och-hantering : Vi skulle använda fönsterhandtag för att få uppsättningen aktiva fönster och sedan utföra åtgärder på samma.

I exemplet nedan, för varje fönsterhandtag, körs förarens växling till. Därför minskade chanserna för att skicka fel felparameter.

for (String handle : driver.getWindowHandles()) { try { driver.switchTo().window(handle); } catch (NoSuchWindowException e) { System.out.println(“An exceptional case”); } }

# 3) org.openqa.selenium.NoSuchFrameException

När WebDriver försöker växla till en ogiltig ram kastas NoSuchFrameException under NotFoundException-klassen.

Koden nedan kan kasta org.openqa.selenium.NoSuchFrameException om en ram 'frame_11' inte finns eller inte är tillgänglig.

driver.switchTo (). ram ('ram_11');

Undantagshantering:

try { driver.switchTo().frame('frame_11'); } catch (NoSuchFrameException e)

I detta fall kastas undantaget även om ramen inte är laddad.

Undvik-och-hantering : Försök att vänta.

I exemplet nedan väntar WebDriver i 10 sekunder på att ramen ska vara tillgänglig. Om ramen är tillgänglig och fortfarande finns ett undantag, fångas den.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.frameToBeAvaliableAndSwitchToIt(frame_11)); try { driver.switchTo().frame('frame_11'); } catch (WebDriverException e) { System.out.println(“An exceptional case”); } } catch (TimeOutException e) { System.out.println(“WebDriver couldn’t locate the frame”); }

# 4) org.openqa.selenium.NoAlertPresentException

NoAlertPresentException under NotFoundException kastas när WebDriver försöker växla till en varning som inte är tillgänglig.

org.openqa.selenium.NoAlertPresentException kommer att kastas Om nedanför automatiseringskod accepterar samtal () operation i Alert () -klassen när en varning ännu inte finns på skärmen.

driver.switchTo (). alert (). acceptera ();

Undantagshantering:

try { driver.switchTo().alert().accept(); } catch (NoSuchAlertException e)

I det här fallet kastas undantaget även om varningen inte laddas helt.

Undvik-och-hantering : Använd alltid uttrycklig eller flytande väntan under en viss tid i alla fall där en varning förväntas. Om varningen är tillgänglig och fortfarande finns ett undantag, fångas den.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.alertIsPresent()); try { driver.switchTo().alert().accept(); } catch (NoAlertPresentException e) { System.out.println(“An exceptional case”); } } catch (TimeOutException e) System.out.println(“WebDriver couldn’t locate the Alert”); }

# 5) org.openqa.selenium.InvalidSelectorException

Denna underklass av NoSuchElementException klass uppstår när en väljare är felaktig eller syntaktiskt ogiltig. Detta undantag förekommer ofta när XPATH-lokaliserare används.

Tänk på exemplet nedan:

klicka påXPathButtonAndWait (“// knapp (@ typ =’ knapp ’) (100)”);

Detta skulle kasta ett InvalidSelectorExeption eftersom XPATH-syntaxen är felaktig.

Undvik och hantera : För att undvika detta bör vi kontrollera lokaliseraren som används eftersom sökaren sannolikt är felaktig eller syntaxen är fel. Användning av Firebug för att hitta xpath kan minska detta undantag.

Nedanstående kod visar hur man hanterar det med Try / Catch

try { clickXPathButtonAndWait('//button(@type='button')'); } catch (InvalidSelectorException e) { }

# 6) org.openqa.selenium.ElementNotVisibleException

ElementNotVisibleException klass är en underklass av ElementNotInteractableException klass. Detta undantag kastas när WebDriver försöker utföra en åtgärd på ett osynligt webbelement som inte kan interageras med. Det vill säga att webbelementet är i ett dolt tillstånd.

Till exempel, i koden nedan, om typen av knapp med id 'skicka' är 'dold' i HTML, org.openqa.selenium.ElementNotVisibleException kommer att kastas.

driver.findElement(By.id('submit')).click(); Exception Handling: try { driver.findElement(By.id('submit')).click(); } catch (ElementNotVisibleException e)

I det här fallet kastas undantaget även om sidan inte har laddats helt.

Undvik-och-hantering : Det finns två sätt att göra detta. Vi kan antingen använda vänta tills elementet blir helt.

Koden nedan väntar 10 sekunder på elementet. Om elementet är synligt och fortfarande undantag kastas, fångas det.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.visibilityOfElementLocated(By.id(”submit”)); try { driver.findElement(By.id('submit')).click(); } catch (WebDriverException e) { System.out.println(“Exceptional case”); } } catch (TimeOutException e) System.out.println(“WebDriver couldn’t find this element visible”); }

# 7) org.openqa.selenium.ElementNotSelectableException

Detta undantag kommer under InvalidElementStateException klass . ElementNotSelectableException indikerar att webbelementet finns på webbsidan men inte kan väljas.

Till exempel, nedanstående kod kan kasta ett ElementNotSelectableException om id 'snabb' är inaktiverad.

Välj rullgardinsmeny = ny Välj (driver.findElement (By.id (“snabb”)));

Undantagshantering:

Prova {
Välj rullgardinsmeny = ny Välj (driver.findElement (By.id (“snabb”)));
} fånga (ElementNotSelectableException e)

I detta fall kastas undantag även om elementet aktiveras efter ett tag.

Undvik-och-hantering : Vi kan lägga till ett väntkommando för att vänta tills elementet blir klickbart. Om det fortfarande finns ett undantag fångas det.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions. elementToBeClickable(By.id(”swift”)); try { Select dropdown = new Select(driver.findElement(By.id('swift'))); } catch (WebDriverException e) { System.out.println(“Exceptional case”); } } catch (TimeOutException e) System.out.println(“WebDriver found that this element was not selectable.”); }

# 8) org.openqa.selen .TimeoutException

Detta undantag inträffar när ett kommandot slutför mer än väntetiden. Väntetider används främst i WebDriver för att undvika undantaget ElementNotVisibleException.

Ibland kan testsidan kanske inte laddas helt innan nästa kommando i programmet. Om WebDriver försöker hitta ett element på webbsidan innan sidan laddas helt, kastas undantaget ElementNotVisibleException. För att undvika detta undantag läggs väntekommandon till.

Men om komponenterna inte laddas även efter väntan, undantaget org.openqa.selen .TimeoutException kommer att kastas.

driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);

driver.get (“https://www.softwaretestinghelp.com”);

I programmet ovan läggs en implicit väntan på 10 sekunder. Om sidan www.softwaretestinghelp.com laddas inte på tio sekunder, då kastas TimeoutException.

Undvik och hantera : För att undvika detta kan vi manuellt kontrollera den genomsnittliga tiden för en sida att ladda och justera väntetiden

Eller så kan vi lägga till uttrycklig väntan med JavaScript-köraren tills sidan laddas.

I exemplet nedan används JavaScript-köraren. Efter sidnavigering kallar vi JavaScript return document.readyState i 20 sekunder tills 'komplett' returneras.

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30)); wait.until(webDriver -> ((JavascriptExecutor)webDriver).executeScript('return document.readyState').equals('complete')); driver.get('https://www.softwaretestinghelp.com');

# 9) org.openqa.selenium.NoSuchSessionException

Detta undantag kastas när en metod anropas efter att WebDriver.quit () avslutat webbläsaren. Detta kan också hända på grund av problem med webbläsare som kraschar och WebDriver kan inte utföra något kommando med drivrutinsinstansen.

För att se detta undantag kan koden nedan köras.

driver.quit ()

Välj rullgardinsmeny = ny Välj (driver.findElement (By.id (“snabb”)));

Undvik och hantera : Välj alltid den senaste stabila versionen av webbläsaren för att köra Selenium Webdriver-testcases.

Detta undantag kan minskas med hjälp av driver.quit () när alla tester har slutförts. Försök inte använda dem efter varje testfall. Detta kan leda till problem när drivrutinsinstansen är ogiltig och kommande testfall försöker använda den utan att initialiseras.

Koden nedan skapar WebDriver-instans i @BeforeSuite TestiNG-anteckningen och förstör den i @AfterSuite TestiNG-anteckningen

@BeforeSuite public void setUp() throws MalformedURLException { WebDriver driver = new FirefoxDriver(); } @AfterSuite public void testDown() { driver.quit(); }

# 10) org.openqa.selenium.StaleElementReferenceException

Detta undantag säger att ett webbelement inte längre finns på webbsidan.

Det här felet är inte detsamma som ElementNotVisibleException.

StaleElementReferenceException kastas när ett objekt för ett visst webbelement skapades i programmet utan problem och dock; detta element finns inte längre i fönstret. Detta kan hända om det fanns en

  • Navigera till en annan sida
  • DOM har uppdaterats
  • En ram eller fönsterbrytare

WebElement firstName = driver.findElement (By.id (“firstname”));

driver.switchTo (). fönster (Child_Window);

element.sendKeys (“Aaron”);

java programmering intervju frågor för erfarna

I koden ovan skapades objektet förnamn och sedan byttes fönstret. Sedan försöker WebDriver att skriva ”Aaron” i formulärfältet. I det här fallet kastas StaleElementReferenceException.

Undvik och hantera : Bekräfta att vi försöker göra åtgärden i rätt fönster. För att undvika problem på grund av DOM-uppdatering kan vi använda Dynamic Xpath

Låt oss diskutera ett annat exempel.

Säg att 'id' för ett användarnamnfält är 'username_1' och XPath kommer att vara det // * (@ id = ’förnamn_1?) . När du öppnar sidan igen kan 'id' ändra till ' 'förnamn _11 '. I det här fallet misslyckas testet eftersom WebDriver inte kunde hitta elementet. I det här fallet kastas StaleElementReferenceException.

I det här fallet kan vi använda en dynamisk xpath som,

try { driver.findElement(By.xpath(“//*(contains(@id,firstname’))”)).sendKeys(“Aaron”); } catch (StaleElementReferenceException e)

I exemplet ovan används dynamisk XPATH och om undantaget fortfarande finns, fångas det.

Slutsats

Undantagshantering är den väsentliga delen av alla Java-program och selen-skript. Vi kan bygga robust och optimal kod med hanterar ett undantag på smarta sätt . Och det är också en bästa praxis att hantera undantag i ett skript som ger dig en bättre rapport när ett program misslyckas av någon anledning.

Här har vi försökt täcka processen och ramen för undantagshantering som krävs för att implementeras i selenskript.

Kom ihåg att det inte är obligatoriskt att alltid hantera undantaget i a försök fånga blockera. Du kan också kasta ett undantag beroende på kravet i ett skript.

Ett undantag bör inte ignoreras eftersom de bryter programkörningen. I den här handledningen gick vi igenom olika undantag och sätt att minska risken för att få dem genom manuella kontroller och koder.

Att lägga till väntetider kan kontrollera vissa fall som 'NoSuchElementException', 'ElementNotFoundException', 'ElementNotVisibleException'.

Nästa handledning # 20 : I den kommande handledningen skulle vi diskutera olika typer av testramar tillgängliga . Vi skulle också studera fördelar och nackdelar med att använda en avancerad ramstrategi vid automatiseringstestning. Vi skulle diskutera i detalj om det testdatadrivna ramverket.

Vänligen skicka dina frågor, relaterade till hanteringsundantag, i Selenium WebDriver, om du har några.

Rekommenderad läsning

^