Poppenspeler versus Selenium: wat is beter voor automatisering?

Geautomatiseerd testen is een essentieel onderdeel geworden van moderne webontwikkeling. Naarmate webapplicaties complexer worden, is het niet langer haalbaar om elke functie handmatig te testen. Met geautomatiseerde testtools kunnen ontwikkelaars tests schrijven die gebruikersinteracties simuleren en verifiëren dat de applicatie werkt zoals verwacht.

Twee van de meest populaire tools voor geautomatiseerd browsertesten zijn Puppeteer en Selenium. Beiden kunnen een browser starten, naar webpagina's navigeren, communiceren met elementen op een pagina en beweringen doen over de pagina-inhoud. Er zijn echter enkele belangrijke verschillen die ervoor zorgen dat elke tool beter geschikt is voor bepaalde testscenario's.

In deze uitgebreide gids vergelijken we Puppeteer en Selenium om u te helpen bepalen welke de juiste keuze is voor uw behoeften.

Wat is poppenspeler?

poppenspeler is een Node-bibliotheek ontwikkeld door het Chrome-team. Het biedt een API op hoog niveau om Chrome zonder hoofd te besturen via het DevTools-protocol.

Puppeteer werkt standaard zonder hoofd, maar kan worden geconfigureerd om volledig (niet-hoofdloos) Chrome of Chromium te gebruiken.

Enkele belangrijke kenmerken van Puppeteer:

• Genereert schermafbeeldingen en PDF's van pagina's
• Crawlt een site om inhoud te extraheren
• Automatiseert het indienen van formulieren, UI-testen en toetsenbordinvoer
• Maakt responsief testen mogelijk door apparaatemulatie in te stellen
• Maakt uitvoering van browser-JavaScript mogelijk
• API voor browsergebeurtenissen zoals navigatie- en consolelogboeken
• Ondersteunt de installatie van extensies

Puppeteer ondersteunt alleen Chromium-gebaseerde browsers zoals Chrome en Microsoft Edge. Het werkt niet met Firefox of Safari.

Wat is Selenium?

Selenium is een open source pakket met tools om webbrowsers te automatiseren. Het bestaat al langer dan Puppeteer en heeft aanhangers van meerdere browserleveranciers.

Selenium ondersteunt meerdere talen, waaronder Java, C#, Python, JavaScript en Ruby. Het kan Chrome, Firefox, Edge en Safari op desktopplatforms automatiseren. Selenium ondersteunt ook mobiele browsers voor Android- en iOS-tests.

Kenmerken van Selenium:

• Cross-browser compatibiliteit
• Mobiele testmogelijkheden
• IDE voor opnemen en afspelen
• Raster voor het distribueren van tests over meerdere machines
• Integraties met verschillende testrunners zoals JUnit, TestNG, Mocha
• Grote gebruikersgemeenschap in verschillende sectoren

In tegenstelling tot Puppeteer staat Selenium niet toe dat browser-JavaScript wordt uitgevoerd of rechtstreeks met DevTools werkt.

Syntaxisvergelijking

Puppeteer gebruikt een beknopte API die leest als pseudocode. Bijvoorbeeld:

