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