Hoe te wachten tot een pagina is geladen met selenium

De reden dat dit gebeurt, is dat het Selenium-webstuurprogramma de webpagina moet downloaden en de pagina moet weergeven voordat u er iets aan kunt doen. In het verleden genereerde de webserver de inhoud van een website en de browser downloadde deze en gaf deze weer. Tegenwoordig hebben we veel web-apps met één pagina die een beetje anders werken. In Single Page Web Apps (SPA's) bedient de webserver alleen de frontend-codes. Zodra de frontend-code in de browser is weergegeven, gebruikt de frontend-code AJAX om API-gegevens op te vragen bij de webserver. Zodra de frontend de API-gegevens ontvangt, worden ze weergegeven in de browser. Dus ook al is de browser klaar met het downloaden en weergeven van de webpagina, de webpagina is nog steeds niet klaar. U moet wachten tot het de API-gegevens ontvangt en deze ook weergeeft. De oplossing voor dit probleem is dus te wachten tot de gegevens beschikbaar zijn voordat we iets met Selenium doen.

In Selenium zijn er 2 soorten wachttijden:
1) Impliciet wachten
2) Expliciet wachten

1) Impliciet wachten: Dit is het gemakkelijkst te implementeren. Een impliciete wachttijd vertelt het Selenium-webstuurprogramma om enkele seconden te wachten totdat het DOM (documentobjectmodel) gereed is (de webpagina moet gereed zijn).

2) Expliciet wachten: Dit is een beetje ingewikkelder dan het impliciete wachten. In expliciete wachttijd vertel je de Selenium-webdriver waarop hij moet wachten. Selenium wacht tot die specifieke voorwaarde is vervuld. Zodra dit is voltooid, is het Selenium-webstuurprogramma klaar om andere opdrachten uit te voeren. Meestal is de expliciete wachttijd variabel. Het hangt ervan af hoe snel aan de voorwaarden wordt voldaan. In het ergste geval zal het expliciete wachten net zo lang wachten als het impliciete wachten.

In dit artikel laat ik je zien hoe je (impliciet en expliciet) kunt wachten tot een pagina is geladen met Selenium. Dus laten we beginnen.

Vereisten:

Om de commando's en voorbeelden van dit artikel uit te proberen, moet je hebben,

1) Een Linux-distributie (bij voorkeur Ubuntu) die op uw computer is geïnstalleerd.
2) Python 3 geïnstalleerd op uw computer.
3) PIP 3 geïnstalleerd op uw computer.
4) Python virtueel pakket geïnstalleerd op uw computer.
5) Mozilla Firefox- of Google Chrome-webbrowsers die op uw computer zijn geïnstalleerd.
6) Moet weten hoe de Firefox Gecko Driver of Chrome Web Driver te installeren.

Voor het voldoen aan de vereisten 4, 5 en 6, lees mijn artikel Inleiding tot Selenium met Python 3 op Linuxhint.com.

U kunt veel artikelen over de andere onderwerpen vinden op LinuxHint.com . Zorg ervoor dat je ze bekijkt als je hulp nodig hebt.

Een projectmap instellen:

Maak een nieuwe projectdirectory om alles overzichtelijk te houden selenium-wacht/ als volgt:

Navigeer naar de selenium-wacht/ projectmap als volgt:

Maak als volgt een virtuele Python-omgeving in de projectdirectory:

Activeer de virtuele omgeving als volgt:

Installeer Selenium met PIP3 als volgt:

Download en installeer alle vereiste webstuurprogramma's in de chauffeurs/ map van het project. Ik heb het proces van het downloaden en installeren van webstuurprogramma's uitgelegd in mijn artikel Inleiding tot Selenium met Python 3 . Als je hulp nodig hebt, zoek dan op LinuxHint.com voor dat artikel.

Ik zal de Google Chrome-webbrowser gebruiken voor de demonstratie in dit artikel. Dus ik zal de gebruiken chromedriver binair van de chauffeurs/ map.

Maak een nieuw Python-script om te experimenteren met impliciet wachten ex01.py in uw projectdirectory en typ de volgende regels codes in dat bestand.

Als u klaar bent, slaat u de ex01.py Python-script.

Lijn 1 en 2 importeren alle benodigde Selenium componenten.

Regel 4 maakt een Chrome Options-object.

Lijn 5 schakelt de headless-modus in voor het Chrome-webstuurprogramma.

Regel 7 maakt een Chrome-browserobject met behulp van de chromedriver binair van de chauffeurs/ map.

Regel 8 wordt gebruikt om Selenium te vertellen om impliciet 10 seconden te wachten met behulp van de impliciet_wacht() browser methode.

Regel 10 laadt de www.unixtimestamp.com in de browser.

Regel 12 vindt het tijdstempelelement met behulp van de XPath-selector //h3[@class=’text-danger’][1] en bewaart het in de tijdstempel variabel.

Ik heb de XPath-selector van de Chrome Developer Tool. Zoals je kunt zien, staat de tijdstempel in de eerste h3 element met de klassenaam tekst-gevaar . Er zijn er 2 h3 elementen met de klas tekst-gevaar .

Regel 13 drukt alleen de tijdstempel af van het element dat ik heb geselecteerd met de XPath-selector en opgeslagen in de tijdstempel variabel.

Regel 14 sluit de browser.

Als je klaar bent, voer je het Python-script uit ex01.py als volgt:

Zoals u kunt zien, wordt de huidige tijdstempel geëxtraheerd van unixtimestamp.com en afgedrukt op de console.

Werken met expliciete wachttijd:

Maak een nieuw Python-script om te experimenteren met expliciet wachten ex02.py in uw projectdirectory en typ de volgende regels codes in dat bestand.

