Page Object Model (POM) met Page Factory | Selenium-zelfstudie

page object model with page factory selenium tutorial

Deze diepgaande zelfstudie legt alles uit over het Page Object Model (POM) met Pagefactory met behulp van voorbeelden. U kunt ook de implementatie van POM in selenium leren:

In deze zelfstudie zullen we begrijpen hoe u een Page Object Model maakt met behulp van de Page Factory-benadering. We zullen ons concentreren op:

• Fabrieksklasse
• Hoe u een basis-POM maakt met Page Factory Pattern
• Verschillende annotaties gebruikt in Page Factory Approach

Voordat we zien wat Pagefactory is en hoe het samen met het Page-objectmodel kan worden gebruikt, moeten we eerst begrijpen wat het Page-objectmodel is, dat algemeen bekend staat als POM.

​ Bezoek hier om de Selenium-trainingsserie voor iedereen te zien.

Wat je leert:

• Wat is het Page Object Model (POM)?
  • POM begrijpen met voorbeelden
  • Waarom gebruiken we het Page Object Model?
  • Implementatie van eenvoudige POM in selenium
    • # 1) Scenario om te automatiseren
    • # 2) Selenium-scripts voor het bovenstaande scenario in POM
• Wat is Pagefactory?
• POM met Page Factory
  • Videotutorials - POM met Page Factory
  • Stappen om POM te maken met Page Factory Pattern
  • Paginalaag
  • Stappen om POM te maken met realtime voorbeeld
  • Testlaag
  • Hiërarchie van annotatietype die wordt gebruikt voor het declareren van WebElements
    • # 1) @FindBy
    • # 2) @FindBys
    • # 3) @FindAll
    • # 4) @CacheLookUp
  • Meer over PageFactory.initElements ()
• Veel Gestelde Vragen
• Gevolgtrekking
  • Aanbevolen literatuur

Wat is het Page Object Model (POM)?

Theoretische terminologieën beschrijven de Pagina-objectmodel als een ontwerppatroon dat wordt gebruikt om een ​​objectrepository te bouwen voor de webelementen die beschikbaar zijn in de te testen applicatie. Weinig anderen noemen het een raamwerk voor Selenium-automatisering voor de gegeven toepassing die wordt getest.

Wat ik echter heb begrepen over de term Page Object Model is:

# 1) Het is een ontwerppatroon waarbij u een apart Java-klassenbestand hebt dat overeenkomt met elk scherm of elke pagina in de applicatie. Het klassenbestand kan zowel de objectrepository van de UI-elementen als methoden bevatten.

#twee) In het geval dat een pagina gigantische webelementen bevat, kan de objectrepositoryklasse voor een pagina worden gescheiden van de klasse die methoden voor de bijbehorende pagina bevat.

Voorbeeld: Als de pagina Account registreren veel invoervelden heeft, kan er een klasse RegisterAccountObjects.java zijn die de objectrepository vormt voor de UI-elementen op de pagina Accounts registreren.

Er zou een afzonderlijk klassenbestand RegisterAccount.java kunnen worden gemaakt dat RegisterAccountObjects uitbreidt of overneemt en dat alle methoden bevat die verschillende acties op de pagina uitvoeren.

# 3) Bovendien kan er een algemeen pakket zijn met een {roperties-bestand, Excel-testgegevens en algemene methoden onder een pakket.

Voorbeeld: DriverFactory die heel gemakkelijk op alle pagina's van de applicatie kan worden gebruikt

POM begrijpen met voorbeelden

Controleren hier voor meer informatie over POM.

Hieronder ziet u een momentopname van de webpagina:

Als u op elk van deze links klikt, wordt de gebruiker doorgestuurd naar een nieuwe pagina.

Hier is de momentopname van hoe de projectstructuur met Selenium is opgebouwd met behulp van het Page-objectmodel dat overeenkomt met elke pagina op de website. Elke Java-klasse bevat een objectrepository en methoden voor het uitvoeren van verschillende acties op de pagina.

Bovendien zal er nog een JUNIT of TestNG of een Java-klassebestand zijn dat aanroepen naar klassebestanden van deze pagina's aanroept.

Waarom gebruiken we het Page Object Model?

Er is veel geroezemoes over het gebruik van dit krachtige Selenium-framework, POM of page-objectmodel genaamd. Nu rijst de vraag 'Waarom POM gebruiken?'.

Het simpele antwoord hierop is dat POM een combinatie is van datagedreven, modulaire en hybride frameworks. Het is een aanpak om de scripts systematisch zo te organiseren dat het de QA gemakkelijk maakt om de code probleemloos te onderhouden en ook helpt om overtollige of dubbele code te voorkomen.

