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