पेज फैक्ट्री मॉडल (POM) पेज फैक्ट्री के साथ | सेलेनियम ट्यूटोरियल

page object model with page factory selenium tutorial

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

ऑपरेटिंग सिस्टम का चयन करें प्रक्षेपण का एक कार्यक्रम चुनें (वैकल्पिक रूप से)

अपनी समस्या का वर्णन करें

यह गहराई से ट्यूटोरियल उदाहरणों का उपयोग करते हुए पेजफैक्ट्री के साथ पेज ऑब्जेक्ट मॉडल (पीओएम) के बारे में बताते हैं। आप सेलेनियम में पोम के कार्यान्वयन को भी जान सकते हैं:

इस ट्यूटोरियल में, हम समझेंगे कि पेज फैक्ट्री दृष्टिकोण का उपयोग करके पेज ऑब्जेक्ट मॉडल कैसे बनाया जाए। हम पर ध्यान केंद्रित करेंगे:

फैक्टरी वर्ग
पेज फैक्ट्री पैटर्न का उपयोग करके बेसिक पोम कैसे बनाएं
पेज फैक्टरी दृष्टिकोण में प्रयुक्त विभिन्न एनोटेशन

इससे पहले कि हम देखें कि पेजफैक्ट क्या है और इसका उपयोग पेज ऑब्जेक्ट मॉडल के साथ कैसे किया जा सकता है, आइए समझते हैं कि पेज ऑब्जेक्ट मॉडल क्या है जिसे आमतौर पर पीओएम के रूप में जाना जाता है।

=> सभी के लिए सेलेनियम प्रशिक्षण श्रृंखला देखने के लिए यहां जाएं।

सेलेनियम में पेज फैक्ट्री के साथ पेज ऑब्जेक्ट मॉडल

आप क्या सीखेंगे:

पेज ऑब्जेक्ट मॉडल (POM) क्या है?
Pagefactory क्या है?
पेज फैक्ट्री का उपयोग कर पोम
बार बार पूछे जाने वाले प्रश्न
निष्कर्ष
- अनुशंसित पाठ

पेज ऑब्जेक्ट मॉडल (POM) क्या है?

सैद्धांतिक शब्दावली का वर्णन है पेज ऑब्जेक्ट मॉडल एक डिजाइन पैटर्न के रूप में परीक्षण के तहत आवेदन में उपलब्ध वेब तत्वों के लिए एक वस्तु भंडार बनाने के लिए उपयोग किया जाता है। कुछ अन्य लोग इसे परीक्षण के तहत दिए गए आवेदन के लिए सेलेनियम स्वचालन के ढांचे के रूप में संदर्भित करते हैं।

हालाँकि, मैंने पेज ऑब्जेक्ट मॉडल के बारे में जो समझा है वह है:

# 1) यह एक डिज़ाइन पैटर्न है जहां आपके पास एप्लिकेशन में प्रत्येक स्क्रीन या पृष्ठ के अनुरूप एक अलग जावा क्लास फ़ाइल है। वर्ग फ़ाइल में UI तत्वों के ऑब्जेक्ट रिपॉजिटरी के साथ-साथ विधियाँ भी शामिल हो सकती हैं।

#दो) यदि किसी पृष्ठ पर विनम्र वेब तत्व हैं, तो पृष्ठ के लिए ऑब्जेक्ट रिपॉजिटरी वर्ग को उस वर्ग से अलग किया जा सकता है जिसमें संबंधित पृष्ठ के लिए विधियां शामिल हैं।

उदाहरण: यदि रजिस्टर खाता पृष्ठ में कई इनपुट फ़ील्ड हैं, तो एक रजिस्टर हो सकता है RegisterAccountObjects.java जो रजिस्टर खाता पृष्ठ पर यूआई तत्वों के लिए ऑब्जेक्ट रिपॉजिटरी बनाता है।

एक अलग श्रेणी की फ़ाइल RegisterAccount.java जो कि पेज पर अलग-अलग क्रियाओं को करने वाली सभी विधियों को शामिल करती है, जिसमें RegisterAccountObjects का विस्तार या इनहेरिट करना हो सकता है।

# 3) इसके अलावा, एक {roperties फ़ाइल, एक्सेल परीक्षण डेटा और एक पैकेज के तहत आम तरीकों के साथ एक सामान्य पैकेज हो सकता है।

उदाहरण: DriverFactory जो अनुप्रयोग में सभी पृष्ठों पर बहुत आसानी से उपयोग किया जा सकता है

उदाहरण के साथ पोम को समझना

जाँच यहां पोम के बारे में अधिक जानने के लिए।

नीचे वेब पेज का एक स्नैपशॉट है:

पोम संदर्भ साइट

इनमें से प्रत्येक लिंक पर क्लिक करने से उपयोगकर्ता एक नए पृष्ठ पर पहुंच जाएगा।

यहां बताया गया है कि वेबसाइट पर प्रत्येक पृष्ठ के अनुरूप पेज ऑब्जेक्ट मॉडल का उपयोग करके सेलेनियम के साथ प्रोजेक्ट संरचना कैसे बनाई गई है। प्रत्येक जावा वर्ग में पृष्ठ के भीतर विभिन्न क्रियाओं को करने के लिए वस्तु भंडार और विधियाँ शामिल हैं।

इसके अलावा, इन पेजों की क्लास फ़ाइलों के लिए एक और JUNIT या TestNG या कॉल करने वाली एक जावा क्लास फाइल होगी।

CheckboxesPage.Java

हम पेज ऑब्जेक्ट मॉडल का उपयोग क्यों करते हैं?

POM या पेज ऑब्जेक्ट मॉडल नामक इस शक्तिशाली सेलेनियम ढांचे के उपयोग पर चारों ओर एक चर्चा है। अब, यह सवाल उठता है कि 'पोम क्यों इस्तेमाल करें?'।

इसका सरल उत्तर यह है कि POM डेटा-चालित, मॉड्यूलर और हाइब्रिड फ्रेमवर्क का एक संयोजन है। यह स्क्रिप्ट को व्यवस्थित रूप से इस तरह से व्यवस्थित करने के लिए एक दृष्टिकोण है कि क्यूए को कोड को परेशानियों से मुक्त बनाए रखना आसान बनाता है और अनावश्यक या डुप्लिकेट कोड को रोकने में भी मदद करता है।

उदाहरण के लिए, यदि किसी विशिष्ट पृष्ठ पर लोकेटर मान में परिवर्तन होता है, तो कोड को कहीं और प्रभावित किए बिना संबंधित पृष्ठ की स्क्रिप्ट में केवल उस त्वरित परिवर्तन को पहचानना और बनाना बहुत आसान है।

हम निम्नलिखित कारणों के कारण सेलेनियम वेबड्राइवर में पेज ऑब्जेक्ट मॉडल अवधारणा का उपयोग करते हैं:

इस POM मॉडल में ऑब्जेक्ट रिपॉजिटरी बनाई जाती है। यह परीक्षण मामलों से स्वतंत्र है और एक अलग परियोजना के लिए पुन: उपयोग किया जा सकता है।
तरीकों का नामकरण सम्मेलन बहुत आसान, समझने योग्य और अधिक यथार्थवादी है।
पृष्ठ ऑब्जेक्ट मॉडल के तहत, हम पृष्ठ कक्षाएं बनाते हैं जिन्हें किसी अन्य प्रोजेक्ट में पुन: उपयोग किया जा सकता है।
पेज ऑब्जेक्ट मॉडल अपने कई लाभों के कारण विकसित ढांचे के लिए आसान है।
इस मॉडल में, एक वेब एप्लिकेशन के विभिन्न पृष्ठों के लिए अलग-अलग कक्षाएं बनाई जाती हैं जैसे कि लॉगिन पेज, होम पेज, कर्मचारी विवरण पृष्ठ, पासवर्ड पृष्ठ बदलें आदि।
यदि किसी वेबसाइट के किसी भी तत्व में कोई बदलाव होता है तो हमें केवल एक वर्ग में परिवर्तन करने की आवश्यकता है, न कि सभी वर्गों में।
डिज़ाइन की गई स्क्रिप्ट पृष्ठ ऑब्जेक्ट मॉडल दृष्टिकोण में अधिक पुन: प्रयोज्य, पठनीय और बनाए रखने योग्य है।
इसकी परियोजना संरचना काफी आसान और समझने योग्य है।
कैश में वेब तत्व और स्टोर तत्वों को इनिशियलाइज़ करने के लिए पेज ऑब्जेक्ट मॉडल में PageFactory का उपयोग कर सकते हैं।
TestNG को पेज ऑब्जेक्ट मॉडल दृष्टिकोण में भी एकीकृत किया जा सकता है।

सेलेनियम में सरल पोम का कार्यान्वयन

(1) परिदृश्य स्वचालित करने के लिए

अब हम पेज ऑब्जेक्ट मॉडल का उपयोग करके दिए गए परिदृश्य को स्वचालित करते हैं।

परिदृश्य नीचे समझाया गया है:

चरण 1: साइट 'https: //demo.vtiger.com' लॉन्च करें।
चरण 2: मान्य क्रेडेंशियल दर्ज करें।
चरण 3: साइट पर लॉगिन करें।
चरण 4: होम पेज को वेरीफाई करें।
चरण 5: साइट लॉगआउट करें।
चरण 6: ब्राउज़र बंद करें।

# 2) पोलेन में उपरोक्त दृश्य के लिए सेलेनियम लिपियों

अब हम ग्रहण में पीओएम संरचना बनाते हैं, जैसा कि नीचे बताया गया है:

चरण 1: ग्रहण में एक परियोजना बनाएं - पोम आधारित संरचना:

a) प्रोजेक्ट “पेज ऑब्जेक्ट मॉडल” बनाएँ।

प्रोजेक्ट बनाएं - पेज ऑब्जेक्ट मॉडल

b) प्रोजेक्ट के तहत 3 पैकेज बनाएं।

पुस्तकालय
पृष्ठों
परीक्षण के मामलों

पुस्तकालय: इसके तहत, हम उन कोड्स को डालते हैं जिन्हें हमारे परीक्षण मामलों में बार-बार कॉल करने की आवश्यकता होती है जैसे कि ब्राउज़र लॉन्च, स्क्रीनशॉट इत्यादि। उपयोगकर्ता प्रोजेक्ट की आवश्यकता के आधार पर इसके तहत अधिक कक्षाएं जोड़ सकते हैं।