Als er bijvoorbeeld een wijziging is in de locatorwaarde op een specifieke pagina, dan is het heel gemakkelijk om die snelle wijziging alleen in het script van de respectieve pagina te identificeren en aan te brengen zonder de code elders te beïnvloeden.

We gebruiken het Page Object Model-concept in Selenium Webdriver om de volgende redenen:

1. In dit POM-model wordt een objectrepository gemaakt. Het is onafhankelijk van testcases en kan worden hergebruikt voor een ander project.
2. De naamgevingsconventie van methoden is heel gemakkelijk, begrijpelijk en realistischer.
3. Onder het Page-objectmodel maken we paginaklassen die kunnen worden hergebruikt in een ander project.
4. Het Page-objectmodel is eenvoudig voor het ontwikkelde raamwerk vanwege de verschillende voordelen.
5. In dit model worden aparte klassen gemaakt voor verschillende pagina's van een webapplicatie, zoals inlogpagina, de startpagina, werknemersdetailpagina, wachtwoord wijzigen, enz.
6. Als er een wijziging is in een element van een website, hoeven we alleen wijzigingen aan te brengen in één klas, en niet in alle klassen.
7. Het ontworpen script is meer herbruikbaar, leesbaar en onderhoudbaar in de benadering van het paginaobjectmodel.
8. De projectstructuur is vrij eenvoudig en begrijpelijk.
9. Kan PageFactory gebruiken in het pagina-objectmodel om het webelement te initialiseren en elementen in de cache op te slaan.
10. TestNG kan ook worden geïntegreerd in de Page Object Model-benadering.

Implementatie van eenvoudige POM in selenium

# 1) Scenario om te automatiseren

Nu automatiseren we het gegeven scenario met behulp van het Page Object Model.

Het scenario wordt hieronder uitgelegd:

Stap 1: Start de site 'https: //demo.vtiger.com'.
Stap 2: Voer de geldige inloggegevens in.
Stap 3: Log in op de site.
Stap 4: Controleer de startpagina.
Stap 5: Log uit op de site.
Stap 6: Sluit de browser.

# 2) Selenium-scripts voor het bovenstaande scenario in POM

Nu maken we de POM-structuur in Eclipse, zoals hieronder wordt uitgelegd:

Stap 1: Maak een project in Eclipse - op POM gebaseerde structuur:

a) Creëer project “Page Object Model”.

b) Maak 3 pakketten onder het project.

• bibliotheek
• Pagina's
• testgevallen

Bibliotheek: Hieronder plaatsen we die codes die steeds opnieuw moeten worden aangeroepen in onze testcases, zoals Browser starten, Schermafbeeldingen, etc. De gebruiker kan er meer klassen onder toevoegen op basis van de projectbehoefte.

Pagina's: Hieronder worden klassen gemaakt voor elke pagina in de webapplicatie en kunnen meer paginaklassen worden toegevoegd op basis van het aantal pagina's in de applicatie.

Testgevallen: Hieronder schrijven we de login-testcase en kunnen we indien nodig meer testcases toevoegen om de hele applicatie te testen.

c) Klassen onder de pakketten worden getoond in de onderstaande afbeelding.

Stap twee: Maak de volgende klassen onder het bibliotheekpakket.

Browser.java: In deze klasse zijn 3 browsers (Firefox, Chrome en Internet Explorer) gedefinieerd en deze wordt aangeroepen in de login-testcase. Op basis van de vereiste kan de gebruiker de applicatie ook in verschillende browsers testen.

ScreenShot.java: In deze klasse wordt een screenshotprogramma geschreven en het wordt aangeroepen in de testcase wanneer de gebruiker een screenshot wil maken om te zien of de test mislukt of slaagt.

Stap 3 : Maak paginaklassen onder Paginapakket.

HomePage.java: Dit is de Home-paginaklasse, waarin alle elementen van de startpagina en methoden zijn gedefinieerd.

LoginPage.java: Dit is de klasse Login-pagina, waarin alle elementen van de inlogpagina en -methoden zijn gedefinieerd.

Stap 4: Maak testcases voor het inlogscenario.

LoginTestCase.java: Dit is de klasse LoginTestCase, waar de testcase wordt uitgevoerd. De gebruiker kan ook meer testcases maken volgens de projectbehoefte.

Stap 5: Voer 'LoginTestCase.java' uit.

Stap 6: Uitvoer van het pagina-objectmodel:

• Start de Chrome-browser.
• De demo-website wordt geopend in de browser.
• Log in op de demosite.
• Controleer de startpagina.
• Log uit op de site.
• Sluit de browser.

