👩🏼‍🔧 🤹🏼 🤘🏿 क्रांति या पेज ऑब्जेक्ट मॉडल का विकास? 🙁 🐫 🛐

सभी को नमस्कार! मेरा नाम अर्टिओम सोकोवेट्स है । मैं एटलस पर अपने लेख का अनुवाद साझा करना चाहता हूं: HTML एलिमेंट्स फ्रेमवर्क का पुनर्जन्म, जो पेज ऑब्जेक्ट के साथ काम करने के लिए पूरी तरह से अलग दृष्टिकोण प्रस्तुत करता है।

विवरण में जाने से पहले, मैं पूछना चाहता हूं: पेज ऑब्जेक्ट के लिए कितने रैपर हैं जो आप जानते हैं? पृष्ठ तत्व, स्क्रीनप्ले, लोड करने योग्य घटक, चालान की श्रृंखला ...

और क्या होगा यदि हम इंटरफ़ेस पर एक कार्यान्वयन के साथ एक पृष्ठ ऑब्जेक्ट लेते हैं, प्रॉक्सी पैटर्न को तेज करते हैं और जावा 8 कार्यक्षमता का एक सा जोड़ते हैं?

यदि दिलचस्पी है, तो मैं बिल्ली पर स्विच करने का सुझाव देता हूं।

परिचय

मानक PageObject डिज़ाइन पैटर्न का उपयोग करते समय, कई समस्याएं उत्पन्न होती हैं:

तत्वों का दोहराव

public class MainPage { @FindBy(xpath = ".//div[@class = 'header']") private Header header; } public class AnyOtherPage { @FindBy(xpath = ".//div[@class = 'header']") private Header header; }

यहां, हेडर ब्लॉक का उपयोग विभिन्न पेजऑब्जेक्ट कक्षाओं में किया जाता है।

तत्वों के लिए पैरामीटर का अभाव

 public class EditUserPage { @FindBy(xpath = "//div[text()='Text_1']") private TextBlock lastActivity; @FindBy(xpath = "//div[text()='Text_2']") private TextBlock blockReason; }

यह उदाहरण उपयोगकर्ता सेटिंग्स संपादन पृष्ठ के तत्वों का वर्णन करता है। दो TextBlock तत्वों में केवल पाठ मान ("Text_1" और "Text_2") में अंतर के साथ लगभग समान लोकेटर होता है।

एक ही प्रकार का कोड

 public class UserPage { @FindBy(xpath = "//div[text()='']/input") private UfsTextInput innerPhone; @FindBy(xpath = "//div[text()='Email']/input") private UfsTextInput email; @FindBy(xpath = "//button[text()='']") private UfsButton save; @FindBy(xpath = "//button[text()='']") private UfsButton toUsersList; }

रोजमर्रा के काम में, आप एक ही तत्व के साथ कोड की कई लाइनों से मिलकर पेज ऑब्जेक्ट पा सकते हैं। भविष्य में, ऐसी कक्षाएं बनाए रखने के लिए "असुविधाजनक" हैं।