Als u klaar bent, slaat u de ex02.py Python-script.

Regel 1-5 importeert alle benodigde componenten uit de Selenium-bibliotheek.

Regel 7 maakt een object Chrome-opties.

Line 8 schakelt de headless-modus in voor de Chrome-webdriver.

Regel 10 maakt een Chrome-browserobject met behulp van de chromedriver binair van de chauffeurs/ map.

Regel 12 laadt de www.unixtimestamp.com in de browser.

Het expliciete wachten wordt geïmplementeerd in het try-finally-blok (van regel 14-20)

Regel 15-17 gebruikt maakt WebDriverWacht() object. Het eerste argument van WebDriverWacht() is het browserobject, en het tweede argument is de maximaal toegestane tijd (in het slechtste geval) om aan de voorwaarde te voldoen, in dit geval 10 seconden.

In de tot() blok, verwachte_condities.presence_of_element_located() methode wordt gebruikt om ervoor te zorgen dat het element aanwezig is voordat wordt geprobeerd het element te selecteren. Hier, Door.XPATH wordt gebruikt om de . te vertellen presence_of_element_located() methode dat we een XPath-selector hebben gebruikt om het element te selecteren. De XPath-selector is: //h3[@class=’text-danger’][1] .

Zodra het element is gevonden, wordt het opgeslagen in de tijdstempel variabel.

Regel 18 drukt alleen de tijdstempel van het geselecteerde element af.

Ten slotte sluit regel 19-20 de browser.

Als u klaar bent, voert u de ex02.py Python-script als volgt:

Zoals u kunt zien, wordt de huidige tijdstempel van unixtimestamp.com afgedrukt op de console.

Elementen selecteren in expliciete wachttijden:

In het eerdere gedeelte heb ik gebruikt Door.XPATH voor het selecteren van het element met behulp van de XPath-selector. U kunt de elementen ook selecteren met behulp van ID, tagnaam, CSS-klassenaam, CSS-selector, enz.

De ondersteunde selectiemethoden worden hieronder weergegeven:

Door.XPATH – Selecteert element/elementen met behulp van XPath-selector.

Door.CLASS_NAME – Selecteert element/elementen met behulp van CSS-klassenaam.

Door.CSS_SELECTOR – Selecteert element/elementen met behulp van CSS-selector.

Door.ID – Selecteert element op ID

Bij naam – Selecteert element/elementen op naam.

Door.TAG_NAME – Selecteert element/elementen op HTML-tagnaam.

Door.LINK_TEXT – Selecteert element/elementen op linktekst van tot (anker) HTML-tag.

Door.PARTIAL_LINK_TEXT – Selecteert element/elementen door gedeeltelijke linktekst van tot (anker) HTML-tag.

Ga voor meer informatie hierover naar de Python Selenium API-documentatiepagina .

Verwachte omstandigheden in expliciete wachttijden:

In het eerdere expliciete wachtvoorbeeld heb ik de . gebruikt presence_of_element_located() methode van verwachte_voorwaarden als de expliciete wachtvoorwaarde om ervoor te zorgen dat het element waar ik naar op zoek was, bestaat voordat ik het selecteer.

Er zijn andere verwachte_voorwaarden u kunt gebruiken als een expliciete wachtvoorwaarde. Sommige ervan zijn:

titel_is(titel) – controleert of de titel van de pagina is titel .

title_contains(gedeeltelijke_titel) – controleert of de titel van de pagina een deel van de titel bevat gedeeltelijke_titel .

zichtbaarheid_van(element) – controleert of de element is zichtbaar op de pagina waarvan het element een breedte en hoogte heeft die groter is dan 0.

zichtbaarheid_van_element_located(locator) -

presence_of_element_located(locator) – Zorg ervoor dat het element dat zich (bij de zoeker ) is aanwezig op de pagina. De zoeker is een tupel van (Door, kiezer), zoals ik heb laten zien in het expliciete wachtvoorbeeld.

presence_of_all_element_located() – Zorgt ervoor dat alle elementen overeenkomen met de zoeker staat op de pagina. De zoeker is een (Door, kiezer) tupel.

text_to_be_present_in_element(locator, tekst) – Controleert of de tekst is aanwezig in het element dat zich bij de bevindt zoeker . De zoeker is een (Door, kiezer) tupel.

element_to_be_clickable(locator) – Controleert of het element dat zich bij de bevindt zoeker is zichtbaar en klikbaar. De zoeker is een (Door, kiezer) tupel.

element_to_be_selected(locator) – Controleert of het element dat zich bij de bevindt zoeker is geselecteerd. De zoeker is een (Door, kiezer) tupel.

alert_is_present() – verwacht dat er een waarschuwingsdialoogvenster aanwezig is op de pagina.

Er zijn veel meer verwachte_voorwaarden voor u beschikbaar om te gebruiken. Ga voor meer informatie hierover naar de Python Selenium API-documentatiepagina .

Conclusie:

In dit artikel heb ik de impliciete en expliciete wachttijden van Selenium besproken. Ik heb je ook laten zien hoe je kunt werken met een impliciete en expliciete wachttijd. Je moet altijd proberen om expliciet te wachten in je Selenium-projecten, aangezien Selenium zal proberen de wachttijd zo veel mogelijk te verminderen. Op deze manier hoeft u niet elke keer dat u uw Selenium-projecten uitvoert een bepaald aantal seconden te wachten. Het expliciete wachten zou veel seconden moeten besparen.

Ga voor meer informatie over Selenium-wachten naar de officiële Selenium Python Library wacht Documentatiepagina .