Laten we nu het belangrijkste concept van deze tutorial onderzoeken dat de aandacht trekt, d.w.z. 'Pagefactory'.

Wat is Pagefactory?

PageFactory is een manier om het 'Page Object Model' te implementeren. Hier volgen we het principe van scheiding van Page Object Repository en Test Methods. Het is een ingebouwd concept van Page Object Model dat zeer geoptimaliseerd is.

Laten we nu meer duidelijkheid krijgen over de term Pagefactory.

# 1) Ten eerste biedt het concept genaamd Pagefactory een alternatieve manier in termen van syntaxis en semantiek voor het creëren van een objectrepository voor de webelementen op een pagina.

#twee) Ten tweede gebruikt het een iets andere strategie voor de initialisatie van de webelementen.

# 3) De objectrepository voor de UI-webelementen kan worden gebouwd met behulp van:

• Gebruikelijke ‘POM zonder Pagefactory’ en,
• Als alternatief kunt u ‘POM with Pagefactory’ gebruiken.

Hieronder is een grafische weergave van hetzelfde gegeven:

Nu zullen we met Pagefactory alle aspecten bekijken die de gebruikelijke POM van POM onderscheiden.

a) Het verschil in de syntaxis van het lokaliseren van een element met de gebruikelijke POM versus POM met Pagefactory.

Bijvoorbeeld , Klik hier om het zoekveld te vinden dat op de pagina wordt weergegeven.

POM zonder Pagefactory:

# 1) Hieronder ziet u hoe u het zoekveld vindt met behulp van de gebruikelijke POM:

# 2) De onderstaande stap geeft de waarde 'investering' door aan het veld Zoeken in NSE.

POM met Pagefactory:

# 1) U kunt het zoekveld vinden met Pagefactory zoals hieronder weergegeven.

De annotatie @FindBy wordt gebruikt in Pagefactory om een ​​element te identificeren, terwijl POM zonder Pagefactory de driver.findElement () methode om een ​​element te lokaliseren.

De tweede verklaring voor Pagefactory na @FindBy wijst een type toe WebElement klasse die precies hetzelfde werkt als de toewijzing van een elementnaam van het type WebElement-klasse als een retourneringstype van de methode driver.findElement () dat wordt gebruikt in de gebruikelijke POM (searchNSETxt in dit voorbeeld).

We zullen kijken naar de @FindBy annotaties in detail in het komende deel van deze tutorial.

#twee) De onderstaande stap geeft de waarde 'investering' door aan het Search NSE-veld en de syntaxis blijft hetzelfde als die van de gebruikelijke POM (POM zonder Pagefactory).

b) Het verschil in de strategie van initialisatie van webelementen met de gebruikelijke POM versus POM met Pagefactory.

POM gebruiken zonder Pagefactory:

Hieronder vindt u een codefragment om het Chrome-stuurprogrammapad in te stellen. Er wordt een WebDriver-instantie gemaakt met de naam stuurprogramma en de ChromeDriver wordt toegewezen aan de ‘stuurprogramma’. Hetzelfde stuurprogramma-object wordt vervolgens gebruikt om de website van de National Stock Exchange te starten, de zoekbox te lokaliseren en de tekenreekswaarde in het veld in te voeren.

Het punt dat ik hier wil benadrukken, is dat wanneer het POM is zonder paginafabriek, de driverinstantie in eerste instantie wordt gemaakt en elk webelement opnieuw wordt geïnitialiseerd telkens wanneer er een oproep naar dat webelement is met driver.findElement () of driver .findElements ().

Dit is de reden waarom, met een nieuwe stap van driver.findElement () voor een element, de DOM-structuur opnieuw wordt gescand en de vernieuwde identificatie van het element op die pagina wordt gedaan.

POM gebruiken met Pagefactory:

Naast het gebruik van @FindBy annotatie in plaats van de driver.findElement () methode, wordt het onderstaande codefragment ook gebruikt voor Pagefactory. De statische methode initElements () van de klasse PageFactory wordt gebruikt om alle UI-elementen op de pagina te initialiseren zodra de pagina wordt geladen.

De bovenstaande strategie maakt de PageFactory-benadering enigszins anders dan de gebruikelijke POM. In de gebruikelijke POM moet het webelement expliciet worden geïnitialiseerd, terwijl in de Pagefactory-benadering alle elementen worden geïnitialiseerd met initElements () zonder expliciet elk webelement te initialiseren.

