def test_change_tab_and_successful_login(self):
# Create a second driver
second_wrapper = DriverWrapper()
second_wrapper.config.set('Driver', 'type', 'firefox')
second_wrapper.connect()
# [Mobile] Open tabs activity
MenuPageObject().open_option('Views').open_option('Tabs').open_option('1. Content By Id')
tabs_page = TabsPageObject()
assert_equal('tab1', tabs_page.content1.text)
# [Web] Login and check welcome message
user = {'username': '******', 'password': '******'}
expected_login_message = "You logged into a secure area!"
expected_logout_message = "You logged out of the secure area!"
secure_area = LoginPageObject(second_wrapper).open().login(user)
assert_in(expected_login_message, secure_area.message.get_message())
# [Mobile] Open second tab and check content
tabs_page.tab2.click()
assert_equal('tab2', tabs_page.content2.text)
# [Web] Logout and check logout message
login_page = secure_area.logout()
assert_in(expected_logout_message, login_page.message.get_message())
def setUp(self):
os.environ["Config_log_filename"] = os.path.join(
self.root_path, 'conf', 'logging.conf')
os.environ["Config_prop_filenames"] = os.path.join(
self.root_path, 'conf', 'properties.cfg')
self.driver_wrapper = DriverWrapper()
self.driver_wrapper.configure()
def step_impl(context, browser):
if browser == 'browser1':
# Use default driver
context.current_page = {'browser1': LoginPageObject()}
else:
# Create a second driver
second_wrapper = DriverWrapper()
second_wrapper.connect()
context.current_page['browser2'] = LoginPageObject(second_wrapper)
# Open home page
context.current_page[browser].open()
def step_impl(context, browser):
if browser == 'browser1':
# Use default driver
context.current_page = {'browser1': LoginPageObject()}
else:
# Create a second driver
second_wrapper = DriverWrapper()
second_wrapper.connect()
context.current_page['browser2'] = LoginPageObject(second_wrapper)
# Open home page
context.current_page[browser].open()
def test_two_driver_wrappers(driver_wrapper):
page_object = RegisterPageObject()
second_driver_wrapper = DriverWrapper()
second_page_object = RegisterPageObject(second_driver_wrapper)
# Check that the page object and its instance page elements have the same driver wrapper
assert page_object.driver_wrapper == driver_wrapper
assert page_object.language.driver_wrapper == driver_wrapper
assert page_object.email.driver_wrapper == driver_wrapper
assert page_object.address.driver_wrapper == driver_wrapper
assert page_object.menu.driver_wrapper == driver_wrapper
assert page_object.menu.logo.driver_wrapper == driver_wrapper
assert page_object.menu_group.driver_wrapper == driver_wrapper
assert page_object.menu_group.logo.driver_wrapper == driver_wrapper
# Check that the second page object and its instance page elements have the second driver wrapper
assert second_page_object.driver_wrapper == second_driver_wrapper
assert second_page_object.language.driver_wrapper == second_driver_wrapper
assert second_page_object.email.driver_wrapper == second_driver_wrapper
assert second_page_object.address.driver_wrapper == second_driver_wrapper
assert second_page_object.menu.driver_wrapper == second_driver_wrapper
assert second_page_object.menu.logo.driver_wrapper == second_driver_wrapper
assert second_page_object.menu_group.driver_wrapper == second_driver_wrapper
assert second_page_object.menu_group.logo.driver_wrapper == second_driver_wrapper
# Check that the class elements have the last driver wrapper
# This kind of elements could not be used with multiple drivers
assert page_object.username.driver_wrapper == second_driver_wrapper
assert page_object.password.driver_wrapper == second_driver_wrapper
assert page_object.menu.register.driver_wrapper == second_driver_wrapper
assert second_page_object.username.driver_wrapper == second_driver_wrapper
assert second_page_object.password.driver_wrapper == second_driver_wrapper
assert second_page_object.menu.register.driver_wrapper == second_driver_wrapper
def test_multiple(driver_wrapper):
# Request a new additional wrapper
new_wrapper = DriverWrapper()
# Check that wrapper and new_wrapper are different
assert driver_wrapper != new_wrapper
assert DriverWrappersPool.driver_wrappers[0] == driver_wrapper
assert DriverWrappersPool.driver_wrappers[1] == new_wrapper
def test_multiple(self):
# Request a new additional wrapper
new_wrapper = DriverWrapper()
# Check that wrapper and new_wrapper are different
assert_not_equal(self.driver_wrapper, new_wrapper)
assert_equal(DriverWrappersPool.driver_wrappers[0], self.driver_wrapper)
assert_equal(DriverWrappersPool.driver_wrappers[1], new_wrapper)
def test_initialize_config_files_new():
config_files = None
# Initialize config files
init_config_files = DriverWrapper._initialize_config_files(config_files)
# Check expected config files
assert init_config_files.config_properties_filenames is None
assert init_config_files.output_log_filename is None
def get_default_wrapper(cls):
"""Returns the default (first) driver wrapper
:returns: default driver wrapper
:rtype: toolium.driver_wrapper.DriverWrapper
"""
if cls.is_empty():
# Create a new driver wrapper if the pool is empty
from toolium.driver_wrapper import DriverWrapper
DriverWrapper()
return cls.driver_wrappers[0]
def test_initialize_config_files_new_environment():
config_files = None
os.environ["Config_environment"] = 'android'
# Initialize config files
init_config_files = DriverWrapper._initialize_config_files(config_files)
del os.environ["Config_environment"]
# Check expected config files
assert init_config_files.config_properties_filenames == 'properties.cfg;android-properties.cfg;local-android-properties.cfg'
assert init_config_files.output_log_filename == 'toolium_android.log'
def test_initialize_config_files_configured():
config_files = ConfigFiles()
config_files.set_config_properties_filenames('test.conf',
'local-test.conf')
config_files.set_output_log_filename('test.log')
# Initialize config files
init_config_files = DriverWrapper._initialize_config_files(config_files)
# Check expected config files
assert init_config_files.config_properties_filenames == 'test.conf;local-test.conf'
assert init_config_files.output_log_filename == 'test.log'
def test_multiple(driver_wrapper):
# Request a new additional wrapper
new_wrapper = DriverWrapper()
# Modify new wrapper
first_driver_type = 'firefox'
new_driver_type = 'opera'
new_wrapper.config.set('Driver', 'type', new_driver_type)
# Check that wrapper and new_wrapper are different
assert driver_wrapper.config.get('Driver', 'type') == first_driver_type
assert new_wrapper.config.get('Driver', 'type') == new_driver_type
assert new_wrapper != driver_wrapper
def test_multiple(self):
# Request a new additional wrapper
new_wrapper = DriverWrapper()
# Modify new wrapper
first_driver_type = 'firefox'
new_driver_type = 'opera'
new_wrapper.config.set('Driver', 'type', new_driver_type)
# Check that wrapper and new_wrapper are different
assert_equal(first_driver_type,
self.driver_wrapper.config.get('Driver', 'type'))
assert_equal(new_driver_type, new_wrapper.config.get('Driver', 'type'))
assert_not_equal(self.driver_wrapper, new_wrapper)
def test_initialize_config_files_configured_environment():
config_files = ConfigFiles()
config_files.set_config_properties_filenames('test.conf',
'local-test.conf')
config_files.set_output_log_filename('test.log')
os.environ["Config_environment"] = 'android'
# Initialize config files
init_config_files = DriverWrapper._initialize_config_files(config_files)
del os.environ["Config_environment"]
# Check expected config files
assert init_config_files.config_properties_filenames == 'test.conf;local-test.conf;android-test.conf;local-android-test.conf'
assert init_config_files.output_log_filename == 'test_android.log'
class DriverWrapperTests(DriverWrapperCommon):
def setUp(self):
os.environ["Config_log_filename"] = os.path.join(self.root_path, 'conf', 'logging.conf')
os.environ["Config_prop_filenames"] = os.path.join(self.root_path, 'conf', 'properties.cfg')
self.driver_wrapper = DriverWrapper()
self.driver_wrapper.configure()
def test_multiple(self):
# Request a new additional wrapper
new_wrapper = DriverWrapper()
# Modify new wrapper
first_driver_type = 'firefox'
new_driver_type = 'opera'
new_wrapper.config.set('Driver', 'type', new_driver_type)
# Check that wrapper and new_wrapper are different
assert_equal(first_driver_type, self.driver_wrapper.config.get('Driver', 'type'))
assert_equal(new_driver_type, new_wrapper.config.get('Driver', 'type'))
assert_not_equal(self.driver_wrapper, new_wrapper)
def test_configure_no_changes(self):
# Check previous values
assert_equal('firefox', self.driver_wrapper.config.get('Driver', 'type'))
# Modify wrapper
self.driver_wrapper.config.set('Driver', 'type', 'opera')
# Trying to configure again
self.driver_wrapper.configure()
# Configuration has not been initialized
assert_equal('opera', self.driver_wrapper.config.get('Driver', 'type'))
def test_configure_change_configuration_file(self):
# Check previous values
assert_equal('firefox', self.driver_wrapper.config.get('Driver', 'type'))
# Modify wrapper
self.driver_wrapper.config.set('Driver', 'type', 'opera')
# Change driver type and try to configure again
os.environ["Config_prop_filenames"] = os.path.join(self.root_path, 'conf', 'android-properties.cfg')
self.driver_wrapper.configure()
# Check that configuration has been initialized
assert_equal('android', self.driver_wrapper.config.get('Driver', 'type'))
@mock.patch('toolium.driver_wrapper.ConfigDriver.create_driver')
def test_connect(self, create_driver):
# Mock data
expected_driver = mock.MagicMock()
create_driver.return_value = expected_driver
self.driver_wrapper.utils = mock.MagicMock()
# Connect and check the returned driver
assert_equal(expected_driver, self.driver_wrapper.connect(maximize=False))
# Check that the wrapper has been configured
assert_equal('firefox', self.driver_wrapper.config.get('Driver', 'type'))
logger = logging.getLogger('selenium.webdriver.remote.remote_connection')
assert_equal('DEBUG', logging.getLevelName(logger.level))
def test_connect_api(self):
# Mock data
expected_driver = None
# Change driver type to api and configure again
os.environ["Config_prop_filenames"] = os.path.join(self.root_path, 'conf', 'api-properties.cfg')
self.driver_wrapper.configure()
# Connect and check that the returned driver is None
self.driver_wrapper.configure()
assert_equal(expected_driver, self.driver_wrapper.connect(maximize=False))
# Check that the wrapper has been configured
assert_equal('', self.driver_wrapper.config.get('Driver', 'type'))
assert_equal('false', self.driver_wrapper.config.get('Jira', 'enabled'))
logger = logging.getLogger('selenium.webdriver.remote.remote_connection')
assert_equal('DEBUG', logging.getLevelName(logger.level))
@data(*mobile_tests)
@unpack
def test_is_mobile_test(self, driver_type, is_mobile, is_android, is_ios):
self.driver_wrapper.config.set('Driver', 'type', driver_type)
assert_equal(is_mobile, self.driver_wrapper.is_mobile_test())
assert_equal(is_android, self.driver_wrapper.is_android_test())
assert_equal(is_ios, self.driver_wrapper.is_ios_test())
@data(*web_tests)
@unpack
def test_is_web_test(self, driver_type, appium_app, appium_browser_name, is_web, is_android_web, is_ios_web):
self.driver_wrapper.config.set('Driver', 'type', driver_type)
if appium_app is not None:
self.driver_wrapper.config.set('AppiumCapabilities', 'app', appium_app)
if appium_browser_name is not None:
self.driver_wrapper.config.set('AppiumCapabilities', 'browserName', appium_browser_name)
assert_equal(is_web, self.driver_wrapper.is_web_test())
assert_equal(is_android_web, self.driver_wrapper.is_android_web_test())
assert_equal(is_ios_web, self.driver_wrapper.is_ios_web_test())
@data(*maximizable_drivers)
@unpack
def test_is_maximizable(self, driver_type, is_maximizable):
self.driver_wrapper.config.set('Driver', 'type', driver_type)
assert_equal(is_maximizable, self.driver_wrapper.is_maximizable())
def setUp(self):
os.environ["Config_log_filename"] = os.path.join(self.root_path, 'conf', 'logging.conf')
os.environ["Config_prop_filenames"] = os.path.join(self.root_path, 'conf', 'properties.cfg')
self.driver_wrapper = DriverWrapper()
self.driver_wrapper.configure()
class DriverWrapperTests(DriverWrapperCommon):
def setUp(self):
os.environ["Config_log_filename"] = os.path.join(
self.root_path, 'conf', 'logging.conf')
os.environ["Config_prop_filenames"] = os.path.join(
self.root_path, 'conf', 'properties.cfg')
self.driver_wrapper = DriverWrapper()
self.driver_wrapper.configure()
def test_multiple(self):
# Request a new additional wrapper
new_wrapper = DriverWrapper()
# Modify new wrapper
first_driver_type = 'firefox'
new_driver_type = 'opera'
new_wrapper.config.set('Driver', 'type', new_driver_type)
# Check that wrapper and new_wrapper are different
assert_equal(first_driver_type,
self.driver_wrapper.config.get('Driver', 'type'))
assert_equal(new_driver_type, new_wrapper.config.get('Driver', 'type'))
assert_not_equal(self.driver_wrapper, new_wrapper)
def test_configure_no_changes(self):
# Check previous values
assert_equal('firefox',
self.driver_wrapper.config.get('Driver', 'type'))
# Modify wrapper
self.driver_wrapper.config.set('Driver', 'type', 'opera')
# Trying to configure again
self.driver_wrapper.configure()
# Configuration has not been initialized
assert_equal('opera', self.driver_wrapper.config.get('Driver', 'type'))
def test_configure_change_configuration_file(self):
# Check previous values
assert_equal('firefox',
self.driver_wrapper.config.get('Driver', 'type'))
# Modify wrapper
self.driver_wrapper.config.set('Driver', 'type', 'opera')
# Change driver type and try to configure again
os.environ["Config_prop_filenames"] = os.path.join(
self.root_path, 'conf', 'android-properties.cfg')
self.driver_wrapper.configure()
# Check that configuration has been initialized
assert_equal('android',
self.driver_wrapper.config.get('Driver', 'type'))
@mock.patch('toolium.driver_wrapper.ConfigDriver.create_driver')
def test_connect(self, create_driver):
# Mock data
expected_driver = mock.MagicMock()
create_driver.return_value = expected_driver
self.driver_wrapper.utils = mock.MagicMock()
# Connect and check the returned driver
assert_equal(expected_driver,
self.driver_wrapper.connect(maximize=False))
# Check that the wrapper has been configured
assert_equal('firefox',
self.driver_wrapper.config.get('Driver', 'type'))
logger = logging.getLogger(
'selenium.webdriver.remote.remote_connection')
assert_equal('DEBUG', logging.getLevelName(logger.level))
def test_connect_api(self):
# Mock data
expected_driver = None
# Change driver type to api and configure again
os.environ["Config_prop_filenames"] = os.path.join(
self.root_path, 'conf', 'api-properties.cfg')
self.driver_wrapper.configure()
# Connect and check that the returned driver is None
self.driver_wrapper.configure()
assert_equal(expected_driver,
self.driver_wrapper.connect(maximize=False))
# Check that the wrapper has been configured
assert_equal('', self.driver_wrapper.config.get('Driver', 'type'))
assert_equal('false',
self.driver_wrapper.config.get('Jira', 'enabled'))
logger = logging.getLogger(
'selenium.webdriver.remote.remote_connection')
assert_equal('DEBUG', logging.getLevelName(logger.level))
@data(*mobile_tests)
@unpack
def test_is_mobile_test(self, driver_type, is_mobile, is_android, is_ios):
self.driver_wrapper.config.set('Driver', 'type', driver_type)
assert_equal(is_mobile, self.driver_wrapper.is_mobile_test())
assert_equal(is_android, self.driver_wrapper.is_android_test())
assert_equal(is_ios, self.driver_wrapper.is_ios_test())
@data(*web_tests)
@unpack
def test_is_web_test(self, driver_type, appium_app, appium_browser_name,
is_web, is_android_web, is_ios_web):
self.driver_wrapper.config.set('Driver', 'type', driver_type)
if appium_app is not None:
self.driver_wrapper.config.set('AppiumCapabilities', 'app',
appium_app)
if appium_browser_name is not None:
self.driver_wrapper.config.set('AppiumCapabilities', 'browserName',
appium_browser_name)
assert_equal(is_web, self.driver_wrapper.is_web_test())
assert_equal(is_android_web, self.driver_wrapper.is_android_web_test())
assert_equal(is_ios_web, self.driver_wrapper.is_ios_web_test())
@data(*maximizable_drivers)
@unpack
def test_is_maximizable(self, driver_type, is_maximizable):
self.driver_wrapper.config.set('Driver', 'type', driver_type)
assert_equal(is_maximizable, self.driver_wrapper.is_maximizable())