पेज: इसके तहत, वेब एप्लिकेशन में प्रत्येक पृष्ठ के लिए कक्षाएं बनाई जाती हैं और एप्लिकेशन में पृष्ठों की संख्या के आधार पर अधिक पेज कक्षाएं जोड़ सकते हैं।

परीक्षण के मामलों: इसके तहत हम लॉगिन टेस्ट केस लिखते हैं और पूरे एप्लिकेशन को टेस्ट करने के लिए आवश्यकता से अधिक टेस्ट केस जोड़ सकते हैं।

पोम - एसआरसी

ग) संकुल के तहत कक्षाएं नीचे की छवि में दिखाई जाती हैं।

संकुल के तहत कक्षाएं

कदम दो: लाइब्रेरी पैकेज के तहत निम्न कक्षाएं बनाएं।

Browser.java: इस वर्ग में, 3 ब्राउज़र (फ़ायरफ़ॉक्स, क्रोम और इंटरनेट एक्सप्लोरर) को परिभाषित किया गया है और इसे लॉगिन परीक्षण मामले में कहा जाता है। आवश्यकता के आधार पर, उपयोगकर्ता विभिन्न ब्राउज़रों में एप्लिकेशन का परीक्षण कर सकता है।

 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; } }

स्क्रीनशॉट.जावा: इस वर्ग में, एक स्क्रीनशॉट कार्यक्रम लिखा जाता है और इसे परीक्षण के मामले में कहा जाता है, जब उपयोगकर्ता परीक्षण में विफल रहता है या पास लेना चाहता है।

 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(); } } }

चरण 3 : पेज पैकेज के तहत पेज कक्षाएं बनाएं।

होमपेज.जावा: यह होम पेज क्लास है, जिसमें होम पेज के सभी तत्वों और विधियों को परिभाषित किया गया है।

 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: यह लॉगिन पेज क्लास है, जिसमें लॉगिन पेज और विधियों के सभी तत्वों को परिभाषित किया गया है।

 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(); } }

चरण 4: लॉगिन परिदृश्य के लिए टेस्ट केस बनाएँ।

LoginTestCase.java: यह LoginTestCase क्लास है, जहाँ टेस्ट केस निष्पादित किया जाता है। उपयोगकर्ता परियोजना की आवश्यकता के अनुसार अधिक परीक्षण मामले भी बना सकता है।

 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(); } }

चरण 5: 'LoginTestCase.java' निष्पादित करें।

चरण 6: पृष्ठ ऑब्जेक्ट मॉडल का आउटपुट:

Chrome ब्राउज़र लॉन्च करें।
ब्राउज़र में डेमो वेबसाइट खोली जाती है।
डेमो साइट पर लॉगिन करें।
होम पेज को वेरीफाई करें।
साइट लॉगआउट करें।
ब्राउज़र बंद करें।

अब, आइए इस ट्यूटोरियल की मुख्य अवधारणा पर ध्यान दें जो ध्यान आकर्षित करती है। 'पृष्ठसक्रियकारक'।

Pagefactory क्या है?

पेजफैक्ट 'पेज ऑब्जेक्ट मॉडल' को लागू करने का एक तरीका है। यहां, हम पेज ऑब्जेक्ट रिपोजिटरी और टेस्ट मेथड्स के पृथक्करण के सिद्धांत का पालन करते हैं। यह पेज ऑब्जेक्ट मॉडल की एक इनबिल्ट अवधारणा है जो बहुत अनुकूलित है।

आइए अब पेजफैक्टिंग शब्द पर अधिक स्पष्टता रखें।

# 1) सबसे पहले, पेजफैक्ट नामक अवधारणा, एक पृष्ठ पर वेब तत्वों के लिए एक वस्तु भंडार बनाने के लिए वाक्य रचना और शब्दार्थ के संदर्भ में एक वैकल्पिक तरीका प्रदान करती है।

#दो) दूसरे, यह वेब तत्वों के आरंभ के लिए थोड़ी अलग रणनीति का उपयोग करता है।

# 3) यूआई वेब तत्वों के लिए ऑब्जेक्ट रिपॉजिटरी का उपयोग करके बनाया जा सकता है:

सामान्य ual पेजम के बिना पोम ’और
वैकल्पिक रूप से, आप पेजफैक्ट्री के साथ 'पोम' का उपयोग कर सकते हैं।

नीचे दिए गए एक सचित्र प्रतिनिधित्व है:

UI वेब तत्वों के लिए ऑब्जेक्ट रिपॉजिटरी

अब हम उन सभी पहलुओं पर गौर करेंगे जो पेजम के साथ पीओएम से सामान्य पीओएम को अलग करते हैं।

क) पेजफैक्ट्री के साथ सामान्य पीओएम बनाम पीओएम का उपयोग करके किसी तत्व को खोजने के सिंटैक्स में अंतर।

उदाहरण के लिए , क्लिक करें यहां पृष्ठ पर दिखाई देने वाले खोज फ़ील्ड का पता लगाने के लिए।

अगर

पेजम के बिना पोम:

1) नीचे आप सामान्य पोम का उपयोग करके खोज क्षेत्र का पता लगाते हैं:

WebElement searchNSETxt=driver.findElement(By.id(“searchBox”));

# 2) नीचे दिया गया चरण खोज एनएसई क्षेत्र में मूल्य 'निवेश' को पार करता है।

searchNSETxt.sendkeys(“investment”);

POM का उपयोग पेजफैक्ट्री:

# 1) आप नीचे दिखाए गए अनुसार पेजफैक्ट का उपयोग करके खोज क्षेत्र का पता लगा सकते हैं।

एनोटेशन @ इंडियाबाय एक तत्व की पहचान करने के लिए पेजफैक्ट में उपयोग किया जाता है जबकि पेजफैक्ट के बिना पीओएम का उपयोग करता है Driver.findElement () एक तत्व का पता लगाने की विधि।

पेजफैक्ट्री के बाद दूसरा बयान @ इंडियाबाय एक प्रकार प्रदान कर रहा है WebElement क्लास जो कि रिटर्न के तरीके के रूप में WebElement क्लास के तत्व नाम के असाइनमेंट के समान काम करती है Driver.findElement () इसका उपयोग सामान्य POM में किया जाता है (इस उदाहरण में searchNSETxt)।

हम देखेंगे @ इंडियाबाय इस ट्यूटोरियल के आगामी भाग में विस्तार से टिप्पणी।

@FindBy(id = 'searchBox') WebElement searchNSETxt;

#दो) नीचे दिया गया चरण खोज एनएसई क्षेत्र में मूल्य 'निवेश' पास करता है और वाक्यविन्यास सामान्य पीओएम (पेजफैक्ट्री के बिना पीओएम) के समान रहता है।

searchNSETxt.sendkeys(“investment”);

ख) पेजफैक्ट्री के साथ सामान्य पीओएम बनाम पीओएम का उपयोग करते हुए वेब तत्वों के प्रारंभिककरण की रणनीति में अंतर।

पेजफैक्ट्री के बिना पोम का उपयोग करना:

नीचे दिया गया Chrome ड्राइवर पथ सेट करने के लिए एक कोड स्निपेट है। WebDriver का उदाहरण ड्राइवर के नाम के साथ बनाया गया है और ChromeDver को 'ड्राइवर' को सौंपा गया है। फिर उसी ड्राइवर ऑब्जेक्ट का उपयोग नेशनल स्टॉक एक्सचेंज वेबसाइट लॉन्च करने, सर्चबॉक्स का पता लगाने और स्ट्रिंग मान को फ़ील्ड में दर्ज करने के लिए किया जाता है।

जिस बिंदु पर मैं यहाँ प्रकाश डालना चाहता हूँ वह यह है कि जब यह पेज फैक्ट्री के बिना POM होता है, तो चालक का उदाहरण शुरू में बनाया जाता है और हर वेब तत्व को हर बार नए सिरे से आरंभीकृत किया जाता है, जब उस वेब तत्व में driver.findElement () या ड्राइवर का उपयोग करके कॉल होता है। .findElements ()।

यही कारण है कि, एक तत्व के लिए driver.findElement () के एक नए चरण के साथ, DOM संरचना को फिर से स्कैन किया जाता है और उस पृष्ठ पर तत्व की ताज़ा पहचान की जाती है।

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”);

पेजफैक्ट्री के साथ पोम का उपयोग करना:

Driver.findElement () विधि के बजाय @FindBy एनोटेशन का उपयोग करने के अलावा, नीचे दिए गए कोड स्निपेट को पेजफैक्ट्री के लिए अतिरिक्त रूप से उपयोग किया जाता है। PageFactory वर्ग की स्थिर initElements () विधि का उपयोग पेज लोड होते ही पृष्ठ पर सभी UI तत्वों को आरंभ करने के लिए किया जाता है।

public PagefactoryClass(WebDriver driver) { this.driver = driver; PageFactory.initElements(driver, this); }

उपरोक्त रणनीति पेजफैक्ट दृष्टिकोण को सामान्य पीओएम से थोड़ा अलग बनाती है। सामान्य POM में, वेब तत्व को स्पष्ट रूप से प्रारंभ करना होता है जबकि पेजफैक्टिक दृष्टिकोण में सभी तत्वों को प्रत्येक वेब तत्व को स्पष्ट किए बिना initElements () के साथ आरंभ किया जाता है।

उदाहरण के लिए: यदि WebElement घोषित किया गया था, लेकिन सामान्य POM में आरंभिक नहीं है, तो 'चर प्रारंभ करें' त्रुटि या NullPointerException को फेंक दिया गया है। इसलिए सामान्य POM में, प्रत्येक WebElement को स्पष्ट रूप से प्रारंभ किया जाना है। PageFactory इस मामले में सामान्य POM पर एक लाभ के साथ आता है।

आइए हम वेब तत्व को इनिशियलाइज़ न करें BDate (पेजम के बिना पीओएम), आप देख सकते हैं कि त्रुटि 'आरंभिक चर' प्रदर्शित करता है और उपयोगकर्ता को इसे शून्य करने के लिए आरंभ करने के लिए प्रेरित करता है, इसलिए, आप यह नहीं मान सकते हैं कि तत्वों को प्रारंभिक रूप से पता लगाने पर प्राप्त होता है।