Bijvoorbeeld: Als het WebElement is gedeclareerd maar niet is geïnitialiseerd in de gebruikelijke POM, wordt de fout 'initialiseer variabele' of NullPointerException gegenereerd. Daarom moet in de gebruikelijke POM elk WebElement expliciet worden geïnitialiseerd. PageFactory biedt in dit geval een voordeel ten opzichte van de gebruikelijke POM.

Laten we het webelement niet initialiseren BDate (POM zonder Pagefactory), kunt u zien dat de fout ’Initialize variable’ wordt weergegeven en de gebruiker vraagt ​​om deze op null te initialiseren, dus u kunt er niet van uitgaan dat de elementen impliciet worden geïnitialiseerd bij het lokaliseren ervan.

Element BDate expliciet geïnitialiseerd (POM zonder Pagefactory):

Laten we nu eens kijken naar een paar voorbeelden van een compleet programma dat PageFactory gebruikt om onduidelijkheid uit te sluiten bij het begrijpen van het implementatie-aspect.

Voorbeeld 1:

• Ga naar ‘http://www.nseindia.com/’
• Selecteer ‘Valutaderivaten’ in de vervolgkeuzelijst naast het zoekveld.
• Zoek naar ‘USDINR’. Controleer de tekst ‘US Dollar-Indian Rupee - USDINR’ op de resulterende pagina.

Programmastructuur:

• PagefactoryClass.java die een objectrepository bevat met behulp van het paginafabriekconcept voor nseindia.com dat een constructor is voor het initialiseren van alle webelementen is gemaakt, methode selectCurrentDerivative () om waarde te selecteren uit het vervolgkeuzeveld Searchbox, selectSymbol () om een ​​symbool op de pagina die hierna verschijnt en verificatietekst () om te controleren of de paginakop is zoals verwacht of niet.
• NSE_MainClass.java is het hoofdklassebestand dat alle bovenstaande methoden aanroept en de respectieve acties op de NSE-site uitvoert.

PagefactoryClass.java

NSE_MainClass.java

Voorbeeld 2:

• Ga naar ‘https://www.shoppersstop.com/brands’
• Navigeer naar de haute curry-link.
• Controleer of de Haute Curry-pagina de tekst 'Start New Something' bevat.

Programmastructuur

• shopperstopPagefactory.java die een objectrepository bevat met behulp van het pagefactory-concept voor shoppersstop.com die een constructor is voor het initialiseren van alle webelementen is gemaakt, methoden closeExtraPopup () om een ​​pop-upvenster met waarschuwingen af ​​te handelen dat wordt geopend, klik op OnHauteCurryLink () om op Haute Curry te klikken Koppel en verifieerStartNewSomething () om te controleren of de Haute Curry-pagina de tekst 'Start new something' bevat.
• Shopperstop_CallPagefactory.java is het hoofdklassebestand dat alle bovenstaande methoden aanroept en de respectieve acties op de NSE-site uitvoert.

shopperstopPagefactory.java

Shopperstop_CallPagefactory.java

POM met Page Factory

Videotutorials - POM met Page Factory

Deel I

Deel II

Een Factory-klasse wordt gebruikt om het gebruik van pagina-objecten eenvoudiger en gemakkelijker te maken.

• Eerst moeten we de webelementen vinden door middel van annotaties @FindBy in paginaklassen ​
• Initialiseer vervolgens de elementen met initElements () bij het instantiëren van de paginaklasse.

# 1) @FindBy:

@FindBy annotatie wordt gebruikt in PageFactory om de webelementen te lokaliseren en te declareren met behulp van verschillende locators.Hier geven we het attribuut en de waarde die wordt gebruikt voor het lokaliseren van het webelement door aan de @FindBy-annotatie en vervolgens wordt het WebElement gedeclareerd.

Er zijn 2 manieren waarop de annotatie kan worden gebruikt.

Bijvoorbeeld:

Het eerste is echter de standaardmanier om WebElements aan te geven.

'Hoe' is een klasse en heeft statische variabelen zoals ID, XPATH, CLASSNAME, LINKTEXT, etc.
'gebruik makend van' - Om een ​​waarde toe te kennen aan een statische variabele.

In bovenstaande voorbeeld hebben we het kenmerk ‘id’ gebruikt om het webelement ‘E-mail’ te vinden. Evenzo kunnen we de volgende locators gebruiken met de @FindBy-annotaties:

• naam van de klasse
• css
• naam
• xpath
• tagName
• verbind tekst
• gedeeltelijkeLinkText

# 2) initElements ():

De initElements is een statische methode van de PageFactory-klasse die wordt gebruikt om alle webelementen te initialiseren die zich bevinden bij @FindBy-annotatie. Zo kunnen de paginaklassen gemakkelijk worden geïnstantieerd.

