class EnvironmentSetup(unittest.TestCase): PAGE_LOAD_TIME = 20 IMPLICITLY_WAIT = 10 log = cl.customLogger(logging.DEBUG) def setUp(self): self.log.debug("Properties initialization") self.prop = Property() try: self.dic_prop = self.prop.load_property_files("/Users/user/PycharmProjects/BGETest/config/config.properties") self.log.debug("Properties successfully loaded.") self.log.debug(self.dic_prop) except FileNotFoundError as err: self.log.error("config.properties file not found!!!") raise ValueError("There is no config.properties file in the project directory" + str(err)) browserName = self.dic_prop.get("browser", "chrome") if browserName.lower() == "firefox": self.driver = webdriver.Firefox() self.log.debug("Object for firefox is created - " + str(self.driver)) elif browserName.lower() == "chrome": self.driver = webdriver.Chrome() self.log.debug("Object for chrome is created - " + str(self.driver)) elif browserName.lower() == "safari": self.driver = webdriver.Safari() self.log.debug("Object for safari is created - " + str(self.driver)) else: raise ValueError("Unknown browser, please check the config.properties file") self.eventListener = WebEventListener() self.driver = EventFiringWebDriver(self.driver, self.eventListener) self.driver.maximize_window() self.driver.delete_all_cookies() self.log.debug("Cookies are successfully deleted") self.driver.set_page_load_timeout(self.PAGE_LOAD_TIME) self.driver.implicitly_wait(self.IMPLICITLY_WAIT) self.driver.get(self.dic_prop.get("url")) self.longMessage = False self.log.debug(self.id()) self.screenshot = ScreenShot(self.driver) try: self.screenshotName = "./results/{}.png".format(str(self.id()).split('.')[3]) except IndexError: self.screenshotName = "./results/{}.png".format(str(self.id()).split('.')[2]) def tearDown(self): if self.driver is not None: self.driver.close() self.driver.quit()
class MainTest(unittest.TestCase): @classmethod def setUpClass(self): driver = Config().browser() print("Run started at:" + str(datetime.datetime.utcnow())) self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener()) self.ef_driver.maximize_window() def assert_element_text(self, xpath, expected_text): """ Compare expected text with observed value from web element :param xpath: xpath to element with text to be observed :param expected_text: text what we expecting to be found :return: None """ element = self.ef_driver.find_element_by_xpath(xpath) return self.assertEqual( element.text, expected_text, f'Expected message differ from {expected_text}') def assert_element_contains_innerText(self, selector, expected_text): """ Compare expected text with observed value from web elements :param selector: css_selector to list with elements to be observed :param expected_text: text what we expecting to be found in element from the list :return: assertions for every element """ elements = self.ef_driver.find_elements_by_css_selector(selector) for element in elements: return self.assertIn( element.get_attribute('innerText'), expected_text, f'Expected message differ from {expected_text}') def assert_title(self, url, expected_text): self.ef_driver.get(url) actual_title = self.ef_driver.title self.assertEqual( expected_text, actual_title, f'Expected {expected_text} differ from actual driver,') def go_driver_give_that_page(self, driver, url, page_object): tested_page = page_object(driver) driver.get(url) return tested_page @classmethod def tearDownClass(self): self.ef_driver.close() if (self.ef_driver != None): print("Test environment destroyed.") print("Run completed at: " + str(datetime.datetime.utcnow())) """
def driver(request): browser = request.config.getoption("--browser") if browser == "firefox": desired_capabilities = { "browserName": "firefox" } else: desired_capabilities = { "browserName": "chrome" } wd = webdriver.Remote(command_executor=GRID_HOST, desired_capabilities=desired_capabilities) wd = EventFiringWebDriver(wd, MyListener(LOG_FILENAME)) wd.maximize_window() yield wd wd.quit()
def start_browser(browser_name, url): web_driver = None if browser_name == "chrome": web_driver = webdriver.Chrome( executable_path=".\\resources\\drivers\\chromedriver") elif browser_name == "firefox": web_driver = webdriver.Firefox( executable_path=".\\resources\\drivers\\geckodriver") driver = EventFiringWebDriver(web_driver, MyListener()) driver.implicitly_wait(properties.get_implicit_wait()) driver.maximize_window() driver.get(url) return driver
def driver(request): """Launching webdriver""" browser_name = request.config.getoption("--browser") print(browser_name) if browser_name == 'firefox': capabilities = webdriver.DesiredCapabilities.FIREFOX.copy() capabilities['timeouts'] = { 'implicit': 300000, 'pageLoad': 300000, 'script': 30000 } capabilities['loggingPrefs'] = { 'browser': 'ALL', 'client': 'ALL', 'driver': 'ALL', 'performance': 'ALL', 'server': 'ALL' } profile = webdriver.FirefoxProfile() profile.set_preference('app.update.auto', False) profile.set_preference('app.update.enabled', False) profile.accept_untrusted_certs = True wd = EventFiringWebDriver( webdriver.Firefox(firefox_profile=profile, capabilities=capabilities), TestListenerDB()) wd.maximize_window() elif browser_name == 'chrome': capabilities = webdriver.DesiredCapabilities.CHROME.copy() capabilities['acceptSslCerts'] = True capabilities['acceptInsecureCerts'] = True capabilities['goog:loggingPrefs'] = {'performance': 'ALL'} # chrome_options = Options() # chrome_options.add_experimental_option('w3c', False) wd = EventFiringWebDriver( webdriver.Chrome(desired_capabilities=capabilities), TestListenerDB()) wd.fullscreen_window() else: print('Unsupported browser!') sys.exit(1) wd.implicitly_wait((request.config.getoption("--iwait"))) wd.set_page_load_timeout((request.config.getoption("--pltimeout"))) implicitly_wait = request.config.getoption("--iwait") page_load_timeout = request.config.getoption("--pltimeout") print(implicitly_wait) print(page_load_timeout) yield wd wd.quit()
def driver(request): browser = request.config.getoption("--browser") if browser == "firefox": firefox_options = FirefoxOptions() # firefox_options.add_argument("-headless") execute_path = DRIVER_PATH + "geckodriver.exe" wd = webdriver.Firefox(options=firefox_options, executable_path=execute_path) else: chrome_options = ChromeOptions() chrome_options.add_argument("--headless") execute_path = DRIVER_PATH + "chromedriver.exe" wd = webdriver.Chrome(options=chrome_options, executable_path=execute_path) wd = EventFiringWebDriver(wd, MyListener(DB_FILENAME)) wd.maximize_window() yield wd wd.quit()
def wd(request, base_url, logger): """ Браузер по умолчанию Chrome """ browser = request.config.getoption("--browser") selenoid = request.config.getoption("--selenoid") executor = request.config.getoption("--executor") if selenoid: capabilities = { "browserName": browser, "version": "", "enableVNC": True, "enableVideo": False, "acceptSslCerts": True } hub = f"http://{executor}:4444/wd/hub" driver = webdriver.Remote(command_executor=hub, desired_capabilities=capabilities) else: if browser == "chrome": options = webdriver.ChromeOptions() options.add_argument('headless') options.add_argument('--ignore-certificate-errors') options.add_argument('--ignore-ssl-errors') driver = webdriver.Chrome(options=options) elif browser == "firefox": options = webdriver.FirefoxOptions() options.add_argument('--ignore-certificate-errors') options.add_argument('--ignore-ssl-errors') options.add_argument("-headless") driver = webdriver.Firefox(options=options) logger.info(f"Getting started browser {browser}") driver = EventFiringWebDriver(driver, WdEventListener(logging.getLogger("DRIVER"))) driver.implicitly_wait(request.config.getoption("--time")) driver.maximize_window() yield driver data_on_failed_test(browser, driver, request) driver.quit() logger.info(f"Browser {browser} shutdown") return driver
def driver(request): browser = request.config.getoption("--browser") if browser == "firefox": wd = webdriver.Remote( command_executor= 'http://*****:*****@hub.browserstack.com:80/wd/hub', desired_capabilities=DESIRED_CAP) else: chrome_options = ChromeOptions() chrome_options.add_argument("--headless") execute_path = DRIVER_PATH + "chromedriver.exe" wd = webdriver.Chrome(options=chrome_options, executable_path=execute_path) wd = EventFiringWebDriver(wd, MyListener(LOG_FILENAME)) wd.maximize_window() yield wd wd.quit()
def driver(request): wait = request.config.getoption("--wait") browser = request.config.getoption("--browser") if browser == 'firefox': capabilities = webdriver.DesiredCapabilities.FIREFOX.copy() capabilities['timeouts'] = { 'implicit': int(wait), 'pageLoad': int(wait) } capabilities['loggingPrefs'] = { 'browser': 'ALL', 'client': 'ALL', 'driver': 'ALL', 'performance': 'ALL', 'server': 'ALL' } profile = webdriver.FirefoxProfile() profile.set_preference('app.update.auto', False) profile.set_preference('app.update.enabled', False) profile.accept_untrusted_certs = True wd = EventFiringWebDriver( webdriver.Firefox(firefox_profile=profile, capabilities=capabilities), MyListener()) wd.maximize_window() elif browser == 'chrome': capabilities = webdriver.DesiredCapabilities.CHROME.copy() capabilities['timeouts'] = { 'implicit': int(wait), 'pageLoad': int(wait) } capabilities['acceptSslCerts'] = True capabilities['acceptInsecureCerts'] = True wd = webdriver.Chrome(desired_capabilities=capabilities) wd.fullscreen_window() else: print('Unsupported browser!') sys.exit(1) yield wd wd.quit()
def driver(request, logger, proxy): browser = request.config.getoption('--browser') if browser == 'chrome': options = ChromeOptions() options.add_argument('--headless') options.add_argument('--start-fullscreen') options.add_argument(f'--proxy-server={proxy.proxy}') options.add_experimental_option('w3c', False) caps = DesiredCapabilities.CHROME.copy() caps['timeouts'] = { 'implicit': 20000, 'pageLoad': 20000, 'script': 20000 } caps['loggingPrefs'] = {'browser': 'ALL', 'performance': 'ALL'} wd = EventFiringWebDriver( webdriver.Chrome(options=options, desired_capabilities=caps), BaseListener(logger)) elif browser == 'firefox': options = FirefoxOptions() options.add_argument('--headless') caps = DesiredCapabilities.FIREFOX.copy() caps['timeouts'] = { 'implicit': 25000, 'pageLoad': 25000, 'script': 25000 } wd = EventFiringWebDriver( webdriver.Firefox(options=options, desired_capabilities=caps, proxy=proxy.proxy), BaseListener(logger)) wd.maximize_window() else: raise ValueError('Unsupported browser.') yield wd wd.quit()
class LostHatLoginPageTests(unittest.TestCase): @classmethod def setUp(self): self.base_url = 'https://autodemo.testoneo.com/en/' self.login_url = self.base_url + 'login' driver = webdriver.Chrome( executable_path=r"C:\TestFiles\chromedriver.exe") self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener()) self.ef_driver.maximize_window() time.sleep(2) @classmethod def tearDown(self): self.ef_driver.quit() def assert_element_text(self, driver, xpath, expected_text): element = driver.find_element_by_xpath(xpath) element_text = element.text self.assertEqual( expected_text, element_text, f'Expected text differ from actual on page: {driver.current_url}') @screenshot_decorator def test_login_text_header(self): expected_text = 'Log in to your account' #oczekiwany tekst xpath = '//header[@class="page-header"]' driver = self.ef_driver time.sleep(2) driver.get(self.login_url) time.sleep(2) self.assert_element_text(driver, xpath, expected_text) @screenshot_decorator def test_correct_login(self): # expected_text is a user name and user surname used during registration expected_text = 'm s' user_email = '*****@*****.**' user_pass = '******' username_xpath = '//a[@class="account"]/*[@class="hidden-sm-down"]' driver = self.ef_driver driver.get(self.login_url) time.sleep(2) fh.user_login(driver, user_email, user_pass) self.assert_element_text(driver, username_xpath, expected_text) @screenshot_decorator def test_incorrect_login(self): expected_text = 'Authentication failed.' user_email = '*****@*****.**' user_pass = '******' alert_xpath = '//*[@id="content"]/section/div/ul/li' driver = self.ef_driver driver.get(self.login_url) time.sleep(2) fh.user_login(driver, user_email, user_pass) self.assert_element_text(driver, alert_xpath, expected_text)
class LostHatFrontPageTests(unittest.TestCase): @classmethod def setUp(self): self.base_url = 'https://autodemo.testoneo.com/en/' driver = webdriver.Chrome( executable_path=r"C:\TestFiles\chromedriver.exe") self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener()) self.ef_driver.maximize_window() time.sleep(2) @classmethod def tearDown(self): self.ef_driver.quit() @screenshot_decorator def test_slider(self): slider_xpath = ('//*[@id="carousel"]/ul/li[2]/a/figure/img') driver = self.ef_driver driver.get(self.base_url) time.sleep(2) driver.find_element_by_xpath(slider_xpath) @screenshot_decorator def test_slider_minimum_size(self): expected_min_height = 300 expected_min_width = 600 slider_xpath = '//*[@id="carousel"]' driver = self.ef_driver driver.get(self.base_url) slider_element = driver.find_element_by_xpath(slider_xpath) actual_slider_height = slider_element.size['height'] actual_slider_width = slider_element.size['width'] with self.subTest('Element height'): self.assertLess( expected_min_height, actual_slider_height, f'Element height found by xpath {slider_xpath} on page {driver.current_url} ' f'is smaller than expected {expected_min_height}px') with self.subTest('Element width'): self.assertLess( expected_min_width, actual_slider_width, f'Element width found by xpath {slider_xpath} on page {driver.current_url} ' f'is smaller than expected {expected_min_width}px') @screenshot_decorator def test_slider_contain_exact_number_of_slides(self): expected_number_of_slides = 3 slides_xpath = '//*[@id="carousel"]/ul/li' driver = self.ef_driver driver.get(self.base_url) slider_elements = driver.find_elements_by_xpath(slides_xpath) actual_numer_of_slides = len(slider_elements) self.assertEqual(expected_number_of_slides, actual_numer_of_slides, f'Slides number differ for page {self.base_url}') @screenshot_decorator def test_slides_required_title_text(self): expected_text_included_in_slide = 'sample' slides_titles_xpath = '//*[@id="carousel"]/ul/li//*[contains(@class, "text-uppercase")]' driver = self.ef_driver driver.get(self.base_url) title_elements = driver.find_elements_by_xpath(slides_titles_xpath) for title_element in title_elements: title_element_text = title_element.get_attribute("textContent") title_element_text_lower = title_element_text.lower() with self.subTest(title_element_text_lower): self.assertIn( expected_text_included_in_slide, title_element_text_lower, f"Slides does not contain expected text for page {self.base_url}" ) # product-miniature js-product-miniature @screenshot_decorator def test_number_of_product(self): expected_number_of_product = 8 product_xpath = '//*[@class="product-miniature js-product-miniature"]' driver = self.ef_driver driver.get(self.base_url) product_elements = driver.find_elements_by_xpath(product_xpath) actual_number_of_product = len(product_elements) self.assertEqual(expected_number_of_product, actual_number_of_product, f'Product number differ for page {self.base_url}') @screenshot_decorator def test_featured_product_price_in_pl(self): expected_product_currency = 'PLN' products_price_xpath = '//*[@class="product-miniature js-product-miniature"]//*[@class="[price"]' driver = self.ef_driver driver.get(self.base_url) product_price_elements = driver.find_elements_by_xpath( products_price_xpath) for product_price_element in product_price_elements: product_price_element_text = product_price_element.get_attribute( "textContent") with self.subTest(product_price_element_text): self.assertIn( expected_product_currency, product_price_element_text, f"Explected text not found in product description for page {self.base_url}" )
driver = element._parent def apply_style(s): driver.execute_script("arguments[0].setAttribute('style', arguments[1]);", element, s) original_style = element.get_attribute('style') apply_style("background: yellow; border: 2px solid red;") time.sleep(.3) apply_style(original_style) plain_driver = webdriver.Chrome(executable_path=ChromeDriverManager().install()) #plain_driver=webdriver.Chrome(executable_path="C:/Users/shaik/PycharmProjects/drivers/chromedriver_win32/chromedriver.exe") driver=EventFiringWebDriver(plain_driver, EventListener()) driver.get("https://fs2.formsite.com/meherpavan/form2/index.html?1537702596407") driver.maximize_window() time.sleep(2) male_radio=driver.find_element_by_id("RESULT_RadioButton-7_0") print("Is Male radio button selected or not :",male_radio.is_selected()) print("Is Male radio button visible or not :",male_radio.is_displayed()) time.sleep(2) wait=WebDriverWait(driver,10) #wait.until(expected_conditions.element_to_be_clickable(male_radio)) if male_radio.is_selected(): print("radio button is already selected") else: print("radio button is NOT selected") highlight(male_radio) #male_radio.click() driver.execute_script("arguments[0].click();", male_radio) time.sleep(5)
class SeletiounTestMixin(unittest.TestCase): BASE_EXT_QUERIES = { 'app-main': "Ext.ComponentQuery.query('app-main')", 'error_msg': "Ext.ComponentQuery.query('messagebox[title=Error]{isVisible()}')", 'confirm_msg': "Ext.ComponentQuery.query('messagebox:visible')", 'cofirm_msg_btn': "Ext.ComponentQuery.query('messagebox:visible button[text=Yes]')[0]", 'is_masked': "Ext.getBody().isMasked()" } def setUp(self): options = webdriver.ChromeOptions() options.add_argument('headless') options.add_argument("--no-sandbox") options.add_argument("--disable-dev-shm-usage") self.driver = EventFiringWebDriver( webdriver.Chrome(chrome_options=options), ScreenshotListener()) self.driver.set_page_load_timeout(10) self.driver.set_script_timeout(10) self.driver.maximize_window() self.driver.get(self.get_host()) self.wait_content_is_ready() def wait_content_is_ready(self): self.wait_js( "document.readyState=='complete' && window.Ext != undefined && window.Ext.ComponentQuery != undefined && {app-main}.length>0 && {app-main}[0].rendered" .format(**self.BASE_EXT_QUERIES), 'View is not rendered!') def wait_js(self, query, error, timeout=20, silent=False): try: WebDriverWait(self.driver, timeout).until( lambda _: self.driver.execute_script("return %s" % query), error) except TimeoutException as e: if not silent: self.driver._listener.on_exception(e, self.driver.wrapped_driver) raise e def wait_while_load_mask(self, silent=False): self.wait_js("!Ext.getBody().isMasked()", 'Loading takes too much time.', silent=silent) def click_by_id(self, dom_id): element = self.driver.find_element_by_id(dom_id) builder = ActionChains(self.driver) builder.move_to_element(element).click(element).perform() def click_component(self, query): cmp_id = self.driver.execute_script("return %s.id" % query) self.driver.find_element_by_id(cmp_id).click() def get_host(self): return "http://127.0.0.1:%s" % TORNADO_PORT def open_page(self, relative_url): self.driver.get("%s/%s" % (self.get_host(), relative_url)) self.wait_content_is_ready() def refresh_page(self): self.driver.get(self.driver.current_url) self.wait_content_is_ready() def tearDown(self): self.driver.close() self.driver.quit()