POM में त्रुटि - वैरिएबल को प्रारंभ करें

तत्व BDate स्पष्ट रूप से प्रारंभिक (पेजफैक्ट बिना POM):

स्पष्ट रूप से_संशोधित

अब, कार्यान्वयन पहलू को समझने में किसी भी अस्पष्टता को दूर करने के लिए PageFactory का उपयोग करके एक संपूर्ण कार्यक्रम के उदाहरणों पर एक नज़र डालते हैं।

उदाहरण 1:

N http://www.nseindia.com/ पर जाएं
खोज क्षेत्र के आगे ड्रॉपडाउन से, 'मुद्रा डेरिवेटिव्स' चुनें।
'USDINR' के लिए खोज करें। परिणाम पृष्ठ पर 'यूएस डॉलर-इंडियन रुपया - यूएसडीएनआर' पाठ को सत्यापित करें।

कार्यक्रम की संरचना:

PagefactoryClass.java जिसमें nseindia.com के लिए पेज फैक्ट्री कॉन्सेप्ट का उपयोग करके ऑब्जेक्ट रिपॉजिटरी शामिल है, जो सभी वेब एलिमेंट्स को इनिशियलाइज़ करने के लिए एक कंस्ट्रक्टर है, मेथडाउनडाउनडाउन फील्ड से वैल्यू सिलेक्ट करने के लिए सेलेक्टडेरिवेटिव () सेलेक्ट सिम्बल () सिंबल को सिलेक्ट करने के लिए पेज हेडर के अनुसार अपेक्षित है या नहीं, यह सत्यापित करने के लिए अगला और सत्यापन पृष्ठ () दिखाता है।
NSE_MainClass.java मुख्य वर्ग फ़ाइल है जो उपरोक्त सभी विधियों को कॉल करती है और 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  उदाहरण 2: 
  B https://www.shoppersstop.com/brands 'पर जाएं
 ह्यूट करी लिंक पर नेविगेट करें।
 सत्यापित करें कि हाउट करी पृष्ठ में 'नया कुछ प्रारंभ करें' पाठ शामिल है।
 
  कार्यक्रम की संरचना 
  shopperstopPagefactory.java जिसमें shoppersstop.com के लिए पेजफैक्ट्री कॉन्सेप्ट का उपयोग करके ऑब्जेक्ट रिपॉजिटरी शामिल है, जो सभी वेब एलिमेंट्स को इनिशियलाइज़ करने के लिए कंस्ट्रक्टर है, जो एक ओपनिंग पॉप अप बॉक्स को हैंडल करने के लिए तरीकेExtraPopup () को बंद करता है, Haute Curry पर क्लिक करने के लिएOnOnauteCurryLink () पर क्लिक करें। लिंक और सत्यापित करें कि क्या हूट करी पेज में 'नया कुछ शुरू करें' है, तो सत्यापित करने के लिए सत्यापित करें।
 Shopperstop_CallPagefactory.java मुख्य वर्ग फ़ाइल है जो उपरोक्त सभी विधियों को कॉल करता है और 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(); } }पेज फैक्ट्री का उपयोग कर पोम
 वीडियो ट्यूटोरियल - पेज फैक्ट्री के साथ पीओएम
  भाग I 
   
 
  भाग द्वितीय 
   <span data-mce-type='bookmark' style='display: inline-block; width: 0px; overflow: hidden; line-height: 0;' class='mce_SELRES_start'>?</span>
फैक्टरी ऑब्जेक्ट का उपयोग पेज ऑब्जेक्ट को सरल और आसान बनाने के लिए किया जाता है।
  सबसे पहले, हमें एनोटेशन द्वारा वेब तत्वों को खोजने की आवश्यकता है @ इंडियाबाय पेज कक्षाओं में । 
 तब पेज क्लास को इंस्टेंट करते समय initElements () का उपयोग करते हुए तत्वों को इनिशियलाइज़ करें।
 
  # 1)  @FindBy: 
 @FindBy एनोटेशन का उपयोग पेजफैक्ट में विभिन्न लोकेटरों का उपयोग करके वेब तत्वों को खोजने और घोषित करने के लिए किया जाता है।यहां, हम वेब तत्व को @FindBy एनोटेशन और फिर WebElement घोषित करने के लिए उपयोग किए जाने वाले विशेषता के साथ-साथ उसका मान भी पास करते हैं।
  एनोटेशन का उपयोग करने के 2 तरीके हो सकते हैं। 
  उदाहरण के लिए: 
@FindBy(how = How.ID, using='EmailAddress') WebElement Email; @FindBy(id='EmailAddress') WebElement Email;हालाँकि, पूर्व WebElements घोषित करने का मानक तरीका है।
  'किस तरह' एक वर्ग है और इसमें स्थिर चर जैसे ID, XPATH, CLASSNAME, LINKTEXT, आदि हैं। 
  'का उपयोग कर' - एक स्थिर चर के लिए एक मूल्य प्रदान करने के लिए।
 ऊपरोक्त में उदाहरण , हमने वेब तत्व to ईमेल ’का पता लगाने के लिए’ id ’विशेषता का उपयोग किया है। इसी प्रकार, हम @FindBy एनोटेशन के साथ निम्नलिखित लोकेटर का उपयोग कर सकते हैं:
  कक्षा का नाम
 सीएसएस
 नाम
 xpath
 टैग नाम
 लिंक पाठ
 partLinkText
 
  # 2) initElements (): 
 InitElements PageFactory वर्ग की एक स्थिर विधि है जिसका उपयोग @FindBy एनोटेशन द्वारा स्थित सभी वेब तत्वों को आरंभ करने के लिए किया जाता है। इस प्रकार, पृष्ठ वर्गों को आसानी से तत्काल करना।
initElements(WebDriver driver, java.lang.Class pageObjectClass) हमें यह भी समझना चाहिए कि पीओएम ओओपीएस सिद्धांतों का पालन करता है। 
  WebElements को प्राइवेट मेंबर वेरिएबल (डाटा हाइडिंग) के रूप में घोषित किया गया है।
 इसी तरीके (इनकैप्सुलेशन) के साथ बाइंडिंग वेबलाइज़।
 
 पेज फैक्ट्री पैटर्न का उपयोग करके पोम बनाने के चरण
  # 1) प्रत्येक वेबपृष्ठ के लिए एक अलग जावा वर्ग फ़ाइल बनाएँ।
  #दो) प्रत्येक कक्षा में, सभी वेबलेवल्स को चर के रूप में घोषित किया जाना चाहिए (एनोटेशन - @ फ़ाइंडबाय का उपयोग करके) और आरंभिक initElement () पद्धति का उपयोग करके। घोषित की गई वेबलाइंस को कार्रवाई के तरीकों में इस्तेमाल करने के लिए आरंभीकृत किया जाना है।
  # 3) उन चरों पर काम करने वाली संगत विधियों को परिभाषित करें।
  आइए एक सरल परिदृश्य का उदाहरण लें: 
  किसी एप्लिकेशन का URL खोलें।
 ईमेल एड्रेस और पासवर्ड डेटा टाइप करें।
 लॉगइन बटन पर क्लिक करें।
 खोज पृष्ठ पर सफल लॉगिन संदेश सत्यापित करें।
 
 पृष्ठ परत
  यहाँ हमारे पास 2 पृष्ठ हैं, 
   मुखपृष्ठ - वह पेज जो URL दर्ज करते समय खुलता है और जहां हम लॉगिन के लिए डेटा दर्ज करते हैं।
  सर्चपज - एक पेज जो एक सफल लॉगिन के बाद प्रदर्शित होता है।
 
 पेज लेयर में, वेब एप्लिकेशन में प्रत्येक पेज को एक अलग जावा क्लास के रूप में घोषित किया गया है और इसके लोकेटर और कार्यों का उल्लेख किया गया है।
 वास्तविक समय उदाहरण के साथ POM बनाने के लिए कदम
  # 1) प्रत्येक पृष्ठ के लिए एक जावा वर्ग बनाएँ: 
 इस में उदाहरण , हम 2 वेब पेज, 'होम' और 'सर्च' पेज एक्सेस करेंगे।
 इसलिए, हम पेज लेयर (या एक पैकेज में कहते हैं, com.automation.pages) में 2 जावा कक्षाएं बनाएंगे।
Package Name :com.automation.pages HomePage.java SearchPage.java # 2) एनोटेशन @FindBy का उपयोग करके वैरिएबल को वैरिएबल के रूप में परिभाषित करें: 
 हम साथ बातचीत करेंगे:
  मुख पृष्ठ पर ईमेल, पासवर्ड, लॉगिन बटन क्षेत्र।
 खोज पृष्ठ पर सफल संदेश।
 
 इसलिए हम @FindBy का उपयोग करके WebElements को परिभाषित करेंगे
  उदाहरण के लिए: अगर हम विशेषता आईडी का उपयोग करके EmailAddress की पहचान करने जा रहे हैं, तो इसकी परिवर्तनशील घोषणा है
//Locator for EmailId field @FindBy(how=How.ID,using='EmailId') private WebElementEmailIdAddress; # 3) WebElements पर किए गए कार्यों के लिए तरीके बनाएं। 
  WebElements पर नीचे की क्रियाएं की जाती हैं: 
  ईमेल पता फ़ील्ड पर कार्रवाई टाइप करें।
 पासवर्ड फ़ील्ड में क्रिया टाइप करें।
 लॉगिन बटन पर कार्रवाई पर क्लिक करें।
 
  उदाहरण के लिए, उपयोगकर्ता-परिभाषित तरीके WebElement पर प्रत्येक क्रिया के लिए बनाए जाते हैं,