We moeten ook begrijpen dat POM de OOPS-principes volgt.

• WebElements worden gedeclareerd als privélidvariabelen (Data Hiding).
• WebElements binden met overeenkomstige methoden (inkapseling).

Stappen om POM te maken met Page Factory Pattern

# 1) Maak voor elke webpagina een apart Java-klassebestand.

#twee) In elke klasse moeten alle WebElements worden gedeclareerd als variabelen (met annotatie - @FindBy) en geïnitialiseerd met de methode initElement (). Gedeclareerde WebElements moeten worden geïnitialiseerd om te worden gebruikt in de actiemethoden.

# 3) Definieer overeenkomstige methoden die op die variabelen werken.

Laten we een voorbeeld nemen van een eenvoudig scenario:

• Open de URL van een applicatie.
• Typ e-mailadres en wachtwoordgegevens.
• Klik op de Login-knop.
• Controleer het succesvolle aanmeldingsbericht op de zoekpagina.

Paginalaag

Hier hebben we 2 pagina's,

1. Startpagina - De pagina die opent wanneer de URL wordt ingevoerd en waar we de gegevens invoeren om in te loggen.
2. SearchPage - Een pagina die wordt weergegeven na een succesvolle login.

In Page Layer wordt elke pagina in de webapplicatie gedeclareerd als een afzonderlijke Java-klasse en worden de locators en acties daar vermeld.

Stappen om POM te maken met realtime voorbeeld

# 1) Maak een Java-klasse voor elke pagina:

In deze voorbeeld , krijgen we toegang tot 2 webpagina's, 'Home' en 'Zoeken' pagina's.

Daarom zullen we 2 Java-klassen maken in Page Layer (of in een pakket, bijvoorbeeld com.automation.pages).

# 2) Definieer WebElements als variabelen met Annotation @FindBy:

We zouden interactie hebben met:

• E-mail, wachtwoord, login-knopveld op de startpagina.
• Succesvol bericht op de zoekpagina.

Dus we zullen WebElements definiëren met @FindBy

Bijvoorbeeld: Als we het EmailAddress gaan identificeren met attribuut-id, dan is de variabele declaratie dat

# 3) Maak methoden voor acties die worden uitgevoerd op WebElements.

De onderstaande acties worden uitgevoerd op WebElements:

• Typ actie in het veld E-mailadres.
• Typ actie in het veld Wachtwoord.
• Klik op de actie op de Login-knop.

Bijvoorbeeld, Door de gebruiker gedefinieerde methoden worden voor elke actie op het WebElement gemaakt als,

Hier wordt de Id doorgegeven als een parameter in de methode, aangezien invoer door de gebruiker wordt verzonden vanuit de hoofdtestcase.

Notitie ​Er moet een constructor worden gemaakt in elke klasse in de paginalaag om de driverinstantie van de klasse Main in de testlaag te krijgen en ook om WebElements (paginaobjecten) te initialiseren die in de paginaklasse zijn gedeclareerd met PageFactory.InitElement () .

We starten de driver hier niet, maar de instantie wordt ontvangen van de Main Class wanneer het object van de Page Layer-klasse wordt gemaakt.

InitElement () - wordt gebruikt om de gedeclareerde WebElements te initialiseren, met behulp van een driverinstantie van de hoofdklasse. Met andere woorden, WebElements worden gemaakt met behulp van de driverinstantie. Pas nadat de WebElements zijn geïnitialiseerd, kunnen ze worden gebruikt in de methoden om acties uit te voeren.

Er worden twee Java-klassen gemaakt voor elke pagina, zoals hieronder wordt weergegeven:

HomePage.java

SearchPage.Java

Testlaag

Testcases zijn geïmplementeerd in deze klasse. We maken een apart pakket, zeg com.automation.test, en maken hier een Java-klasse (MainClass.java)

Stappen om testcases te maken:

• Initialiseer de driver en open de applicatie.
• Maak een object van de PageLayer-klasse (voor elke webpagina) en geef de driverinstantie als parameter door.
• Gebruik het gemaakte object om de methoden in de PageLayer-klasse (voor elke webpagina) aan te roepen om acties / verificatie uit te voeren.
• Herhaal stap 3 totdat alle acties zijn uitgevoerd en sluit vervolgens de driver.

Hiërarchie van annotatietype die wordt gebruikt voor het declareren van WebElements

Annotaties worden gebruikt om een ​​locatiestrategie voor de UI-elementen op te stellen.

# 1) @FindBy

