Testen is een essentiële fase in softwareontwikkeling en absoluut noodzakelijk voor vlekkeloze software die aansluit bij de behoeften van de klant. Handmatig software testen kan aanzienlijk veel tijd en moeite kosten wanneer het wordt uitgevoerd door personen die onervaren zijn en niet over de vereiste vaardigheden op dit gebied beschikken.
Maar hoe zit het met machines? Dit is precies wat we in dit artikel zullen bespreken — geautomatiseerd testen met Selenium.
Selenium is een van de meest populaire en veelgebruikte open-source frameworks voor webautomatisering die het testen versnellen, menselijke fouten minimaliseren en consistente testresultaten waarborgen. Net als elk framework of hulpmiddel heeft het echter zijn eigen voor- en nadelen. Het volgende artikel behandelt de belangrijkste beperkingen en uitdagingen bij geautomatiseerd testen met Selenium, samen met mogelijke oplossingen om deze aan te pakken.
Belangrijkste uitdagingen met Selenium
Laten we dus zonder verder uitstel de meest voorkomende uitdagingen in automatiseringstesten doornemen:
1. Omgaan met pop-ups en meldingen
In webautomatisering is een melding een berichtvenster dat informatie of mededelingen voor de gebruiker bevat. Het kan aanvullende acties vereisen, zoals het invoeren van gegevens, of toestemming vragen om door te gaan met de volgende stappen. Interactie met een webapplicatie omvat het omgaan met verschillende soorten pop-ups en meldingen. Hieronder kunnen we de volgende groepen definiëren:
- Browser-niveau meldingen
- Webgebaseerde meldingen (JavaScript-meldingen)
- OS-niveau pop-ups
Browser-niveau meldingen
In deze groep kunnen we voorbeelden van meldingen opnemen zoals:
- “Ken uw locatie”
- “Krijg toegang tot camera/microfoon”
- “Toon meldingen”
Oplossingen voor browser-niveau meldingen
Aangezien deze meldingen betrekking hebben op het browseniveau, verschilt de afhandeling ervan per browser. In het geval van de Chrome-browser kunnen we bijvoorbeeld de ChromeOptions-klasse gebruiken, die specifieke methoden bevat voor het configureren van ChromeDriver-mogelijkheden. Hieronder vindt u codefragmenten voor het afhandelen van “Geolocatie” en “Meldingen” meldingen.
public class BrowserAlert {
protected WebDriver webDriver;
@BeforeMethod (alwaysRun = true)
public void setUp(){
WebDriverManager.chromedriver().setup();
// create object of ChromeOptions class
ChromeOptions options = new ChromeOptions();
// disable notifications
options.addArguments("--disable-notifications");
// disable geolocation
options.addArguments("--disable-geolocation");
webDriver = new ChromeDriver(options);
}
}
public class BrowserAlert {
protected WebDriver webDriver;
@BeforeMethod (alwaysRun = true)
public void setUp(){
WebDriverManager.chromedriver().setup();
// create Map to store preferences
Map prefs = new HashMap<>();
// set appropriate value: 1-allow; 2-block; 0-default state
// notifications
prefs.put("profile.default_content_setting_values.notifications", 1);
// geolocation
prefs.put("profile.default_content_setting_values.geolocation", 1);
// create object of ChromeOptions class
ChromeOptions options = new ChromeOptions();
// set Experimental Option - prefs
options.setExperimentalOption("prefs", prefs);
// initialize ChromeDriver with predefined settings
webDriver = new ChromeDriver(options);
}
} Webgebaseerde meldingen
Er zijn de volgende soorten meldingen in Selenium:
- Eenvoudige melding: Deze wordt gebruikt om informatie aan de gebruiker weer te geven. Een eenvoudige melding bevat een bericht met een [OK]-knop.
- Prompt melding: Deze melding bevat een tekstveld in zijn venster en wordt gebruikt wanneer de gebruiker er wat gegevens in moet invoeren.
- Bevestigingsmelding: Deze melding biedt de optie om deze te accepteren of te weigeren (met [OK] of [Annuleren] knoppen).
Oplossingen voor webgebaseerde meldingen
Meldingen, zoals hierboven vermeld, kunnen worden beheerd via de Alert-interface, die beschikbaar is in Selenium WebDriver. Deze interface biedt geschikte methoden voor interactie met meldingen:
- void accept()
- void dismiss()
- String getText()
- void sendKeys(String text)
Hieronder staan enkele codefragmenten voor het afhandelen van meldingen:
Melding accepteren:
wait.until(ExpectedConditions.alertIsPresent());
Alert alert = webDriver.switchTo().alert();
// press the [OK] button
alert.accept();Melding weigeren:
wait.until(ExpectedConditions.alertIsPresent());
Alert alert = webDriver.switchTo().alert();
// press the [Cancel] button
alert.dismiss();Tekst ophalen uit melding:
wait.until(ExpectedConditions.alertIsPresent());
Alert alert = webDriver.switchTo().alert();
// get Alert text
String alertText = alert.getText();Gegevens invoeren in tekstveld in melding:
wait.until(ExpectedConditions.alertIsPresent());
Alert alert = webDriver.switchTo().alert();
// enter text into Alert
alert.sendKeys("Sample Alert text");
alert.accept();OS-niveau pop-ups
Tijdens het automatiseringsproces van webapplicaties zijn er gevallen waarin we moeten interageren met desktop pop-ups (bijv. upload/download pop-ups, etc.). Het is echter onmogelijk om dergelijke OS-niveau pop-ups af te handelen met Selenium WebDriver, aangezien deze alleen met browsers interageert.
Oplossingen voor OS-niveau pop-ups
In dergelijke situaties moeten we tools van derden (zoals AutoIT, WinAppDriver etc.) onderzoeken en integreren, die mogelijkheden bieden om Windows-gebaseerde applicaties te automatiseren.
2. Omgaan met dynamische inhoud
Veel webapplicaties en websites bevatten dynamische web-elementen, die worden gekenmerkt door de volgende kenmerken:
- Elementen verschijnen op de pagina na een bepaalde tijd
- Elementen worden zichtbaar op de pagina na specifieke gebruikersacties
- Verschillende elementen zijn beschikbaar voor verschillende gebruikers, afhankelijk van hun vereisten
- Elementen hebben dynamische attributen (bijv. ID’s)
Het automatiseren van webapplicaties met dynamische inhoud kan uitdagend worden in automatiseringstesten met Selenium. Dit komt doordat locators voor web-elementen vaak kunnen veranderen, wat potentiële redenen voor testfouten kan veroorzaken.
Oplossingen voor het afhandelen van dynamische inhoud
Dynamische web-elementen kunnen worden beheerd met de volgende opties:
1. Gebruik van wachttijden in Selenium WebDriver (impliciet, expliciet en vloeiend)
- Impliciete wachttijd. Dit instrueert de WebDriver om een bepaalde tijd te wachten voordat een uitzondering wordt gegenereerd. Impliciete wachttijden kunnen in het volgende formaat worden gedeclareerd:
webDriver.manage().timeouts().implicitlyWait(Duration.ofSeconds(30));- Expliciete wachttijd. Dit houdt in dat de WebDriver wordt geïnstrueerd om te wachten op specifieke voorwaarden of op een maximale tijd voordat een uitzondering wordt gegenereerd. Verschillende soorten verwachte voorwaarden (als voorbeelden), die kunnen worden gebruikt in Expliciete Wachttijd, worden hieronder vermeld:
- alertIsPresent()
- elementToBeClickable()
- elementToBeSelected()
- frameToBeAvailableAndSwitchToIt()
- presenceOfElementLocated()
- visibilityOfElementLocated()
Voor het declareren van Expliciete Wachttijd moeten we een object van de WebDriverWait-klasse maken:
WebDriverWait wait = new WebDriverWait(webDriver, Duration.ofSeconds(30));
wait.until(ExpectedConditions.elementToBeClickable(By.id("element_id")));- Vloeiende wachttijd. Dit definieert de maximale tijd om te wachten op een geschikte voorwaarde en de frequentie waarmee deze voorwaarde wordt gecontroleerd. Gebruikers kunnen de wachttijd ook configureren om bepaalde uitzonderingen te negeren bij het zoeken naar een element op de pagina.
Wait wait = new FluentWait<>(webDriver)
.withTimeout(Duration.ofSeconds(30))
.pollingEvery(Duration.ofSeconds(20))
.ignoring(NoSuchElementException.class);
wait.until(ExpectedConditions.alertIsPresent());
} 2. Gebruik van dynamische XPath / CSS-selectors
In het geval van dynamische inhoud kunnen we mogelijk web-elementen niet identificeren met behulp van locators zoals id, naam, tagName, className, enz. In dergelijke situaties moeten aangepaste XPath- of CSS-selectors worden gebruikt.
3. Timeout-afhandeling en synchronisatie van gebeurtenissen
Deze uitdaging is een van de meest voorkomende en wijdverbreide problemen bij testautomatisering geworden. Synchronisatieproblemen doen zich voor wanneer we bewerkingen moeten uitvoeren met webelementen die nog niet aanwezig zijn op de pagina of niet in de juiste staat zijn (niet klikbaar, niet ingeschakeld, niet zichtbaar, enz.). In de meeste gevallen leiden deze problemen tot fouten in testscripts. Daarom is het cruciaal om deze uitdagingen aan te pakken om de stabiliteit en nauwkeurigheid van testscripts te verbeteren.
Oplossingen voor timeout-afhandeling
Om de bovengenoemde problemen aan te pakken, zijn de volgende methoden beschikbaar:
- Gebruik maken van waits (Implicit, Explicit, Fluent). Deze zijn toegankelijk binnen Selenium WebDriver (zoals beschreven in de vorige paragraaf)
- Gebruik maken van timeout-methoden, zoals pageLoadTimeout(), scriptTimeout(), enz. De waarden voor deze timeouts worden geconfigureerd op WebDriver-niveau
webDriver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(50));
webDriver.manage().timeouts().scriptTimeout(Duration.ofSeconds(60));4. Beperkte rapportage
Rapportage speelt een cruciale rol in het gehele testautomatiseringsproces. Gedetailleerde rapporten helpen QA-automatiseringstechnici bij het analyseren van resultaten en het verkrijgen van nauwkeurige informatie over de testuitvoering, inclusief uitvoeringstijd, het aantal geslaagde/mislukte testcases en fouten bij mislukte tests (inclusief screenshots). Vanwege beperkingen kan Selenium echter geen uitgebreide rapporten genereren. Daarom zijn de generatie en het onderhoud van rapporten ook gebruikelijke uitdagingen geworden bij automatisering met Selenium.
Oplossingen voor beperkte rapportage
Er zijn oplossingen beschikbaar voor het genereren van rapporten die kunnen interageren met Selenium en mogelijkheden bieden om gedetailleerde resultaten van testuitvoering te verkrijgen. Over het algemeen kunnen we rapportagetools in twee groepen indelen:
- Ingebouwde rapportage wordt geleverd door het juiste testautomatiseringsframework (gebaseerd op de programmeertaal). In Java kunnen we bijvoorbeeld frameworks zoals JUnit of TestNG gebruiken, die standaardfuncties voor het genereren van rapporten in HTML-formaat bevatten. Voorbeelden van dergelijke rapporten worden hieronder weergegeven:
TestNG:
JUnit:
- Externe tools (bibliotheken) zijn niet standaard opgenomen in het testframework en vereisen extra configuratie en integratie met het automatiseringsproject. Enkele voorbeelden van dergelijke tools zijn Allure en Extent Reports.
Allure:
Extent Report:
Natuurlijk heeft elke rapportagetool zijn eigen specificaties, voordelen en beperkingen. Daarom moet u alle voor- en nadelen van de bestaande tools analyseren en de meest geschikte en effectieve voor uw project selecteren.
5. Beperkte afhandeling van Captcha's
In het tijdperk van snelle vooruitgang in digitale technologieën blijft gegevensbeveiliging een van de meest kritieke taken in softwareontwikkeling. Hackers gebruiken vaak bots om toegang te krijgen tot vertrouwelijke gebruikersinformatie, wat resulteert in het verlies van essentiële gegevens en het ongeautoriseerde gebruik ervan. Een maatregel die kan helpen bij het bestrijden van bots is Captcha.
Deze technologie wordt gebruikt om te bepalen of de gebruiker een mens of een bot is. Captcha’s zijn inherent dynamische componenten, wat betekent dat ze alleen succesvol kunnen worden uitgevoerd via menselijke analyse. Captcha-afhandeling is ook een van de uitdagingen in Selenium, wat kan leiden tot testfouten tijdens het automatiseringsproces.
Oplossingen voor Captcha-afhandeling
Hoewel het afhandelen van Captcha’s in Selenium inderdaad een lastige taak is en niet als best practice wordt beschouwd, zijn er een paar manieren om Captcha’s te beheren:
- Captcha uitschakelen in de testomgeving
- Wachten toevoegen in het testscript en handmatig doorgaan met Captcha-afhandeling
Het is echter belangrijk om te onthouden dat niet alle testscenario’s kunnen worden geautomatiseerd. Sommige scenario’s lenen zich beter voor handmatige verificatie. Tests die Captcha-interacties omvatten, vallen in dergelijke scenario’s.
Testen van mobiele en desktop-apps
Natuurlijk is Selenium een veelgebruikt framework voor het automatiseren van webgebaseerde applicatietests. Het ondersteunt interactie met de meest populaire browsers (Chrome, Edge, Firefox, Safari) op verschillende desktopbesturingssystemen (Windows, Mac OS, Linux). Wanneer het echter gaat om het automatiseren van mobiele of desktop-applicatietests, kan Selenium ons dergelijke mogelijkheden niet bieden.
Oplossingen voor testen van mobiele en desktop-apps
Als alternatieve oplossing voor het automatiseren van mobiele apps is er Appium. Het is een open-source framework dat wordt gebruikt om native, hybride en mobiele webapplicaties te automatiseren op zowel Android- als iOS-platforms.
Voor desktop-apps zijn er verschillende tools beschikbaar, waaronder WinAppDriver, Sikulix en Ranorex Studio. Elk van deze tools heeft zijn eigen beperkingen, dus het is belangrijk om een grondige analyse van de tool uit te voeren voordat u begint met het gebruik ervan.
Schaalbaarheid
Schaalbaarheid wordt beschouwd als een van de belangrijkste uitdagingen bij testautomatisering. Een van de belangrijkste doelen van webautomatisering is om zoveel mogelijk tests uit te voeren op verschillende browsers (met verschillende versies) en besturingssystemen. Deze aanpak helpt de testdekking binnen een minimale tijd te vergroten.
Selenium WebDriver zelf biedt de mogelijkheid om tests sequentieel uit te voeren. Bij een groot aantal tests kan deze aanpak echter tijdrovend zijn en niet zo efficiënt zijn als gewenst.
Oplossingen voor schaalbaarheid
Tot de schaalbare benaderingen bij testautomatisering kunnen we Selenium Grid rekenen. Deze tool stelt u in staat om tests uit te voeren op meerdere combinaties van browsers en besturingssystemen. Het is echter belangrijk op te merken dat Selenium Grid het niet toestaat om tests gelijktijdig op een specifieke browser en besturingssysteem uit te voeren. Als alternatief kunt u een cloudgebaseerde tool gebruiken die de mogelijkheid biedt om tests gelijktijdig op meerdere browsers en besturingssystemen uit te voeren.
Samenvattend
In het proces van webautomatisering komen we vaak diverse uitdagingen en beperkingen tegen, aangezien technologieën voortdurend veranderen, zich ontwikkelen en evolueren. Elk hulpmiddel en framework dat voor automatiseringsdoeleinden wordt gebruikt, heeft zijn eigen voordelen en nadelen. QA-automatiseringstechnici moeten zich bewust zijn van deze factoren en deze overwegen bij het beginnen met het gebruik van deze tools.
Selenium is geen uitzondering. Het is inderdaad een krachtig framework voor webautomatisering, maar het heeft ook beperkingen die moeten worden aangepakt. Dit artikel heeft de belangrijkste uitdagingen bij testautomatisering met Selenium beschreven. Ondanks deze beperkingen zijn er manieren om ze op te lossen of te beheren en de voordelen van Selenium te maximaliseren. Het is belangrijk om te onthouden dat geen enkele tool perfect is! We moeten zowel de voor- als nadelen van elke tool overwegen.
Of het nu gaat om handmatige of geautomatiseerde tests (beide zijn belangrijke fasen van het QA-proces), deze moeten worden uitgevoerd door een zeer gekwalificeerd team.
Zie hoe we Kazidomi hielpen
de levering van functies te versnellen met testautomatisering en de #1 startup in België te worden