चरणों के साथ बड़ा वर्ग

 public class MainSteps { public void hasText(HtmlElement e, Matcher m) public void hasValue(HtmlElement e, Matcher m) public void linkContains(HtmlElement e, String s) public void hasSize(List<HtmlElement> e, Matcher m) public void hasItem(List<HtmlElement> e, Matcher m) //... }

समय के साथ, तत्वों के साथ काम करने के लिए चरणों का वर्ग बढ़ता है। अधिक ध्यान देने की आवश्यकता है ताकि कोई डुप्लिकेट तरीके न हों।

पेज ऑब्जेक्ट की दुनिया के लिए आपका गाइड

HTML एलिमेंट फ्रेमवर्क के पुनर्जन्म का उद्देश्य उपरोक्त समस्याओं को हल करना है, एक परीक्षण परियोजना के लिए कोड की संख्या को कम करना, सूचियों और अपेक्षाओं के साथ अधिक विचारशील कार्य, साथ ही विस्तार प्रणाली के लिए धन्यवाद के लिए अपने लिए टूल को ठीक करना।

एटलस इंटरफेस के माध्यम से पेज ऑब्जेक्ट पैटर्न के कार्यान्वयन के साथ यूआई ऑटो-परीक्षणों को विकसित करने के लिए एक नई पीढ़ी का जावा फ्रेमवर्क है। यह दृष्टिकोण तत्वों के पेड़ के निर्माण में कई विरासत की संभावना प्रदान करता है, जो अंततः आपके ऑटोटेस्ट्स के लिए एक संक्षिप्त कोड प्रदान करता है।

फ्रेमवर्क का मुख्य नवाचार मानक कक्षाओं के बजाय इंटरफेस का उपयोग है।

यह क्या github.com मुखपृष्ठ विवरण जैसा दिखता है:

 public interface MainPage extends WebPage, WithHeader { @FindBy("//a[contains(text(), 'Or start a free)]") AtlasWebElement trial(); }

उपरोक्त कोड एक तत्व के साथ GitHub साइट के मुख्य पृष्ठ का वर्णन करता है और WebPage और WithHeader परतों से एकाधिक वंशानुक्रम (उदाहरण केवल शैक्षिक उद्देश्यों के लिए दिया गया है, इसलिए अधिकांश वेब तत्व छोड़ दिए गए हैं)।

फ्रेमवर्क वास्तुकला

वर्तमान में एटलस में तीन मॉड्यूल होते हैं:

एटलस कोर
एटलस-webdriver
एटलस-appium

एटलस-कोर इंटरफेस का उपयोग करके पेज ऑब्जेक्ट्स को संसाधित करने के लिए बुनियादी कार्यक्षमता का वर्णन करता है। इंटरफेस का उपयोग करने का बहुत विचार प्रसिद्ध रेट्रोफिट टूल से लिया गया था।

स्वचालित यूआई वेब और यूआई मोबाइल स्क्रिप्ट विकसित करने के लिए अन्य दो एटलस-वेबड्राइवर और एटलस-ऐपियम मॉड्यूल का उपयोग किया जाता है। वेब पेजों का वर्णन करने के लिए मुख्य प्रवेश बिंदु वेबपेज इंटरफ़ेस है, और मोबाइल स्क्रीन के लिए - स्क्रीन। वैचारिक रूप से, एटलस-वेबड्राइवर और एटलस-एपियम एक्सटेंशन (पैकेज *। कस्टमेशन) पर बनाए जाते हैं।

तत्वों

यह उपकरण UI तत्वों (WebElement वर्ग का एक एनालॉग) के साथ काम करने के लिए दो विशेष वर्गों के साथ आता है।

AtlasWebElement और AtlasMobileElement को पूरक और प्रतीक्षा विधि द्वारा पूरक होना चाहिए । (इन तरीकों पर विचार लेख में आगे होगा)।

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

मुख्य विशेषताएं

आइए टूल की कार्यक्षमता पर अधिक विस्तार से विचार करें:

कक्षाओं के बजाय इंटरफेस

मानक PageObjects का वर्णन करते समय, कक्षाओं के बजाय इंटरफेस का उपयोग किया जाता है।

 public interface MainPage extends WebPage, WithHeader { @FindBy("//a[contains(text(), 'Or start a free trial of Enterprise Server')]") AtlasWebElement trial(); }

यह उदाहरण GitHub प्रारंभ पृष्ठ पर लिंक का वर्णन करता है।

तत्वों का पैरामीटर

कल्पना कीजिए कि हमारे पास खेतों के साथ एक रूप है:

इसका वर्णन करने के लिए, आपको @FindBy एनोटेशन के साथ 11 चर बनाने की आवश्यकता है और यदि आवश्यक हो, तो गेटटर घोषित करें।

एटलस का उपयोग करते हुए, आपको केवल एक पैरामीटर एटलसवेब एलिमेंट एलिमेंट की आवश्यकता होती है।

 public interface MainPage extends WebPage { @FindBy("//div[text()='{{ text }}']/input") AtlasWebElement input(@Param("text") String text); }

स्वचालित परीक्षण कोड इस प्रकार है:

 @Test public void simpleTest() { onMainPage().input("First Name").sendKeys("*"); onMainPage().input("Postcode").sendKeys("*"); onMainPage().input("Email").sendKeys("*"); }

हम वांछित पृष्ठ की ओर मुड़ते हैं, पैरामीटर के साथ विधि को कॉल करते हैं और तत्व के साथ आवश्यक क्रियाएं करते हैं। पैरामीटर के साथ एक विधि एक विशिष्ट क्षेत्र का वर्णन करती है।

एकाधिक वंशानुक्रम

यह पहले उल्लेख किया गया था कि एक ब्लॉक (उदाहरण के लिए, हेडर), जिसका उपयोग विभिन्न पेज ऑब्जेक्ट्स में किया जाता है, कोड का दोहराव है।

एक हैडर जीथब है।

हम इस ब्लॉक का वर्णन करते हैं (अधिकांश वेब तत्वों को छोड़ दिया जाता है):

 public interface Header extends AtlasWebElement { @FindBy(".//input[contains(@class,'header-search-input')]") AtlasWebElement searchInput(); }

इसके बाद, एक परत बनाएं जो किसी भी पेज से जुड़ी हो:

 public interface WithHeader { @FindBy("//header[contains(@class,'Header')]") Header header(); }

हम हेडर ब्लॉक के साथ मुख्य पृष्ठ का विस्तार करते हैं।

 public interface MainPage extends WebPage, WithHeader { @FindBy("//a[contains(text(), 'Or start a)]") AtlasWebElement trial(); }

सामान्य तौर पर, आप अधिक परतें बना सकते हैं और उन्हें वांछित पृष्ठ से जोड़ सकते हैं। नीचे दिए गए उदाहरण में, हेडर, फुटर, साइडबार परतों को मुख्य पृष्ठ से कनेक्ट करें।

 public interface MainPage extends WithHeader, WithFooter, WithSidebar {}

चलो आगे बढ़ते हैं। हैडर में 4 बटन, 3 ड्रॉप-डाउन मेनू और एक खोज फ़ील्ड शामिल हैं:

चलो अपना स्वयं का बटन तत्व बनाते हैं और एक तत्व के साथ चार बटन का वर्णन करते हैं।

 public interface Button extends AtlasWebElement { @FindBy(".//a[contains(., '{{ value }}')]") AtlasWebElement selectButton(@Param("value") String value); }

बटन बटन को हेडर लेयर से कनेक्ट करें। इस प्रकार, हम गिटहब हेडर की कार्यक्षमता का विस्तार करते हैं।

 public interface Header extends WithButton { … }

एक अलग बटन तत्व वेबसाइट की विभिन्न परतों से जुड़ा हो सकता है और जल्दी से वांछित पृष्ठ पर वांछित तत्व प्राप्त कर सकता है।

एक उदाहरण:

 @Test public void simpleTest() { onMainPage().open("https://github.com"); onMainPage().header().button("Priing").click(); }

परीक्षण की दूसरी पंक्ति में, साइट का हेडर एक्सेस किया जाता है, फिर हम मान "मूल्य" के साथ पैरामीटर किए गए बटन को कॉल करते हैं और क्लिक करते हैं।

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

डिफ़ॉल्ट तरीके

जावा 8 ने डिफ़ॉल्ट तरीके पेश किए, जिनका उपयोग वांछित कार्यक्षमता को पूर्वनिर्धारित करने के लिए किया जाता है।

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

 if(onMainPage().rentFilter().checkbox("").getAttribute("class").contains("disabled")) { onMainPage().rentFilter().checkbox("").click(); }

इस सभी कोड को चरण वर्ग में संग्रहीत नहीं करने के लिए, इसे तत्व के बगल में डिफ़ॉल्ट विधि के रूप में रखना संभव है।

 public interface Checkbox extends AtlasWebElement { @FindBy("//...") AtlasWebElement checkBox((@Param("value") String value); default void selectCheckbox(String value) { if (checkBox(value).getAttribute("class").contains("disabled")) { checkBox(value).click(); } } }

अब परीक्षा में कदम इस तरह होगा:

 onMainPage().rentFilter().selectCheckbox("");

एक और उदाहरण जिसमें आप एक क्षेत्र में सफाई और टाइपिंग वर्णों को संयोजित करना चाहते हैं।

 onMainPage().header().input("GitHub").clear(); onMainPage().header().input("GitHub").sendKeys("*");

एक ऐसी विधि को परिभाषित करें जो क्षेत्र को साफ़ करे और तत्व को स्वयं लौटाए:

 public interface Input extends AtlasWebElement { @FindBy("//xpath") AtlasWebElement input(@Param("value") String value); default AtlasWebElement withClearInput(String value) { input(value).clear(); return input(value); } }

परीक्षण विधि में, चरण इस प्रकार है:

 onMainPage().header().withClearInput("GitHub").sendKeys("Atlas");

इस तरह, तत्व में वांछित व्यवहार को प्रोग्राम किया जा सकता है।

पुनर्प्रयास (पुन: प्रयास करें)

एटलस में अंतर्निहित रिट्रीट हैं। आपको NotFoundException , StaleElementReferenceException और WebDriverException जैसे अपवादों के बारे में चिंता करने की आवश्यकता नहीं है, और आप सेलेनियम API की स्पष्ट और अंतर्निहित अपेक्षाओं का उपयोग करने के बारे में भी भूल सकते हैं।

 onSite().onSearchPage("Junit 5").repositories().waitUntil(hasSize(10));

यदि श्रृंखला के किसी बिंदु पर आपने एक अपवाद पकड़ा है, तो चरण शुरुआत से दोहराता है।

उस समय अंतराल को स्वतंत्र रूप से समायोजित करना संभव है जिसके दौरान आप दोहरा सकते हैं, या पुनरावृत्ति की आवृत्ति।

 Atlas atlas = new Atlas(new WebDriverConfiguration(driver)) .context(new RetryerContext(new DefaultRetryer(3000L, 1000L, Collections.singletonList(Throwable.class))));

हम प्रति सेकंड एक बार के मतदान दर के साथ तीन सेकंड के लिए उम्मीद करते हैं।

हम रिट्री एनोटेशन का उपयोग करके किसी विशिष्ट आइटम के लिए प्रतीक्षा को भी समायोजित कर सकते हैं। सभी तत्वों के लिए, खोज 3 सेकंड के भीतर होगी, और एक के मामले में यह 20 होगी।

 @Retry(timeout = 20_000L, polling = 2000L) @IOSFindBy(xpath = "//XCUIElementTypeSearchField[@name='Search Wikipedia']") @AndroidFindBy(xpath = "//*[contains(@text, 'Search Wikipedia')]") AtlasMobileElement searchWikipedia();

सूचियों के साथ काम करें

बॉक्स से बाहर, उपकरण सूचियों के साथ काम प्रदान करता है। इसका क्या मतलब है? एक इनपुट टैग के साथ एक क्षेत्र है जहां हम पाठ दर्ज करते हैं, फिर एक ड्रॉप-डाउन सूची दिखाई देती है, तत्व तुरंत प्रकट नहीं होते हैं।

इस तरह के मामलों के लिए एक संस्था एलीमेंट्सकॉलशन है। इसकी मदद से सूचियों के साथ एक काम है।

 public interface ContributorsPage extends WebPage, WithHeader { @FindBy(".//ol[contains(@class, 'contrib-data')]//li[contains(@class, 'contrib-person')]") ElementsCollection<RepositoryCard> hovercards(); }

का उपयोग करें:

 onSite().onContributorsPage().hovercards().waitUntil(hasSize(4));

तत्वों को फ़िल्टर करना और उन्हें किसी अन्य प्रकार की सूची में परिवर्तित करना भी संभव है।

स्मार्ट जोर

जैसा कि पहले उल्लेख किया गया है, AtlasWebElement और AtlasMobileElement संस्थाएं चेक (स्टेटमेंट) के साथ काम करने के लिए वेट यूटिलिट तरीकों का उपयोग करना चाहिए।

विधि	विवरण
चाहिए (...)	एक तत्व के साथ विभिन्न कथन (जांच) करता है। एक जोर देता है
WaitUntil (...)	एक तत्व के साथ विभिन्न कथन (जांच) करता है। एक RuntimeException फेंकता है

ऐसा क्यों किया जाता है? स्वचालित स्क्रिप्टिंग के लिए रिपोर्ट चलाने के समय को बचाने के लिए। अधिकांश कार्यात्मक जांच स्क्रिप्ट के अंत में की जाती हैं: वे एक कार्यात्मक परीक्षण विशेषज्ञ के लिए रुचि रखते हैं, और एक स्वचालित परीक्षण विशेषज्ञ के लिए मध्यवर्ती जांच करते हैं। इसलिए, यदि उत्पाद की कार्यक्षमता काम नहीं करती है, तो यह मान लेना तर्कसंगत है कि किसी अपवाद को छोड़ दें, अन्यथा एक RuntexException।

लुभाना तुरंत दिखाएगा कि हम क्या व्यवहार कर रहे हैं: या तो हमारे पास एक उत्पाद दोष है (एफटी विशेषज्ञ काम लेता है), या ऑटोटेस्ट टूट जाता है (एटी विशेषज्ञ समझता है)।

एक्सटेंशन मॉडल

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

आइए हम एक सार उदाहरण की जांच करते हैं: इंटरनेट एक्सप्लोरर 11 के लिए यूआई-परीक्षण विकसित करना आवश्यक है (कुछ स्थानों पर यह अभी भी उपयोग किया जाता है)। ऐसे समय होते हैं जब तत्वों पर मानक क्लिक काम नहीं करता है, तो आप जेएस-क्लिक का उपयोग कर सकते हैं। आप संपूर्ण परीक्षण प्रोजेक्ट पर क्लिक को अस्थायी रूप से ओवरराइड करने का निर्णय लेते हैं।

 onMainPage().header().button("en").click();

यह कैसे करना है?

एक एक्सटेंशन बनाएं जो MethodExtension इंटरफ़ेस को लागू करता है।

 public class JSClickExt implements MethodExtension { @Override public Object invoke(Object proxy, MethodInfo methodInfo, Configuration config) { final WebDriver driver = config.getContext(WebDriverContext.class) .orElseThrow(() -> new AtlasException("Context doesn't exist")).getValue(); final JavascriptExecutor js = (JavascriptExecutor) driver; js.executeScript("arguments[0].click();", proxy); return proxy; } @Override public boolean test(Method method) { return method.getName().equals("click"); } }

हम दो तरीकों को फिर से परिभाषित करते हैं। परीक्षण () विधि में, हम निर्दिष्ट करते हैं कि हम क्लिक विधि को ओवरराइड करते हैं। आह्वान विधि आवश्यक तर्क को लागू करती है। अब तत्व पर क्लिक जावास्क्रिप्ट के माध्यम से होगा।

हम एक्सटेंशन को निम्नानुसार कनेक्ट करते हैं:

 atlas = new Atlas(new WebDriverConfiguration(driver, "https://github.com")) .extension(new JSClickExt());

एक्सटेंशन की मदद से डेटाबेस में तत्वों के लिए खोजकर्ताओं को बनाना और अन्य दिलचस्प विशेषताओं को लागू करना संभव है - यह सब आपकी कल्पना और आवश्यकताओं पर निर्भर करता है।

PageObjects (वेबसाइट) के लिए एकल प्रविष्टि बिंदु

उपकरण आपको अपने सभी पृष्ठ एक ही स्थान पर संग्रहीत करने की अनुमति देता है और केवल भविष्य में साइट इकाई के माध्यम से काम करता है।

 public interface GitHubSite extends WebSite { @Page MainPage onMainPage(); @Page(url = "search") SearchPage onSearchPage(@Query("q") String value); @Page(url = "{profile}/{project}/tree/master/") ProjectPage onProjectPage(@Path("profile") String profile, @Path("project") String project); @Page ContributorsPage onContributorsPage(); }

इसके अतिरिक्त, पेज के लिए तेज़ यूआरएल, क्वेरी पैरामीटर और पथ खंड सेट करना संभव है।

 onSite().onProjectPage("qameta", "atlas").contributors().click();

ऊपर की रेखा में दो पथ खंड (क्यूमेटा और एटलस) हैं, जो github.com/qameta/atlas/tree/master में अनुवाद करता है। इस दृष्टिकोण का मुख्य लाभ यह है कि इस पर क्लिक किए बिना वांछित पृष्ठ को तुरंत खोलना संभव है।

 @Test public void usePathWebSiteTest() { onSite().onProjectPage("qameta", "atlas").contributors().click(); onSite().onContributorsPage().hovercards().waitUntil(hasSize(4)); }

मोबाइल तत्व के साथ काम करें

मोबाइल तत्व (AtlasMobileElement) के साथ कार्य करना AtlasWebElement वेब तत्व के साथ काम करने के समान है। इसके अतिरिक्त, AtlasMobileElement में तीन तरीके जोड़े गए हैं: स्क्रीन को ऊपर / नीचे स्क्रॉल करना (स्क्रॉलअप / स्क्रॉलडाउन) और होल्ड (लॉन्गप्रेस) के साथ किसी आइटम पर क्लिक करना।

मैं आपको विकिपीडिया अनुप्रयोग की मुख्य स्क्रीन का एक उदाहरण देता हूँ। एक तत्व iOS प्लेटफॉर्म और एंड्रॉइड दोनों के लिए वर्णित है। वे एक पैरामीटर बटन का भी वर्णन करते हैं।

 public interface MainScreen extends Screen { @Retry(timeout = 20_000L, polling = 2000L) @IOSFindBy(xpath = "//XCUIElementTypeSearchField[@name='Search Wikipedia']") @AndroidFindBy(xpath = "//*[contains(@text, 'Search Wikipedia')]") AtlasMobileElement searchWikipedia(); @IOSFindBy(id = "{{ value }}") AtlasMobileElement button(@Param("value") String value); }

टेस्ट एक जैसे लगते हैं:

 public void simpleExample() { onMainScreen().searchWikipedia().click(); onSearchScreen().search().sendKeys("Atlas"); onSearchScreen().item("Atlas LV-3B").swipeDownOn().click(); onArticleScreen().articleTitle().should(allOf(displayed(), text("Atlas LV-3B"))); }

ऊपर के उदाहरण में, हम विकिपीडिया मुख्य पृष्ठ खोलते हैं, खोज पट्टी पर क्लिक करते हैं, पाठ एटलस दर्ज करते हैं, फिर सूची आइटम को एटलस LV-3B के साथ स्क्रॉल करें और इसके दृश्य पर जाएं। अंतिम पंक्ति यह जांचती है कि शीर्षक प्रदर्शित किया गया है और वांछित मूल्य शामिल है।

श्रोता

इवेंट लॉगिंग को एक विशेष श्रोता (श्रोता इंटरफ़ेस) का उपयोग करके लागू किया जा सकता है। प्रत्येक विधि में चार घटनाएं होती हैं जब कहा जाता है: पहले , पास , असफल । के बाद ।

इस इंटरफ़ेस का उपयोग करके, आप रिपोर्टिंग को व्यवस्थित कर सकते हैं। नीचे Allure श्रोता का एक उदाहरण है, जो लिंक पर पाया जा सकता है।

आगे, एटलस क्लास को इनिशियलाइज़ करते समय श्रोता को कनेक्ट करें।

 atlas = new Atlas(new WebDriverConfiguration(driver)).listener(new AllureListener());

उपरोक्त तरीके से, विभिन्न रिपोर्टिंग सिस्टम (उदाहरण के लिए, रिपोर्टपोर्ट) के लिए श्रोता बनाना संभव है।

संबंध

UI वेब को स्वचालित करने के लिए, यह एटलस-वेबड्राइवर निर्भरता को पंजीकृत करने और नवीनतम वर्तमान संस्करण को इंगित करने के लिए पर्याप्त है (संस्करण 1.6.0 इस लेखन के समय प्रासंगिक है)।

maven:

  <dependency> <groupId>io.qameta.atlas</groupId> <artifactId>atlas-webdriver</artifactId> <version>${atlas.version}</version> </dependency>

Gradle:

 dependencies { ompile 'io.qameta.atlas:atlas-webdriver:1.+' }

यदि आप UI मोबाइल को स्वचालित करना चाहते हैं तो हम भी ऐसा ही करते हैं।

maven:

 <dependency> <groupId>io.qameta.atlas</groupId> <artifactId>atlas-appium</artifactId> <version>${atlas.version}</version> </dependency>

Gradle:

 dependencies { ompile 'io.qameta.atlas:atlas-appium:1.+' }

के उपयोग

अपने प्रोजेक्ट में निर्भरता जोड़ने के बाद, आपको एटलस क्लास उदाहरण को इनिशियलाइज़ करना होगा।

 @Before public void startDriver() { driver = new ChromeDriver(); atlas = new Atlas(new WebDriverConfiguration(driver)); }

हम एटलस कंस्ट्रक्टर को कॉन्फ़िगरेशन की आवृत्ति, साथ ही चालक को पास करते हैं।

वर्तमान में दो कॉन्फ़िगरेशन हैं: WebDriverConfiguration और AppiumDriverConfiguration। प्रत्येक कॉन्फ़िगरेशन में विशिष्ट डिफ़ॉल्ट एक्सटेंशन होते हैं।

अगला, हम एक विधि परिभाषित करते हैं जो सभी PageObject बनाएगी।

 private <T extends WebPage> T onPage(Class<T> page) { return atlas.create(driver, page); }

एक साधारण परीक्षण मामले का एक उदाहरण:

 @Test public void simpleTest() { onPage(MainPage.class).open("https://github.com"); onPage(MainPage.class).header().searchInput().sendKeys("Atlas"); onPage(MainPage.class).header().searchInput().submit(); }

हम साइट खोलते हैं, हेडर लेयर की ओर मुड़ते हैं, उसमें एक टेक्स्ट फील्ड (सर्च इनपुट) खोजते हैं, टेक्स्ट एंटर करते हैं और एंटर दबाते हैं।

परिणाम

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

हाइजेनबग , सेलेनियम कैंप और नेक्साइन क्यूए मीटअप की रिपोर्ट की वीडियो क्लिप उपलब्ध हैं । एक टेलीग्राम चैट @atlashelp है।

इस उपकरण का उपयोग करके, आप कोड की एक महत्वपूर्ण संख्या को कम कर सकते हैं (Yandex, SberTech और Tinkoff जैसी कंपनियों द्वारा परियोजनाओं पर परीक्षण)।

क्रांति या पेज ऑब्जेक्ट मॉडल का विकास?