Als het op Pagefactory aankomt, fungeert @FindBy als een magische toverstok. Het voegt alle kracht toe aan het concept. U weet nu dat @FindBy-annotatie in Pagefactory hetzelfde presteert als die van driver.findElement () in het gebruikelijke pagina-objectmodel. Het wordt gebruikt om WebElement / WebElements te lokaliseren met één criterium ​

# 2) @FindBys

Het wordt gebruikt om WebElement te lokaliseren met meer dan één criterium en moeten voldoen aan alle gegeven criteria. Deze criteria moeten worden vermeld in een ouder-kindrelatie. Met andere woorden, dit gebruikt de voorwaardelijke relatie EN om de WebElements te lokaliseren met behulp van de opgegeven criteria. Het gebruikt meerdere @FindBy om elk criterium te definiëren.

Bijvoorbeeld:

HTML-broncode van een WebElement:

In POM:

In het bovenstaande voorbeeld bevindt het WebElement ‘SearchButton’ zich alleen als het komt overeen met beide het criterium waarvan de id-waarde 'zoekId_1' is en de naamwaarde 'zoekveld'. Merk op dat het eerste criterium bij een bovenliggende tag hoort en het tweede criterium bij een onderliggende tag.

# 3) @FindAll

Het wordt gebruikt om WebElement te lokaliseren met meer dan één criterium en het moet voldoen aan ten minste een van de opgegeven criteria. Dit maakt gebruik van voorwaardelijke OF-relaties om WebElements te lokaliseren. Het gebruikt meerdere @FindBy om alle criteria te definiëren.

Bijvoorbeeld:

HTML-broncode:

In POM:

In het bovenstaande voorbeeld staat de WebElement ‘Gebruikersnaam als deze komt overeen met ten minste één van de genoemde criteria.

# 4) @CacheLookUp

Wanneer het WebElement vaker wordt gebruikt in testgevallen, zoekt Selenium naar het WebElement telkens wanneer het testscript wordt uitgevoerd. In die gevallen waarin bepaalde WebElements wereldwijd worden gebruikt voor alle TC ( Bijvoorbeeld, Inlogscenario vindt plaats voor elke TC), kan deze annotatie worden gebruikt om die WebElements in het cachegeheugen te behouden zodra deze voor de eerste keer wordt gelezen.

Dit helpt op zijn beurt de code om sneller uit te voeren, omdat het elke keer niet naar het WebElement op de pagina hoeft te zoeken, maar zijn referentie uit het geheugen kan halen.

Dit kan een voorvoegsel zijn van @FindBy, @FindBys en @FindAll.

Bijvoorbeeld:

Merk ook op dat deze annotatie alleen moet worden gebruikt voor WebElements waarvan de attribuutwaarde (zoals xpath, id-naam, klassenaam, enz.) Niet vaak verandert. Zodra het WebElement voor de eerste keer is gelokaliseerd, behoudt het zijn referentie in het cachegeheugen.

Dus dan gebeurt er na een paar dagen een verandering in het kenmerk van het WebElement. Selenium zal het element niet kunnen lokaliseren, omdat het zijn oude referentie al in zijn cachegeheugen heeft en geen rekening zal houden met de recente wijziging in WebElement.

Meer over PageFactory.initElements ()

Nu we de strategie van Pagefactory begrijpen bij het initialiseren van de webelementen met InitElements (), gaan we proberen de verschillende versies van de methode te begrijpen.

De methode zoals we die kennen neemt het driverobject en het huidige klasseobject als de invoerparameters en retourneert het paginaobject door impliciet en proactief alle elementen op de pagina te initialiseren.

In de praktijk verdient het gebruik van de constructor zoals getoond in de bovenstaande sectie meer de voorkeur boven de andere manieren van gebruik.

Alternatieve manieren om de methode te bellen is:

# 1) In plaats van 'deze' pointer te gebruiken, kunt u het huidige klasseobject maken, de driverinstantie eraan doorgeven en de statische methode initElements aanroepen met parameters, d.w.z. het driverobject en het klasseobject dat zojuist is gemaakt.

#twee) De derde manier om elementen te initialiseren met de klasse Pagefactory, is door de api genaamd 'reflectie' te gebruiken. Ja, in plaats van een klasseobject te maken met een 'nieuw' sleutelwoord, kan classname.class worden doorgegeven als onderdeel van de invoerparameter initElements ().

Veel Gestelde Vragen

V # 1) Wat zijn de verschillende locatorstrategieën die worden gebruikt voor @FindBy?

Antwoord: Het simpele antwoord hierop is dat er geen verschillende locatorstrategieën zijn die worden gebruikt voor @FindBy.

