def driver(request, driver_class, driver_kwargs): """ Returns a WebDriver instance based on options and capabilities This is copied from pytest-selenium 1.11.4, but modified to retry getting the driver up to 3 times to cope with intermittent connection resets in TravisCI. We ripped the original ``driver = driver_class(**driver_kwargs)`` out and replaced it with the ``get_driver_for_class()`` function, which is wrapped in the retrying package's ``@retry`` decorator. """ kwargs = driver_kwargs if driver_class == ChromeWD: kwargs['desired_capabilities']['loggingPrefs'] = {'browser': 'ALL'} driver = get_driver_for_class(driver_class, kwargs) event_listener = request.config.getoption('event_listener') if event_listener is not None: # Import the specified event listener and wrap the driver instance mod_name, class_name = event_listener.rsplit('.', 1) mod = __import__(mod_name, fromlist=[class_name]) event_listener = getattr(mod, class_name) if not isinstance(driver, EventFiringWebDriver): driver = EventFiringWebDriver(driver, event_listener()) request.node._driver = driver yield driver driver.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'} wd = EventFiringWebDriver( webdriver.Chrome(options=options, desired_capabilities=caps), ChromeListener(logger)) else: raise ValueError('Unsupported browser.') yield wd wd.quit()
def browser(logger, request): selected_browser = request.config.getoption('--browser') if selected_browser not in ('firefox', 'chrome'): raise ValueError( f'--browser option can only be "firefox" or "chrome", received "{selected_browser}"' ) executor = request.config.getoption('--executor') browser_logger = logging.getLogger('Browser') logger.info(f'Starting {selected_browser.capitalize()}') browser = EventFiringWebDriver( webdriver.Remote( command_executor=f'http://{executor}:4444/wd/hub', desired_capabilities={ 'browserName': selected_browser, 'loggingPrefs': { 'browser': 'ALL' }, 'acceptInsecureCerts': True, }, ), EventListener(browser_logger), ) browser.implicitly_wait(request.config.getoption('--time')) browser.get(request.config.getoption('--url')) # Ожидание на случай первоначальной установки WebDriverWait(browser, 100).until(EC.visibility_of_element_located(HEADER)) failed = request.session.testsfailed yield browser if request.session.testsfailed > failed: browser.save_screenshot( f'screenshots/{datetime.now().strftime("%d-%m-%Y %H-%M-%S")}.png') browser.quit()
def driver(request, driver_class, driver_kwargs): """Returns a WebDriver instance based on options and capabilities""" retries = int(request.config.getini("max_driver_init_attempts")) for retry in Retrying(stop=stop_after_attempt(retries), wait=wait_exponential(), reraise=True): with retry: LOGGER.info( f"Driver init, attempt {retry.retry_state.attempt_number}/{retries}" ) driver = driver_class(**driver_kwargs) event_listener = request.config.getoption("event_listener") if event_listener is not None: # Import the specified event listener and wrap the driver instance mod_name, class_name = event_listener.rsplit(".", 1) mod = __import__(mod_name, fromlist=[class_name]) event_listener = getattr(mod, class_name) if not isinstance(driver, EventFiringWebDriver): driver = EventFiringWebDriver(driver, event_listener()) request.node._driver = driver yield driver driver.quit()
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()
def setUp(request): W_driver = wdf.get_driver() driver = EventFiringWebDriver(W_driver, MyListeners()) if request.node is not None: request.node.driver = driver yield if request.node.rep_call.failed: allure.attach(driver.get_screenshot_as_png(), name=request.function.__name__, attachment_type=allure.attachment_type.PNG) driver.quit()
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()
class BaseTestClass(unittest.TestCase): @classmethod def setUp(self): self.base_url = 'https://autodemo.testoneo.com/en/' self.login_url = self.base_url + 'login' self.sample_product_url = self.base_url + 'men/1-1-hummingbird-printed-t-shirt.html' self.subpage_art_url = self.base_url + '9-art' driver = webdriver.Chrome( executable_path=r"C:\Users\Dominika\Downloads\chromedriver_win32(" r"1)\chromedriver.exe") self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener()) @classmethod def tearDown(self): self.ef_driver.quit()
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, driver_class, driver_kwargs): """Returns a WebDriver instance based on options and capabilities""" driver = driver_class(**driver_kwargs) event_listener = request.config.getoption('event_listener') if event_listener is not None: # Import the specified event listener and wrap the driver instance mod_name, class_name = event_listener.rsplit('.', 1) mod = __import__(mod_name, fromlist=[class_name]) event_listener = getattr(mod, class_name) if not isinstance(driver, EventFiringWebDriver): driver = EventFiringWebDriver(driver, event_listener()) request.node._driver = driver yield driver driver.quit()
def driver(request, driver_class, driver_kwargs): """Returns a WebDriver instance based on options and capabilities""" driver = driver_class(**driver_kwargs) event_listener = request.config.getoption("event_listener") if event_listener is not None: # Import the specified event listener and wrap the driver instance mod_name, class_name = event_listener.rsplit(".", 1) mod = __import__(mod_name, fromlist=[class_name]) event_listener = getattr(mod, class_name) if not isinstance(driver, EventFiringWebDriver): driver = EventFiringWebDriver(driver, event_listener()) request.node._driver = driver yield driver driver.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()
class BaseTestClass(unittest.TestCase): @classmethod def setUp(self): self.base_url = 'https://autodemo.testoneo.com/en/' self.login_url = self.base_url + 'login' self.product_url = self.base_url + 'art/12-mountain-fox-vector-graphics.html' self.sample_product_url = self.base_url + 'men/1-1-hummingbird-printed-t-shirt.html' self.clothes_product_url = self.base_url + '3-clothes' self.accessories_product_url = self.base_url + '6-accessories' self.art_product_url = self.base_url + '9-art' driver = webdriver.Chrome( executable_path= r"C:\Personal_Belongings\Python\Chromedriver\chromedriver.exe") self.ef_driver = EventFiringWebDriver(driver, ScreenshotListener()) @classmethod def tearDown(self): self.ef_driver.quit()
def start_browser(): configs = Properties() configs.load(open(os.path.join(PROJECT_ROOT, 'app.properties'), 'rb')) browser_name = configs.get("browser").data options = webdriver.ChromeOptions() options.add_argument('--no-sandbox') options.add_argument('--disable-gpu') options.add_argument('--window-size=1920,1080') options.add_argument('lang=ru') if browser_name == "chrome": driver = webdriver.Chrome( executable_path=CHROME_DRIVER_DICT[sys.platform], options=options) elif browser_name == "opera": driver = webdriver.Opera( executable_path=OPERA_DRIVER_DICT[sys.platform], options=options) driver.maximize_window() elif browser_name == "yandex": driver = webdriver.Opera( executable_path=YANDEX_DRIVER_DICT[sys.platform], options=options) driver.maximize_window() else: driver = webdriver.Chrome( executable_path=CHROME_DRIVER_DICT[sys.platform], options=options) listener = LoggedListener() driver = EventFiringWebDriver(driver=driver, event_listener=listener) yield driver if sys.exc_info(): allure.attach(body=driver.get_screenshot_as_png(), name='screenshot', attachment_type=AttachmentType.PNG) driver.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") implicit_wait = request.config.getoption("--wait") if browser == 'chrome': chrome_options = Options() chrome_options.add_argument(f'--proxy-server={proxy.proxy}') chrome_options.add_experimental_option('w3c', False) # chrome_options.add_argument("--start-fullscreen") # chrome_options.add_argument("--headless") driver = EventFiringWebDriver(Chrome(options=chrome_options), MyListener(logger)) # driver = webdriver.Remote( # "http://localhost:4444/wd/hub", # desired_capabilities={'browserName': 'chrome'}) elif browser == 'firefox': driver = Firefox() elif browser == 'safari': driver = Safari() else: raise ValueError(f'Unrecognized browser {browser}') driver.implicitly_wait(implicit_wait) yield driver driver.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 Client(object): def __init__(self, test_id, options): self.test_id = test_id self.host = options.host self.port = options.port self.base_url = options.base_url self.api = options.api.upper() self.webdriver = self.api == 'WEBDRIVER' self.rc = self.api == 'RC' if self.webdriver: self.driver = options.driver self.capabilities = options.capabilities or [] self.chrome_path = options.chrome_path self.chrome_options = options.chrome_options or '{}' self.firefox_path = options.firefox_path self.firefox_preferences = options.firefox_preferences or [] self.profile_path = options.profile_path self.extension_paths = options.extension_paths or [] self.opera_path = options.opera_path self.timeout = options.webqatimeout if self.driver.upper() == 'REMOTE': self.browser_name = options.browser_name self.browser_version = options.browser_version self.platform = options.platform if options.event_listener: mod_name, class_name = options.event_listener.rsplit('.', 1) mod = __import__(mod_name, fromlist=[class_name]) self.event_listener = getattr(mod, class_name) else: self.event_listener = None if self.rc: self.browser = options.environment or options.browser self.timeout = options.webqatimeout * 1000 self.capture_network = options.capture_network self.default_implicit_wait = 10 self.sauce_labs_credentials = options.sauce_labs_credentials_file self.assume_untrusted = options.assume_untrusted self.proxy_host = options.proxy_host self.proxy_port = options.proxy_port def check_usage(self): self.check_basic_usage() if self.webdriver: self.check_webdriver_usage() else: self.check_rc_usage() def check_basic_usage(self): if not self.base_url: raise pytest.UsageError('--baseurl must be specified.') def check_webdriver_usage(self): if self.driver.upper() == 'REMOTE': if not self.browser_name: raise pytest.UsageError("--browsername must be specified when using the 'webdriver' api.") if not self.platform: raise pytest.UsageError("--platform must be specified when using the 'webdriver' api.") def check_rc_usage(self): if not self.browser: raise pytest.UsageError("--browser or --environment must be specified when using the 'rc' api.") def start(self): self.check_usage() if self.webdriver: self.start_webdriver_client() self.selenium.implicitly_wait(self.default_implicit_wait) else: self.start_rc_client() self.selenium.set_timeout(self.timeout) self.selenium.set_context(self.test_id) def start_webdriver_client(self): capabilities = {} for c in self.capabilities: name, value = c.split(':') # handle integer capabilities if value.isdigit(): value = int(value) # handle boolean capabilities elif value.lower() in ['true', 'false']: value = value.lower() == 'true' capabilities.update({name: value}) if self.proxy_host and self.proxy_port: proxy = Proxy() proxy.http_proxy = '%s:%s' % (self.proxy_host, self.proxy_port) proxy.ssl_proxy = proxy.http_proxy proxy.add_to_capabilities(capabilities) profile = None if self.driver.upper() == 'REMOTE': capabilities.update(getattr(webdriver.DesiredCapabilities, self.browser_name.upper())) if json.loads(self.chrome_options) or self.extension_paths: capabilities = self.create_chrome_options( self.chrome_options, self.extension_paths).to_capabilities() if self.browser_name.upper() == 'FIREFOX': profile = self.create_firefox_profile( self.firefox_preferences, self.profile_path, self.extension_paths) if self.browser_version: capabilities['version'] = self.browser_version capabilities['platform'] = self.platform.upper() executor = 'http://%s:%s/wd/hub' % (self.host, self.port) try: self.selenium = webdriver.Remote(command_executor=executor, desired_capabilities=capabilities or None, browser_profile=profile) except AttributeError: valid_browsers = [attr for attr in dir(webdriver.DesiredCapabilities) if not attr.startswith('__')] raise AttributeError("Invalid browser name: '%s'. Valid options are: %s" % (self.browser_name, ', '.join(valid_browsers))) elif self.driver.upper() == 'CHROME': options = None if self.chrome_options or self.extension_paths: options = self.create_chrome_options( self.chrome_options, self.extension_paths) if self.chrome_path: self.selenium = webdriver.Chrome(executable_path=self.chrome_path, chrome_options=options, desired_capabilities=capabilities or None) else: self.selenium = webdriver.Chrome(chrome_options=options, desired_capabilities=capabilities or None) elif self.driver.upper() == 'FIREFOX': binary = self.firefox_path and FirefoxBinary(self.firefox_path) or None profile = self.create_firefox_profile( self.firefox_preferences, self.profile_path, self.extension_paths) self.selenium = webdriver.Firefox( firefox_binary=binary, firefox_profile=profile, capabilities=capabilities or None) elif self.driver.upper() == 'IE': self.selenium = webdriver.Ie() elif self.driver.upper() == 'OPERA': capabilities.update(webdriver.DesiredCapabilities.OPERA) self.selenium = webdriver.Opera(executable_path=self.opera_path, desired_capabilities=capabilities) else: self.selenium = getattr(webdriver, self.driver)() if self.event_listener is not None and not isinstance(self.selenium, EventFiringWebDriver): self.selenium = EventFiringWebDriver(self.selenium, self.event_listener()) def start_rc_client(self): self.selenium = selenium(self.host, str(self.port), self.browser, self.base_url) if self.capture_network: self.selenium.start('captureNetworkTraffic=true') else: self.selenium.start() @property def session_id(self): if self.webdriver: return self.selenium.session_id else: return self.selenium.get_eval('selenium.sessionId') def create_firefox_profile(self, preferences, profile_path, extensions): profile = webdriver.FirefoxProfile(profile_path) for p in preferences: name, value = p.split(':') # handle integer preferences if value.isdigit(): value = int(value) # handle boolean preferences elif value.lower() in ['true', 'false']: value = value.lower() == 'true' profile.set_preference(name, value) profile.assume_untrusted_cert_issuer = self.assume_untrusted profile.update_preferences() for extension in extensions: profile.add_extension(extension) return profile def create_chrome_options(self, preferences, extensions): options = webdriver.ChromeOptions() options_from_json = json.loads(preferences) if 'arguments' in options_from_json: for args_ in options_from_json['arguments']: options.add_argument(args_) if 'binary_location' in options_from_json: options.binary_location = options_from_json['binary_location'] for extension in extensions: options.add_extension(extension) return options @property def screenshot(self): try: if self.webdriver: screenshot = self.selenium.get_screenshot_as_base64() else: screenshot = self.selenium.capture_entire_page_screenshot_to_string('') return screenshot except: return None @property def html(self): try: if self.webdriver: html = self.selenium.page_source else: html = self.selenium.get_html_source() return html.encode('utf-8') except: return None @property def log(self): try: if self.rc: return self.selenium.get_log().encode('utf-8') except: return None @property def network_traffic(self): try: if self.rc and self.capture_network: return self.selenium.captureNetworkTraffic('json') except: return None @property def url(self): try: if self.webdriver: url = self.selenium.current_url else: url = self.selenium.get_location() return url except: return None def stop(self): try: if self.webdriver: self.selenium.quit() else: self.selenium.stop() except: pass
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}" )
class Browser(Container, HasWindow, Waitable): def __init__(self, browser='chrome', *args, **kwargs): """ Creates a nerodia.browser.Browser instance :param browser: firefox, ie, chrome, remote or Selenium WebDriver instance :type browser: selenium.webdriver.remote.webdriver.WebDriver or str :param args: args passed to the underlying driver :param kwargs: kwargs passed to the underlying driver """ if isinstance(browser, six.string_types[0]): module = import_module('selenium.webdriver.{}.webdriver'.format( browser.lower())) caps = Capabilities(browser, **kwargs) self.driver = module.WebDriver(**caps.kwargs) elif isinstance(browser, WebDriver): self.driver = browser else: raise TypeError( 'A browser name or WebDriver instance must be supplied, ' 'got {}'.format(type(browser))) if 'listener' in kwargs: self.driver = EventFiringWebDriver(self.driver, kwargs.get('listener')) self.after_hooks = AfterHooks(self) self.current_frame = None self.closed = False self.default_context = True self._original_window = None @property def wd(self): return self.driver @staticmethod def start(url, browser='chrome', *args, **kwargs): """ Creates a Browser instance :param url: url to navigate to after starting browser :type url: str :param browser: firefox, ie, chrome, remote or Selenium WebDriver instance :type browser: selenium.webdriver.remote.webdriver.WebDriver or str :param args: args passed to the underlying driver :param kwargs: kwargs passed to the underlying driver """ b = Browser(browser, *args, **kwargs) b.goto(url) return b def __repr__(self): from selenium.common.exceptions import UnexpectedAlertPresentException try: return '#<{}:0x{:x} url={!r} title={!r}>'.format( self.__class__.__name__, self.__hash__() * 2, self.url, self.title) except UnexpectedAlertPresentException: return '#<{}:0x{:x} alert=True>'.format(self.__class__.__name__, self.__hash__() * 2) except: # noqa return '#<{}:0x{:x} closed={}>'.format(self.__class__.__name__, self.__hash__() * 2, self.closed) selector_string = __repr__ def goto(self, uri): """ Goes to the given URL :param uri: the URL :type uri: str :return: the url you end up at :rtype: str """ scheme = urlparse(uri).scheme if scheme == '' or '.' in scheme: uri = 'http://{}'.format(uri) self.driver.get(uri) self.after_hooks.run() return uri def back(self): """ Navigates back in history """ self.driver.back() self.after_hooks.run() def forward(self): """ Navigates forward in history """ self.driver.forward() self.after_hooks.run() @property def url(self): """ Returns the URL of the current page :rtype: str """ self.assert_exists() return self.driver.current_url @property def title(self): """ Returns the title of the current page :rtype: str """ return self.driver.title def close(self): """ Closes the browser """ if not self.closed: self.driver.quit() self.closed = True quit = close @property def cookies(self): """ Handles cookies :rtype: nerodia.cookies.Cookies """ return Cookies(self.driver) @property def name(self): """ Returns the browser name :rtype: str """ return self.driver.name @property def text(self): """ Returns the text of the page body :return: """ return self.body().text @property def html(self): """ Returns HTML code of the current page :rtype: str """ return self.driver.page_source @property def alert(self): """ Handles Javascript alerts, confirms and prompts :rtype: nerodia.alert.Alert """ return Alert(self) def refresh(self): """ Refreshes the current page """ self.driver.refresh() self.after_hooks.run() def wait(self, timeout=5): """ Waits until the readyState of document is complete, raises a TimeoutException if timeout is exceeded :param timeout: time to wait :type timeout: int """ return self.wait_until( lambda b: b.ready_state == "complete", timeout=timeout, message="waiting for document.readyState == 'complete'") @property def ready_state(self): """ Returns the readyState of the document :rtype: str """ return self.execute_script('return document.readyState;') @property def status(self): """ Returns the text of the status bar :return: """ return self.execute_script('return window.status;') def execute_script(self, script, *args): """ Executes JavaScript snippet :param script: Javascript Snippet to execute :type script: str :param args: Arguments will be available in the given script in the 'arguments' pseudo-array :return: result of script """ from .elements.element import Element args = [e.wd if isinstance(e, Element) else e for e in args] returned = self.driver.execute_script(script, *args) return self._wrap_elements_in(self, returned) def send_keys(self, *args): """ Sends sequence of keystrokes to currently active element :param args: keystrokes """ self.driver.switch_to.active_element.send_keys(*args) @property def screenshot(self): """ Handles screenshots of current pages :rtype: nerodia.screenshot.Screenshot """ from .screenshot import Screenshot return Screenshot(self.driver) @property def exist(self): """ True if browser is not closed and False otherwise :rtype: bool """ return not self.closed and self.window().present exists = exist @property def browser(self): return self def assert_exists(self): self._ensure_context() if self.window().present: return raise NoMatchingWindowFoundException('browser window was closed') # private def _ensure_context(self): if self.closed: raise Error('browser was closed') if not self.default_context: self.driver.switch_to.default_content() self.default_context = True @staticmethod def _wrap_elements_in(scope, obj): if isinstance(obj, WebElement): return Browser._wrap_element(scope, obj) elif isinstance(obj, list): return [Browser._wrap_elements_in(scope, e) for e in obj] elif isinstance(obj, dict): for k, v in obj.items(): obj[k] = Browser._wrap_elements_in(scope, v) return obj else: return obj @staticmethod def _wrap_element(scope, element): from .elements.html_elements import HTMLElement klass = nerodia.element_class_for( element.tag_name.lower()) or HTMLElement return klass(scope, {'element': element})
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()
def driver(request): browser = request.config.getoption("--browser") try: timeout_str = request.config.getoption("--timeouts") timeout = int(timeout_str) except ValueError: print("Bad --timeouts value: ".join(timeout_str)) timeout = 10000 if browser == 'firefox': capabilities = webdriver.DesiredCapabilities.FIREFOX.copy() capabilities['timeouts'] = { 'implicit': timeout, 'pageLoad': timeout, 'script': timeout } 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 = webdriver.Firefox(firefox_profile=profile, capabilities=capabilities) wd.maximize_window() elif browser == 'chrome': capabilities = webdriver.DesiredCapabilities.CHROME.copy() capabilities['timeouts'] = { 'implicit': timeout, 'pageLoad': timeout, 'script': timeout } capabilities['acceptSslCerts'] = True capabilities['acceptInsecureCerts'] = True wd = webdriver.Chrome(desired_capabilities=capabilities) wd.maximize_window() elif browser == 'ie': options = IeOptions() options.add_argument("--start-fullscreen") options.add_argument('--headless') wd = webdriver.Ie(options=options) else: print('Unsupported browser!') sys.exit(1) log_folder = request.config.getoption("--logfolder") logger = get_logger(log_folder, "webDriverLog") logged_driver = EventFiringWebDriver(wd, WdEventListener(logger)) yield logged_driver if browser == 'chrome': browser_logger = get_logger(log_folder, "chromeLog", "%(message)s") for l in logged_driver.get_log("browser"): browser_logger.info(l) logged_driver.quit()
#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) print("Is Male radio button visible or not :",male_radio.is_displayed()) print("Is Male radio button selected or not :",male_radio.is_selected()) print(len(driver.find_elements_by_class_name('multiple_choice'))) #driver.find_element_by_id("RESULT_CheckBox-8_0").click() chkbox=driver.find_element_by_xpath("//table[@class='inline_grid choices']//input[@id='RESULT_CheckBox-8_0']") highlight(chkbox) driver.execute_script("arguments[0].click();", chkbox) chkbox.click() time.sleep(5) driver.quit()