def configure(self,
tc_config_files,
is_selenium_test=True,
behave_properties=None):
"""Configure initial selenium instance using logging and properties files for Selenium or Appium tests
:param tc_config_files: test case specific config files
:param is_selenium_test: true if test is a selenium or appium test case
:param behave_properties: dict with behave user data properties
"""
# Configure config and output directories
DriverWrappersPool.configure_common_directories(tc_config_files)
# Configure logger
self.configure_logger(tc_config_files.config_log_filename,
tc_config_files.output_log_filename)
# Initialize the config object
self.configure_properties(tc_config_files.config_properties_filenames,
behave_properties)
# Configure visual directories
if is_selenium_test:
driver_info = self.config.get('Driver', 'type')
DriverWrappersPool.configure_visual_directories(driver_info)
self.configure_visual_baseline()
def configure_logger(self, tc_config_log_filename=None, tc_output_log_filename=None):
"""Configure selenium instance logger
:param tc_config_log_filename: test case specific logging config file
:param tc_output_log_filename: test case specific output logger file
"""
# Get config logger filename
config_log_filename = DriverWrappersPool.get_configured_value('Config_log_filename', tc_config_log_filename,
'logging.conf')
config_log_filename = os.path.join(DriverWrappersPool.config_directory, config_log_filename)
# Configure logger only if logging filename has changed
if self.config_log_filename != config_log_filename:
# Get output logger filename
output_log_filename = DriverWrappersPool.get_configured_value('Output_log_filename', tc_output_log_filename,
'toolium.log')
output_log_filename = os.path.join(DriverWrappersPool.output_directory, output_log_filename)
output_log_filename = output_log_filename.replace('\\', '\\\\')
try:
logging.config.fileConfig(config_log_filename, {'logfilename': output_log_filename}, False)
except Exception as exc:
print("[WARN] Error reading logging config file '{}': {}".format(config_log_filename, exc))
self.config_log_filename = config_log_filename
self.output_log_filename = output_log_filename
self.logger = logging.getLogger(__name__)
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
new_driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure wrapper
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.realpath(__file__))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
config_files.set_config_log_filename('logging.conf')
new_driver_wrapper.configure(config_files)
yield new_driver_wrapper
# Remove used environment properties after test
global environment_properties
for env_property in environment_properties:
try:
del os.environ[env_property]
except KeyError:
pass
environment_properties = []
def setUp(self):
# Get default driver wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
if not SeleniumTestCase.driver:
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(
DriverWrappersPool.get_default_config_directory())
# Create driver
self.driver_wrapper.configure(True, self.config_files)
self.driver_wrapper.connect()
# Discard previous logcat logs
self.driver_wrapper.utils.discard_logcat_logs()
SeleniumTestCase.driver = self.driver_wrapper.driver
self.utils = self.driver_wrapper.utils
# Get common configuration of reusing driver
self.reuse_driver = self.driver_wrapper.config.getboolean_optional(
'Driver', 'reuse_driver')
# Set implicitly wait
self.utils.set_implicit_wait()
# Call BasicTestCase setUp
super(SeleniumTestCase, self).setUp()
def setUp(self):
# Get default driver wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
if not SeleniumTestCase.driver:
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory())
# Create driver
self.driver_wrapper.configure(True, self.config_files)
self.driver_wrapper.connect()
SeleniumTestCase.driver = self.driver_wrapper.driver
self.utils = self.driver_wrapper.utils
# Monkey patching assert_screenshot method in PageElement to use the correct test name
file_suffix = self.get_method_name()
def assert_screenshot_page_element(self, filename, threshold=0, exclude_elements=[], force=False):
VisualTest(self.driver_wrapper, force).assert_screenshot(self.web_element, filename, file_suffix,
threshold, exclude_elements)
PageElement.assert_screenshot = assert_screenshot_page_element
# Get common configuration of reusing driver
self.reuse_driver = self.driver_wrapper.config.getboolean_optional('Driver', 'reuse_driver')
# Set implicitly wait timeout
self.utils.set_implicitly_wait()
# Call BasicTestCase setUp
super(SeleniumTestCase, self).setUp()
def module_driver_fixture(request):
previous_fails = request.session.testsfailed
yield None
DriverWrappersPool.close_drivers(
scope='module',
test_name=os.path.splitext(os.path.basename(request.node.name))[0],
test_passed=request.session.testsfailed == previous_fails)
def driver_wrapper():
"""Create a new mock element and a new driver before each test"""
global mock_element
mock_element = mock.MagicMock(spec=WebElement)
mock_element.find_element.return_value = child_element
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure wrapper
root_path = os.path.dirname(os.path.realpath(__file__))
config_files = ConfigFiles()
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
config_files.set_config_log_filename('logging.conf')
DriverWrappersPool.configure_common_directories(config_files)
driver_wrapper.configure_properties()
driver_wrapper.driver = mock.MagicMock()
driver_wrapper.is_mobile_test = mock.MagicMock(return_value=False)
return driver_wrapper
def tearDownClass(cls):
# Call BasicTestCase tearDownClass
super(SeleniumTestCase, cls).tearDownClass()
# Close browser and stop driver if it has been reused
DriverWrappersPool.close_drivers_and_download_videos(cls.get_subclass_name())
SeleniumTestCase.driver = None
def tearDownClass(cls):
# Call BasicTestCase tearDownClass
super(SeleniumTestCase, cls).tearDownClass()
# Close browser and stop driver if it has been reused
DriverWrappersPool.close_drivers_and_download_videos(cls.get_subclass_name())
SeleniumTestCase.driver = None
def tearDown(self):
# Call BasicTestCase tearDown
super(SeleniumTestCase, self).tearDown()
# Close drivers
DriverWrappersPool.close_drivers(scope='function',
test_name=self.get_subclassmethod_name(),
test_passed=self._test_passed)
def setUp(self):
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
config_files = ConfigFiles()
config_files.set_config_directory(os.path.join(self.root_path, 'conf'))
config_files.set_output_directory(
os.path.join(self.root_path, 'output'))
DriverWrappersPool.configure_common_directories(config_files)
def setUp(self):
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(
DriverWrappersPool.get_default_config_directory())
# Get default driver wrapper and connect it
self.driver_wrapper = DriverWrappersPool.connect_default_driver_wrapper(
config_files=self.config_files)
SeleniumTestCase.driver = self.driver_wrapper.driver
self.utils = self.driver_wrapper.utils
# Monkey patching assert_screenshot method in PageElement to use the correct test name
file_suffix = self.get_method_name()
def assert_screenshot_page_element(self,
filename,
threshold=0,
exclude_elements=[],
force=False):
VisualTest(self.driver_wrapper,
force).assert_screenshot(self.web_element, filename,
file_suffix, threshold,
exclude_elements)
PageElement.assert_screenshot = assert_screenshot_page_element
# Call BasicTestCase setUp
super(SeleniumTestCase, self).setUp()
def configure_logger(self, tc_config_log_filename=None, tc_output_log_filename=None):
"""Configure selenium instance logger
:param tc_config_log_filename: test case specific logging config file
:param tc_output_log_filename: test case specific output logger file
"""
# Get config logger filename
config_log_filename = DriverWrappersPool.get_configured_value('Config_log_filename', tc_config_log_filename,
'logging.conf')
config_log_filename = os.path.join(DriverWrappersPool.config_directory, config_log_filename)
# Configure logger only if logging filename has changed
if self.config_log_filename != config_log_filename:
# Get output logger filename
output_log_filename = DriverWrappersPool.get_configured_value('Output_log_filename', tc_output_log_filename,
'toolium.log')
output_log_filename = os.path.join(DriverWrappersPool.output_directory, output_log_filename)
output_log_filename = output_log_filename.replace('\\', '\\\\')
try:
logging.config.fileConfig(config_log_filename, {'logfilename': output_log_filename}, False)
except Exception as exc:
print("[WARN] Error reading logging config file '{}': {}".format(config_log_filename, exc))
self.config_log_filename = config_log_filename
self.output_log_filename = output_log_filename
self.logger = logging.getLogger(__name__)
def tearDown(self):
# Call BasicTestCase tearDown
super(SeleniumTestCase, self).tearDown()
# Close drivers
DriverWrappersPool.close_drivers(
scope='function',
test_name=self.get_subclassmethod_name(),
test_passed=self._test_passed)
def setUp(self):
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
if not self.driver_wrapper.driver and not self.config_files.config_directory:
# By default config directory is located in test path
self.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory())
super(AppiumTestCase, self).setUp()
AppiumTestCase.app_strings = self.driver_wrapper.app_strings
def driver_wrapper(request):
default_driver_wrapper = DriverWrappersPool.connect_default_driver_wrapper(
)
yield default_driver_wrapper
DriverWrappersPool.close_drivers(
scope='function',
test_name=request.node.name,
test_passed=not request.node.rep_call.failed)
def setUp(self):
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
if not self.driver_wrapper.driver and not self.config_files.config_directory:
# By default config directory is located in test path
self.config_files.set_config_directory(
DriverWrappersPool.get_default_config_directory())
super(AppiumTestCase, self).setUp()
AppiumTestCase.app_strings = self.driver_wrapper.app_strings
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.driver = mock.MagicMock()
return driver_wrapper
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.driver = mock.MagicMock()
return driver_wrapper
def test_close_drivers_function(scope, driver_wrapper):
DriverWrappersPool.save_all_webdriver_logs = mock.MagicMock()
# Close drivers
DriverWrappersPool.close_drivers(scope, 'test_name')
if scope == 'function':
# Check that save_all_webdriver_logs has been called
DriverWrappersPool.save_all_webdriver_logs.assert_called_once_with('test_name', True)
else:
# Check that save_all_webdriver_logs has not been called
DriverWrappersPool.save_all_webdriver_logs.assert_not_called()
def setUp(self):
# Configure logger and properties
if not isinstance(self, SeleniumTestCase):
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory())
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.configure(False, self.config_files)
# Get config and logger instances
self.config = self.driver_wrapper.config
self.logger = logging.getLogger(__name__)
self.logger.info("Running new test: %s", self.get_subclassmethod_name())
def setUp(self):
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
# Create default wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure properties
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.realpath(__file__))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
self.driver_wrapper.configure(tc_config_files=config_files)
def setUp(self):
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
config_files = ConfigFiles()
config_files.set_config_directory(os.path.join(self.root_path, 'conf'))
config_files.set_output_directory(os.path.join(self.root_path, 'output'))
DriverWrappersPool.configure_common_directories(config_files)
self.driver_wrapper.configure_properties()
def setUp(self):
# Configure logger and properties
if not isinstance(self, SeleniumTestCase):
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory())
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.configure(False, self.config_files)
# Get config and logger instances
self.config = self.driver_wrapper.config
self.logger = logging.getLogger(__name__)
self.logger.info("Running new test: {0}".format(self.get_subclassmethod_name()))
def setUp(self):
"""Create a new mock element and a new driver before each test"""
global mock_element
mock_element = mock.MagicMock(spec=WebElement)
mock_element.find_element.return_value = child_element
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.driver = mock.MagicMock()
def setUp(self):
"""Create a new mock element and a new driver before each test"""
global mock_element
mock_element = mock.MagicMock(spec=WebElement)
mock_element.find_element.return_value = child_element
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.driver = mock.MagicMock()
def setUp(self):
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
# Create default wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure properties
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.realpath(__file__))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
self.driver_wrapper.configure(tc_config_files=config_files)
def setUp(self):
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
config_files = ConfigFiles()
config_files.set_config_directory(os.path.join(self.root_path, 'conf'))
config_files.set_output_directory(
os.path.join(self.root_path, 'output'))
DriverWrappersPool.configure_common_directories(config_files)
self.driver_wrapper.configure_properties()
def __init__(self):
if not DriverWrappersPool.is_empty():
# Copy config object and other properties from default driver
default_wrapper = DriverWrappersPool.get_default_wrapper()
self.config = default_wrapper.config.deepcopy()
self.logger = default_wrapper.logger
self.config_properties_filenames = default_wrapper.config_properties_filenames
self.config_log_filename = default_wrapper.config_log_filename
self.output_log_filename = default_wrapper.output_log_filename
self.visual_baseline_directory = default_wrapper.visual_baseline_directory
self.baseline_name = default_wrapper.baseline_name
# Create utils instance and add wrapper to the pool
self.utils = Utils(self)
DriverWrappersPool.add_wrapper(self)
def setUp(self):
"""Create a new mock element and a new driver before each test"""
# Create a mock element
self.mock_element = mock.MagicMock(spec=WebElement)
self.mock_element.find_element.return_value = child_element
self.mock_element.text = 'text value'
self.mock_element.get_attribute.return_value = 'input text value'
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.driver = mock.MagicMock()
def setUp(self):
"""Create a new mock element and a new driver before each test"""
# Create a mock element
self.mock_element = mock.MagicMock(spec=WebElement)
self.mock_element.find_element.return_value = child_element
self.mock_element.text = 'text value'
self.mock_element.get_attribute.return_value = 'input text value'
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.driver = mock.MagicMock()
def __init__(self):
if not DriverWrappersPool.is_empty():
# Copy config object and other properties from default driver
default_wrapper = DriverWrappersPool.get_default_wrapper()
self.config = default_wrapper.config.deepcopy()
self.logger = default_wrapper.logger
self.config_properties_filenames = default_wrapper.config_properties_filenames
self.config_log_filename = default_wrapper.config_log_filename
self.output_log_filename = default_wrapper.output_log_filename
self.visual_baseline_directory = default_wrapper.visual_baseline_directory
self.baseline_name = default_wrapper.baseline_name
# Create utils instance and add wrapper to the pool
self.utils = Utils(self)
DriverWrappersPool.add_wrapper(self)
def tearDown(self):
# Call BasicTestCase tearDown
super(SeleniumTestCase, self).tearDown()
test_name = self.get_subclassmethod_name().replace('.', '_')
# Capture screenshot on error
if not self._test_passed:
DriverWrappersPool.capture_screenshots(test_name)
# Write Webdriver logs to files
self.utils.save_all_webdriver_logs(self.get_subclassmethod_name())
# Close browser and stop driver if it must not be reused
DriverWrappersPool.close_drivers_and_download_videos(test_name, self._test_passed, self.reuse_driver)
if not self.reuse_driver:
SeleniumTestCase.driver = None
def configure_properties(self,
tc_config_prop_filenames=None,
behave_properties=None):
"""Configure selenium instance properties
:param tc_config_prop_filenames: test case specific properties filenames
:param behave_properties: dict with behave user data properties
"""
prop_filenames = DriverWrappersPool.get_configured_value(
'Config_prop_filenames', tc_config_prop_filenames,
'properties.cfg;local-properties.cfg')
prop_filenames = [
os.path.join(DriverWrappersPool.config_directory, filename)
for filename in prop_filenames.split(';')
]
prop_filenames = ';'.join(prop_filenames)
# Configure config only if properties filename has changed
if self.config_properties_filenames != prop_filenames:
# Initialize the config object
self.config = ExtendedConfigParser.get_config_from_file(
prop_filenames)
self.config_properties_filenames = prop_filenames
# Override properties with system properties
self.config.update_properties(os.environ)
# Override properties with behave userdata properties
if behave_properties:
self.config.update_properties(behave_properties)
def test_find_parent_directory_relative():
directory = 'conf'
filename = 'properties.cfg'
expected_config_directory = os.path.join(os.getcwd(), 'conf')
assert expected_config_directory == DriverWrappersPool._find_parent_directory(
directory, filename)
def test_find_parent_directory_file_not_found():
directory = 'conf'
filename = 'unknown'
expected_config_directory = os.path.join(os.getcwd(), 'conf')
assert expected_config_directory == DriverWrappersPool._find_parent_directory(
directory, filename)
def _initialize_config_files(tc_config_files=None):
"""Initialize config files and update config files names with the environment
:param tc_config_files: test case specific config files
:returns: initialized config files object
"""
# Initialize config files
if tc_config_files is None:
tc_config_files = ConfigFiles()
# Update properties and log file names if an environment is configured
env = DriverWrappersPool.get_configured_value('Config_environment', None, None)
if env:
# Update config properties filenames
prop_filenames = tc_config_files.config_properties_filenames
new_prop_filenames_list = prop_filenames.split(';') if prop_filenames else ['properties.cfg']
base = new_prop_filenames_list[0].split('.')[0]
ext = new_prop_filenames_list[0].split('.')[1]
new_prop_filenames_list.append('{}-{}.{}'.format(env, base, ext))
new_prop_filenames_list.append('local-{}-{}.{}'.format(env, base, ext))
tc_config_files.set_config_properties_filenames(*new_prop_filenames_list)
# Update output log filename
output_log_filename = tc_config_files.output_log_filename
base = output_log_filename.split('.')[0] if output_log_filename else 'toolium'
ext = output_log_filename.split('.')[1] if output_log_filename else 'log'
tc_config_files.set_output_log_filename('{}_{}.{}'.format(base, env, ext))
return tc_config_files
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
new_driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure wrapper
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.realpath(__file__))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
config_files.set_config_log_filename('logging.conf')
new_driver_wrapper.configure(config_files)
return new_driver_wrapper
def __init__(self, driver_wrapper=None):
"""Initialize Utils instance
:param driver_wrapper: driver wrapper instance
"""
self.driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper()
# Configure logger
self.logger = logging.getLogger(__name__)
def tearDown(self):
# Call BasicTestCase tearDown
super(SeleniumTestCase, self).tearDown()
test_name = self.get_subclassmethod_name().replace('.', '_')
# Capture screenshot on error
if not self._test_passed:
DriverWrappersPool.capture_screenshots(test_name)
# Write Webdriver logs to files
self.utils.save_all_webdriver_logs(self.get_subclassmethod_name())
# Close browser and stop driver if it must not be reused
DriverWrappersPool.close_drivers_and_download_videos(
test_name, self._test_passed, self.reuse_driver)
if not self.reuse_driver:
SeleniumTestCase.driver = None
def driver_wrapper():
# Create a mock element
global mock_element
mock_element = mock.MagicMock(spec=WebElement)
mock_element.find_element.return_value = child_element
mock_element.text = 'text value'
mock_element.get_attribute.return_value = 'input text value'
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.driver = mock.MagicMock()
return driver_wrapper
def __init__(self, driver_wrapper=None):
"""Initialize Utils instance
:param driver_wrapper: driver wrapper instance
"""
self.driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper()
# Configure logger
self.logger = logging.getLogger(__name__)
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
new_driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure wrapper
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.realpath(__file__))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
config_files.set_config_log_filename('logging.conf')
new_driver_wrapper.configure(config_files)
return new_driver_wrapper
def driver_wrapper():
# Create a mock element
global mock_element
mock_element = mock.MagicMock(spec=WebElement)
mock_element.find_element.return_value = child_element
mock_element.text = 'text value'
mock_element.get_attribute.return_value = 'input text value'
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.driver = mock.MagicMock()
return driver_wrapper
def __init__(self, driver_wrapper=None, force=False):
self.driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper(
)
self.force = force
if not self.driver_wrapper.config.getboolean_optional(
'VisualTests', 'enabled') and not self.force:
return
if 'PerceptualEngine' not in globals():
raise Exception(
'The visual tests are enabled, but needle is not installed')
self.utils = self.driver_wrapper.utils
self.logger = logging.getLogger(__name__)
self.output_directory = DriverWrappersPool.visual_output_directory
# Update baseline with real platformVersion value
if '{platformVersion}' in self.driver_wrapper.baseline_name:
platform_version = self.driver_wrapper.driver.desired_capabilities[
'platformVersion']
baseline_name = self.driver_wrapper.baseline_name.replace(
'{platformVersion}', platform_version)
self.driver_wrapper.baseline_name = baseline_name
self.driver_wrapper.visual_baseline_directory = os.path.join(
DriverWrappersPool.output_directory, 'visualtests', 'baseline',
baseline_name)
self.baseline_directory = self.driver_wrapper.visual_baseline_directory
engine_type = self.driver_wrapper.config.get_optional(
'VisualTests', 'engine', 'pil')
if engine_type == 'perceptualdiff':
self.engine = PerceptualEngine()
# elif engine_type == 'imagemagick':
# self.engine = MagickEngine()
elif engine_type == 'pil':
self.engine = PilEngine()
else:
self.logger.warn(
"Engine '{}' not found, using pil instead. Review your properties.cfg file."
.format(engine_type))
self.engine = PilEngine()
self.save_baseline = self.driver_wrapper.config.getboolean_optional(
'VisualTests', 'save')
# Create folders
if not os.path.exists(self.baseline_directory):
os.makedirs(self.baseline_directory)
if not os.path.exists(self.output_directory):
os.makedirs(self.output_directory)
# Copy html template to output directory
orig_template_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'resources',
self.template_name)
dst_template_path = os.path.join(self.output_directory,
self.report_name)
if not os.path.exists(dst_template_path):
shutil.copyfile(orig_template_path, dst_template_path)
self._add_summary_to_report()
def driver_wrapper():
# Create a new wrapper
new_driver_wrapper = DriverWrappersPool.get_default_wrapper()
# Configure wrapper
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.realpath(__file__))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_output_directory(os.path.join(root_path, 'output'))
DriverWrappersPool.configure_common_directories(config_files)
yield new_driver_wrapper
# Remove environment properties after test
try:
del os.environ["Config_log_filename"]
except KeyError:
pass
def setUp(self):
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
self.driver_wrapper.driver = mock.MagicMock()
# Configure properties
self.root_path = os.path.dirname(os.path.realpath(__file__))
config_files = ConfigFiles()
config_files.set_config_directory(os.path.join(self.root_path, 'conf'))
config_files.set_config_properties_filenames('properties.cfg')
config_files.set_output_directory(os.path.join(self.root_path, 'output'))
self.driver_wrapper.configure(tc_config_files=config_files)
# Create a new Utils instance
self.utils = Utils()
def driver_wrapper():
# Configure properties
config_files = ConfigFiles()
root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_config_properties_filenames('properties.cfg')
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.configure(config_files)
return driver_wrapper
def configure(self, is_selenium_test=True, tc_config_files=ConfigFiles()):
"""Configure initial selenium instance using logging and properties files for Selenium or Appium tests
:param is_selenium_test: true if test is a selenium or appium test case
:param tc_config_files: test case specific config files
"""
# Configure config and output directories
DriverWrappersPool.configure_common_directories(tc_config_files)
# Configure logger
self.configure_logger(tc_config_files.config_log_filename, tc_config_files.output_log_filename)
# Initialize the config object
self.configure_properties(tc_config_files.config_properties_filenames)
# Configure visual directories
if is_selenium_test:
driver_info = self.config.get('Driver', 'type').replace('-', '_')
DriverWrappersPool.configure_visual_directories(driver_info)
self.configure_visual_baseline()
def setUp(self):
# Get default driver wrapper
self.driver_wrapper = DriverWrappersPool.get_default_wrapper()
if not SeleniumTestCase.driver:
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory())
# Create driver
self.driver_wrapper.configure(True, self.config_files)
self.driver_wrapper.connect()
SeleniumTestCase.driver = self.driver_wrapper.driver
self.utils = self.driver_wrapper.utils
# Get common configuration of reusing driver
self.reuse_driver = self.driver_wrapper.config.getboolean_optional('Driver', 'reuse_driver')
# Set implicitly wait
self.utils.set_implicit_wait()
# Call BasicTestCase setUp
super(SeleniumTestCase, self).setUp()
def setUp(self):
# By default config directory is located in test path
if not self.config_files.config_directory:
self.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory())
# Get default driver wrapper and connect it
self.driver_wrapper = DriverWrappersPool.connect_default_driver_wrapper(config_files=self.config_files)
SeleniumTestCase.driver = self.driver_wrapper.driver
self.utils = self.driver_wrapper.utils
# Monkey patching assert_screenshot method in PageElement to use the correct test name
file_suffix = self.get_method_name()
def assert_screenshot_page_element(self, filename, threshold=0, exclude_elements=[], force=False):
VisualTest(self.driver_wrapper, force).assert_screenshot(self.web_element, filename, file_suffix,
threshold, exclude_elements)
PageElement.assert_screenshot = assert_screenshot_page_element
# Call BasicTestCase setUp
super(SeleniumTestCase, self).setUp()
def test_configure_environment(driver_wrapper):
# Check previous values
assert driver_wrapper.config.get('Driver', 'type') == 'firefox'
# Change environment and try to configure again
os.environ["Config_environment"] = 'android'
config_files = DriverWrappersPool.initialize_config_files(ConfigFiles())
driver_wrapper.configure(config_files)
del os.environ["Config_environment"]
# Check that configuration has been initialized
assert driver_wrapper.config.get('Driver', 'type') == 'android'
def test_singleton(driver_wrapper):
# Request default wrapper
new_wrapper = DriverWrappersPool.get_default_wrapper()
# Modify new wrapper
new_driver_type = 'opera'
new_wrapper.config.set('Driver', 'type', new_driver_type)
# Check that both wrappers are the same object
assert new_driver_type == driver_wrapper.config.get('Driver', 'type')
assert new_driver_type == new_wrapper.config.get('Driver', 'type')
assert driver_wrapper == new_wrapper
assert DriverWrappersPool.driver_wrappers[0] == driver_wrapper
def test_singleton(self):
# Request default wrapper
new_wrapper = DriverWrappersPool.get_default_wrapper()
# Modify new wrapper
new_driver_type = 'opera'
new_wrapper.config.set('Driver', 'type', new_driver_type)
# Check that both wrappers are the same object
assert_equal(new_driver_type, self.driver_wrapper.config.get('Driver', 'type'))
assert_equal(new_driver_type, new_wrapper.config.get('Driver', 'type'))
assert_equal(self.driver_wrapper, new_wrapper)
assert_equal(DriverWrappersPool.driver_wrappers[0], self.driver_wrapper)
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.driver = mock.MagicMock()
# Configure properties
root_path = os.path.dirname(os.path.realpath(__file__))
config_files = ConfigFiles()
config_files.set_config_directory(os.path.join(root_path, 'conf'))
config_files.set_config_properties_filenames('properties.cfg')
config_files.set_output_directory(os.path.join(root_path, 'output'))
driver_wrapper.configure(config_files)
yield driver_wrapper
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
def save_jira_conf():
"""Read Jira configuration from properties file and save it"""
global enabled, execution_url, summary_prefix, labels, comments, fix_version, build, only_if_changes, attachments
config = DriverWrappersPool.get_default_wrapper().config
enabled = config.getboolean_optional('Jira', 'enabled')
execution_url = config.get_optional('Jira', 'execution_url')
summary_prefix = config.get_optional('Jira', 'summary_prefix')
labels = config.get_optional('Jira', 'labels')
comments = config.get_optional('Jira', 'comments')
fix_version = config.get_optional('Jira', 'fixversion')
build = config.get_optional('Jira', 'build')
only_if_changes = config.getboolean_optional('Jira', 'onlyifchanges')
attachments = []
def __init__(self, driver_wrapper=None, force=False):
self.driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper()
self.force = force
if not self.driver_wrapper.config.getboolean_optional('VisualTests', 'enabled') and not self.force:
return
if 'PerceptualEngine' not in globals():
raise Exception('The visual tests are enabled, but needle is not installed')
self.utils = self.driver_wrapper.utils
self.logger = logging.getLogger(__name__)
self.output_directory = DriverWrappersPool.visual_output_directory
# Update baseline with real platformVersion value
if '{platformVersion}' in self.driver_wrapper.baseline_name:
platform_version = self.driver_wrapper.driver.desired_capabilities['platformVersion']
baseline_name = self.driver_wrapper.baseline_name.replace('{platformVersion}', platform_version)
self.driver_wrapper.baseline_name = baseline_name
self.driver_wrapper.visual_baseline_directory = os.path.join(DriverWrappersPool.visual_baseline_directory,
baseline_name)
self.baseline_directory = self.driver_wrapper.visual_baseline_directory
engine_type = self.driver_wrapper.config.get_optional('VisualTests', 'engine', 'pil')
if engine_type == 'perceptualdiff':
self.engine = PerceptualEngine()
elif engine_type == 'imagemagick':
if 'MagickEngine' not in globals():
self.logger.warn("Engine '{}' not found, using pil instead. It should be installed "
"the master version of needle, not the 0.3.".format(engine_type))
self.engine = PilEngine()
else:
self.engine = MagickEngine()
elif engine_type == 'pil':
self.engine = PilEngine()
else:
self.logger.warn(
"Engine '{}' not found, using pil instead. Review your properties.cfg file.".format(engine_type))
self.engine = PilEngine()
self.save_baseline = self.driver_wrapper.config.getboolean_optional('VisualTests', 'save')
# Create folders
if not os.path.exists(self.baseline_directory):
os.makedirs(self.baseline_directory)
if not os.path.exists(self.output_directory):
os.makedirs(self.output_directory)
# Copy html template to output directory
orig_template_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'resources', self.template_name)
dst_template_path = os.path.join(self.output_directory, self.report_name)
if not os.path.exists(dst_template_path):
shutil.copyfile(orig_template_path, dst_template_path)
self._add_summary_to_report()
def test_jira_annotation_pass(logger):
# Configure jira module
config = DriverWrappersPool.get_default_wrapper().config
try:
config.add_section('Jira')
except Exception:
pass
config.set('Jira', 'enabled', 'true')
# Execute method with jira annotation
MockTestClass().mock_test_pass()
# Check jira status
expected_status = {'TOOLIUM-1': ('TOOLIUM-1', 'Pass', None, [])}
assert expected_status == jira.jira_tests_status
def test_jira_annotation_fail(self):
# Configure jira module
config = DriverWrappersPool.get_default_wrapper().config
try:
config.add_section('Jira')
except Exception:
pass
config.set('Jira', 'enabled', 'true')
# Execute method with jira annotation
assert_raises(AssertionError, MockTestClass().mock_test_fail)
# Check jira status
expected_status = {'TOOLIUM-3': ('TOOLIUM-3', 'Fail', "The test 'test name' has failed: test error", [])}
assert_equal(expected_status, jira.jira_tests_status)
def test_jira_disabled(self):
# Configure jira module
config = DriverWrappersPool.get_default_wrapper().config
try:
config.add_section('Jira')
except Exception:
pass
config.set('Jira', 'enabled', 'false')
# Execute method with jira annotation
MockTestClass().mock_test_pass()
# Check jira status
expected_status = {}
assert_equal(expected_status, jira.jira_tests_status)