public void typeEmailId(String Id){ driver.findElement(EmailAddress).sendKeys(Id) }यहां, आईडी को विधि में एक पैरामीटर के रूप में पारित किया जाता है, क्योंकि इनपुट मुख्य परीक्षण मामले से उपयोगकर्ता द्वारा भेजा जाएगा।
  ध्यान दें :पेज लेयर में प्रत्येक क्लास में एक कंस्ट्रक्टर बनाया जाना है, ताकि टेस्ट लेयर में मेन क्लास से ड्राइवर का इंस्टेंस प्राप्त किया जा सके और PageFactory.Infelement () का उपयोग करते हुए पेज क्लास में घोषित वेबलाइंस (पेज ऑब्जेक्ट्स) को इनिशियलाइज़ भी किया जा सके। ।
 हम यहां ड्राइवर को शुरू नहीं करते हैं, बल्कि इसका उदाहरण मेन क्लास से प्राप्त होता है जब पेज लेयर क्लास का ऑब्जेक्ट बनाया जाता है।
  InitElement () - मुख्य वर्ग से ड्राइवर उदाहरण का उपयोग करते हुए घोषित किए गए WebElements को आरंभीकृत करने के लिए उपयोग किया जाता है। दूसरे शब्दों में, WebElements चालक उदाहरण का उपयोग करके बनाए जाते हैं। WebElements के आरंभ होने के बाद ही, उनका उपयोग क्रियाओं को करने के तरीकों में किया जा सकता है।
  नीचे दिखाए गए अनुसार प्रत्येक पृष्ठ के लिए दो जावा कक्षाएं बनाई गई हैं: 
  होमपेज.जावा 
 //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. } } टेस्ट लेयर
 इस श्रेणी में टेस्ट केस लागू किए जाते हैं। हम एक अलग पैकेज कहते हैं, com.automation.test और फिर यहां जावा क्लास बनाएं (MainClass.java)
  टेस्ट केस बनाने के चरण: 
  ड्राइवर को आरम्भ करें और एप्लिकेशन खोलें।
 पेजलेयर क्लास (प्रत्येक वेबपेज के लिए) का एक ऑब्जेक्ट बनाएं और ड्राइवर उदाहरण को पैरामीटर के रूप में पास करें।
 बनाई गई वस्तु का उपयोग करना, क्रिया / सत्यापन करने के लिए पेजलेयर क्लास (प्रत्येक वेबपेज के लिए) में विधियों के लिए एक कॉल करें।
 चरण 3 को दोहराएं जब तक कि सभी क्रियाएं नहीं की जाती हैं और तब ड्राइवर को बंद करें।
 
 //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(); } } विकृतीकरण प्रकार वेबसाईटों की घोषणा के लिए प्रयुक्त पदानुक्रम
 UI तत्वों के लिए स्थान रणनीति बनाने में सहायता के लिए एनोटेशन का उपयोग किया जाता है।
 # 1) @FindBy
 जब यह पेजफैक्ट्री की बात आती है, तो @FindBy एक जादुई छड़ी के रूप में कार्य करता है। यह अवधारणा के लिए सभी शक्ति जोड़ता है। अब आप जानते हैं कि पेजफैक्ट में @FindBy एनोटेशन सामान्य पृष्ठ ऑब्जेक्ट मॉडल में Driver.findElement () के समान ही करता है। इसका उपयोग WebElement / WebElements का पता लगाने के लिए किया जाता है एक कसौटी के साथ ।
 # 2) @FindBys
 इसका उपयोग WebElement का पता लगाने के लिए किया जाता है एक से अधिक मापदंड और दिए गए सभी मानदंडों को पूरा करने की आवश्यकता है। इन मानदंडों का उल्लेख माता-पिता-बच्चे के संबंध में किया जाना चाहिए। दूसरे शब्दों में, यह निर्दिष्ट मानदंडों का उपयोग करके WebElements का पता लगाने के लिए AND सशर्त संबंध का उपयोग करता है। यह प्रत्येक मानदंड को परिभाषित करने के लिए कई @FindBy का उपयोग करता है।
  उदाहरण के लिए: 
  एक WebElement का HTML स्रोत कोड: 
 पोम में: 
@FindBys({ @FindBy(id = 'searchId_1'), @FindBy(name = 'search_field') }) WebElementSearchButton;उपरोक्त उदाहरण में, WebElement above SearchButton ’केवल तभी स्थित है जब यह दोनों से मेल खाता है मानदंड जिनकी आईडी मान 'searchId_1' है और नाम मान 'search_field' है। कृपया ध्यान दें कि पहला मानदंड एक पैरेंट टैग और दूसरा टैग चाइल्ड टैग के लिए है।
 # 3) @FindAll
 इसका उपयोग WebElement का पता लगाने के लिए किया जाता है एक से अधिक मापदंड और इसे दिए गए मानदंडों में से कम से कम एक से मेल खाना चाहिए। यह WebElements का पता लगाने के लिए OR सशर्त संबंधों का उपयोग करता है। यह सभी मानदंडों को परिभाषित करने के लिए कई @FindBy का उपयोग करता है।
  उदाहरण के लिए: 
  HTML सोर्सकोड: 
 पोम में: 
