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()
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 get_browser(self): if self.remote and self.host is None: self.host = "127.0.0.1" if self.remote and self.port is None: self.port = "4444" if self.browser == "chrome": desired_capabilities = DesiredCapabilities.CHROME.copy() options = webdriver.ChromeOptions() options.add_argument("--start-maximized") options.add_argument("--ignore-certificate-errors") if self.remote: try: driver = webdriver.Remote(desired_capabilities=desired_capabilities, options=options, command_executor="http://" + self.host + ":" + self.port + "/wd/hub") except Exception: logging.exception("WebDriver Host is not available") raise ConnectionError("WebDriver Host is not available") else: driver = webdriver.Chrome(executable_path=ChromeDriverManager().install(), options=options) elif self.browser == "firefox": desired_capabilities = DesiredCapabilities.FIREFOX.copy() options = webdriver.FirefoxOptions() if self.remote: try: driver = webdriver.Remote(desired_capabilities=desired_capabilities, options=options, command_executor="http://" + self.host + ":" + self.port + "/wd/hub") except Exception: logging.exception("WebDriver Host is not available") raise ConnectionError("WebDriver Host is not available") else: driver = webdriver.Firefox(executable_path=GeckoDriverManager().install(), options=options) else: raise Exception("Provide valid browser name") driver.maximize_window() try: urlopen(self.base_url) except Exception: driver.quit() raise Exception("Target host is not available") w_driver = EventFiringWebDriver(driver, WebDriverListener()) w_driver.get(self.base_url) return w_driver
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 browser(logger, request): selected_browser = request.config.getoption('--browser') browser = EventFiringWebDriver( webdriver.Remote( command_executor=f'http://{env.str("SELENOID_HOST")}:4444/wd/hub', desired_capabilities={ 'browserName': selected_browser, 'acceptInsecureCerts': True }, ), EventListener(logging.getLogger('Browser')), ) request.addfinalizer(browser.quit) browser.get(f'http://{env.str("PRESTASHOP_HOST")}') # Ожидание на случай первоначальной установки WebDriverWait(browser, 100).until(EC.visibility_of_element_located(HEADER)) return browser
def main(): num = 1 url = "https://tinder.com/app/login" profile = webdriver.FirefoxProfile("") driver = webdriver.Firefox(firefox_profile=profile) driver = EventFiringWebDriver(driver, MyListener()) driver.get(url) time.sleep(5) driver.refresh() time.sleep(5) while num < 10000: num = num + 1 driver.find_element_by_tag_name("body").send_keys(Keys.RIGHT) #wait = WebDriverWait(driver, 20) wait = WebDriverWait(driver, 100000) element = wait.until( expected_conditions.visibility_of_element_located( (By.CSS_SELECTOR, "button.button:nth-child(5)"))) element.click() time.sleep(0.5) print(num) driver.close()
print("in highlight method") 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)
class LostHatSmokeTests(BaseTestClass): @classmethod def setUpClass(self): self.base_url = 'https://autodemo.testoneo.com/en/' self.login_url = self.base_url + 'login' 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()) @screenshot_decorator def test_base_page_title(self): expected_title = 'Lost Hat' self.assert_title(self.base_url, expected_title) @screenshot_decorator def test_product_clothes_page_title(self): expected_title = 'Clothes' self.assert_title(self.clothes_product_url, expected_title) @screenshot_decorator def test_product_accessories_page_title(self): expected_title = 'Accessories' self.assert_title(self.accessories_product_url, expected_title) @screenshot_decorator def test_product_art_page_title(self): expected_title = 'Art' self.assert_title(self.art_product_url, expected_title) @screenshot_decorator def test_login_page_title(self): expected_title = 'Login' self.assert_title(self.login_url, expected_title) def get_page_title(self, url): self.ef_driver.get(url) return self.ef_driver.title def assert_title(self, url, expected_title): actual_title = self.get_page_title(url) self.assertEqual(expected_title, actual_title, f'Expected {expected_title} differ from actual title {actual_title} on page: {url}') @screenshot_decorator def test_search_bar_existance(self): driver = self.ef_driver driver.get(self.base_url) search_bar_xpath = '//*[@id="search_widget"]/form' element_existance = oh.check_exists_by_xpath(driver, search_bar_xpath) self.assertEqual(True, element_existance, f'Element with xpath: {search_bar_xpath} does not exist on the page with url: {driver.current_url}') @screenshot_decorator def test_search_bar_phrase_input(self): driver = self.ef_driver driver.get(self.base_url) minimum_expected_elements = 5 search_bar_xpath = '//*[@name="s"]' product_list_xpath = '//*[@class="product-miniature js-product-miniature"]' search_bar_element = driver.find_element_by_xpath(search_bar_xpath) search_bar_element.send_keys('mug') search_bar_element.send_keys(Keys.ENTER) product_list_element = driver.find_elements_by_xpath(product_list_xpath) self.assertLessEqual(minimum_expected_elements, len(product_list_element), f"Expected number {minimum_expected_elements} isn't less or equal than actual number of elements found: {len(product_list_element)}")
def wait_for_presence_of_element(name, by, waittime=10): wait = WebDriverWait(ef_driver, waittime) try: return wait.until( EC.presence_of_element_located((getattr(By, by), name))) except: print("da lief was schief") google = "https://www.google.de/" dominion_url = "https://dominion.games/" browser = webdriver.Firefox() browser.implicitly_wait(10) #seconds ef_driver = EventFiringWebDriver(browser, GamelogListener()) ef_driver.get(dominion_url) # ef_driver.implicitly_wait(15) try: username_input = wait_for_presence_of_element("username-input", "ID") username_input.clear() username_input.send_keys("schlafi") except: print("Da kam nix! :(") try: passwd_input = wait_for_presence_of_element("password", "NAME") passwd_input.clear() passwd_input.send_keys("ganxta89") print("login form filled") ef_driver.implicitly_wait(5)
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})
from selenium import webdriver from time import sleep from selenium.webdriver.support.event_firing_webdriver import EventFiringWebDriver from Weblistner.listener import MyListeners driver = webdriver.Chrome() event_driver = EventFiringWebDriver(driver, MyListeners()) event_driver.implicitly_wait(10) event_driver.get("https://demo.actitime.com/login.do")
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()
#****** Listener class ****** class EventListener(AbstractEventListener): def on_exception(self, exception, wdriver): print("exception raised and listener caught **###@@@ ", exception) wdriver.get_screenshot_as_file("error_screenshot.png") wdriver.close() plain_driver = webdriver.Chrome( executable_path= "C:/Users/shaik/PycharmProjects/drivers/chromedriver_win32/chromedriver.exe" ) driver = EventFiringWebDriver(plain_driver, EventListener()) driver.get("https://www.expedia.com/") time.sleep(5) #driver.implicitly_wait(5) driver.maximize_window() try: if driver.find_element(By.ID, "tab-flight-tab-hp").is_displayed(): driver.find_element(By.ID, "tab-flight-tab-hp").click() else: driver.find_element( By.XPATH, "//li/a[@aria-controls='wizard-flight-pwa'").click() except: print("exception in identifying object") driver.find_element(By.ID, "flight-origin-hp-flight").send_keys("CHI") driver.find_element(By.ID, "flight-destination-hp-flight").send_keys("NYC") driver.find_element(By.ID,
def parse_seasons(driver, player_dict): edge_ef_driver = EventFiringWebDriver(driver, LiquipediaNavListener()) season_titles = [] link_texts = [] seasons = [] # quick hack for cleaning the list... bottom of page contains redundant links! link_elements = edge_ef_driver.find_elements_by_partial_link_text("RLCS Season") for link_element in link_elements: if '-' in link_element.wrapped_element.text: # Get season title season_title = link_element.wrapped_element.text season_titles.append(season_title) link_texts.append(link_element.get_attribute("href")) season_num = 0 for link in link_texts: is_final = "Finals" == season_titles[season_num].split('-')[1].strip() edge_ef_driver.get(link) time.sleep(20) # Get teams teamcards = edge_ef_driver.find_elements_by_class_name("teamcard") team_dict = parse_teams(teamcards, season_titles[season_num], player_dict) # Get matches matches = [] if not is_final: # Group stage tables = edge_ef_driver.find_elements_by_class_name("matchlist table table-bordered collapsible") for table in tables: table_entries = table.find_elements_by_class_name("match-row") event = table.find_elements_by_tag_name("th").wrapped_element.text for match in table_entries: team1 = team_dict.get( table_entries[0].find_element_by_tag_name("span").get_attribute("data-highlightingclass")) team2 = team_dict.get( table_entries[3].find_element_by_tag_name("span").get_attribute("data-highlightingclass")) team1_wins = table_entries[1].wrapped_element.text.lstrip() team2_wins = table_entries[2].wrapped_element.text.lstrip() if not team1_wins == "W" and not team1_wins == "FF": for num in range(int(team1_wins)): matches.append(Match(team1=team1, team2=team2, victor=team1, season_title=season_titles[season_num], event=event)) for num in range(int(team2_wins)): matches.append(Match(team1=team1, team2=team2, victor=team2, season_title=season_titles[season_num], event=event)) # Playoffs bracket_web_elements = edge_ef_driver.find_elements_by_class_name("bracket-column-matches") bracket_headers = [bracket.find_elements_by_class_name("bracket-header") for bracket in bracket_web_elements] if re.search(r"Season [789]", season_titles[season_num]): bracket_tuples = make_brackets(bracket_web_elements, bracket_headers, True) else: bracket_tuples = make_brackets(bracket_web_elements, bracket_headers, False) get_bracket_matches(season_titles[season_num], team_dict, bracket_tuples, matches) else: bracket_web_elements = edge_ef_driver.find_elements_by_class_name("bracket-column-matches") bracket_headers = [bracket.find_elements_by_class_name("bracket-header") for bracket in bracket_web_elements] bracket_tuples = make_brackets(bracket_web_elements, bracket_headers, False) get_bracket_matches(season_titles[season_num], team_dict, bracket_tuples, matches) season = Season(season_titles[season_num], player_dict, set(list(team_dict.values())), matches) seasons.append(season) edge_ef_driver.back() season_num += 1 time.sleep(5) return seasons