page object model with page factory selenium tutorial
Tento podrobný výukový program vysvetľuje všetko o modeli objektových stránok (POM) pomocou Pagefactory s použitím príkladov. Môžete sa tiež naučiť implementáciu POM v seléne:
V tomto tutoriáli pochopíme, ako vytvoriť model objektu stránky pomocou prístupu Page Factory. Zameriame sa na:
- Trieda továrne
- Ako vytvoriť základný POM pomocou vzoru Page Factory
- Rôzne anotácie použité v prístupe Page Factory
Predtým, ako sa dozvieme, čo je Pagefactory a ako sa dá používať spolu s objektovým modelom Page, pochopme, čo je Page Object Model, ktorý je všeobecne známy ako POM.
=> Navštívte tu a pozrite si sériu školení pre selén pre všetkých.
Čo sa dozviete:
- Čo je to Page Object Model (POM)?
- Čo je Pagefactory?
- POM pomocou Page Factory
- často kladené otázky
- Záver
Čo je to Page Object Model (POM)?
Teoretické terminológie popisujú Objektový model stránky ako návrhový vzor používaný na zostavenie úložiska objektov pre webové prvky dostupné v testovanej aplikácii. Málokto to označuje ako rámec pre automatizáciu selénu pre danú testovanú aplikáciu.
Čo som však pochopil o pojme Page Object Model, je:
# 1) Je to návrhový vzor, v ktorom máte samostatný súbor triedy Java zodpovedajúci každej obrazovke alebo stránke v aplikácii. Súbor triedy môže obsahovať úložisko objektov prvkov používateľského rozhrania, ako aj metódy.
#dva) V prípade, že sa na stránke nachádzajú rozsiahle webové prvky, je možné triedu úložiska objektov pre stránku oddeliť od triedy, ktorá obsahuje metódy pre príslušnú stránku.
Príklad: Ak má stránka Registračný účet veľa vstupných polí, môže existovať trieda RegisterAccountObjects.java, ktorá tvorí archív objektov pre prvky používateľského rozhrania na stránke Registračné účty.
Je možné vytvoriť samostatný súbor triedy RegisterAccount.java rozširujúci alebo dediaci RegisterAccountObjects, ktorý obsahuje všetky metódy vykonávajúce rôzne akcie na stránke.
# 3) Okrem toho by v balíku mohol byť všeobecný balík so súborom {roperties, testovacími údajmi programu Excel a bežnými metódami.
Príklad: DriverFactory, ktorý sa dal veľmi ľahko použiť na všetkých stránkach aplikácie
Pochopenie POM s príkladom
Skontrolujte tu dozvedieť sa viac o POM.
Nižšie je uvedený prehľad webovej stránky:
Kliknutím na každý z týchto odkazov sa používateľ presmeruje na novú stránku.
Tu je snímka toho, ako je štruktúra projektu so selénom zostavená pomocou objektového modelu stránky zodpovedajúceho každej stránke na webe. Každá trieda Java obsahuje úložisko objektov a metódy na vykonávanie rôznych akcií na stránke.
Okrem toho bude existovať ďalší JUNIT alebo TestNG alebo súbor triedy Java, ktorý bude volať na súbory triedy z týchto stránok.
Prečo používame objektový model stránky?
O používaní tohto výkonného selénového rámca, ktorý sa nazýva POM alebo stránkový objektový model, panuje rozruch. Teraz vyvstáva otázka „Prečo používať POM?“.
Jednoduchá odpoveď na to je, že POM je kombináciou dátovo riadeného, modulárneho a hybridného rámca. Jedná sa o prístup k systematickému usporiadaniu skriptov takým spôsobom, že uľahčuje QA udržiavanie kódu bez problémov a tiež pomáha predchádzať nadbytočnému alebo duplicitnému kódu.
Napríklad ak dôjde k zmene hodnoty lokátora na konkrétnej stránke, je veľmi ľahké ju identifikovať a vykonať túto rýchlu zmenu iba v skripte príslušnej stránky bez toho, aby to malo vplyv na iný kód.
Koncept Selenium Webdriver používame v modeli Page Object Model z nasledujúcich dôvodov:
- V tomto modeli POM je vytvorené úložisko objektov. Je nezávislý od testovacích prípadov a môže byť znovu použitý pre iný projekt.
- Konvencia názvov metód je veľmi ľahká, zrozumiteľná a realistickejšia.
- Pod objektovým modelom stránky vytvárame triedy stránok, ktoré je možné znova použiť v inom projekte.
- Objektový model Page je pre rozvinutý rámec ľahký vďaka niekoľkým výhodám.
- V tomto modeli sa vytvárajú samostatné triedy pre rôzne stránky webovej aplikácie, ako je prihlasovacia stránka, domovská stránka, stránka podrobností zamestnancov, stránka so zmenami hesla atď.
- Ak dôjde k zmene v ktoromkoľvek prvku webovej stránky, stačí vykonať zmeny iba v jednej triede, a nie vo všetkých triedach.
- Navrhnutý skript je viac prístupný, čitateľný a udržiavateľný v prístupe k modelu objektu stránky.
- Jeho projektová štruktúra je celkom ľahká a zrozumiteľná.
- Môže použiť PageFactory v objektovom modeli stránky na inicializáciu webového prvku a ukladanie prvkov do medzipamäte.
- TestNG je tiež možné integrovať do prístupu k objektovému modelu stránky.
Implementácia jednoduchého POM v seléne
# 1) Scenár na automatizáciu
Teraz automatizujeme daný scenár pomocou modelu objektu stránky.
Scenár je vysvetlený nižšie:
Krok 1: Spustite web „https: //demo.vtiger.com“.
Krok 2: Zadajte platné poverenie.
Krok 3: Prihláste sa na stránku.
Krok 4: Overte domovskú stránku.
Krok 5: Odhláste sa z lokality.
Krok 6: Zatvorte Prehliadač.
# 2) Selénové skripty pre uvedený scenár v POM
Teraz v Eclipse vytvoríme štruktúru POM, ako je vysvetlené nižšie:
Krok 1: Vytvorte projekt v štruktúre Eclipse - POM:
a) Vytvorte projektový „Page Object Model“.
b) Vytvorte 3 balík v rámci projektu.
- knižnica
- strán
- testovacie prípady
Knižnica: Do tohto poľa vložíme kódy, ktoré je potrebné volať znova a znova v našich testovacích prípadoch, ako je spustenie prehliadača, snímky obrazovky atď. Používateľ môže do nej pridať ďalšie triedy na základe potreby projektu.
Stránky: V rámci toho sa vytvárajú triedy pre každú stránku vo webovej aplikácii a môžu pridať ďalšie triedy stránok na základe počtu stránok v aplikácii.
Testovacie prípady: V tejto časti napíšeme testovací prípad prihlásenia a podľa potreby môžeme pridať ďalšie testovacie prípady na otestovanie celej aplikácie.
c) Triedy v rámci balíkov sú zobrazené na obrázku nižšie.
Krok dva: V balíku knižníc vytvorte nasledujúce triedy.
Browser.java: V tejto triede sú definované 3 prehliadače (Firefox, Chrome a Internet Explorer), ktoré sa volajú v testovacom prípade prihlásenia. Na základe požiadavky môže používateľ otestovať aplikáciu aj v rôznych prehliadačoch.
package library; import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; import org.openqa.selenium.firefox.FirefoxDriver; import org.openqa.selenium.ie.InternetExplorerDriver; public class Browser { static WebDriver driver; public static WebDriver StartBrowser(String browsername , String url) { // If the browser is Firefox if (browsername.equalsIgnoreCase('Firefox')) { // Set the path for geckodriver.exe System.setProperty('webdriver.firefox.marionette',' E://Selenium//Selenium_Jars//geckodriver.exe '); driver = new FirefoxDriver(); } // If the browser is Chrome else if (browsername.equalsIgnoreCase('Chrome')) { // Set the path for chromedriver.exe System.setProperty('webdriver.chrome.driver','E://Selenium//Selenium_Jars//chromedriver.exe'); driver = new ChromeDriver(); } // If the browser is IE else if (browsername.equalsIgnoreCase('IE')) { // Set the path for IEdriver.exe System.setProperty('webdriver.ie.driver','E://Selenium//Selenium_Jars//IEDriverServer.exe'); driver = new InternetExplorerDriver(); } driver.manage().window().maximize(); driver.get(url); return driver; } }
ScreenShot.java: V tejto triede je napísaný program snímok obrazovky, ktorý sa vyvolá v testovacom prípade, keď chce používateľ vytvoriť snímku obrazovky s informáciami o tom, či test zlyhá alebo vyhovuje.
package library; import java.io.File; import org.apache.commons.io.FileUtils; import org.openqa.selenium.OutputType; import org.openqa.selenium.TakesScreenshot; import org.openqa.selenium.WebDriver; public class ScreenShot { public static void captureScreenShot(WebDriver driver, String ScreenShotName) { try { File screenshot=((TakesScreenshot)driver).getScreenshotAs(OutputType. FILE ); FileUtils.copyFile(screenshot, new File('E://Selenium//'+ScreenShotName+'.jpg')); } catch (Exception e) { System. out .println(e.getMessage()); e.printStackTrace(); } } }
Krok 3: Vytvorte triedy stránok v časti Balík stránok.
HomePage.java: Toto je trieda domovskej stránky, v ktorej sú definované všetky prvky domovskej stránky a metódy.
package pages; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; public class HomePage { WebDriver driver; By logout = By.id('p_lt_ctl03_wSOB_btnSignOutLink'); By home = By.id('p_lt_ctl02_wCU2_lblLabel'); //Constructor to initialize object public HomePage(WebDriver dr) { this .driver=dr; } public String pageverify() { return driver.findElement(home).getText(); } public void logout() { driver.findElement(logout).click(); } }
LoginPage.java: Toto je trieda prihlasovacej stránky, v ktorej sú definované všetky prvky prihlasovacej stránky a metódy.
package pages; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; public class LoginPage { WebDriver driver; By UserID = By.xpath('//*(contains(@id,'Login1_UserName'))'); By password = By.xpath('//*(contains(@id,'Login1_Password'))'); By Submit = By.xpath('//*(contains(@id,'Login1_LoginButton'))'); //Constructor to initialize object public LoginPage(WebDriver driver) { this .driver = driver; } public void loginToSite(String Username, String Password) { this .enterUsername(Username); this .enterPasssword(Password); this .clickSubmit(); } public void enterUsername(String Username) { driver.findElement(UserID).sendKeys(Username); } public void enterPasssword(String Password) { driver.findElement(password).sendKeys(Password); } public void clickSubmit() { driver.findElement(Submit).click(); } }
Krok 4: Vytvorte testovacie prípady pre scenár prihlásenia.
LoginTestCase.java: Toto je trieda LoginTestCase, kde sa vykoná testovací prípad. Užívateľ môže tiež vytvoriť viac testovacích prípadov podľa potreby projektu.
package testcases; import java.util.concurrent.TimeUnit; import library.Browser; import library.ScreenShot; import org.openqa.selenium.WebDriver; import org.testng.Assert; import org.testng.ITestResult; import org.testng.annotations.AfterMethod; import org.testng.annotations.AfterTest; import org.testng.annotations.BeforeTest; import org.testng.annotations.Test; import pages.HomePage; import pages.LoginPage; public class LoginTestCase { WebDriver driver; LoginPage lp; HomePage hp; int i = 0; // Launch of the given browser. @BeforeTest public void browserlaunch() { driver = Browser.StartBrowser('Chrome', 'http://demostore.kenticolab.com/Special-Pages/Logon.aspx'); driver.manage().timeouts().implicitlyWait(30,TimeUnit. SECONDS ); lp = new LoginPage(driver); hp = new HomePage(driver); } // Login to the Site. @Test(priority = 1) public void Login() { lp.loginToSite('gaurav.3n@gmail.com','Test@123'); } // Verifing the Home Page. @Test(priority = 2) public void HomePageVerify() { String HomeText = hp.pageverify(); Assert.assertEquals(HomeText, 'Logged on as'); } // Logout the site. @Test(priority = 3) public void Logout() { hp.logout(); } // Taking Screen shot on test fail @AfterMethod public void screenshot(ITestResult result) { i = i+1; String name = 'ScreenShot'; String x = name+String.valueOf(i); if (ITestResult. FAILURE == result.getStatus()) { ScreenShot.captureScreenShot(driver, x); } } @AfterTest public void closeBrowser() { driver.close(); } }
Krok 5: Vykonajte „LoginTestCase.java“.
Krok 6: Výstup objektového modelu stránky:
- Spustite prehliadač Chrome.
- Demonštračná webová stránka sa otvorí v prehliadači.
- Prihláste sa na demo stránku.
- Overte domovskú stránku.
- Odhláste sa z lokality.
- Zatvorte prehliadač.
Teraz sa pozrime na hlavný koncept tohto tutoriálu, ktorý upúta pozornosť, t.j. „Pagefactory“.
Čo je Pagefactory?
PageFactory je spôsob implementácie „Page Object Model“. Postupujeme tu podľa princípu oddelenia stránok a úložísk testovacích metód. Jedná sa o vstavaný koncept Page Object Model, ktorý je veľmi optimalizovaný.
Teraz si objasnime pojem Pagefactory.
# 1) Po prvé, koncept s názvom Pagefactory poskytuje alternatívny spôsob z hľadiska syntaxe a sémantiky pre vytváranie archívu objektov pre webové prvky na stránke.
#dva) Po druhé, používa trochu inú stratégiu na inicializáciu webových prvkov.
# 3) Úložisko objektov pre webové prvky používateľského rozhrania bolo možné vytvoriť pomocou:
- Zvyčajné „POM bez Pagefactory“ a
- Prípadne môžete použiť program „POM with Pagefactory“.
Nižšie je uvedené ich obrázkové znázornenie:
Teraz sa pozrieme na všetky aspekty, ktoré odlišujú obvyklý POM od POM pomocou Pagefactory.
a) Rozdiel v syntaxi umiestnenia prvku pomocou obvyklého POM vs POM s Pagefactory.
Napríklad , Kliknite tu vyhľadajte vyhľadávacie pole, ktoré sa zobrazuje na stránke.
POM bez Pagefactory:
# 1) Ďalej je uvedené, ako vyhľadáte vyhľadávacie pole pomocou obvyklého POM:
WebElement searchNSETxt=driver.findElement(By.id(“searchBox”));
# 2) Nasledujúci krok odovzdá hodnotu „investícia“ do poľa Vyhľadať NSE.
searchNSETxt.sendkeys(“investment”);
POM pomocou Pagefactory:
# 1) Vyhľadávacie pole môžete vyhľadať pomocou aplikácie Pagefactory, ako je uvedené nižšie.
Anotácia @FindBy sa v Pagefactory používa na identifikáciu prvku, zatiaľ čo POM bez Pagefactory používa driver.findElement () metóda na vyhľadanie prvku.
Druhé vyhlásenie pre Pagefactory po @FindBy je priradenie typu WebElement trieda, ktorá funguje úplne podobne ako priradenie názvu prvku typu WebElement triedy ako návratový typ metódy driver.findElement () ktorý sa používa v obvyklom POM (v tomto príklade searchNSETxt).
Pozrime sa na @FindBy anotácie podrobne v nadchádzajúcej časti tohto tutoriálu.
@FindBy(id = 'searchBox') WebElement searchNSETxt;
#dva) Nasledujúci krok odovzdá hodnotu „investícia“ do poľa Hľadať NSE a syntax zostane rovnaká ako u obvyklého POM (POM bez Pagefactory).
searchNSETxt.sendkeys(“investment”);
b) Rozdiel v stratégii inicializácie webových prvkov pomocou obvyklých POM vs POM s Pagefactory.
Používanie POM bez Pagefactory:
Ďalej je uvedený útržok kódu na nastavenie cesty k ovládaču Chrome. Inštancia WebDriver sa vytvorí s ovládačom názvu a ChromeDriver sa priradí k „ovládaču“. Rovnaký objekt ovládača sa potom použije na spustenie webovej stránky Národnej burzy cenných papierov, vyhľadanie políčka searchBox a zadanie hodnoty reťazca do poľa.
Bod, ktorý by som tu chcel zdôrazniť, je, že keď je to POM bez továrne na stránky, inštancia ovládača sa vytvorí pôvodne a každý webový prvok sa čerstvo inicializuje zakaždým, keď dôjde k volaniu na tento webový prvok pomocou ovládača.findElement () alebo ovládača .findElements ().
To je dôvod, prečo je s novým krokom driver.findElement () pre prvok znova prehľadaná štruktúra DOM a na tejto stránke je vykonaná obnovená identifikácia prvku.
System.setProperty('webdriver.chrome.driver', 'C:\eclipse-workspace\automationframework\src\test\java\Drivers\chromedriver.exe'); WebDriver driver = new ChromeDriver(); driver.get('http://www.nseindia.com/'); WebElement searchNSETxt=driver.findElement(By.id(“searchBox”)); searchNSETxt.sendkeys(“investment”);
Používanie POM s Pagefactory:
Okrem použitia poznámky @FindBy namiesto metódy driver.findElement () sa pre stránku Pagefactory používa dodatočne aj nasledujúci útržok kódu. Statická metóda initElements () triedy PageFactory sa používa na inicializáciu všetkých prvkov používateľského rozhrania na stránke hneď po načítaní stránky.
public PagefactoryClass(WebDriver driver) { this.driver = driver; PageFactory.initElements(driver, this); }
Vyššie uvedená stratégia mierne odlišuje prístup PageFactory od obvyklého POM. V obvyklom POM musí byť webový prvok explicitne inicializovaný, zatiaľ čo v prístupe Pagefactory sú všetky prvky inicializované pomocou initElements () bez výslovnej inicializácie každého webového prvku.
Napríklad: Ak bol prvok WebElement deklarovaný, ale nebol inicializovaný v obvyklom POM, bude vyvolaná chyba „inicializovať premennú“ alebo NullPointerException. Preto je v bežnom POM každý WebElement výslovne inicializovaný. PageFactory má v tomto prípade výhodu oproti obvyklému POM.
Neinicializujeme webový prvok BDate (POM bez Pagefactory), môžete vidieť, že chyba „Inicializovať premennú“ sa zobrazuje a vyzýva používateľa, aby ju inicializoval na nulu, preto nemôžete predpokladať, že sa prvky implicitne inicializujú pri ich lokalizácii.
Explicitne inicializovaný prvok BDate (POM bez Pagefactory):
Teraz sa pozrime na niekoľko príkladov kompletného programu pomocou PageFactory, aby sme vylúčili akékoľvek nejasnosti v porozumení aspektu implementácie.
Príklad 1:
- Prejdite na stránku „http://www.nseindia.com/“
- V rozbaľovacej ponuke vedľa vyhľadávacieho poľa vyberte možnosť Deriváty mien.
- Vyhľadajte výraz „USDINR“. Na výslednej stránke overte text „americký dolár-indická rupia - USDINR“.
Štruktúra programu:
- Stránka PagefactoryClass.java, ktorá obsahuje úložisko objektov pomocou konceptu page factory pre nseindia.com, ktorý je konštruktorom na inicializáciu všetkých webových prvkov, pomocou metódy selectCurrentDerivative () vyberte hodnotu z rozbaľovacieho poľa Vyhľadávacie pole, vyberte symbol () a vyberte symbol na stránka, ktorá sa zobrazí ďalej, a verifytext () na overenie, či je hlavička stránky podľa očakávania alebo nie.
- NSE_MainClass.java je hlavný súbor triedy, ktorý volá všetky vyššie uvedené metódy a vykonáva príslušné akcie na webe NSE.
PagefactoryClass.java
package com.pagefactory.knowledge; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.FindBy; import org.openqa.selenium.support.PageFactory; import org.openqa.selenium.support.ui.Select; public class PagefactoryClass { WebDriver driver; @FindBy(id = 'QuoteSearch') WebElement Searchbox; @FindBy(id = 'cidkeyword') WebElement Symbol; @FindBy(id = 'companyName') WebElement pageText; public PagefactoryClass(WebDriver driver) { this.driver = driver; PageFactory.initElements(driver, this); } public void selectCurrentDerivative(String derivative) { Select select = new Select(Searchbox); select.selectByVisibleText(derivative); // 'Currency Derivatives' } public void selectSymbol(String symbol) { Symbol.sendKeys(symbol); } public void verifytext() { if (pageText.getText().equalsIgnoreCase('U S Dollar-Indian Rupee - USDINR')) { System.out.println('Page Header is as expected'); } else System.out.println('Page Header is NOT as expected'); } }
NSE_MainClass.java
package com.pagefactory.knowledge; import java.util.List; import java.util.concurrent.TimeUnit; import org.openqa.selenium.By; import org.openqa.selenium.StaleElementReferenceException; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.chrome.ChromeDriver; public class NSE_MainClass { static PagefactoryClass page; static WebDriver driver; public static void main(String() args) { System.setProperty('webdriver.chrome.driver', 'C:\Users\eclipse-workspace\automation-framework\src\test\java\Drivers\chromedriver.exe'); driver = new ChromeDriver(); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); driver.get('https://www.nseindia.com/'); driver.manage().window().maximize(); test_Home_Page_ofNSE(); } public static void test_Home_Page_ofNSE() throws StaleElementReferenceException { page = new PagefactoryClass(driver); page.selectCurrentDerivative('Currency Derivatives'); page.selectSymbol('USD'); List Options = driver.findElements(By.xpath('//span(contains(.,'USD'))')); int count = Options.size(); for (int i = 0; i Príklad 2:
- Prejdite na „https://www.shoppersstop.com/brands“
- Prejdite na odkaz Haute curry.
- Skontrolujte, či stránka Haute Curry obsahuje text „Spustiť niečo nové“.
Štruktúra programu
- shopperstopPagefactory.java, ktorá obsahuje úložisko objektov s využitím konceptu pagefactory pre shoppersstop.com, čo je konštruktor na inicializáciu všetkých webových prvkov, metódy closeExtraPopup () na spracovanie vyskakovacieho okna s upozornením, ktoré sa otvorí, kliknite na tlačidloOnHauteCurryLink () a kliknite na Haute Curry Prepojením a overenímStartNewSomething () overte, či stránka Haute Curry obsahuje text „Spustiť nové niečo“.
- Shopperstop_CallPagefactory.java je súbor hlavnej triedy, ktorý volá všetky vyššie uvedené metódy a vykonáva príslušné akcie na webe NSE.
shopperstopPagefactory.java
package com.inportia.automation_framework; import org.openqa.selenium.JavascriptExecutor; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.FindBy; import org.openqa.selenium.support.PageFactory; public class shopperstopPagefactory { WebDriver driver; @FindBy(id='firstVisit') WebElement extrapopup; @FindBy(xpath='//img(@src='https://sslimages.shoppersstop.com /sys-master/root/haf/h3a/9519787376670/brandMedia_HauteCurry_logo.png')') WebElement HCLink; @FindBy(xpath='/html/body/main/footer/div(1)/p') WebElement Startnew; public shopperstopPagefactory(WebDriver driver) { this.driver=driver; PageFactory.initElements(driver, this); } public void closeExtraPopup() { extrapopup.click(); } public void clickOnHauteCurryLink() { JavascriptExecutor js = (JavascriptExecutor) driver; js.executeScript('arguments(0).click();',HCLink); js.executeAsyncScript('window.setTimeout(arguments(arguments.length - 1), 10000);'); if(driver.getCurrentUrl().equals('https://www.shoppersstop.com/haute-curry')) { System.out.println('We are on the Haute Curry page'); } else { System.out.println('We are NOT on the Haute Curry page'); } } public void verifyStartNewSomething() { if (Startnew.getText().equalsIgnoreCase('Start Something New')) { System.out.println('Start new something text exists'); } else System.out.println('Start new something text DOESNOT exists'); } }
Shopperstop_CallPagefactory.java
package com.inportia.automation_framework; import java.util.concurrent.TimeUnit; import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; public class Shopperstop_CallPagefactory extends shopperstopPagefactory { public Shopperstop_CallPagefactory(WebDriver driver) { super(driver); // TODO Auto-generated constructor stub } static WebDriver driver; public static void main(String() args) { System.setProperty('webdriver.chrome.driver', 'C:\eclipse-workspace\automation-framework\src\test\java\Drivers\chromedriver.exe'); driver = new ChromeDriver(); Shopperstop_CallPagefactory s1=new Shopperstop_CallPagefactory(driver); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); driver.get('https://www.shoppersstop.com/brands'); s1.clickOnHauteCurryLink(); s1.verifyStartNewSomething(); } }
POM pomocou Page Factory
Videonávody - POM s funkciou Page Factory
Časť I.
Časť II
Trieda Factory sa používa na zjednodušenie a zjednodušenie používania objektov stránky.
- Najskôr musíme nájsť webové prvky pomocou anotácie @FindBy v triedach stránok .
- Pri inštancii triedy stránky potom inicializujte prvky pomocou initElements ().
# 1) @FindBy:
Anotácia @FindBy sa v aplikácii PageFactory používa na vyhľadanie a deklaráciu webových prvkov pomocou rôznych lokátorov.Tu odovzdáme atribút a jeho hodnotu použitú na lokalizáciu webového prvku do anotácie @FindBy a potom je deklarovaný WebElement.
Existujú 2 spôsoby, ako je možné anotáciu použiť.
Napríklad:
@FindBy(how = How.ID, using='EmailAddress') WebElement Email; @FindBy(id='EmailAddress') WebElement Email;
Prvý z nich je však štandardný spôsob deklarovania WebElements.
„Ako“ je trieda a má statické premenné ako ID, XPATH, CLASSNAME, LINKTEXT atď.
'použitím' - Priradiť hodnotu statickej premennej.
Vo vyššie uvedenom príklad , na vyhľadanie webového prvku „Email“ sme použili atribút „id“. Podobne môžeme použiť nasledujúce lokátory s anotáciami @FindBy:
- className
- css
- názov
- xpath
- tagName
- linkText
- partialLinkText
# 2) initElements ():
InitElements je statická metóda triedy PageFactory, ktorá sa používa na inicializáciu všetkých webových prvkov umiestnených v anotácii @FindBy. Teda, ľahké vytváranie inštancií tried stránok.
initElements(WebDriver driver, java.lang.Class pageObjectClass)
Mali by sme tiež pochopiť, že POM dodržiava zásady OOPS.
- WebElements sú deklarované ako súkromné členské premenné (skrývanie údajov).
- Viazanie WebElements s príslušnými metódami (zapuzdrenie).
Kroky na vytvorenie POM pomocou vzoru Page Factory
# 1) Vytvorte samostatný súbor triedy Java pre každú webovú stránku.
#dva) V každej triede by mali byť všetky prvky WebElements deklarované ako premenné (pomocou anotácie - @FindBy) a inicializované pomocou metódy initElement (). Deklarované prvky WebElements musia byť inicializované, aby sa mohli použiť v metódach akcie.
# 3) Definujte zodpovedajúce metódy pôsobiace na tieto premenné.
Uveďme si príklad jednoduchého scenára:
- Otvorte adresu URL aplikácie.
- Zadajte údaje o e-mailovej adrese a hesle.
- Kliknite na tlačidlo Prihlásiť sa.
- Overte úspešnú prihlasovaciu správu na stránke vyhľadávania.
Vrstva stránky
Máme tu 2 stránky,
- Domovská stránka - Stránka, ktorá sa otvorí po zadaní adresy URL a kde zadáme údaje pre prihlásenie.
- Vyhľadávacia stránka - Stránka, ktorá sa zobrazí po úspešnom prihlásení.
Vo vrstve stránky je každá stránka webovej aplikácie deklarovaná ako samostatná trieda Java a sú tam uvedené jej lokátory a akcie.
Kroky na vytvorenie POM s príkladom v reálnom čase
# 1) Vytvorte triedu Java pre každú stránku:
V tomto príklad , prejdeme na 2 webové stránky, na stránky „Domov“ a „Vyhľadávanie“.
Preto vytvoríme 2 triedy Java v Page Layer (alebo v balíku povedzme com.automation.pages).
Package Name :com.automation.pages HomePage.java SearchPage.java
# 2) Definujte WebElements ako premenné pomocou anotácie @FindBy:
Spolupracovali by sme s:
- Pole tlačidla E-mail, heslo, prihlásenie na domovskej stránke.
- Správa bola úspešná na stránke vyhľadávania.
Definujeme teda WebElements pomocou @FindBy
Napríklad: Ak sa chystáme identifikovať EmailAddress pomocou atribútu id, potom je jej deklarácia premennej
//Locator for EmailId field @FindBy(how=How.ID,using='EmailId') private WebElementEmailIdAddress;
# 3) Vytvorte metódy pre akcie vykonávané na WebElements.
Na WebElements sa vykonávajú nasledujúce akcie:
- Do poľa E-mailová adresa zadajte akciu.
- Do poľa Heslo zadajte akciu.
- Kliknite na akciu na tlačidle Prihlásenie.
Napríklad, Užívateľom definované metódy sa vytvárajú pre každú akciu na WebElement ako,
public void typeEmailId(String Id){ driver.findElement(EmailAddress).sendKeys(Id) }
Tu sa Id odovzdá ako parameter v metóde, pretože vstup bude odoslaný používateľom z hlavného testovacieho prípadu.
Poznámka :V každej z tried vo stránke Page Layer musí byť vytvorený konštruktor, aby sa získala inštancia ovládača z triedy Main v testovacej vrstve a tiež aby sa inicializovali WebElements (objekty stránky) deklarované v triede stránky pomocou PageFactory.InitElement (). .
Tu neiniciujeme ovládač, skôr je jeho inštancia prijatá z hlavnej triedy, keď je vytvorený objekt triedy Page Layer.
InitElement () - slúži na inicializáciu deklarovaných WebElements pomocou inštancie ovládača z hlavnej triedy. Inými slovami, WebElements sa vytvárajú pomocou inštancie ovládača. Až po inicializácii prvkov WebElements ich možno použiť v metódach na vykonávanie akcií.
Pre každú stránku sú vytvorené dve triedy Java, ako je uvedené nižšie:
HomePage.java
//package com.automation.pages; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; public class HomePage { WebDriver driver; // Locator for Email Address @FindBy(how=How.ID,using='EmailId') private WebElement EmailIdAddress; // Locator for Password field @FindBy(how=How.ID,using='Password ') private WebElement Password; // Locator for SignIn Button @FindBy(how=How.ID,using='SignInButton') private WebElement SignInButton; // Method to type EmailId public void typeEmailId(String Id){ driver.findElement(EmailAddress).sendKeys(Id) } // Method to type Password public void typePassword(String PasswordValue){ driver.findElement(Password).sendKeys(PasswordValue) } // Method to click SignIn Button public void clickSignIn(){ driver.findElement(SignInButton).click() } // Constructor // Gets called when object of this page is created in MainClass.java public HomePage(WebDriver driver) { // 'this' keyword is used here to distinguish global and local variable 'driver' //gets driver as parameter from MainClass.java and assigns to the driver instance in this class this.driver=driver; PageFactory.initElements(driver,this); // Initialises WebElements declared in this class using driver instance. } }
SearchPage.Java
//package com.automation.pages; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; public class SearchPage{ WebDriver driver; // Locator for Success Message @FindBy(how=How.ID,using='Message') private WebElement SuccessMessage; // Method that return True or False depending on whether the message is displayed public Boolean MessageDisplayed(){ Boolean status = driver.findElement(SuccessMessage).isDisplayed(); return status; } // Constructor // This constructor is invoked when object of this page is created in MainClass.java public SearchPage(WebDriver driver) { // 'this' keyword is used here to distinguish global and local variable 'driver' //gets driver as parameter from MainClass.java and assigns to the driver instance in this class this.driver=driver; PageFactory.initElements(driver,this); // Initialises WebElements declared in this class using driver instance. } }
Testovacia vrstva
V tejto triede sú implementované testovacie prípady. Vytvoríme samostatný balík povedzme com.automation.test a potom tu vytvoríme triedu Java (MainClass.java)
Kroky na vytvorenie testovacích prípadov:
- Inicializujte ovládač a otvorte aplikáciu.
- Vytvorte objekt triedy PageLayer (pre každú webovú stránku) a odovzdajte inštanciu ovládača ako parameter.
- Pomocou vytvoreného objektu zavolajte metódy v triede PageLayer (pre každú webovú stránku), aby ste mohli vykonať akcie / overenie.
- Opakujte krok 3, kým nevykonáte všetky činnosti, a potom zatvorte ovládač.
//package com.automation.test; import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; public class MainClass { public static void main(String() args) { System.setProperty('webdriver.chrome.driver','./exefiles/chromedriver.exe'); WebDriver driver= new ChromeDriver(); driver.manage().window().maximize(); driver.get('URL mentioned here'); // Creating object of HomePage and driver instance is passed as parameter to constructor of Homepage.Java HomePage homePage= new HomePage(driver); // Type EmailAddress homePage.typeEmailId('abc@ymail.com'); // EmailId value is passed as paramter which in turn will be assigned to the method in HomePage.Java // Type Password Value homePage.typePassword('password123'); // Password value is passed as paramter which in turn will be assigned to the method in HomePage.Java // Click on SignIn Button homePage.clickSignIn(); // Creating an object of LoginPage and driver instance is passed as parameter to constructor of SearchPage.Java SearchPage searchPage= new SearchPage(driver); //Verify that Success Message is displayed Assert.assertTrue(searchPage.MessageDisplayed()); //Quit browser driver.quit(); } }
Pri deklarovaní prvkov WebElements sa používa hierarchia typu anotácie
Anotácie sa používajú na zostavenie stratégie umiestnenia pre prvky používateľského rozhrania.
# 1) @FindBy
Pokiaľ ide o Pagefactory, @FindBy funguje ako kúzelná palička. Dodáva konceptu všetku silu. Teraz ste si vedomí, že anotácia @FindBy v Pagefactory funguje rovnako ako anotácia driver.findElement () v obvyklom modeli stránky. Používa sa na vyhľadanie WebElement / WebElements s jedným kritériom .
# 2) @FindBys
Používa sa na vyhľadanie WebElement s viac ako jedno kritérium a musia zodpovedať všetkým uvedeným kritériám. Tieto kritériá by sa mali uviesť vo vzťahu rodiča a dieťaťa. Inými slovami, toto používa podmienený vzťah A na vyhľadanie WebElements pomocou zadaných kritérií. Na definovanie každého kritéria používa viacnásobné pole @FindBy.
Napríklad:
Zdrojový kód HTML prvku WebElement:
V POM:
@FindBys({ @FindBy(id = 'searchId_1'), @FindBy(name = 'search_field') }) WebElementSearchButton;
Vo vyššie uvedenom príklade je prvok WebElement „SearchButton“ umiestnený, iba ak je zhoduje sa s oboma kritériá, ktorých hodnota id je „searchId_1“ a hodnota názvu je „search_field“. Upozorňujeme, že prvé kritérium patrí nadradenej značke a druhé kritérium podradenej značke.
# 3) @FindAll
Používa sa na vyhľadanie WebElement s viac ako jedno kritérium a musí zodpovedať aspoň jednému z daných kritérií. Pri hľadaní prvkov WebElements sa používa ALEBO podmienené vzťahy. Na definovanie všetkých kritérií používa viacnásobné @FindBy.
Napríklad:
Zdrojový kód HTML:
V POM:
@FindBys({ @FindBy(id = 'UsernameNameField_1'), // doesn’t match @FindBy(name = 'User_Id') //matches @FindBy(className = “UserName_r”) //matches }) WebElementUserName;
Vo vyššie uvedenom príklade je WebElement „Používateľské meno umiestnené, ak je zápasy aspoň s jedným uvedených kritérií.
# 4) @CacheLookUp
Keď sa WebElement v testovacích prípadoch používa častejšie, selén vyhľadá WebElement pri každom spustení testovacieho skriptu. V tých prípadoch, keď sa určité WebElements globálne používajú pre všetky TC ( Napríklad, Scenár prihlásenia sa stane pre každú TC), túto anotáciu je možné použiť na udržanie týchto WebElements v pamäti cache hneď po prvom prečítaní.
To zase pomáha kódu, aby sa vykonával rýchlejšie, pretože zakaždým, keď nemusí hľadať WebElement na stránke, môže skôr získať svoj odkaz z pamäte.
Môže to byť ako predpona pre ľubovoľné z @FindBy, @FindBys a @FindAll.
Napríklad:
@CacheLookUp @FindBys({ @FindBy(id = 'UsernameNameField_1'), @FindBy(name = 'User_Id') @FindBy(className = “UserName_r”) }) WebElementUserName;
Upozorňujeme, že táto anotácia by sa mala používať iba pre prvky WebElements, ktorých hodnota atribútu (napríklad xpath, názov ID, názov triedy atď.) Sa nemení dosť často. Po prvom umiestnení WebElement si udržiava svoj odkaz v pamäti cache.
Takže potom dôjde k zmene v atribúte WebElement po niekoľkých dňoch, selén nebude schopný nájsť prvok, pretože už má v pamäti cache svoj starý odkaz a nebude brať ohľad na nedávnu zmenu vo WebElement.
Viac na PageFactory.initElements ()
Teraz, keď rozumieme stratégii Pagefactory pri inicializácii webových prvkov pomocou nástroja InitElements (), skúsme pochopiť rôzne verzie metódy.
Metóda, ako vieme, vezme objekt ovládača a aktuálny objekt triedy ako vstupné parametre a vráti objekt stránky implicitnou a proaktívnou inicializáciou všetkých prvkov na stránke.
V praxi je použitie konštruktora, ako je uvedené v predchádzajúcej časti, výhodnejšie ako iné spôsoby jeho použitia.
Alternatívne spôsoby volania tejto metódy sú:
# 1) Namiesto použitia ukazovateľa „tento“ môžete vytvoriť aktuálny objekt triedy, odovzdať mu inštanciu ovládača a zavolať statickú metódu initElements s parametrami, tj. Objekt ovládača a objekt triedy, ktorý bol práve vytvorený.
public PagefactoryClass(WebDriver driver) { //version 2 PagefactoryClass page=new PagefactoryClass(driver); PageFactory.initElements(driver, page); }
#dva) Tretím spôsobom, ako inicializovať prvky pomocou triedy Pagefactory, je použitie API s názvom „reflexia“. Áno, namiesto vytvorenia objektu triedy pomocou „nového“ kľúčového slova je možné odovzdať classname.class ako súčasť vstupného parametra initElements ().
public PagefactoryClass(WebDriver driver) { //version 3 PagefactoryClass page=PageFactory.initElements(driver, PagefactoryClass.class); }
často kladené otázky
Otázka č. 1) Aké sú rôzne stratégie lokátorov, ktoré sa používajú pre @FindBy?
Odpoveď: Jednoduchá odpoveď na to je, že pre @FindBy neexistujú žiadne rôzne stratégie lokátorov.
Používajú rovnakých 8 lokátorských stratégií, ktoré používa metóda findElement () v obvyklom POM:
- id
- názov
- className
- xpath
- css
- tagName
- linkText
- partialLinkText
Otázka č. 2) Existujú aj iné verzie použitia anotácií @FindBy?
Odpoveď: Ak je potrebné prehľadať webový prvok, použijeme anotáciu @FindBy. Vypracujeme tiež alternatívne spôsoby použitia @FindBy spolu s rôznymi lokátorskými stratégiami.
Už sme videli, ako používať verziu 1 @FindBy:
@FindBy(id = 'cidkeyword') WebElement Symbol;
Verzia 2 @FindBy je odovzdaním vstupného parametra ako Ako a Použitím .
Ako hľadá stratégiu lokátora, pomocou ktorej by bol webový prvok identifikovaný. Kľúčové slovo použitím definuje hodnotu lokátora.
Pre lepšie pochopenie pozri nižšie
- How.ID vyhľadáva prvok pomocou id stratégia a prvok, ktorý sa pokúša identifikovať, má id = kľúčové slovo.
@FindBy(how = How.ID, using = ' cidkeyword') WebElement Symbol;
- How.CLASS_NAME vyhľadáva prvok pomocou className stratégia a prvok, ktorý sa pokúša identifikovať, má class = nová trieda.
@FindBy(how = How.CLASS_NAME, using = 'newclass') WebElement Symbol;
Otázka č. 3) Existuje rozdiel medzi týmito dvoma verziami @FindBy?
Odpoveď: Odpoveď je nie, medzi týmito dvoma verziami nie je žiadny rozdiel. Je to len tak, že prvá verzia je kratšia a ľahšia v porovnaní s druhou verziou.
Otázka č. 4) Čo použijem v pagefactory v prípade, že existuje zoznam webových prvkov, ktoré sa majú umiestniť?
Odpoveď: V obvyklom vzorovom dizajne objektu stránky máme program driver.findElements () na vyhľadanie viacerých prvkov patriacich do rovnakej triedy alebo názvu značky, ale ako nájdeme tieto prvky v prípade modelu objektu stránky pomocou nástroja Pagefactory? Najjednoduchší spôsob, ako dosiahnuť tieto prvky, je použiť rovnakú anotáciu @FindBy.
Rozumiem, že sa tento riadok zdá byť škrabadlom pre mnohých z vás. Ale áno, je to odpoveď na otázku.
Pozrime sa na nasledujúci príklad:
Pri použití obvyklého objektového modelu stránky bez Pagefactory použijete driver.findElements na vyhľadanie viacerých prvkov, ako je uvedené nižšie:
private List multipleelements_driver_findelements = driver.findElements (By.class(“last”));
To isté možno dosiahnuť pomocou objektového modelu stránky s Pagefactory, ako je uvedené nižšie:
@FindBy (how = How.CLASS_NAME, using = 'last') private List multipleelements_FindBy;
V zásade platí, že priradenie prvkov k zoznamu typu WebElement robí trik bez ohľadu na to, či sa stránka Pagefactory používa alebo nepoužíva pri identifikácii a lokalizácii prvkov.
Otázka č. 5) Je možné v rovnakom programe použiť návrh objektu Page bez Pagefactory aj s Pagefactory?
Odpoveď: Áno, v rovnakom programe je možné použiť návrh objektu stránky bez Pagefactory aj s Pagefactory. Môžete prejsť programom uvedeným nižšie v Odpoveď na otázku č. 6 zistiť, ako sa obe používajú v programe.
Jedna vec, ktorú treba pamätať, je, že konceptu Pagefactory s funkciou cache sa treba vyhnúť na dynamických prvkoch, zatiaľ čo návrh objektu stránky funguje dobre pre dynamické prvky. Pagefactory však vyhovuje iba statickým prvkom.
Otázka č. 6) Existujú alternatívne spôsoby identifikácie prvkov na základe viacerých kritérií?
ako odstrániť prvky z poľa
Odpoveď: Alternatívou na identifikáciu prvkov na základe viacerých kritérií je použitie anotácií @FindAll a @FindBys. Tieto anotácie pomáhajú identifikovať jeden alebo viac prvkov v závislosti od hodnôt získaných z kritérií, ktoré boli v ňom odovzdané.
# 1) @FindAll:
@FindAll môže obsahovať viac @FindBy a vráti všetky prvky, ktoré sa zhodujú s akýmkoľvek @FindBy, v jednom zozname. Funkcia @FindAll sa používa na označenie poľa v objekte stránky, čo naznačuje, že pri vyhľadávaní by sa mala použiť séria značiek @FindBy. Potom vyhľadá všetky prvky, ktoré zodpovedajú niektorému z kritérií FindBy.
Upozorňujeme, že prvky nie sú zaručene v poradí podľa dokumentov.
Syntax na použitie funkcie @FindAll je uvedená nižšie:
@FindAll( { @FindBy(how = How.ID, using = 'foo'), @FindBy(className = 'bar') } )
Vysvetlenie: @FindAll vyhľadá a identifikuje samostatné prvky zodpovedajúce každému z kritérií @FindBy a vypíše ich. Vo vyššie uvedenom príklade najskôr vyhľadá prvok, ktorého id = 'foo', a potom identifikuje druhý prvok pomocou className = 'bar'.
Za predpokladu, že pre každé kritérium FindBy bol identifikovaný jeden prvok, bude výsledkom @FindAll výpis 2 prvkov. Nezabudnite, že pre každé kritérium môže byť identifikovaných viac prvkov. Jednoduchými slovami teda @ Nájsť všetko akty rovnocenné s ALEBO operátor splnil kritériá @FindBy.
# 2) @FindBys:
FindBys sa používa na označenie poľa v objekte stránky na označenie, že vyhľadávanie by malo používať sériu značiek @FindBy v reťazci, ako je popísané v ByChained. Keď požadované objekty WebElement musia zodpovedať všetkým daným kritériám, použite anotáciu @FindBys.
Syntax na použitie @FindBys je uvedená nižšie:
@FindBys( { @FindBy(name=”foo”) @FindBy(className = 'bar') } )
Vysvetlenie: @FindBys vyhľadá a identifikuje prvky, ktoré vyhovujú všetkým kritériám @FindBy, a zobrazí ich zoznam. Vo vyššie uvedenom príklade bude prehľadávať prvky, ktorých meno = „foo“ a className = „bar“.
Výsledkom funkcie @FindAll bude výpis 1 prvku, ak predpokladáme, že v daných kritériách bol jeden prvok identifikovaný menom a menom triedy.
Ak neexistuje ani jeden prvok, ktorý spĺňa všetky splnené podmienky FindBy, potom bude výsledkom @FindBys nula prvkov. Mohol by byť identifikovaný zoznam webových prvkov, ak všetky podmienky vyhovujú viacerým prvkom. Jednoducho povedané, @ FindBys akty rovnocenné s A operátor splnil kritériá @FindBy.
Pozrime sa na implementáciu všetkých vyššie uvedených anotácií prostredníctvom podrobného programu:
Upravíme program www.nseindia.com uvedený v predchádzajúcej časti, aby sme pochopili implementáciu anotácií @FindBy, @FindBys a @FindAll
# 1) Repozitár objektov PagefactoryClass sa aktualizuje takto:
Zoznam newlist = driver.findElements (By.tagName („a“));
@FindBy (ako = ako. TAG_NAME , pomocou = „a“)
súkromné Zoznam findbyvalue;
@FindAll ({ @FindBy (className = “sel”), @FindBy (xpath = ”// a (@ id =‘ tab5 ′) ”)})
súkromné Zoznam findallvalue;
@FindBys ({ @FindBy (className = “sel”), @FindBy (xpath = ”// a (@ id =‘ tab5 ′) ”)})
súkromné Zoznam findbysvalue;
# 2) Nová metóda seeHowFindWorks () je napísaná v PagefactoryClass a je vyvolaná ako posledná metóda v triede Main.
Metóda je uvedená nižšie:
private void seeHowFindWorks() { System.out.println('driver.findElements(By.tagName()) '+newlist.size()); System.out.println('count of @FindBy- list elements '+findbyvalue.size()); System.out.println('count of @FindAll elements '+findallvalue.size()); for(int i=0;i Nižšie je uvedený výsledok zobrazený v okne konzoly po vykonaní programu:

Pokúsme sa teraz podrobne porozumieť kódu:
# 1) Prostredníctvom vzoru návrhu objektu stránky identifikuje prvok „newlist“ všetky značky s ukotvením „a“. Inými slovami, získame počet všetkých odkazov na stránke.
Dozvedeli sme sa, že pagefactory @FindBy robí rovnakú prácu ako driver.findElement (). Element findbyvalue je vytvorený na získanie počtu všetkých odkazov na stránke prostredníctvom stratégie vyhľadávania, ktorá má koncept pagefactory.
Ukazuje sa správne, že driver.findElement () aj @FindBy vykonávajú rovnakú prácu a identifikujú rovnaké prvky. Ak sa pozriete na snímku obrazovky výsledného okna konzoly vyššie, počet odkazov identifikovaných s prvkom nový zoznam a počet odkazov na nájdenie sú rovnaké, t.j. 299 odkazy nájdené na stránke.
Výsledok sa ukázal nižšie:
driver.findElements(By.tagName()) 299 count of @FindBy- list elements 299
#dva) Tu rozpracujeme prácu s anotáciou @FindAll, ktorá sa bude týkať zoznamu webových prvkov s menom findallvalue.
Pri dôkladnom prezeraní každého kritéria @FindBy v anotácii @FindAll prvé kritérium @FindBy vyhľadáva prvky s className = 'sel' a druhé kritérium @FindBy vyhľadáva konkrétny prvok pomocou XPath = “// a (@ id = 'tab5')
Poďme teraz stlačiť kláves F12 na kontrolu prvkov na stránke nseindia.com a získanie určitých podrobností o prvkoch zodpovedajúcich kritériám @FindBy.
Na stránke sú dva prvky, ktoré zodpovedajú výrazu className = ”sel”:
do) Element „Fundamentals“ má značku zoznamu, t.j.
s className = ”sel”. Pozri snímku nižšie

b) Ďalším prvkom „Kniha objednávok“ je cesta XPath s kotviacim štítkom, ktorý má názov triedy „sel“.

c) Druhý @FindBy s XPath má kotvovú značku, ktorej id je ' tab5 “. V odpovedi na hľadanie je identifikovaný iba jeden prvok, ktorým je Základy.
Pozri snímku nižšie:

Keď bol vykonaný test nseindia.com, dostali sme počet prvkov prehľadaných pomocou.
@FindAll ako 3. Prvky pre findallvalue pri zobrazení boli: Fundamentals as the 0thindexový prvok, kniha objednávok ako 1svindexový prvok a Základy opäť ako 2ndindexový prvok. Už sme sa dozvedeli, že @FindAll identifikuje prvky pre každé kritérium @FindBy osobitne.
Podľa toho istého protokolu identifikoval pri prvom vyhľadávaní kritérií, tj. ClassName = „sel“, dva prvky, ktoré vyhovujú podmienke, a priniesol „Fundamentals“ a „Order Book“.
Potom sa presunula na ďalšie kritériá @FindBy a na základe xpath zadanej pre druhú @FindBy mohla načítať prvok ‘Fundamentals’. Preto nakoniec identifikoval 3 prvky, resp.
Teda nedostane prvky, ktoré vyhovujú niektorej z podmienok @FindBy, ale zaoberá sa osobitne každou z @FindBy a rovnako identifikuje prvky. V súčasnom príklade sme navyše videli, že nesleduje, či sú prvky jedinečné ( Napr. Prvok „Fundamentals“ (Základy), ktorý sa v tomto prípade zobrazil dvakrát ako súčasť výsledku dvoch kritérií @FindBy).
# 3) Tu rozpracujeme prácu s anotáciou @FindBys, ktorá sa bude týkať zoznamu webových prvkov s názvom findbysvalue. Aj tu prvé kritérium @FindBy vyhľadáva prvky s className = ‘sel‘ a druhé kritérium @FindBy vyhľadáva konkrétny prvok pomocou xpath = “// a (@ id =” tab5 ”).
Teraz, keď vieme, prvkami identifikovanými pre prvú podmienku @FindBy sú „Základy“ a „Kniha objednávok“ a prvkom druhého kritéria @FindBy je „Základy“.
Ako sa teda výsledný @FindBys bude líšiť od @FindAll? V predchádzajúcej časti sme sa dozvedeli, že @FindBys je ekvivalentný podmienenému operátoru AND, a preto hľadá prvok alebo zoznam prvkov, ktoré vyhovujú všetkým podmienkam @FindBy.
Podľa nášho súčasného príkladu je hodnota „Fundamentals“ jediným prvkom, ktorý má class = „sel“ a id = „tab5“, čím sú splnené obe podmienky. Z tohto dôvodu je veľkosť testovacej skrinky @FindBys 1 a zobrazuje hodnotu ako „Základy“.
Ukladanie prvkov do medzipamäte v aplikácii Pagefactory
Zakaždým, keď sa stránka načíta, všetky prvky na stránke sa vyhľadajú znova vyvolaním hovoru cez @FindBy alebo driver.findElement () a na stránke je nové hľadanie prvkov.
Väčšinu času, keď sú prvky dynamické alebo sa za behu neustále menia, najmä ak ide o prvky AJAX, má určite zmysel, že pri každom načítaní stránky sa znova vyhľadajú všetky prvky na stránke.
Ak má webová stránka statické prvky, uloženie prvku do pamäte cache môže pomôcť rôznymi spôsobmi. Keď sú prvky uložené v pamäti, nemusí ich pri načítaní stránky znova vyhľadávať, môže odkazovať na úložisko prvkov v pamäti. To ušetrí veľa času a zvýši lepší výkon.
Pagefactory poskytuje túto funkciu ukladania prvkov do medzipamäte pomocou anotácie @CacheLookUp .
Anotácia hovorí vodičovi, aby pre prvky použil rovnakú inštanciu lokátora z DOM a aby ich znovu neprehľadával, zatiaľ čo metóda initElements stránky Pagefactory výrazne prispieva k ukladaniu statického prvku do medzipamäte. InitElements robia prácu cache prvkov.
Toto robí koncept pagefactory špeciálnym oproti bežnému vzorovému vzoru objektu stránky. Prichádza s vlastnými kladmi a zápormi, o ktorých si povieme niečo neskôr. Napríklad prihlasovacie tlačidlo na domovskej stránke Facebooku je statický prvok, ktorý je možné uložiť do medzipamäte, a je ideálnym prvkom na uloženie do medzipamäte.
Pozrime sa teraz na to, ako implementovať anotáciu @CacheLookUp
Najskôr budete musieť importovať balíček pre Cachelookup:
import org.openqa.selenium.support.CacheLookup
Nižšie je uvedený úryvok zobrazujúci definíciu prvku pomocou funkcie @CacheLookUp. Hneď ako UniqueElement hľadáte prvýkrát, program initElement () uloží verziu prvku do medzipamäte, aby vodič nabudúce nehľadal prvok, ale odkazuje na tú istú vyrovnávaciu pamäť, a akciu vykoná priamo na prvku. preč.
@FindBy(id = 'unique') @CacheLookup private WebElement UniqueElement;
Pozrime sa teraz na skutočný program, ako sú akcie s webovým prvkom vo vyrovnávacej pamäti rýchlejšie ako s webovým prvkom bez medzipamäte:
Ďalším vylepšením programu nseindia.com som napísal ďalšiu novú metódu monitorPerformance (), v ktorej vytvorím prvok vo vyrovnávacej pamäti pre vyhľadávacie pole a prvok bez vyrovnávacej pamäte pre to isté vyhľadávacie pole.
Potom sa pokúsim získať tagname prvku 3000-krát pre prvok v pamäti aj bez pamäte a pokúsiť sa odhadnúť čas potrebný na dokončenie úlohy pomocou prvku v pamäti aj bez pamäte.
Zvážil som to 3000 krát, aby sme videli viditeľný rozdiel v načasovaní týchto dvoch. Očakávam, že element v pamäti by mal v porovnaní s prvkom bez cache dokončiť získanie názvu značky 3000 krát za kratší čas.
Teraz už vieme, prečo by prvok vo vyrovnávacej pamäti mal pracovať rýchlejšie, tj vodič má pokyn, aby nevyhľadával prvok po prvom vyhľadávaní, ale priamo na ňom ďalej pracoval, a to neplatí pre prvok bez vyrovnávacej pamäte, kde sa vyhľadávanie prvku vykonáva pre všetko 3000 krát a potom sa na ňom vykoná akcia.
Nižšie je uvedený kód metódy monitorPerformance ():
private void monitorPerformance() { //non cached element long NoCache_StartTime = System.currentTimeMillis(); for(int i = 0; i <3000; i ++) { Searchbox.getTagName(); } long NoCache_EndTime = System.currentTimeMillis(); long NoCache_TotalTime=(NoCache_EndTime-NoCache_StartTime)/1000; System.out.println('Response time without caching Searchbox ' + NoCache_TotalTime+ ' seconds'); //cached element long Cached_StartTime = System.currentTimeMillis(); for(int i = 0; i < 3000; i ++) { cachedSearchbox.getTagName(); } long Cached_EndTime = System.currentTimeMillis(); long Cached_TotalTime=(Cached_EndTime - Cached_StartTime)/1000; System.out.println('Response time by caching Searchbox ' + Cached_TotalTime+ ' seconds'); }
Po vykonaní sa v okne konzoly zobrazí nasledujúci výsledok:
Podľa výsledku je úloha na prvku bez vyrovnávacej pamäte dokončená v 82 sekúnd, zatiaľ čo čas potrebný na dokončenie úlohy na prvku v pamäti bol iba 37 sekúnd. Toto je skutočne viditeľný rozdiel v čase odozvy prvku uloženého v pamäti aj bez vyrovnávacej pamäte.

Otázka č. 7) Aké sú klady a zápory anotácie @CacheLookUp v koncepte Pagefactory?
Odpoveď:
Pros @CacheLookUp a situácie uskutočniteľné pre jeho použitie:
@CacheLookUp je uskutočniteľný, keď sú prvky statické alebo sa počas načítania stránky vôbec nemenia. Takéto prvky nemenia čas chodu. V takýchto prípadoch je vhodné použiť anotáciu na zlepšenie celkovej rýchlosti vykonania testu.
Nevýhody anotácie @CacheLookUp:
Najväčšou nevýhodou toho, že sú prvky uložené v anotácii, je strach z častého získavania StaleElementReferenceExceptions.
Dynamické prvky sa obnovujú pomerne často s tými, ktoré sú náchylné na rýchlu zmenu v priebehu niekoľkých sekúnd alebo minút časového intervalu.
Ďalej uvádzame niekoľko príkladov dynamických prvkov:
- Na webovej stránke sú stopky, ktoré aktualizujú časovač každú sekundu.
- Rámec, ktorý neustále aktualizuje správu o počasí.
- Stránka so správou o aktuálnych aktualizáciách Sensexu.
Na použitie anotácie @CacheLookUp nie sú vôbec ideálne alebo možné. Ak tak urobíte, riskujete, že dostanete výnimku StaleElementReferenceExceptions.
Pri ukladaní týchto prvkov do medzipamäte sa počas vykonávania testu zmení DOM DOMov, avšak ovládač vyhľadá verziu DOM, ktorá už bola pri ukladaní do pamäte uložená. Toto umožňuje, aby vodič vyhľadal zastaraný prvok, ktorý už na webovej stránke neexistuje. To je dôvod, prečo je vyvolaná StaleElementReferenceException.
Triedy továrne:
Pagefactory je koncept postavený na viacerých továrenských triedach a rozhraniach. Tu sa v tejto časti dozvieme o niekoľkých továrenských triedach a rozhraniach. Na pár z nich sa pozrieme AjaxElementLocatorFactory , ElementLocatorFactory a DefaultElementFactory.
Zaujímalo nás niekedy, či Pagefactory poskytuje nejaký spôsob, ako začleniť implicitné alebo explicitné čakanie na prvok, kým nebude splnená určitá podmienka ( Príklad: Kým nebude prvok viditeľný, povolený, klikateľný atď.)? Ak áno, tu je vhodná odpoveď.
AjaxElementLocatorFactory je jedným z významných prispievateľov medzi všetkými triedami tovární. Výhodou AjaxElementLocatorFactory je, že triede stránky Objekt môžete priradiť hodnotu časového limitu pre webový prvok.
Aj keď Pagefactory neposkytuje explicitnú funkciu čakania, existuje alternatíva implicitného čakania pomocou triedy AjaxElementLocatorFactory . Túto triedu možno použiť, keď aplikácia používa komponenty a prvky Ajaxu.
Takto to implementujete do kódu. V rámci konštruktora, keď použijeme metódu initElements (), môžeme použiť AjaxElementLocatorFactory na zabezpečenie implicitného čakania na prvky.
PageFactory.initElements(driver, this); can be replaced with PageFactory.initElements( new AjaxElementLocatorFactory(driver, 20), this);
Vyššie uvedený druhý riadok kódu znamená, že vodič nastaví časový limit 20 sekúnd pre všetky prvky na stránke, keď je každý z nich načítaný, a ak sa niektorý z prvkov nenájde po 20 sekundách, hodí sa chyba „NoSuchElementException“ pre ten chýbajúci prvok.
Čakanie môžete tiež definovať nižšie:
public pageFactoryClass(WebDriver driver) { ElementLocatorFactory locateMe = new AjaxElementLocatorFactory(driver, 30); PageFactory.initElements(locateMe, this); this.driver = driver; }
Vyššie uvedený kód funguje perfektne, pretože trieda AjaxElementLocatorFactory implementuje rozhranie ElementLocatorFactory.
Tu sa nadradené rozhranie (ElementLocatorFactory) vzťahuje na objekt podradenej triedy (AjaxElementLocatorFactory). Preto sa pri prideľovaní časového limitu pomocou AjaxElementLocatorFactory používa koncept Java „upcasting“ alebo „runtime polymorfizmus“.
S ohľadom na to, ako to technicky funguje, AjaxElementLocatorFactory najskôr vytvorí AjaxElementLocator pomocou SlowLoadableComponent, ktorý nemusí načítanie dokončiť, keď sa vráti load (). Po volaní load () by metóda isLoaded () mala naďalej zlyhávať, kým sa komponent úplne nenačíta.
Inými slovami, všetky prvky sa vyhľadajú čerstvo pri každom prístupe k prvku v kóde vyvolaním volania locator.findElement () z triedy AjaxElementLocator, ktoré potom použije časový limit do načítania cez triedu SlowLoadableComponent.
Po priradení časového limitu cez AjaxElementLocatorFactory sa navyše prvky s anotáciou @CacheLookUp už nebudú ukladať do medzipamäte, pretože anotácia bude ignorovaná.
Existuje tiež variácia na to, ako môžeš zavolajte na initElements () metóda a ako nemal by zavolajte na AjaxElementLocatorFactory priradiť časový limit prvku.
# 1) Môžete tiež určiť názov prvku namiesto objektu ovládača, ako je uvedené nižšie v metóde initElements ():
PageFactory.initElements( , this);
Metóda initElements () vo vyššie uvedenom variante interne vyvolá volanie triedy DefaultElementFactory a konštruktor DefaultElementFactory akceptuje objekt rozhrania SearchContext ako vstupný parameter. Objekt webového ovládača aj webový prvok patria do rozhrania SearchContext.
V takom prípade bude metóda initElements () vopred inicializovaná iba pre uvedený prvok a nebudú inicializované všetky prvky na webovej stránke.
#dva) Tu je však zaujímavá zmena tejto skutočnosti, ktorá uvádza, ako by ste objekt AjaxElementLocatorFactory nemali konkrétnym spôsobom nazývať. Ak použijem vyššie uvedenú variantu initElements () spolu s AjaxElementLocatorFactory, zlyhá.
Príklad: Nasledujúci kód, tj. Odovzdanie názvu prvku namiesto objektu ovládača do definície AjaxElementLocatorFactory, nebude fungovať, pretože konštruktor pre triedu AjaxElementLocatorFactory vezme ako vstupný parameter iba objekt webového ovládača, a preto by objekt SearchContext s webovým prvkom pre ňu nepracoval.
PageFactory.initElements(new AjaxElementLocatorFactory(, 10), this);
Otázka č. 8) Je použitie pagefactory uskutočniteľnou možnosťou v porovnaní s bežným návrhovým vzorom stránky?
Odpoveď: Toto je najdôležitejšia otázka, ktorú ľudia majú, a preto mi napadlo venovať sa jej na konci tutoriálu. Teraz poznáme „vstup a výstup“ o Pagefactory, počnúc jej konceptmi, použitými anotáciami, ďalšími podporovanými funkciami, implementáciou prostredníctvom kódu, kladmi a zápormi.
Napriek tomu zostávame pri tejto zásadnej otázke, že ak má pagefactory toľko dobrých vecí, prečo by sme sa nemali držať jeho používania.
Pagefactory prichádza s konceptom CacheLookUp, o ktorom sme videli, že nie je uskutočniteľný pre dynamické prvky, ako sú napríklad často aktualizované hodnoty prvku. Takže, pagefactory bez CacheLookUp, je dobré ísť na výber? Áno, ak sú xpaths statické.
Pádom však je, že aplikácia modernej doby je naplnená ťažkými dynamickými prvkami, kde vieme, že návrh objektu stránky bez pagefactory funguje nakoniec dobre, ale funguje koncept pagefactory rovnako dobre aj s dynamickými xpaths? Možno nie. Tu je rýchly príklad:
Na webovej stránke nseindia.com sa zobrazuje tabuľka uvedená nižšie.

Cesta x tabuľky je
'//*(@id='tab9Content')/table/tbody/tr(+count+)/td(1)'
Chceme načítať hodnoty z každého riadku pre prvý stĺpec „Kúpiť množstvo“. Aby sme to dosiahli, budeme musieť zvýšiť počítadlo riadkov, ale index stĺpca zostane 1. Nie je možné, aby sme tento dynamický XPath mohli odovzdať v anotácii @FindBy, pretože anotácia akceptuje hodnoty, ktoré sú statické a nedá sa odovzdať žiadna premenná to.
Tu PageFactory úplne zlyhá, zatiaľ čo obvyklý POM s ňou funguje skvele. Môžete ľahko použiť cyklus for na zvýšenie indexu riadkov pomocou takýchto dynamických xpaths v metóde driver.findElement ().
Záver
Page Object Model je návrhový koncept alebo vzor používaný v automatizačnom rámci selénu.
Pomenovanie konvekcie metód je v modeli objektu stránky užívateľsky prívetivé. Kód v POM je ľahko pochopiteľný, opakovane použiteľný a udržiavateľný. Ak v POM dôjde k akejkoľvek zmene vo webovom prvku, stačí vykonať zmeny v príslušnej triede a nie upraviť všetky triedy.
Pagefactory rovnako ako obvyklý POM je vynikajúci koncept, ktorý sa dá uplatniť. Musíme však vedieť, kde je zvyčajný POM možný a kde stránka Pagefactory dobre vyhovuje. V statických aplikáciách (kde sú XPath aj elementy statické) je možné stránku Pagefactory liberálne implementovať s ďalšími výhodami lepšieho výkonu.
Alternatívne, keď aplikácia zahŕňa dynamické aj statické prvky, môžete mať zmiešanú implementáciu pom s Pagefactory a bez Pagefactory podľa uskutočniteľnosti pre každý webový prvok.
Autor: Tento tutoriál napísal Shobha D. Pracuje ako vedúca projektu a má viac ako 9-ročné skúsenosti v oblasti manuálu, automatizácie (Selenium, IBM Rational Functional Tester, Java) a testovania API (SOAPUI and Rest assured in Java) .
Teraz už len na vás, na ďalšiu implementáciu Pagefactory.
Šťastné objavovanie !!!
=> Navštívte tu a naučte sa selén od nuly.
Odporúčané čítanie
- 30+ najlepších návodov na selén: Naučte sa selén na skutočných príkladoch
- Efektívne skriptovanie selénu a riešenie problémov - scenáre selénu # 27
- Ladenie selénových skriptov pomocou denníkov (výučba Log4j) - výučba selénu č. 26
- Úvod do rámca JUnit a jeho použitie v selénovom skripte - selén výučba # 11
- 7 faktorov ovplyvňujúcich odhad testu projektu automatizácie selénu - selén výučba # 32
- Tvrdenia v seléne pomocou rámcov Junit a TestNG
- Ako používať rámec TestNG na vytváranie skriptov selénu - návod na testovanie selénu TestNG # 12
- Naučte sa, ako používať poznámky TestNG v seléne (s príkladmi)