// Navigate to a URL
await page.goto(‘https://www.example.com‘);

// Get an element 
const button = await page.$(‘#submit-button‘); 

// Click the button  
await button.click();

Selenium gebruikt een uitgebreidere API:

// Launch browser
WebDriver driver = new ChromeDriver();

// Navigate to URL
driver.get("https://www.example.com");

// Find element
WebElement button = driver.findElement(By.id("submit-button"));

// Click element  
button.click(); 

De API van Puppeteer voelt gebruiksvriendelijker en gemakkelijker te lezen. Het gebruik van async/await-syntaxis vermindert het nestelen van callbacks. Over het algemeen heeft Puppeteer minder standaardcode nodig dan Selenium.

Browsers starten

Om een ​​browserinstantie te starten, gebruikt Puppeteer:

const browser = await puppeteer.launch();

Met Selenium moet u een specifieke stuurprogrammaklasse initialiseren:

// Launch Chrome  
WebDriver driver = new ChromeDriver();

// Launch Firefox
WebDriver driver = new FirefoxDriver(); 

Puppeteer lanceert alleen Chromium, terwijl Selenium meerdere browsers ondersteunt. Voor cross-browser testen is Selenium een ​​betere keuze.

Elementen lokaliseren

Poppenspeler vindt elementen met behulp van:

// Get element by CSS selector
const el = await page.$(‘.className‘);

// Get element by XPath  
const el = await page.$x(‘//xpath‘); 

Selenium lokaliseert elementen via WebDriver-locators:

// Find by CSS
WebElement el = driver.findElement(By.cssSelector(".className"));

// Find by XPath
WebElement el = driver.findElement(By.xpath("//xpath"));

Beide tools bieden een breed scala aan locatiestrategieën, zoals ID, klasse, tekst en DOM-hiërarchie. Over het algemeen is de elementselectie in beide eenvoudig.

Interactie met elementen

Om te communiceren met elementen op een pagina gebruikt Puppeteer:

// Type into an input  
await page.type(‘#input‘, ‘Hello world‘);

// Click a button
await button.click(); 

// Select an option
await page.select(‘#dropdown‘, ‘option2‘);

De equivalente Selenium-code is:

// Type text  
driver.findElement(By.id("input")).sendKeys("Hello world");

// Click button
button.click();

// Select option
Select dropdown = new Select(driver.findElement(By.id("dropdown")));
dropdown.selectByVisibleText("option2");

De API van Puppeteer voelt compacter en expressiever aan. Selenium vereist extra standaard voor sommige interacties, zoals het selecteren van vervolgkeuzelijsten.

Paginanavigatie

Om naar pagina's te navigeren gebruikt Puppeteer:

// Navigate to URL 
await page.goto(‘https://example.com‘);

// Click a link
await page.click(‘a.page2‘); 

// Go back
await page.goBack();

En in Selenium:

// Open URL
driver.get("https://example.com");

// Click link
driver.findElement(By.cssSelector("a.page2")).click();

// Go back  
driver.navigate().back();

Navigatiemethoden lijken erg op elkaar tussen de twee tools. Puppeteer verwijdert een deel van de breedsprakigheid rond de geneste stuurprogrammaopdrachten van Selenium.

JavaScript uitvoeren

Een groot voordeel van Puppeteer is de mogelijkheid om browser-JavaScript rechtstreeks uit te voeren:

// Set a cookie 
await page.evaluate(() => {
  document.cookie = "foo=bar"; 
});

// Get an element‘s text 
const text = await page.evaluate(el => el.textContent, element);

Selenium biedt geen methoden om JavaScript rechtstreeks uit te voeren. U moet tijdelijke oplossingen gebruiken, zoals het injecteren van scripts in pagina's.

Wachten op elementen

Web-apps kunnen enige tijd nodig hebben om inhoud dynamisch te laden met JavaScript. Geautomatiseerde tests moeten wachten tot de elementen gereed zijn voordat ze ermee kunnen communiceren.

Met Puppeteer kun je handmatig wachttijden schrijven:

// Wait for selector to be visible
await page.waitForSelector(‘.element‘); 

// Wait for navigation to complete
await page.waitForNavigation();

Selenium heeft ingebouwde expliciete en impliciete wachttijden:

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

// Explicit wait  
WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector(".element")));

Het hebben van configureerbare ingebouwde wachttijden maakt het gemakkelijker om timingproblemen in Selenium op te lossen. Poppenspeler vereist handmatige scriptwachttijden.

Schermafbeeldingen genereren

Beide tools kunnen tijdens het testen screenshots van pagina's maken.

Voorbeeld van een poppenspeler:

// Take a screenshot 
await page.screenshot({path: ‘page.png‘});

Selenium voorbeeld:

// Capture screenshot
File screenshot = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);

De mogelijkheden voor schermafbeeldingen lijken erg op elkaar. De API van Puppeteer is iets eenvoudiger.

PDF's maken

Naast schermafbeeldingen kan Puppeteer PDF's van pagina's genereren:

// Generate PDF
await page.pdf({path: ‘page.pdf‘});

Deze functie is niet ingebouwd in Selenium. U hebt een aangepast hulpprogramma nodig om pagina's naar PDF af te drukken met Selenium.

Pop-ups verwerken

Om waarschuwingen, prompts en browserpop-ups af te handelen, biedt Puppeteer de pagina's dialog evenement:

page.on(‘dialog‘, dialog => {
  console.log(dialog.message());
  dialog.accept(); 
});

Selenium gebruikt de Alert-interface om met pop-ups te communiceren:

// Switch to alert
Alert alert = driver.switchTo().alert();  

// Get text
String text = alert.getText();

// Accept alert
alert.accept();

Beide tools kunnen JS-pop-ups verwerken tijdens automatisering. De API van Selenium voelt meer gepolijst aan voor het werken met pop-ups.

Parallel testen

Het parallel uitvoeren van tests kan de uitvoering van tests aanzienlijk versnellen.

Puppeteer ondersteunt parallelle tests niet rechtstreeks. U moet de parallelle uitvoering orkestreren via een afzonderlijke testrunner.

Selenium Grid maakt het mogelijk om tests parallel over meerdere machines te distribueren. Dit maakt het eenvoudig om Selenium-tests te schalen.

Browserlogboeken

Toegang tot browserlogboeken kan handig zijn voor het debuggen van tests en het inspecteren van netwerkactiviteit.

Met Puppeteer kunt u de browserconsole en netwerklogboeken vastleggen:

// Listen for console logs
page.on(‘console‘, msg => {
  console.log(‘Page Log:‘, msg.text()); 
}); 

// Get network request logs
const requests = browser.on(‘request‘, request => {
  request.url(); // Log URLs
});

Selenium biedt geen methoden om rechtstreeks toegang te krijgen tot browserlogboeken. U zou oplossingen moeten vinden om console- of netwerklogboeken te krijgen.

User-agent-simulatie

Het is belangrijk om te testen hoe een website reageert op verschillende apparaten en user agents.

Puppeteer maakt het eenvoudig om user-agentreeksen te vervalsen:

await page.setUserAgent(‘Custom User Agent‘);

Selenium staat het instellen van user-agents niet rechtstreeks toe. Hiervoor moet u browserprofielen configureren.

Prestatie-audits

Puppeteer integreert tools voor het analyseren van paginaprestaties:

// Audit performance 
const metrics = await page.audit({
  disableJavaScript: true // Test without JavaScript 
});

// Log metrics
metrics.totalByteWeight; // Total page weight

Voor prestatie-audits zou Selenium extra tools nodig hebben. Poppenspeler bouwt het meteen in.

Prijsvergelijking

Een van de belangrijkste verschillen tussen Puppeteer en Selenium zijn de beperkingen voor commercieel gebruik.

Poppenspeler is open source en gratis te gebruiken. U kunt het zonder enige beperking commercieel gebruiken.

Selenium is ook open source. De officiële binaire bestanden van Selenium WebDriver hebben echter alleen een licentie voor niet-commercieel gebruik. Voor commercieel gebruik heeft u een licentie nodig van de Selenium-leverancier BrowserStack.

Dit kan Puppeteer de voorkeur geven aan teams die een automatiseringsoplossing commercieel willen gebruiken zonder enige licentiekosten.

Testen zonder hoofd

Headless testen verwijst naar het uitvoeren van een browser zonder enige zichtbare gebruikersinterface. Het biedt een lichtgewicht testomgeving.

Puppeteer start Chrome standaard in de headless-modus, waardoor het ideaal is voor headless testen.

Selenium kan ook worden geconfigureerd om headless te werken met behulp van opties zoals:

chromeOptions.addArguments("--headless"); 

Beide tools maken dus testen zonder hoofd mogelijk, waarbij Puppeteer dit de standaard out-of-box-ervaring maakt.

Continue integratie

CI/CD-integratie is belangrijk voor het automatiseren van testuitvoering bij codewijzigingen.

Puppeteer op zichzelf biedt geen ingebouwde CI/CD-mogelijkheden. U moet het aansluiten op CI-tools zoals Jenkins, CircleCI, enz.

Selenium biedt native integratie met CI/CD-pijplijnen via selenium-grid. Dit maakt het eenvoudig distribueren van tests op de CI-infrastructuur mogelijk.

Mobiel testen

Hoewel beide tools zich richten op webtesten, biedt Selenium bovendien ondersteuning voor mobiel testen.

Het Selenium Appium-project maakt het automatiseren van native mobiele apps op Android- en iOS-platforms mogelijk. Puppeteer ondersteunt geen testen van mobiele apps.

Leercurve

Voor ontwikkelaars die bekend zijn met JavaScript en Node.js is Puppeteer zeer intuïtief om te gebruiken. Het API-ontwerp weerspiegelt nauw de DOM API-concepten.

Selenium heeft een steilere leercurve omdat je de Selenium-specifieke WebDriver API moet leren. Maar Java-ervaring helpt sneller te groeien.

Over het algemeen is Puppeteer eenvoudiger en gemakkelijker op te pikken voor mensen met een webontwikkelingsachtergrond.

Mogelijkheden voor foutopsporing

Het oplossen van falende tests is een belangrijk onderdeel van testautomatisering.

Met Puppeteer kunnen breekpunten en foutopsporing rechtstreeks in Chrome DevTools worden ingesteld, zodat fouten eenvoudig kunnen worden opgespoord:

await page.pause(); // Pause execution

Selenium heeft geen ingebouwde foutopsporing. U moet vertrouwen op loginstructies of externe foutopsporingstools.

Browserondersteuning

De belangrijkste beperking van Puppeteer is dat het alleen Chromium-gebaseerde browsers ondersteunt. Je kunt het dus niet gebruiken om te testen op Firefox of Safari.

Selenium ondersteunt Chrome, Firefox, Edge en Safari, waardoor echte cross-browser testen mogelijk is. Als testdekking in verschillende browsers een prioriteit is, is Selenium waarschijnlijk de betere keuze.

Open source-gemeenschap

Selenium bestaat al meer dan tien jaar en heeft een grote gemeenschap erachter. Er zijn conferenties, gebruikersgroepen en een actief vraag- en antwoordforum gewijd aan Selenium.

Als nieuwer project heeft Puppeteer een veel kleinere gemeenschap. Maar dankzij de ergonomie van de ontwikkelaar en het door Google aangestuurde momentum kan het in de loop van de tijd een inhaalslag maken.

Moet je poppenspeler of selenium gebruiken?

Nu we de twee tools hebben vergeleken, hoe bepaal je of je Puppeteer of Selenium gebruikt?

Hier zijn enkele belangrijke factoren waarmee u rekening moet houden:

• Browser ondersteuning – Als je testen in meerdere browsers nodig hebt, is Selenium de beste optie. Voor testen met alleen Chrome is Puppeteer een goede keuze.

• Mobiel testen – Selenium ondersteunt mobiel internet en native app-testen. Poppenspeler is alleen beschikbaar op de desktop.

• Debugging – De ingebouwde DevTools-integratie van Puppeteer maakt het opsporen van fouten eenvoudiger.

• Cross-platform – Voor Java- en C#-testautomatisering heeft Selenium betere ondersteuning. Poppenspeler is gericht op JS/Node.

• Applicatie type – Puppeteer is zeer geschikt voor het testen van SPA's en kleinere webapps. Selenium schaalt beter voor grotere bedrijfsapps met uitgebreide backend-integraties.

• Commercieel gebruik – Teams die automatisering commercieel willen gebruiken zonder licentiebeperkingen kunnen profiteren van Puppeteer.

• Programmeercomfort – Voor testers met een DevOps- en JavaScript-achtergrond kan Puppeteer een lagere leercurve hebben. Java-gebruikers kunnen sneller overstappen op Selenium.

• Oude investering – Als je al een aanzienlijk aantal Selenium-tests hebt, is het waarschijnlijk zinvol om deze te blijven verbeteren in plaats van helemaal opnieuw te beginnen met Puppeteer.

Voor veel testautomatiseringsbehoeften kunnen beide tools de klus klaren. Ze hebben allemaal unieke sterke punten, waardoor ze geschikt zijn voor specifieke gebruikssituaties. Hopelijk geeft deze gedetailleerde vergelijking duidelijkheid over de vraag of Puppeteer of Selenium de juiste keuze is voor jouw behoeften.