Ze gebruiken dezelfde 8 locatorstrategieën die de methode findElement () in de gebruikelijke POM gebruikt:

1. ID kaart
2. naam
3. naam van de klasse
4. xpath
5. css
6. tagName
7. verbind tekst
8. gedeeltelijkeLinkText

Q # 2) Zijn er ook verschillende versies van het gebruik van @FindBy-annotaties?

Antwoord: Als er een webelement moet worden doorzocht, gebruiken we de annotatie @FindBy. We zullen ingaan op de alternatieve manieren om @FindBy te gebruiken, samen met de verschillende locatorstrategieën.

We hebben al gezien hoe je versie 1 van @FindBy kunt gebruiken:

Versie 2 van @FindBy is door de invoerparameter door te geven als Hoe en Gebruik makend van ​

Hoe zoekt naar de locatorstrategie waarmee het webelement zou worden geïdentificeerd. Het sleutelwoord gebruik makend van definieert de locatorwaarde.

Zie hieronder voor een beter begrip,

• How.ID zoekt het element met ID kaart strategie en het element dat het probeert te identificeren heeft id = cidkeyword.

• How.CLASS_NAME zoekt het element met naam van de klasse strategie en het element dat het probeert te identificeren heeft class = nieuwe klasse.

V # 3) Is er een verschil tussen de twee versies van @FindBy?

Antwoord: Het antwoord is nee, er is geen verschil tussen de twee versies. Alleen de eerste versie is korter en gemakkelijker in vergelijking met de tweede versie.

V # 4) Wat gebruik ik in de pagefactory als er een lijst met webelementen moet worden gevonden?

Antwoord: In het gebruikelijke ontwerppatroon voor pagina-objecten hebben we driver.findElements () om meerdere elementen te lokaliseren die tot dezelfde klasse of tagnaam behoren, maar hoe vinden we dergelijke elementen in het geval van een pagina-objectmodel met Pagefactory? De eenvoudigste manier om dergelijke elementen te bereiken, is door dezelfde annotatie @FindBy te gebruiken.

Ik begrijp dat deze lijn voor velen van jullie een hoofdbreker lijkt. Maar ja, het is het antwoord op de vraag.

Laten we eens kijken naar het onderstaande voorbeeld:

Als u het gebruikelijke pagina-objectmodel zonder Pagefactory gebruikt, gebruikt u driver.findElements om meerdere elementen te lokaliseren, zoals hieronder wordt weergegeven:

Hetzelfde kan worden bereikt met behulp van het pagina-objectmodel met Pagefactory zoals hieronder weergegeven:

Kortom, het toewijzen van de elementen aan een lijst van het type WebElement doet de truc, ongeacht of Pagefactory is gebruikt of niet tijdens het identificeren en lokaliseren van de elementen.

V # 5) Kunnen zowel het Page-objectontwerp zonder pagefactory als met Pagefactory in hetzelfde programma worden gebruikt?

Antwoord: Ja, zowel het pagina-objectontwerp zonder Pagefactory als met Pagefactory kunnen in hetzelfde programma worden gebruikt. U kunt het onderstaande programma doorlopen in het Antwoord op vraag 6 om te zien hoe beide worden gebruikt in het programma.

Een ding om te onthouden is dat het Pagefactory-concept met de cachefunctie moet worden vermeden op dynamische elementen, terwijl pagina-objectontwerp goed werkt voor dynamische elementen. Pagefactory is echter alleen geschikt voor statische elementen.

V # 6) Zijn er alternatieve manieren om elementen te identificeren op basis van meerdere criteria?

declareer een string-array in java

Antwoord: Het alternatief voor het identificeren van elementen op basis van meerdere criteria is het gebruik van de annotaties @FindAll en @FindBys. Deze annotaties helpen om enkele of meerdere elementen te identificeren, afhankelijk van de waarden die worden opgehaald uit de criteria die erin zijn doorgegeven.

# 1) @FindAll:

@FindAll kan meerdere @FindBy bevatten en retourneert alle elementen die overeenkomen met een @FindBy in een enkele lijst. @FindAll wordt gebruikt om een ​​veld op een pagina-object te markeren om aan te geven dat de zoekactie een reeks @FindBy-tags moet gebruiken. Het zoekt dan naar alle elementen die voldoen aan een van de FindBy-criteria.

Merk op dat de elementen niet gegarandeerd in de documentvolgorde zijn.

De syntaxis om @FindAll te gebruiken is als volgt:

