The Puppeteer is een node js bibliotheekgebaseerd framework dat beschikbaar is als open source. Het kan worden gebruikt voor webscraping-tools. Het wordt ook gebruikt voor testautomatiseringstools. Tegenwoordig neemt het gebruik van Puppeteer snel toe in de geautomatiseerde softwaretestruimte. Basiskennis van de opdrachtregel, Javascript en HTML DOM-structuur is vereist om te begrijpen: poppenspeler tutorial. De hele tutorial is onderverdeeld in de onderstaande artikelen.
Puppeteer-zelfstudie
Tosca Tutorial # 1: Poppenspeler Overzicht
Tosca Tutorial # 2: Poppenspeler omgevingsvariabelen
Tosca Tutorial # 3: Puppeteer Web Scraping en Puppeteer Test Automation Overzicht
Tosca Tutorial # 4: Installeer Puppeteer
Tosca Tutorial # 5: Voorbeeld van een poppenspelerproject
Tosca Tutorial # 6: Testen van automatisering van poppenspelers
In deze tutorial "Puppeteer Automation Testing" zullen we de gedetailleerde stappen voor Puppeteer Automation vanaf het begin uitleggen. De onderstaande functies zullen worden uitgelegd om Puppeteer Automation-testen vanaf nul te begrijpen -
· Installeer Puppeteer
· Start de webtoepassing
· Identificeer objecteigenschappen vanuit de Chrome-browser
· Stappen voor het indienen van formulieren - Voer tekst in, klik op gebeurtenis, verificatie
· Screenshot vastleggen
· Voer scripts uit voor Puppeteer Automation
Automatisering van poppenspelers
Testen is vereist om de kwaliteit van softwareproducten te waarborgen. Er zijn meerdere testniveaus gedefinieerd in de softwareontwikkelingsprocessen. Om de functionaliteiten van een software te testen, kan dit handmatig of via een geautomatiseerd proces worden gedaan. De belangrijkste doelen van geautomatiseerde softwaretests zijn:
- Snelle testuitvoering.
- Voorkom de kans op menselijke fouten.
- Verkort de timing van de testuitvoering.
- Verkort de cyclustijd van de release.
- Zorg voor meer functionaliteit zonder concessies te doen aan kwaliteit.
- Meerdere uitvoeringen kunnen parallel worden uitgevoerd.
Puppeteer is een op javascript gebaseerde knooppuntbibliotheek die een applicatie-interface op hoog niveau (API) biedt om de Chrome-webbrowser te besturen via het Chrome DevTools-protocol. De meeste handmatige bewerkingen die in de Chrome-browser worden uitgevoerd, kunnen worden geautomatiseerd met Puppeteer. De poppenspeler is dus een goede keuze voor het snel en gemakkelijk testen van eenheden op webapplicaties.
Aanpak van het testen van poppenspelers op het gebied van automatisering:
De stappen die betrokken zijn bij Puppeteer Automation Testing worden hieronder uitgelegd -
Stap 1 # Identificeer het functionele testscenario:
We zullen de stapsgewijze aanpak laten zien voor het uitvoeren van poppenspeler-automatisering voor het onderstaande scenario -
· Start de webbrowser.
· Roep de Amazon-webtoepassing op.
- Zoek naar het boek "Testboek".
- Voeg het boek uit het resultaat toe aan de winkelwagen.
- Open de winkelwagen en controleer of het boek beschikbaar is in de winkelwagen.
- Capture-scherm en sluit de browser.
Stap2 # Installeer Puppeteer en maak een testcase:
Maak een leeg javascript-bestand als "sample_script.js" in een specifieke map. Hier beschouwen we de hoofdmap als SampleProject. Om Puppeteer te installeren, gebruiken we het commando - "npm install puppeteer". De installatieprocedure neemt enige tijd in beslag, afhankelijk van de netwerksnelheid. Het zal ongeveer 350 MB aan gegevens downloaden. Na de installatie wordt de map node_modules, die verschillende poppenspeler-componenten en package-lock.json-bestand bevat, aangemaakt in de hoofdmap van het voorbeeld van het Puppeteer-project.
Stap3 # Identificatie-eigenschappen van het testobject vastleggen:
We kunnen de identificatie-eigenschappen vastleggen met behulp van de Developers Tool van de Chrome-webbrowser. Bij het analyseren van de verschillende eigenschappen, zoals id, naam, XPath, enz., Zullen we de juiste kiezen die in de scripting kan worden gebruikt om bewerkingen uit te voeren. In deze tutorial "Puppeteer Automation Testing" gebruiken we XPath in het script. Onderstaande stappen die u moet volgen om de XPATH of andere eigenschappen te krijgen,
1. Open Developer Tools die beschikbaar zijn onder “Menu -> Meer tools”, en ga naar het tabblad Elementen.
2. Gebruik de Finder-tool (klik op het pijlpictogram dat beschikbaar is in de linkerbovenhoek van het tabblad Elementen) en markeer het testobject vanuit de toepassing. Hier zullen we het zoekvak inspecteren.
3. Analyseer de gemarkeerde broncode om gewenste eigenschappen te identificeren. Om de XPATH-eigenschap van het testobject te krijgen, klikt u met de rechtermuisknop op het gemarkeerde gedeelte en klikt u op "Kopiëren-> Xpath kopiëren" om de XPATH-eigenschap naar het klembord te kopiëren.
4. Plak nu het Xpath in het tekstvak van de Finder en druk op Enter om te controleren of het Xpath het object uniek identificeert.
5. Evenzo moeten we de identificatie-eigenschappen voor een ander testobject ook vastleggen.
Step4 # Puppeteer Automation Development Stappen:
Om de testcase te voltooien, moeten we bepaalde bewerkingen op webpagina's uitvoeren. Voor elk van de operaties zijn er verschillende methoden beschikbaar. De methoden die worden gebruikt in ons scenario voor "Puppeteer Automation Testing" worden hier uitgelegd.
Applicatie opstarten - Nadat we de poppenspeler hebben opgenomen, moeten we de browser starten met behulp van de poppenspeler-startmethode. Een objectverwijzing kan aan deze methode worden doorgegeven om te definiëren voor headless of headful browser. Vervolgens moeten we de instantie van de webbrowser maken die nodig is om door de URL te navigeren. Hier wordt de async-functie gebruikt om het wachtwoord te gebruiken om de websynchronisatie af te handelen.
// Voeg het poppenspelerpakket toe const puppeteer = required('puppeteer'); (async () => { // de headless browser starten const browser = wacht puppeteer.launch ({ headless: true }); // Maak een instantie van de browser const pagina = wacht browser.newPage (); // Navigeer naar de url wacht op page.goto('https://www.amazon.in/'); })()De volledige tests worden uitgevoerd in een headless browser. Als we de headful-browser willen openen, moeten we het object doorgeven aan de startmethode als "{Headless: false}".
Controleer het bestaan - We moeten de methode gebruiken pagina.waitForXpath die het bestaan van het Xpath controleert en de referentie van het testobject retourneert. Door de retourreferentie te testen, kunnen we een verificatiepunt aan de testcase toevoegen.
\tlet searchBox = wacht op page.waitForXPath("//*[@id='twotabsearchtextbox']",{ zichtbaar: true });
\tif (searchBox === null) //Verificatie van het testobject
\T{
\t\tconsole.log('Amazon-scherm wordt niet weergegeven');
\T}Gegevens invoeren - De ... gebruiken type dan: methode van die objectreferentie, kunnen we de tekst invoeren.
wacht op searchBox.type("Testboek");Klik op Element - Evenzo, met behulp van de Klik methode van elke objectreferentie, kunnen we klikbewerkingen uitvoeren.
laat btnSearch = wachten op page.waitForXPath("//*/input[@id='nav-search-submit-button']",{visible:true }); btnZoeken.klik();Bericht afdrukken in de console - Met behulp van de methode console.log, kunnen we elk bericht in de console als uitvoer afdrukken.
console.log('Console-vertraging is gegenereerd');Raadpleeg het nieuwe tabblad - Met behulp van de methoden page.target en browser.waitforTargetkunnen we de referentie over een nieuw tabblad controleren en opslaan in een variabele.
\tconst pageTarget = pagina.target(); \tconst newTarget = wacht op browser.waitForTarget(target => target.opener() === pageTarget); \t//haal het nieuwe paginaobject op: \tconst page2 = wacht op newTarget.page();
Screenshot vastleggen - Met behulp van de methode bladzijde. Screenshot, is er een momentopname van de specifieke pagina gemaakt en opgeslagen volgens de bestandsnaam die als argument is opgegeven.
wacht op page.screenshot({ pad: 'screenshot1.png' });Sluit pagina en browser - Met behulp van de methode dichtbijkunnen we zowel de webpagina als de browser sluiten.
\tawait-pagina.close(); \tawait browser.close();
Wacht tijd - In bepaalde gevallen is het vereist om te wachten op het laden van de pagina of het voltooien van een afhankelijke taak; we moeten de uitvoering pauzeren voor een vooraf gedefinieerde tijd. Om dit uit te voeren, kunnen we gebruiken de page.waitForTimeout methode die de uitvoering kan pauzeren op basis van de waarde (in milli-seconden) die door het argument is doorgegeven.
wacht op page.waitForTimeout(2000);
Nu hebben we geleerd over de technische basisstappen om ons functionele scenario te automatiseren. Op basis van de kennis kunnen we onderstaande Puppeteer Automation testcase doorlopen. Het gedetailleerde overzicht van de meest gebruikte klassen en methoden zal in volgende berichten worden uitgelegd.
/**
* @naam Amazon zoeken
*/
const poppenspeler = vereisen('poppenspeler');
const reportPath = 'C:\\\\LambdaGeeks\\\\puppteer_proj_sample\\\\output\\\\';
const screenshot = 'screen1.png';
// Wordt gebruikt om het bestand naar een .docx-bestand te exporteren
poging {
(asynchrone () => {
const browser = wacht op poppenspeler.launch({ headless: false });
const pageNew = wacht op browser.newPage()
wacht op pageNew.setViewport({ breedte: 1280, hoogte: 800 });
wacht op paginaNew.goto('https://www.amazon.in/');
\t//Voer zoekcriteria in
\tlet searchBox = wacht op page.waitForXPath("//*[@id='twotabsearchtextbox']",{ zichtbaar: true });
\tif (zoekvak === nul)
\T{
\t\tconsole.log('Amazon-scherm wordt niet weergegeven');
\T}
\telse{\t\t
\t\tawait searchBox.type("Testboek");
\t\tconsole.log('Zoekcriteria zijn ingevoerd');
\t} \t\t
\t//Op de zoekknop geklikt
\tlet btnSearch = wacht op pageNew.waitForXPath("//*/input[@id='nav-search-submit-button']",{ zichtbaar: true });
\tif (btnSearch === null)
\T{
\t\tconsole.log('Zoekknop wordt niet weergegeven');
\T}
\telse{
\t\tawait btnSearch.klik();
\t\tconsole.log('Op de zoekknop geklikt');
\t}\t
\t//Klik op een specifiek zoekresultaat
\tlet myBook = wacht op pageNew.waitForXPath("//*[contains(text(),'Selenium Testing Tools Cookbook Second Edition')]",{ zichtbaar: true })
\tif (mijnboek === null)
\T{
\t\tconsole.log('Boek is niet beschikbaar');
\T}
\telse{
\t\wacht op mijnboek.klik();
\t\tconsole.log('Klik op een specifiek boek om te bestellen');
\t} \t
\t// Bepaal of het nieuwe tabblad is geopend
\tconst paginaTarget = paginaNieuw.doel();
\tconst newTarget = wacht op browser.waitForTarget(target => target.opener() === pageTarget);
\t//haal het nieuwe paginaobject op:
\tconst pagina2 = wacht op newTarget.pageNew();\t
\tawait page2.setViewport({ breedte: 1280, hoogte: 800 });
\T
\t//Voeg toe aan winkelwagen
\tlet addToCart = wacht op pagina2.waitForXPath("//*/input[@id='add-to-cart-button']",{ zichtbaar: true });
\tif (addToCart === null)
\T{
\t\tconsole.log('De knop Toevoegen aan winkelwagen is niet beschikbaar');
\T}
\telse{
\t\tconsole.log('Klik op de knop Toevoegen aan winkelwagen');
\t\tawacht toevoegenToCart.klik();\t\t
\t} \t\t
\t//Controleer het toevoegen aan winkelwagenproces\t
\tlet successMessage = wacht op pagina2.waitForXPath("//*[contains(text(),'Toegevoegd aan winkelwagen')]",{ zichtbaar: true });
\tif (succesbericht === null)
\T{
\t\tconsole.log('Item is niet aan winkelwagen toegevoegd');
\T}
\telse{
\t\tconsole.log('Item is succesvol aan winkelwagen toegevoegd');\t\t
\t} \t\t
\t// Leg het aantal winkelwagen vast
\tlet cartCount = wacht op pagina2.waitForXPath("//*/span[@id='nav-cart-count']",{ zichtbaar: true});
\tlet waarde = wachten op pagina2.evaluate(el => el.textContent, cartCount)
\tconsole.log('Aantal winkelwagens: ' + waarde);
\tcartCount.focus();
\tawait page2.screenshot({ pad: screenshot });
\T
\tawait pageNew.waitForTimeout(2000);
\tawacht op pagina2.close();
\tawait pageNew.close();
wacht op browser.close();
})()
} vangen (err) {
console.error(fout)
}Step5 # Puppeteer Automation Test Execution:
We kunnen de uitvoering starten met behulp van het commando knooppunt sample_script.js via de opdrachtprompt. Tijdens de uitvoering wordt de Chromium-browser geopend en automatisch de functionele stappen uitgevoerd en het screenshot van de laatste pagina opgeslagen. De schermafbeelding en de console-uitvoer zien er als volgt uit.
Conclusie:
In deze tutorial voor het testen van poppenspelers hebben we geleerd over de gedetailleerde stappen voor het testen van poppenspeler automatisering. In de volgende Puppeteer-tutorial zullen we het gedetailleerde overzicht leren van de meest gebruikte poppenspelersklassen en -methoden. Klik alstublieft hier om het referentieportaal voor deze Puppeteer Tutorial te bezoeken.
Hallo, ik ben K. Mondal, ik ben verbonden aan een toonaangevende organisatie. Ik heb meer dan 12 jaar werkervaring in verschillende domeinen, bijvoorbeeld applicatieontwikkeling, automatiseringstesten en IT-consultant. Ik ben erg geïnteresseerd in het leren van verschillende technologieën. Ik ben hier om mijn ambitie te vervullen en draag momenteel bij als auteur en website-ontwikkelaar, zowel bij LambdaGeeks.
Laten we verbinding maken via LinkedIn-