@FindBys({ @FindBy(id = 'UsernameNameField_1'), // doesn’t match @FindBy(name = 'User_Id') //matches @FindBy(className = “UserName_r”) //matches }) WebElementUserName;उपरोक्त उदाहरण में, WebElement above उपयोगकर्ता नाम यदि यह स्थित है कम से कम एक मैच उल्लिखित मानदंड।
 # 4) @ कैशे लूकअप
 जब वेबेमेंट का उपयोग परीक्षण के मामलों में अधिक बार किया जाता है, तो सेलेनियम वेब स्क्रिप्ट के लिए हर बार देखता है जब परीक्षण स्क्रिप्ट चलती है। उन मामलों में, जिसमें कुछ वेबएलाइज़ विश्व स्तर पर सभी टीसी के लिए उपयोग किए जाते हैं ( उदाहरण के लिए, लॉगिन परिदृश्य प्रत्येक टीसी के लिए होता है), इस एनोटेशन को पहली बार पढ़ने के बाद कैश मेमोरी में उन वेबलाइंस को बनाए रखने के लिए उपयोग किया जा सकता है।
 यह बदले में, कोड को तेज़ी से निष्पादित करने में मदद करता है क्योंकि हर बार जब उसे पृष्ठ में WebElement की खोज नहीं करनी होती है, बल्कि यह मेमोरी से अपना संदर्भ प्राप्त कर सकता है।
 यह किसी भी @FindBy, @FindBys और @FindAll के साथ उपसर्ग के रूप में हो सकता है।
  उदाहरण के लिए: 
@CacheLookUp @FindBys({ @FindBy(id = 'UsernameNameField_1'), @FindBy(name = 'User_Id') @FindBy(className = “UserName_r”) }) WebElementUserName;यह भी ध्यान दें कि इस एनोटेशन का उपयोग केवल उन वेबलॉगों के लिए किया जाना चाहिए, जिनके विशेषता मान (जैसे कि xpath, id नाम, वर्ग नाम, आदि) में अक्सर बदलाव नहीं होता है। एक बार जब WebElement पहली बार स्थित होता है, तो यह कैश मेमोरी में इसके संदर्भ को बनाए रखता है।
 तो, फिर कुछ दिनों के बाद वेबइमेन्ट की विशेषता में परिवर्तन होता है, सेलेनियम तत्व का पता नहीं लगा पाएगा, क्योंकि इसकी कैश मेमोरी में पहले से ही इसका पुराना संदर्भ है और यह वेबइमेंट में हाल के बदलाव पर विचार नहीं करेगा।
 PageFactory.initElements पर अधिक ()
 अब जब हम InitElements () का उपयोग करके वेब तत्वों को शुरू करने पर पेजफैक्ट की रणनीति को समझते हैं, तो विधि के विभिन्न संस्करणों को समझने की कोशिश करते हैं।
 जैसा कि हम जानते हैं कि ड्राइवर ऑब्जेक्ट और वर्तमान क्लास ऑब्जेक्ट को इनपुट मापदंडों के रूप में लेता है और पृष्ठ पर सभी तत्वों को प्रारंभिक और सटीक रूप से प्रारंभ करके पृष्ठ ऑब्जेक्ट देता है।
 व्यवहार में, उपरोक्त अनुभाग में दिखाए गए निर्माणकर्ता का उपयोग इसके उपयोग के अन्य तरीकों से अधिक बेहतर है।
  विधि को कॉल करने के वैकल्पिक तरीके हैं: 
  # 1) 'इस' पॉइंटर का उपयोग करने के बजाय, आप वर्तमान क्लास ऑब्जेक्ट बना सकते हैं, ड्राइवर का उदाहरण इसे पास कर सकते हैं और पैरामीटर के साथ स्थैतिक विधि initElements कॉल कर सकते हैं यानी ड्राइवर ऑब्जेक्ट और क्लास ऑब्जेक्ट जो अभी बनाया गया था।
 public PagefactoryClass(WebDriver driver) { //version 2 PagefactoryClass page=new PagefactoryClass(driver); PageFactory.initElements(driver, page); }  #दो) पेजफैक्ट्री क्लास का उपयोग करने वाले तत्वों को इनिशियलाइज़ करने का तीसरा तरीका 'प्रतिबिंब' नामक एपीआई का उपयोग करके है। हाँ, एक 'नए' कीवर्ड के साथ एक क्लास ऑब्जेक्ट बनाने के बजाय, classname.class को initElements () इनपुट पैरामीटर के हिस्से के रूप में पारित किया जा सकता है।
 public PagefactoryClass(WebDriver driver) { //version 3 PagefactoryClass page=PageFactory.initElements(driver, PagefactoryClass.class); } बार बार पूछे जाने वाले प्रश्न
  Q # 1) @FindBy के लिए उपयोग की जाने वाली विभिन्न लोकेटर रणनीतियाँ क्या हैं? 
  उत्तर: इसका सरल उत्तर यह है कि @FindBy के लिए उपयोग की जाने वाली कोई भिन्न लोकेटर रणनीतियाँ नहीं हैं।
  वे समान 8 लोकेटर रणनीतियों का उपयोग करते हैं जो सामान्य पीओएम में खोज () विधि का उपयोग करता है: 
  ईद
 नाम
 कक्षा का नाम
 xpath
 सीएसएस
 टैग नाम
 लिंक पाठ
 partLinkText
 
  Q # 2) क्या @FindBy एनोटेशन के उपयोग के भी अलग-अलग संस्करण हैं? 
  उत्तर: जब कोई वेब तत्व खोजा जाता है, तो हम एनोटेशन @FindBy का उपयोग करते हैं। हम अलग-अलग लोकेटर रणनीतियों के साथ @FindBy का उपयोग करने के वैकल्पिक तरीकों के बारे में विस्तार से बताएंगे।
  हमने पहले ही देखा है कि @FindBy के संस्करण 1 का उपयोग कैसे करें: 
@FindBy(id = 'cidkeyword') WebElement Symbol;@FindBy का संस्करण 2 इनपुट पैरामीटर पास के रूप में है किस तरह तथा का उपयोग करते हुए ।
  किस तरह लोकेटर रणनीति का उपयोग करता है, जिसके उपयोग की पहचान की जाएगी। कीवर्ड का उपयोग करते हुए लोकेटर मान को परिभाषित करता है।
  बेहतर समझ के लिए नीचे देखें, 
  How.ID तत्व का उपयोग करके खोज करता है ईद रणनीति और जिस तत्व को पहचानने की कोशिश करता है, उसमें आईडी = है Cidkeyword। 
 
@FindBy(how = How.ID, using = ' cidkeyword') WebElement Symbol; How.CLASS_NAME तत्व का उपयोग करके खोज करता है कक्षा का नाम रणनीति और जिस तत्व को पहचानने की कोशिश करता है, वह वर्ग = है न्यूक्लास। 
 
@FindBy(how = How.CLASS_NAME, using = 'newclass') WebElement Symbol; Q # 3) क्या @FindBy के दो संस्करणों में अंतर है? 
  उत्तर: इसका उत्तर है, दो संस्करणों में कोई अंतर नहीं है। यह सिर्फ इतना है कि दूसरे संस्करण की तुलना में पहला संस्करण छोटा और आसान है।
  Q # 4) पेजफैक्ट्री में मैं क्या उपयोग कर सकता हूं अगर वेब तत्वों की सूची मौजूद है? 
  उत्तर: सामान्य पृष्ठ ऑब्जेक्ट डिज़ाइन पैटर्न में, हमारे पास Driver.findElements () एक ही वर्ग या टैग नाम से संबंधित कई तत्वों का पता लगाने के लिए है, लेकिन पेजफैक्टी के साथ पेज ऑब्जेक्ट मॉडल के मामले में हम ऐसे तत्वों का पता कैसे लगाते हैं? ऐसे तत्वों को प्राप्त करने का सबसे आसान तरीका उसी एनोटेशन @FindBy का उपयोग करना है।
 मैं समझता हूं कि यह पंक्ति आप में से कई लोगों के लिए सिर-खरोंच लगती है। लेकिन हां, यह सवाल का जवाब है।
  आइए हम निम्न उदाहरण देखें: 
 पेजफैक्ट के बिना सामान्य पृष्ठ ऑब्जेक्ट मॉडल का उपयोग करते हुए, आप नीचे दिखाए गए अनुसार कई तत्वों का पता लगाने के लिए Driver.findElements का उपयोग करते हैं:
 private List  multipleelements_driver_findelements = driver.findElements (By.class(“last”));पेजफैक्ट के साथ पेज ऑब्जेक्ट मॉडल का उपयोग करके इसे प्राप्त किया जा सकता है जैसा कि नीचे दिया गया है:
 @FindBy (how = How.CLASS_NAME, using = 'last')  private List  multipleelements_FindBy;मूल रूप से, तत्वों को वेबइमेंट की सूची में असाइन करना इस बात की परवाह किए बिना कि क्या पेजफैक्ट का उपयोग किया गया है या तत्वों की पहचान और पता लगाने के दौरान नहीं किया गया है।
  Q # 5) क्या पेजफैक्ट्री और पेजफैक्ट्री के साथ पेज ऑब्जेक्ट दोनों को एक ही प्रोग्राम में इस्तेमाल किया जा सकता है? 
  उत्तर: हां, पेजफैक्ट के बिना और पेजफैक्ट्री के साथ दोनों पृष्ठ ऑब्जेक्ट डिज़ाइन को एक ही कार्यक्रम में उपयोग किया जा सकता है। आप नीचे दिए गए कार्यक्रम से गुजर सकते हैं प्रश्न # 6 का उत्तर यह देखने के लिए कि कार्यक्रम में दोनों का उपयोग कैसे किया जाता है।
 एक बात याद रखें कि कैश्ड फीचर वाली पेजफैक्टिक अवधारणा को डायनामिक तत्वों से बचा जाना चाहिए जबकि डायनामिक तत्वों के लिए पेज ऑब्जेक्ट डिजाइन अच्छी तरह से काम करता है। हालाँकि, पेजफैक्ट स्थिर तत्वों को ही सूट करता है।
  Q # 6) क्या कई मानदंडों के आधार पर तत्वों की पहचान करने के वैकल्पिक तरीके हैं? 
आप ट्यूब से वीडियो डाउनलोड करने के लिए सॉफ्टवेयर
  उत्तर: कई मानदंडों के आधार पर तत्वों की पहचान करने का विकल्प एनोटेशन @FindAll और @FindBys का उपयोग कर रहा है। ये एनोटेशन इसमें दिए गए मानदंडों से प्राप्त मूल्यों के आधार पर एकल या कई तत्वों की पहचान करने में मदद करते हैं।
  # 1) @ फ़ाइंड: 
 @FindAll में कई @FindBy हो सकते हैं और वे सभी तत्व वापस आ जाएंगे जो किसी भी सूची में किसी भी @FindBy से मेल खाते हैं। @FindAll का उपयोग पृष्ठ ऑब्जेक्ट पर एक फ़ील्ड को चिह्नित करने के लिए किया जाता है ताकि यह इंगित किया जा सके कि लुकअप को @FindBy टैग की एक श्रृंखला का उपयोग करना चाहिए। यह तब सभी तत्वों की खोज करेगा जो फाइंडबाय के किसी भी मापदंड से मेल खाते हों।
 ध्यान दें कि तत्वों को दस्तावेज़ क्रम में होने की गारंटी नहीं है।
  @FindAll का उपयोग करने का सिंटैक्स निम्नानुसार है: 
@FindAll( { @FindBy(how = How.ID, using = 'foo'), @FindBy(className = 'bar') } ) स्पष्टीकरण: @FindAll प्रत्येक #FindBy मानदंड के अनुरूप अलग-अलग तत्वों की खोज करेगा और उन्हें सूचीबद्ध करेगा। उपरोक्त उदाहरण में, यह पहले एक तत्व खोजेगा जिसका आईडी = 'फू' और फिर, क्लासनाम = 'बार' के साथ दूसरे तत्व की पहचान करेगा।
 यह मानते हुए कि प्रत्येक FindBy मानदंड के लिए एक तत्व की पहचान की गई थी, @FindAll क्रमशः 2 तत्वों को सूचीबद्ध करेगा। याद रखें, प्रत्येक मानदंड के लिए कई तत्वों की पहचान की जा सकती है। इस प्रकार, सरल शब्दों में, @ सब ढूँढ़ो के बराबर कार्य करता है या @FindBy मानदंड पर ऑपरेटर पास हुआ।
  # 2) @FindBys: 
 FindBys का उपयोग पृष्ठ ऑब्जेक्ट पर एक फ़ील्ड को चिह्नित करने के लिए किया जाता है, ताकि यह इंगित किया जा सके कि लुकअप को श्रृंखला में @FindBy टैग की एक श्रृंखला का उपयोग करना चाहिए जैसा कि अलिखित में वर्णित है। जब आवश्यक WebElement ऑब्जेक्ट को दिए गए सभी मानदंडों से मेल खाना चाहिए, तो @FindBys एनोटेशन का उपयोग करें।
  @FindBys का उपयोग करने का सिंटैक्स निम्नानुसार है: 
@FindBys( { @FindBy(name=”foo”) @FindBy(className = 'bar') } ) स्पष्टीकरण: @FindBys सभी @FindBy मानदंडों के अनुरूप तत्वों की खोज और पहचान करेगा और उन्हें सूचीबद्ध करेगा। उपरोक्त उदाहरण में, यह उन तत्वों को खोजेगा जिनके नाम = 'फू' और वर्गनाम = 'बार' है।
 @FindAll 1 तत्व को सूचीबद्ध करने में परिणाम देगा यदि हम मान लें कि दिए गए मानदंडों में नाम और वर्गनाम के साथ एक तत्व की पहचान की गई थी।
 यदि सभी FindBy शर्तों को पूरा करने वाला एक तत्व संतोषजनक नहीं है, तो @FindBys का परिणाम शून्य तत्व होगा। वेब तत्वों की एक सूची हो सकती है, जिसकी पहचान की जाए तो सभी स्थितियाँ कई तत्वों को संतुष्ट करती हैं। सरल शब्दों में, @ FindBys के बराबर कार्य करता है तथा @FindBy मानदंड पर ऑपरेटर पास हुआ।
  हमें एक विस्तृत कार्यक्रम के माध्यम से उपरोक्त सभी एनोटेशन के कार्यान्वयन को देखते हैं: 
 हम एनोटेशन @FindBy, @FindBys और @FindAll के कार्यान्वयन को समझने के लिए पिछले भाग में दिए गए www.nseindia.com प्रोग्राम को संशोधित करेंगे।
  # 1) PagefactoryClass का ऑब्जेक्ट रिपॉजिटरी नीचे के रूप में अद्यतन किया गया है: 
 सूची को सूचीबद्ध करें = driver.findElements (By.tagName ('a'));
  @ इंडियाबाय (कैसे = कैसे। टैग नाम , प्रयोग = 'a') 
  निजी लिस्टबाइवल; 
  @सब ढूँढ़ो ({ @ इंडियाबाय (वर्गनाम = 'sel'), @ इंडियाबाय (xpath = '// एक (@ id = 'tab5”) ')}) 
  निजी सूची खोज; 
  @FindBys ({ @ इंडियाबाय (वर्गनाम = 'sel'), @ इंडियाबाय (xpath = '// एक (@ id = 'tab5”) ')}) 
  निजी सूची खोजक सूची;
  # 2) एक नई विधि SeeHowFindWorks () PagefactoryClass में लिखी गई है और इसे मुख्य वर्ग में अंतिम विधि के रूप में लागू किया गया है। 
  विधि इस प्रकार है: 
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 नीचे दिया गया परिणाम कार्यक्रम के कंसोल विंडो पोस्ट-एक्ज़ीक्यूशन पर दिखाया गया है: 
  
  आइए अब कोड को विस्तार से समझने की कोशिश करते हैं: 
  # 1) पृष्ठ ऑब्जेक्ट डिज़ाइन पैटर्न के माध्यम से, तत्व page newlist ’एंकर’ a ’के साथ सभी टैग की पहचान करता है। दूसरे शब्दों में, हमें पृष्ठ पर सभी लिंक की एक गिनती मिलती है।
 हमें पता चला कि पेजफैक्ट @FindBy ड्राइवर.फाइटमेंट () की तरह ही काम करता है। तत्व खोज-प्रक्रिया को पृष्ठ पर सभी लिंक की गिनती एक खोज रणनीति के माध्यम से पेजफैक्ट्री कॉन्सेप्ट प्राप्त करने के लिए बनाया जाता है।
 यह सही साबित होता है कि दोनों driver.findElement () और @FindBy समान कार्य करते हैं और समान तत्वों की पहचान करते हैं। यदि आप ऊपर दिए गए परिणामी कंसोल विंडो के स्क्रीनशॉट को देखते हैं, तो तत्व की सूची के साथ नए तत्वों की पहचान की जाती है और यह खोजे के बराबर है अर्थात्। 299 लिंक पृष्ठ पर पाए गए।
  परिणाम निम्नानुसार है: 
driver.findElements(By.tagName())  299  count of @FindBy- list elements  299  #दो) यहां हम @FindAll एनोटेशन के कामकाज के बारे में विस्तार से बताते हैं जो कि वेब तत्वों की सूची में नाम खोजने के साथ संबंधित होगा।
 @FindAll एनोटेशन के भीतर प्रत्येक @FindBy मानदंड को देखने के लिए, पहला @FindBy मानदंड उन तत्वों के लिए खोजता है जिनका नामNN = 'sel' है और दूसरा @FindBy मानदंड XPath = '// @ आईडी' के साथ एक विशिष्ट तत्व की खोज करता है 'tab5')
 आइए अब पृष्ठ 12 पर तत्वों का निरीक्षण करने के लिए F12 दबाएं nseindia.com और @FindBy मापदंड के अनुरूप तत्वों पर कुछ स्पष्टताएँ प्राप्त करें।
  पेज पर दो तत्व हैं जिनका नाम क्लासनाम = 'sel' है: 
  सेवा मेरे) 'फंडामेंटल्स' तत्व में सूची टैग है अर्थात्
के साथ className = 'sel'।
  नीचे स्नैपशॉट देखें 
  
  बी) एक अन्य तत्व 'ऑर्डर बुक' में एंकर टैग के साथ एक XPath है जिसका वर्ग नाम Order sel 'है।
  
  सी) XP @ के साथ दूसरे @FindBy में एक एंकर टैग है जिसका ईद है ' टैब 5 ”। खोज के जवाब में केवल एक तत्व की पहचान की गई है जो फंडामेंटल्स है।
  नीचे स्नैपशॉट देखें: 
  
 जब nseindia.com परीक्षण निष्पादित किया गया, तो हमें खोजे गए तत्वों की गिनती मिली।
 @FindAll 3 के रूप में। प्रदर्शित होने पर खोज के लिए तत्व थे: मूल तत्व 0 के रूप में^धसूचकांक तत्व, ऑर्डर बुक 1 के रूप में^{अनुसूचित जनजाति}सूचकांक तत्व और बुनियादी बातों को फिर से 2 के रूप में^{एन डी}सूचकांक तत्व। हमने पहले ही यह जान लिया कि @FindAll प्रत्येक @FindBy मानदंड के लिए अलग से तत्वों की पहचान करता है।
 पहली मानदंड खोज के लिए एक ही प्रोटोकॉल के अनुसार, यानी className = 'sel', इसने इस शर्त को पूरा करने वाले दो तत्वों की पहचान की और इसने 'फंडामेंटल्स' और 'ऑर्डर बुक' प्राप्त किया।
 फिर यह अगले @FindBy मानदंड पर चला गया और दूसरे @FindBy के लिए दिए गए xpath के अनुसार, यह 'फंडामेंटल' तत्व ला सकता है। यही कारण है, यह अंततः 3 तत्वों की पहचान करता है, क्रमशः।
 इस प्रकार, यह @FindBy शर्तों में से किसी एक को संतुष्ट करने वाले तत्वों को प्राप्त नहीं करता है, लेकिन यह प्रत्येक @FindBy के साथ अलग से व्यवहार करता है और इसी तरह तत्वों की पहचान करता है। इसके अतिरिक्त, वर्तमान उदाहरण में, हमने यह भी देखा, कि यदि तत्व अद्वितीय हैं तो यह नहीं देखता है ( जैसे इस मामले में 'फंडामेंटल' तत्व जो दो @FindBy मानदंडों के परिणाम के भाग के रूप में दो बार प्रदर्शित होता है)
  # 3) यहां हम @FindBys एनोटेशन के कामकाज के बारे में विस्तार से बताते हैं, जो वेब तत्वों की सूची में नाम खोजने के साथ संबंधित होगा। यहाँ भी, पहले @FindBy मानदंड तत्वों के लिए खोज करते हैं className = 'sel' के साथ और दूसरा @FindBy मानदंड xpath = '// (a @ @ id =' tab5 ') के साथ एक विशिष्ट तत्व को खोजता है।
 अब जब हम जानते हैं, पहले @FindBy स्थिति के लिए पहचाने जाने वाले तत्व 'फंडामेंटल' और 'ऑर्डर बुक' हैं और दूसरे @FindBy मानदंड 'फंडामेंटल' हैं।
 तो, @FindBys परिणामी @FindAll से भिन्न कैसे होगा? हमने पिछले भाग में जाना कि @FindBys AND सशर्त ऑपरेटर के बराबर है और इसलिए यह किसी तत्व या तत्वों की सूची को देखता है जो सभी @FindBy स्थिति को संतुष्ट करता है।
 हमारे वर्तमान उदाहरण के अनुसार, 'फंडामेंटल' एकमात्र ऐसा तत्व है, जिसमें वर्ग = 'sel' और id = 'tab5' है, जिससे दोनों स्थितियों को पूरा किया जा सकता है। यही कारण है कि आउटफिट में @FindBys का आकार 1 है और यह 'फंडामेंटल' के रूप में मूल्य प्रदर्शित करता है।
  Pagefactory में तत्वों को कैशिंग 
 जब भी कोई पृष्ठ लोड किया जाता है, पृष्ठ पर सभी तत्वों को @FindBy या driver.findElement () के माध्यम से कॉल करके फिर से देखा जाता है और पृष्ठ पर तत्वों की एक नई खोज होती है।
 अधिकांश समय जब तत्व गतिशील होते हैं या रनटाइम के दौरान बदलते रहते हैं, खासकर अगर वे AJAX तत्व हैं, तो यह निश्चित रूप से समझ में आता है कि हर पृष्ठ लोड के साथ पृष्ठ पर सभी तत्वों की एक नई खोज होती है।
 जब वेबपृष्ठ में स्थिर तत्व होते हैं, तो तत्व को कैशिंग करने से कई तरीकों से मदद मिल सकती है। जब तत्वों को कैश किया जाता है, तो पृष्ठ को लोड करने पर फिर से तत्वों का पता नहीं लगाना पड़ता है, इसके बजाय, यह कैश्ड तत्व भंडार को संदर्भित कर सकता है। यह बहुत समय बचाता है और बेहतर प्रदर्शन को बढ़ाता है।
 पेजफैक्ट एक एनोटेशन का उपयोग करके तत्वों को कैशिंग करने की यह सुविधा प्रदान करता है @ कैशे लूकअप ।
 एनोटेशन ड्राइवर को तत्वों के लिए DOM से लोकेटर के एक ही उदाहरण का उपयोग करने के लिए कहता है और उन्हें फिर से खोज नहीं करता है जबकि पेजफैक्ट की initElements विधि प्रमुख रूप से कैश्ड स्टेटिक तत्व के भंडारण में योगदान करती है। InitElements तत्वों के कैशिंग कार्य करते हैं।
 यह पेजफैक्ट अवधारणा को नियमित पेज ऑब्जेक्ट डिज़ाइन पैटर्न पर विशेष बनाता है। यह अपने स्वयं के पेशेवरों और विपक्षों के साथ आता है जिन पर हम थोड़ी देर बाद चर्चा करेंगे। उदाहरण के लिए, फेसबुक होम पेज पर लॉगिन बटन एक स्थिर तत्व है, जिसे कैश किया जा सकता है और कैश किया जाने वाला एक आदर्श तत्व है।
   आइए अब हम देखें कि एनोटेशन @CacheLookUp को कैसे लागू किया जाए  
  आपको पहले नीचे दिए गए Cachelookup के लिए एक पैकेज आयात करना होगा: 
import org.openqa.selenium.support.CacheLookupनीचे स्निपेट @CacheLookUp का उपयोग करके एक तत्व की परिभाषा प्रदर्शित करता है। जैसे ही UniqueElement पहली बार खोजा जाता है, initElement () तत्व के कैश्ड संस्करण को संग्रहीत करता है ताकि अगली बार जब चालक तत्व की तलाश न करे तो यह उसी कैश को संदर्भित करता है और तत्व पर कार्रवाई करता है दूर।
@FindBy(id = 'unique') @CacheLookup private WebElement UniqueElement; आइए अब एक वास्तविक कार्यक्रम के माध्यम से देखते हैं कि कैश्ड वेब एलिमेंट पर क्रियाएँ गैर-कैश्ड वेब एलिमेंट की तुलना में कितनी तेज़ हैं: 
 Nseindia.com प्रोग्राम को आगे बढ़ाते हुए मैंने एक और नया तरीका मॉनिटरपिरफॉर्मेंस () लिखा है जिसमें मैं सर्च बॉक्स के लिए एक कैश्ड एलिमेंट बनाता हूं और उसी सर्च बॉक्स के लिए नॉन-कैश्ड एलिमेंट।
 फिर मैं कैश्ड और गैर-कैश्ड दोनों तत्वों के लिए तत्व का तिगुना 3000 बार प्राप्त करने का प्रयास करता हूं और कैश्ड और गैर-कैश्ड दोनों तत्वों द्वारा कार्य को पूरा करने में लगने वाले समय को नापने की कोशिश करता हूं।
 मैंने 3000 बार विचार किया है ताकि हम दोनों के लिए समय में एक स्पष्ट अंतर देख सकें। मैं उम्मीद करूंगा कि कैश्ड तत्व को कम समय में तग्नेमे को 3000 बार पूरा करना चाहिए जब गैर-कैश्ड तत्व की तुलना में।
 अब हम जानते हैं कि कैश्ड एलिमेंट क्यों तेजी से काम करता है यानी ड्राइवर को निर्देश दिया जाता है कि पहले लुकअप के बाद एलिमेंट को न देखें लेकिन सीधे उस पर काम करते रहें और नॉन-कैशेड एलिमेंट के साथ ऐसा न हो जहां एलिमेंट लुकिंग के लिए किया जाता है सभी 3000 बार और फिर उस पर कार्रवाई की जाती है।
  नीचे विधि मॉनिटरपैरफॉर्मेंस () के लिए कोड है: 
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'); }  निष्पादन पर, हम नीचे का परिणाम कंसोल विंडो में देखेंगे: 
 परिणामस्वरूप, गैर-कैश किए गए तत्व पर कार्य पूरा हो गया है .२ कैश्ड तत्व पर कार्य पूरा करने के लिए लिया गया समय केवल कुछ सेकंड था ३। सेकंड। यह वास्तव में कैश्ड और गैर-कैश्ड दोनों तत्वों के प्रतिक्रिया समय में एक दृश्य अंतर है।
  
  Q # 7) पेजफैक्ट्री अवधारणा में एनोटेशन @ कैशे लूकअप के पेशेवरों और विपक्ष क्या हैं? 
  उत्तर: 
  पेशेवरों @CacheLookUp और इसके उपयोग के लिए संभव स्थितियाँ: 
 जब पृष्ठ लोड किए जाते हैं तो @CacheLookUp संभव है जब तत्व स्थिर होते हैं या बिल्कुल नहीं बदलते हैं। ऐसे तत्व रन टाइम में बदलाव नहीं करते हैं। ऐसे मामलों में, परीक्षण निष्पादन की समग्र गति में सुधार करने के लिए एनोटेशन का उपयोग करना उचित है।
  एनोटेशन की विपक्ष @CacheLookUp: 
 एनोटेशन के साथ कैश्ड तत्वों के होने का सबसे बड़ा नकारात्मक पहलू यह है कि अक्सर StaleElementReferenceException प्राप्त करने का डर होता है।
 गतिशील तत्वों को अक्सर उन लोगों के साथ ताज़ा किया जाता है जो समय अंतराल के कुछ सेकंड या मिनट में जल्दी से बदलने के लिए अतिसंवेदनशील होते हैं।
  नीचे गतिशील तत्वों के कुछ ऐसे उदाहरण हैं: 
  वेब पेज पर स्टॉपवॉच होने से जो हर पल टाइमर अपडेट करता रहता है।
 एक फ्रेम जो लगातार मौसम की रिपोर्ट को अपडेट करता है।
 सेंसक्स अपडेट की रिपोर्ट करने वाला एक पेज।
 
 ये एनोटेशन @CacheLookUp के उपयोग के लिए आदर्श या व्यवहार्य नहीं हैं। यदि आप करते हैं, तो आपको StaleElementReferenceException के अपवाद को प्राप्त करने का जोखिम है।
 ऐसे तत्वों को कैशिंग करने पर, परीक्षण निष्पादन के दौरान, तत्वों के DOM को बदल दिया जाता है, हालांकि ड्राइवर DOM के संस्करण की तलाश करता है जिसे कैशिंग करते समय पहले ही संग्रहीत किया गया था। इससे ड्राइवर द्वारा बासी तत्व को देखा जा सकता है जो अब वेब पेज पर मौजूद नहीं है। यही कारण है कि StaleElementReferenceException को फेंक दिया जाता है।
  फैक्टरी कक्षाएं: 
 पेजफैक्ट्री एक अवधारणा है जो कई कारखाने वर्गों और इंटरफेस पर बनाई गई है। हम इस खंड में यहां कुछ फैक्ट्री कक्षाओं और इंटरफेस के बारे में जानेंगे। जिनमें से कुछ हम देखेंगे AjaxElementLocatorFactory , एलिमेंटलोकेटरफैक्टरी तथा DefaultElementFactory। 
 क्या हमने कभी सोचा है कि पेजफैक्ट किसी तत्व को तब तक इंप्लाट या एक्सप्लोसिव को शामिल करने का कोई तरीका प्रदान करता है जब तक कि एक निश्चित शर्त न लगा दी जाए ( उदाहरण: जब तक कोई तत्व दिखाई नहीं देता, सक्षम, क्लिक करने योग्य, आदि)? यदि हाँ, तो यहाँ इसका उपयुक्त उत्तर है।
  AjaxElementLocatorFactory सभी कारखाने वर्गों में महत्वपूर्ण योगदानकर्ताओं में से एक है। AjaxElementLocatorFactory का लाभ यह है कि आप वेब पेज के लिए ऑब्जेक्ट पेज क्लास के लिए टाइम आउट मान दे सकते हैं।
 हालाँकि, पेजफैक्ट्री स्पष्ट प्रतीक्षा सुविधा प्रदान नहीं करती है, हालाँकि, कक्षा का उपयोग करते हुए निहित प्रतीक्षा करने का एक प्रकार है AjaxElementLocatorFactory । जब आवेदन अजाक्स घटकों और तत्वों का उपयोग करता है तो इस वर्ग को शामिल किया जा सकता है।
 यहां बताया गया है कि आप इसे कोड में कैसे लागू करते हैं। कंस्ट्रक्टर के भीतर, जब हम initElements () विधि का उपयोग करते हैं, तो हम तत्वों पर एक अंतर्निहित प्रतीक्षा प्रदान करने के लिए AjaxElementLocatorFactory का उपयोग कर सकते हैं।
PageFactory.initElements(driver, this); can be replaced with PageFactory.initElements( new AjaxElementLocatorFactory(driver, 20),  this);कोड की ऊपर की दूसरी पंक्ति से तात्पर्य है कि ड्राइवर अपने लोड होने पर सभी तत्वों के लिए पृष्ठ पर 20 सेकंड का समयबाह्य समय निर्धारित करेगा और यदि कोई तत्व 20 सेकंड के इंतजार के बाद नहीं मिलता है, तो 'NoSuchElementException' को फेंक दिया जाता है। उस लापता तत्व के लिए।
  आप नीचे दिए गए प्रतीक्षा को भी परिभाषित कर सकते हैं: 
 public pageFactoryClass(WebDriver driver) { ElementLocatorFactory locateMe = new AjaxElementLocatorFactory(driver, 30); PageFactory.initElements(locateMe, this); this.driver = driver; } उपरोक्त कोड पूरी तरह से काम करता है क्योंकि वर्ग AjaxElementLocatorFactory इंटरफ़ेस ElementLocatorFactory को लागू करता है।
 यहाँ, मूल इंटरफ़ेस (ElementLocatorFactory) बाल वर्ग (AjaxElementLocatorFactory) की वस्तु को संदर्भित करता है। इसलिए, AjaxElementLocatorFactory का उपयोग करते हुए टाइमआउट असाइन करते समय 'अपकास्टिंग' या 'रनटाइम पॉलीमॉर्फिज्म' की जावा अवधारणा का उपयोग किया जाता है।
 यह तकनीकी रूप से कैसे काम करता है, इस संबंध में, AjaxElementLocatorFactory पहले एक SlowLoadableComponent का उपयोग करके एक AjaxElementLocator बनाता है जो लोड () रिटर्न होने पर लोडिंग समाप्त नहीं कर सकता है। लोड करने के लिए एक कॉल के बाद (), isLoaded () विधि विफल होना चाहिए जब तक कि घटक पूरी तरह से लोड नहीं हुआ।
 दूसरे शब्दों में, सभी तत्वों को हर बार नए सिरे से देखा जाएगा जब एक तत्व को AjaxElementLocator वर्ग से locator.findElement () को कॉल करके कोड में एक्सेस किया जाता है जो तब SlowLoadableComponent वर्ग में लोड होने तक एक समयबाह्य लागू होता है।
 इसके अतिरिक्त, AjaxElementLocatorFactory के माध्यम से टाइमआउट असाइन करने के बाद, @CacheLookUp एनोटेशन वाले तत्वों को अब कैश नहीं किया जाएगा क्योंकि एनोटेशन को अनदेखा किया जाएगा।
 भिन्नता भी है कि कैसे आप ऐसा कर सकते हैं बुलाएं initElements () विधि और आप कैसे नहीं चाहिए बुलाएं AjaxElementLocatorFactory किसी तत्व के लिए टाइमआउट निर्दिष्ट करने के लिए।
  # 1) आप ड्राइवर ऑब्जेक्ट के बजाय तत्व नाम निर्दिष्ट कर सकते हैं जैसा कि initElements () विधि में नीचे दिखाया गया है: 
PageFactory.initElements( ,  this);initElements () विधि उपरोक्त संस्करण में आंतरिक रूप से DefaultElementFactory वर्ग के लिए कॉल करता है और DefaultElementFactory का निर्माता SearchContext इंटरफ़ेस ऑब्जेक्ट को इनपुट पैरामीटर के रूप में स्वीकार करता है। वेब ड्राइवर ऑब्जेक्ट और एक वेब तत्व दोनों SearchContext इंटरफ़ेस से संबंधित हैं।
 इस स्थिति में, initElements () विधि केवल उल्लिखित तत्व को आरंभीकृत करेगी और वेबपेज पर सभी तत्व आरंभिक नहीं होंगे।
  #दो) हालांकि, यहां इस तथ्य के लिए एक दिलचस्प मोड़ है जो बताता है कि आपको एक विशिष्ट तरीके से AjaxElementLocatorFactory वस्तु को कैसे नहीं कॉल करना चाहिए। यदि मैं AjaxElementLocatorFactory के साथ initElements () के उपरोक्त संस्करण का उपयोग करता हूं, तो यह विफल हो जाएगा।
  उदाहरण: नीचे दिए गए कोड यानि कि AjaxElementLocatorFactory परिभाषा के लिए ड्राइवर ऑब्जेक्ट के बजाय पासिंग एलिमेंट नाम, AjaxElementLocatorFactory वर्ग के लिए कंस्ट्रक्टर के रूप में काम करने में विफल रहेगा, केवल इनपुट इनपुट पैरामीटर के रूप में वेब ड्राइवर ऑब्जेक्ट लेता है और इसलिए, वेब तत्व के साथ SearchContext ऑब्जेक्ट इसके लिए काम नहीं करेगा।
PageFactory.initElements(new AjaxElementLocatorFactory(, 10), this); Q # 8) क्या पेजफैक्ट्री का उपयोग रेगुलर पेज ऑब्जेक्ट डिज़ाइन पैटर्न पर संभव विकल्प है? 
  उत्तर: यह सबसे महत्वपूर्ण प्रश्न है जो लोगों के पास है और यही कारण है कि मैंने इसे ट्यूटोरियल के अंत में संबोधित करने के बारे में सोचा। अब हम इसकी अवधारणाओं, उपयोग किए जाने वाले एनोटेशन, अतिरिक्त सुविधाओं के बारे में, जिसका यह समर्थन करता है, कोड के माध्यम से कार्यान्वयन, पेशेवरों, और विपक्ष से शुरू होने वाले पेजफैक्ट के बारे में now इन और आउट ’जानते हैं।
 फिर भी, हम इस आवश्यक प्रश्न के साथ बने हुए हैं कि अगर पेजफैक्ट में इतनी अच्छी चीजें हैं, तो हम इसके उपयोग से क्यों न चिपके रहें।
 Pagefactory CacheLookUp की अवधारणा के साथ आता है जिसे हमने देखा है कि यह अक्सर अद्यतन किए गए तत्व के मूल्यों जैसे गतिशील तत्वों के लिए संभव नहीं है। तो, CacheLookUp के बिना पेजफैक्ट्री, क्या विकल्प पर जाना अच्छा है? हाँ, अगर xpaths स्थिर हैं।
 हालाँकि, अधोगति यह है कि आधुनिक युग का अनुप्रयोग भारी गतिशील तत्वों से भरा हुआ है जहाँ हम पेजफैक्ट के बिना पेज ऑब्जेक्ट डिज़ाइन को अच्छी तरह जानते हैं लेकिन क्या पेजफैक्टिक अवधारणा डायनेमिक xpaths के साथ समान रूप से अच्छी तरह से काम करती है? शायद नहीं। यहाँ एक त्वरित उदाहरण है:
 Nseindia.com वेबपेज पर, हम नीचे दी गई तालिका को देखते हैं।
  
  तालिका का xpath है 
'//*(@id='tab9Content')/table/tbody/tr(+count+)/td(1)'हम पहले कॉलम ty बाय क्यूटी ’के लिए प्रत्येक पंक्ति से मान प्राप्त करना चाहते हैं। ऐसा करने के लिए हमें पंक्ति काउंटर को बढ़ाने की आवश्यकता होगी, लेकिन कॉलम इंडेक्स 1. रहेगा। ऐसा कोई तरीका नहीं है जिससे हम @FindBy एनोटेशन में इस डायनेमिक XPath को पास कर सकें क्योंकि एनोटेशन मानों को स्वीकार करता है जो स्थिर हैं और कोई वेरिएबल पास नहीं किया जा सकता है यह।
 यहां वह पृष्ठपृष्ठ है जहां पूरी तरह से विफल रहता है, जबकि सामान्य पीओएम इसके साथ बहुत अच्छा काम करता है। आप ड्राइवर .findElement () विधि में ऐसे डायनेमिक xpaths का उपयोग करके आसानी से पंक्ति सूचकांक को बढ़ाने के लिए लूप के लिए उपयोग कर सकते हैं।
 निष्कर्ष
 पेज ऑब्जेक्ट मॉडल एक डिजाइन अवधारणा या पैटर्न है जिसका उपयोग सेलेनियम स्वचालन ढांचे में किया जाता है।
 पेज ऑब्जेक्ट मॉडल में तरीकों का नामकरण संवहन उपयोगकर्ता के अनुकूल है। POM में कोड समझने, पुन: प्रयोज्य और बनाए रखने में आसान है। POM में, यदि वेब तत्व में कोई परिवर्तन है तो, यह सभी वर्गों को संपादित करने के बजाय, अपनी संबंधित कक्षा में परिवर्तन करने के लिए पर्याप्त है।
 सामान्य पोम की तरह पेजफैक्ट्री को लागू करने के लिए एक अद्भुत अवधारणा है। हालांकि, हमें यह जानने की जरूरत है कि सामान्य POM संभव कहां है और जहां Pagefactory अच्छी तरह से सूट करता है। स्थिर अनुप्रयोगों में (जहां XPath और तत्व दोनों स्थिर हैं), Pagefactory को बेहतर प्रदर्शन के अतिरिक्त लाभों के साथ उदारतापूर्वक लागू किया जा सकता है।
 वैकल्पिक रूप से, जब अनुप्रयोग में गतिशील और स्थिर दोनों तत्व शामिल होते हैं, तो आपके पास पेजफैक्ट के साथ पोम का मिश्रित कार्यान्वयन हो सकता है और प्रत्येक वेब तत्व के लिए व्यवहार्यता के अनुसार पेजफैक्ट्री के बिना।
 लेखक: यह ट्यूटोरियल शोभा डी द्वारा लिखा गया है। वह प्रोजेक्ट लीड के रूप में काम करती है और 9+ वर्षों के अनुभव, मैनुअल, ऑटोमेशन (सेलेनियम, आईबीएम तर्कसंगत कार्यात्मक परीक्षक, जावा) के साथ आती है और एपीआई परीक्षण (एसओएपीयूआई और बाकी का जावा में आश्वासन दिया गया है) ।
   पेजफैक्ट के आगे कार्यान्वयन के लिए अब आप पर।  
   हैप्पी एक्सप्लोरेशन !!!  
  => स्क्रैच से सेलेनियम जानने के लिए यहां जाएं।  
  अनुशंसित पाठ
    30+ सर्वश्रेष्ठ सेलेनियम ट्यूटोरियल: वास्तविक उदाहरणों के साथ सेलेनियम जानें  
  कुशल सेलेनियम स्क्रिप्टिंग और समस्या निवारण परिदृश्य - सेलेनियम ट्यूटोरियल # 27  
  लॉग (लॉग 4 जे ट्यूटोरियल) के साथ सेलेनियम लिपियों को डीबग करना - सेलेनियम ट्यूटोरियल # 26  
  सेलेनियम स्क्रिप्ट में JUnit फ्रेमवर्क और इसके उपयोग का परिचय - सेलेनियम ट्यूटोरियल # 11  
  सेलेनियम स्वचालन परियोजना के परीक्षण के अनुमान को प्रभावित करने वाले 7 कारक - सेलेनियम ट्यूटोरियल # 32  
  सेलेनियम में जीत और TestNG चौखटे का उपयोग करना  
  सेलेनियम लिपियों के निर्माण के लिए TestNG फ्रेमवर्क का उपयोग कैसे करें - TestNG सेलेनियम ट्यूटोरियल # 12  
  सेलेनियम में TestNG एनोटेशन का उपयोग करना सीखें (उदाहरणों के साथ)

पेज फैक्ट्री मॉडल (POM) पेज फैक्ट्री के साथ | सेलेनियम ट्यूटोरियल

पेज ऑब्जेक्ट मॉडल (POM) क्या है?

उदाहरण के साथ पोम को समझना

हम पेज ऑब्जेक्ट मॉडल का उपयोग क्यों करते हैं?

सेलेनियम में सरल पोम का कार्यान्वयन

(1) परिदृश्य स्वचालित करने के लिए

# 2) पोलेन में उपरोक्त दृश्य के लिए सेलेनियम लिपियों

Pagefactory क्या है?

पेज फैक्ट्री का उपयोग कर पोम

वीडियो ट्यूटोरियल - पेज फैक्ट्री के साथ पीओएम

पेज फैक्ट्री पैटर्न का उपयोग करके पोम बनाने के चरण

पृष्ठ परत

वास्तविक समय उदाहरण के साथ POM बनाने के लिए कदम

टेस्ट लेयर

विकृतीकरण प्रकार वेबसाईटों की घोषणा के लिए प्रयुक्त पदानुक्रम

# 1) @FindBy

# 2) @FindBys

# 3) @FindAll

# 4) @ कैशे लूकअप

PageFactory.initElements पर अधिक ()

बार बार पूछे जाने वाले प्रश्न

निष्कर्ष

अनुशंसित पाठ

दिलचस्प लेख

संपादक की पसंद

PS5 शिपमेंट 32 मिलियन अंक पार कर गया, 31 मार्च के लिए तिमाही पूर्वानुमान बढ़ा

एक्सबॉक्स गेम पास पर डेड स्पेस 2 और 3 दोषी गियर स्ट्राइव में शामिल हों

पीसी फ्लैश सेल: सबसे सस्ता मास इफेक्ट: $ 35 पर एंड्रोमेडा और $ 38 के लिए GTA V मेगालोडन बंडल

सर्वश्रेष्ठ MW2 और वारज़ोन 2.0 जाइरो-लक्षित सेटिंग, समझाया गया

सभी Fortnite रैंक वाले स्तर और स्तर, क्रम में

आधुनिक युद्ध 3 लाश पक्षी रैंप ईस्टर अंडा

समीक्षा: एक्स-मेन: डेस्टिनी

टेल्स ऑफ़ हार्ट्स में KOS-MOS कैमियो

एक अच्छा पुराने जमाने का निनटेंडो स्विच एक्सेसरी रिव्यू राउंडअप है

सुदूर रो 5 को एक बहुत जरूरी फोटो मोड मिलता है

मार्वल का स्पाइडर-मैन: माइल्स मोरालेस इस गिरावट में पीसी पर झूलता हुआ आता है

ब्लैक बॉक्स परीक्षण: उदाहरणों और तकनीकों के साथ एक गहराई से ट्यूटोरियल