Uitleg: @FindAll zoekt en identificeert afzonderlijke elementen die voldoen aan elk van de @FindBy-criteria en geeft ze weer. In het bovenstaande voorbeeld zal het eerst een element zoeken waarvan id = 'foo' en vervolgens het tweede element identificeren met className = 'bar'.

Ervan uitgaande dat er één element is geïdentificeerd voor elk FindBy-criterium, zal @FindAll resulteren in een opsomming van respectievelijk 2 elementen. Onthoud dat er voor elk criterium meerdere elementen kunnen worden geïdentificeerd. Dus, in eenvoudige bewoordingen, @ Vind alle handelt gelijkwaardig aan de OF operator op de @FindBy-criteria geslaagd.

# 2) @FindBys:

FindBys wordt gebruikt om een ​​veld op een pagina-object te markeren om aan te geven dat opzoeken een reeks @FindBy-tags in een ketting moet gebruiken, zoals beschreven in ByChained. Als de vereiste WebElement-objecten aan alle opgegeven criteria moeten voldoen, gebruikt u @FindBys-annotatie.

De syntaxis om @FindBys te gebruiken is als volgt:

Uitleg: @FindBys zoekt en identificeert elementen die voldoen aan alle @FindBy-criteria en geeft ze weer. In het bovenstaande voorbeeld zal het elementen zoeken waarvan de naam = 'foo' en className = 'bar'.

@FindAll resulteert in een opsomming van 1 element als we aannemen dat er één element is geïdentificeerd met de naam en de className in de gegeven criteria.

Als er niet één element is dat aan alle FindBy-voorwaarden voldoet, zal de resultante van @FindBys nul elementen zijn. Er kan een lijst met webelementen worden geïdentificeerd als alle voorwaarden aan meerdere elementen voldoen. In eenvoudige bewoordingen @ FindBys handelt gelijkwaardig aan de EN operator op de @FindBy-criteria geslaagd.

Laten we de implementatie van alle bovenstaande annotaties bekijken via een gedetailleerd programma:

We zullen het programma www.nseindia.com uit de vorige sectie aanpassen om de implementatie van de annotaties @FindBy, @FindBys en @FindAll te begrijpen

# 1) De objectrepository van PagefactoryClass wordt als volgt bijgewerkt:

Lijst newlist = driver.findElements (By.tagName ('a'));

@FindBy (how = How. TAG_NAME , met = 'a')
privaat List findbyvalue;
@Vind alle ​ @FindBy (className = 'sel'), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privaat Lijst vind alle waarde;
@FindBys ​ @FindBy (className = 'sel'), @FindBy (xpath = ”// a (@ id =’ tab5 ′) ”)})
privaat Lijst findbysvalue;

# 2) Een nieuwe methode seeHowFindWorks () is geschreven in de PagefactoryClass en wordt aangeroepen als de laatste methode in de Main-klasse.

De methode is als volgt:

Hieronder is het resultaat weergegeven dat wordt weergegeven in het consolevenster na de uitvoering van het programma:

Laten we nu proberen de code in detail te begrijpen:

# 1) Via het ontwerppatroon van het paginaobject identificeert het element ‘nieuwe lijst’ alle tags met anker ‘a’. Met andere woorden, we krijgen een telling van alle links op de pagina.

We hebben geleerd dat de pagefactory @FindBy hetzelfde werk doet als die van driver.findElement (). Het element findbyvalue wordt gemaakt om het aantal links op de pagina te krijgen via een zoekstrategie met een pagefactory-concept.

Het bewijst correct dat zowel driver.findElement () als @FindBy hetzelfde werk doet en dezelfde elementen identificeren. Als je naar de schermafbeelding van het resulterende consolevenster hierboven kijkt, is het aantal links geïdentificeerd met het element newlist en dat van findbyvalue gelijk, d.w.z. 299 links op de pagina.

Het resultaat toonde zoals hieronder:

#twee) Hier gaan we dieper in op de werking van de @FindAll-annotatie die betrekking heeft op de lijst van webelementen met de naam findallvalue.

Kijkend naar elk @FindBy-criterium in de @FindAll-annotatie, zoekt het eerste @FindBy-criterium naar elementen met de className = 'sel' en het tweede @FindBy-criterium zoekt naar een specifiek element met XPath = “// a (@ id = 'tab5')

Laten we nu op F12 drukken om de elementen op de pagina nseindia.com te inspecteren en bepaalde duidelijkheid te krijgen over elementen die overeenkomen met de @FindBy-criteria.

Er zijn twee elementen op de pagina die overeenkomen met de className = ”sel”:

naar) Het element 'Fundamentals' heeft de tag list, d.w.z.