def bdd_common_after_scenario(context_or_world, scenario, status): """Clean method that will be executed after each scenario in behave or lettuce :param context_or_world: behave context or lettuce world :param scenario: running scenario :param status: scenario status (passed, failed or skipped) """ # Get scenario name without spaces and behave data separator scenario_file_name = scenario.name.replace(' -- @', '_').replace(' ', '_') if status == 'skipped': return elif status == 'passed': test_status = 'Pass' test_comment = None context_or_world.logger.info("The scenario '{0}' has passed".format(scenario.name)) else: test_status = 'Fail' test_comment = "The scenario '{0}' has failed".format(scenario.name) DriverWrappersPool.capture_screenshots(scenario_file_name) context_or_world.logger.error(test_comment) # Write Webdriver logs to files context_or_world.utils.save_all_webdriver_logs(scenario.name) # Close browser and stop driver if it must not be reused reuse_driver = context_or_world.toolium_config.getboolean_optional('Driver', 'reuse_driver') DriverWrappersPool.close_drivers_and_download_videos(scenario_file_name, status == 'passed', reuse_driver) # Save test status to be updated later add_jira_status(get_jira_key_from_scenario(scenario), test_status, test_comment)
def driver_wrapper(): # Remove previous visual path root_path = os.path.dirname(os.path.realpath(__file__)) visual_path = os.path.join(root_path, 'output', 'visualtests') if os.path.exists(visual_path): shutil.rmtree(visual_path) # 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) driver_wrapper.config.set('VisualTests', 'enabled', 'true') yield driver_wrapper # Remove visual path visual_path = os.path.join(root_path, 'output', 'visualtests') if os.path.exists(visual_path): shutil.rmtree(visual_path) # Reset wrappers pool values DriverWrappersPool._empty_pool() DriverWrapper.config_properties_filenames = None
def before_all(context): """Initialization method that will be executed before the test execution :param context: behave context """ # Use pytest asserts if behave_pytest is installed install_pytest_asserts() # Get 'Config_environment' property from user input (e.g. -D Config_environment=ios) env = context.config.userdata.get('Config_environment') # Deprecated: Get 'env' property from user input (e.g. -D env=ios) env = env if env else context.config.userdata.get('env') if env: os.environ['Config_environment'] = env if not hasattr(context, 'config_files'): context.config_files = ConfigFiles() context.config_files = DriverWrappersPool.initialize_config_files(context.config_files) # By default config directory is located in environment path if not context.config_files.config_directory: context.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory()) context.global_status = {'test_passed': True} create_and_configure_wrapper(context) # Behave dynamic environment context.dyn_env = DynamicEnvironment(logger=context.logger)
def setUp(self): # Remove previous visual path visual_path = os.path.join(self.root_path, 'output', 'visualtests') if os.path.exists(visual_path): shutil.rmtree(visual_path) # 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 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) self.driver_wrapper.config.set('VisualTests', 'enabled', 'true') # Create a new VisualTest instance self.visual = VisualTest(self.driver_wrapper)
def bdd_common_after_scenario(context_or_world, scenario, status): """Clean method that will be executed after each scenario in behave or lettuce :param context_or_world: behave context or lettuce world :param scenario: running scenario :param status: scenario status (passed, failed or skipped) """ if status == 'skipped': return elif status == 'passed': test_status = 'Pass' test_comment = None context_or_world.logger.info("The scenario '%s' has passed", scenario.name) else: test_status = 'Fail' test_comment = "The scenario '%s' has failed" % scenario.name context_or_world.logger.error("The scenario '%s' has failed", scenario.name) context_or_world.global_status['test_passed'] = False # Close drivers DriverWrappersPool.close_drivers(scope='function', test_name=scenario.name, test_passed=status == 'passed', context=context_or_world) # Save test status to be updated later add_jira_status(get_jira_key_from_scenario(scenario), test_status, test_comment)
def before_all(context): """Initialization method that will be executed before the test execution :param context: behave context """ # Use pytest asserts if behave_pytest is installed install_pytest_asserts() # Get 'Config_environment' property from user input (e.g. -D Config_environment=ios) env = context.config.userdata.get('Config_environment') # Deprecated: Get 'env' property from user input (e.g. -D env=ios) env = env if env else context.config.userdata.get('env') if env: os.environ['Config_environment'] = env if not hasattr(context, 'config_files'): context.config_files = ConfigFiles() context.config_files = DriverWrappersPool.initialize_config_files( context.config_files) # By default config directory is located in environment path if not context.config_files.config_directory: context.config_files.set_config_directory( DriverWrappersPool.get_default_config_directory()) context.global_status = {'test_passed': True} create_and_configure_wrapper(context) # Behave dynamic environment context.dyn_env = DynamicEnvironment(logger=context.logger)
def bdd_common_after_scenario(context_or_world, scenario, status): """Clean method that will be executed after each scenario in behave or lettuce :param context_or_world: behave context or lettuce world :param scenario: running scenario :param status: scenario status (passed, failed or skipped) """ # Get scenario name without spaces and behave data separator scenario_file_name = scenario.name.replace(' -- @', '_').replace(' ', '_') if status == 'skipped': return elif status == 'passed': test_status = 'Pass' test_comment = None context_or_world.logger.info("The scenario '{0}' has passed".format( scenario.name)) else: test_status = 'Fail' test_comment = "The scenario '{0}' has failed".format(scenario.name) DriverWrappersPool.capture_screenshots(scenario_file_name) context_or_world.logger.error(test_comment) # Write Webdriver logs to files context_or_world.utils.save_all_webdriver_logs(scenario.name) # Close browser and stop driver if it must not be reused reuse_driver = context_or_world.toolium_config.getboolean_optional( 'Driver', 'reuse_driver') DriverWrappersPool.close_drivers_and_download_videos( scenario_file_name, status == 'passed', reuse_driver) # Save test status to be updated later add_jira_status(get_jira_key_from_scenario(scenario), test_status, test_comment)
def stop_reused_driver(context, video_name='multiple_tests'): """Close browser and stop driver if it has been reused :param context: behave context :param video_name: downloaded video name """ DriverWrappersPool.close_drivers_and_download_videos( video_name, context.global_status['test_passed']) context.global_status['test_passed'] = {'test_passed': True}
def tearDownClass(cls): # Remove visual path visual_path = os.path.join(cls.root_path, 'output', 'visualtests') if os.path.exists(visual_path): shutil.rmtree(visual_path) # Reset wrappers pool values DriverWrappersPool._empty_pool() DriverWrapper.config_properties_filenames = None
def bdd_common_after_all(context_or_world): """Common after all method in behave or lettuce :param context_or_world: behave context or lettuce world """ # Close browser and stop driver if it has been reused DriverWrappersPool.close_drivers_and_download_videos('multiple_tests') # Update tests status in Jira change_all_jira_status()
def bdd_common_after_all(context_or_world): """Common after all method in behave or lettuce :param context_or_world: behave context or lettuce world """ # Close drivers DriverWrappersPool.close_drivers(scope='session', test_name='multiple_tests', test_passed=context_or_world.global_status['test_passed']) # Update tests status in Jira change_all_jira_status()
def after_feature(context, feature): """Clean method that will be executed after each feature :param context: behave context :param feature: running feature """ # Behave dynamic environment context.dyn_env.execute_after_feature_steps(context) # Close drivers DriverWrappersPool.close_drivers(scope='module', test_name=feature.name, test_passed=context.global_status['test_passed'])
def create_and_configure_wrapper(context_or_world): """Create and configure driver wrapper in behave or lettuce tests :param context_or_world: behave context or lettuce world """ # Create default driver wrapper context_or_world.driver_wrapper = DriverWrappersPool.get_default_wrapper() context_or_world.utils = context_or_world.driver_wrapper.utils # Get behave userdata properties to override config properties try: behave_properties = context_or_world.config.userdata except AttributeError: behave_properties = None # Configure wrapper context_or_world.driver_wrapper.configure(True, context_or_world.config_files, behave_properties) # Copy config object context_or_world.toolium_config = context_or_world.driver_wrapper.config # Configure logger context_or_world.logger = logging.getLogger(__name__)
def __new__(cls, driver_wrapper=None): """Instantiate android or ios page object from base page object depending on driver configuration Base, Android and iOS page objects must be defined with following structure: FOLDER/base/MODULE_NAME.py class BasePAGE_OBJECT_NAME(MobilePageObject) FOLDER/android/MODULE_NAME.py class AndroidPAGE_OBJECT_NAME(BasePAGE_OBJECT_NAME) FOLDER/ios/MODULE_NAME.py class IosPAGE_OBJECT_NAME(BasePAGE_OBJECT_NAME) :param driver_wrapper: driver wrapper instance :returns: android or ios page object instance """ if cls.__name__.startswith('Base'): __driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper() __os_name = 'ios' if __driver_wrapper.is_ios_test() else 'android' __class_name = cls.__name__.replace('Base', __os_name.capitalize()) try: return getattr(importlib.import_module(cls.__module__), __class_name)(__driver_wrapper) except AttributeError: __module_name = cls.__module__.replace('.base.', '.{}.'.format(__os_name)) return getattr(importlib.import_module(__module_name), __class_name)(__driver_wrapper) else: return super(MobilePageObject, cls).__new__(cls)
def __new__(cls, driver_wrapper=None): """Instantiate android or ios page object from base page object depending on driver configuration Base, Android and iOS page objects must be defined with following structure: FOLDER/base/MODULE_NAME.py class BasePAGE_OBJECT_NAME(MobilePageObject) FOLDER/android/MODULE_NAME.py class AndroidPAGE_OBJECT_NAME(BasePAGE_OBJECT_NAME) FOLDER/ios/MODULE_NAME.py class IosPAGE_OBJECT_NAME(BasePAGE_OBJECT_NAME) :param driver_wrapper: driver wrapper instance :returns: android or ios page object instance """ if cls.__name__.startswith('Base'): __driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper( ) __os_name = 'ios' if __driver_wrapper.is_ios_test() else 'android' __class_name = cls.__name__.replace('Base', __os_name.capitalize()) try: return getattr(importlib.import_module(cls.__module__), __class_name)(__driver_wrapper) except AttributeError: __module_name = cls.__module__.replace( '.base.', '.{}.'.format(__os_name)) return getattr(importlib.import_module(__module_name), __class_name)(__driver_wrapper) else: return super(MobilePageObject, cls).__new__(cls)
def bdd_common_before_scenario(context_or_world, scenario): """Common scenario initialization in behave or lettuce :param context_or_world: behave context or lettuce world :param scenario: running scenario """ # Initialize and connect driver wrapper if not DriverWrappersPool.get_default_wrapper().driver: create_and_configure_wrapper(context_or_world) connect_wrapper(context_or_world) # Add assert screenshot methods with scenario configuration add_assert_screenshot_methods(context_or_world, scenario) # Configure Jira properties save_jira_conf() # Add implicitly wait implicitly_wait = context_or_world.toolium_config.get_optional( 'Driver', 'implicitly_wait') if context_or_world.driver and implicitly_wait: context_or_world.driver.implicitly_wait(implicitly_wait) context_or_world.logger.info("Running new scenario: {0}".format( scenario.name))
def __init__(self, by, value, parent=None, driver_wrapper=None, order=None): """Initialize the Group object with the given locator components. If parent is not None, find_elements will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param order: index value if the locator returns more than one element :param driver_wrapper: driver wrapper instance """ self.logger = logging.getLogger(__name__) #: logger instance self.locator = (by, value ) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.init_page_elements() self.reset_object(self.driver_wrapper)
def __init__(self, by, value, parent=None, order=None, wait=False, shadowroot=None, webview=False): """Initialize the PageElement object with the given locator components. If parent is not None, find_element will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param order: index value if the locator returns more than one element :param wait: True if the page element must be loaded in wait_until_loaded method of the container page object :param shadowroot: CSS SELECTOR of JS element where shadowroot tag appears :param webview: True if the element is in a mobile webiew """ super(PageElement, self).__init__() self.locator = (by, value ) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.wait = wait #: True if it must be loaded in wait_until_loaded method of the container page object self.shadowroot = shadowroot #: CSS SELECTOR of the shadowroot for encapsulated element self.webview = webview #: True if element is in a mobile webview self.driver_wrapper = DriverWrappersPool.get_default_wrapper( ) #: driver wrapper instance self.reset_object(self.driver_wrapper)
def __init__(self, by, value, parent=None, driver_wrapper=None, order=None, wait=False, webview=False, webview_context_selection_callback=None, webview_csc_args=None): """Initialize the Group object with the given locator components. If parent is not None, find_elements will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param driver_wrapper: driver wrapper instance :param order: index value if the locator returns more than one element :param wait: True if the page element must be loaded in wait_until_loaded method of the container page object :param shadowroot: CSS SELECTOR of JS element where shadowroot tag appears :param webview: True if the element is in a mobile webiew :param webview_context_selection_callback: method provided to select the desired webview context if automatic_context_selection is enabled. Must return a tuple (context, window_handle) for android, and a context for ios :param webview_csc_args: arguments list for webview_context_selection_callback """ self.logger = logging.getLogger(__name__) #: logger instance self.locator = (by, value) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.wait = wait #: True if it must be loaded in wait_until_loaded method of the container page object self.webview = webview #: True if element is in a mobile webview self.webview_context_selection_callback = webview_context_selection_callback #: callback for selection of the # webview context with automatic_context_selection self.webview_csc_args = webview_csc_args #: arguments list for the context selection callback method self.shadowroot = None #: Not implemented for Group yet self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.init_page_elements() self.reset_object(self.driver_wrapper)
def __init__(self, by, value, parent=None, page_element_class=None, order=None): """Initialize the PageElements object with the given locator components. If parent is not None, find_elements will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param order: index value if the locator returns more than one element :param page_element_class: class of page elements (PageElement, Button...) :param shadowroot: CSS SELECTOR of JS element where shadowroot tag appears """ super(PageElements, self).__init__() self.locator = (by, value ) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.shadowroot = None #: Not implemented for PageElements yet self.driver_wrapper = DriverWrappersPool.get_default_wrapper( ) #: driver wrapper instance # update instance element class or use PageElement class if page_element_class: self.page_element_class = page_element_class self._page_elements = [] self.reset_object(self.driver_wrapper)
def __init__(self, driver_wrapper=None): """Initialize page object properties and update their page elements :param driver_wrapper: driver wrapper instance """ super(PageObject, self).__init__() self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.init_page_elements() self.reset_object(self.driver_wrapper)
def __init__(self, driver_wrapper=None): """Initialize page object properties and update their page elements :param driver_wrapper: driver wrapper instance """ super(PageObject, self).__init__() self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.app_strings = self.driver_wrapper.app_strings #: mobile application strings self.init_page_elements() self._update_page_elements()
def __init__(self, driver_wrapper=None, wait=False): """Initialize page object properties and update their page elements :param driver_wrapper: driver wrapper instance :param wait: True if the page object must be loaded in wait_until_loaded method of the container page object """ super(PageObject, self).__init__() self.wait = wait #: True if it must be loaded in wait_until_loaded method of the container page object self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.init_page_elements() self.reset_object(self.driver_wrapper)
def before_scenario(context, scenario): """Scenario initialization :param context: behave context :param scenario: running scenario """ # Configure reset properties from behave tags if 'no_reset_app' in scenario.tags: os.environ[ 'TOOLIUM_APPIUMCAPABILITIES_NORESET'] = 'AppiumCapabilities_noReset=true' os.environ[ 'TOOLIUM_APPIUMCAPABILITIES_FULLRESET'] = 'AppiumCapabilities_fullReset=false' elif 'reset_app' in scenario.tags: os.environ[ 'TOOLIUM_APPIUMCAPABILITIES_NORESET'] = 'AppiumCapabilities_noReset=false' os.environ[ 'TOOLIUM_APPIUMCAPABILITIES_FULLRESET'] = 'AppiumCapabilities_fullReset=false' elif 'full_reset_app' in scenario.tags: os.environ[ 'TOOLIUM_APPIUMCAPABILITIES_NORESET'] = 'AppiumCapabilities_noReset=false' os.environ[ 'TOOLIUM_APPIUMCAPABILITIES_FULLRESET'] = 'AppiumCapabilities_fullReset=true' # Force to reset driver before each scenario if it has @reset_driver tag if 'reset_driver' in scenario.tags: DriverWrappersPool.stop_drivers() DriverWrappersPool.download_videos( 'multiple tests', context.global_status['test_passed']) DriverWrappersPool.save_all_ggr_logs( 'multiple tests', context.global_status['test_passed']) DriverWrappersPool.remove_drivers() context.global_status['test_passed'] = True # Skip android_only or ios_only scenarios if 'android_only' in scenario.tags and context.driver_wrapper.is_ios_test( ): scenario.skip('Android scenario') return elif 'ios_only' in scenario.tags and context.driver_wrapper.is_android_test( ): scenario.skip('iOS scenario') return # Read @no_driver tag no_driver = 'no_driver' in scenario.tags or 'no_driver' in scenario.feature.tags bdd_common_before_scenario(context, scenario, no_driver) # Behave dynamic environment context.dyn_env.execute_before_scenario_steps(context)
def setup_driver(scenario): """Scenario initialization :param scenario: running scenario """ if not hasattr(world, 'config_files'): world.config_files = ConfigFiles() # By default config directory is located in terrain path if not world.config_files.config_directory: world.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory()) bdd_common_before_scenario(world, scenario)
def setup_driver(scenario): """Scenario initialization :param scenario: running scenario """ if not hasattr(world, 'config_files'): world.config_files = ConfigFiles() # By default config directory is located in terrain path if not world.config_files.config_directory: world.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory()) world.global_status = {'test_passed': True} bdd_common_before_scenario(world, scenario)
def before_scenario(context, scenario): """Scenario initialization :param context: behave context :param scenario: running scenario """ # Configure reset properties from behave tags if 'no_reset_app' in scenario.tags: os.environ["AppiumCapabilities_noReset"] = 'true' os.environ["AppiumCapabilities_fullReset"] = 'false' elif 'reset_app' in scenario.tags: os.environ["AppiumCapabilities_noReset"] = 'false' os.environ["AppiumCapabilities_fullReset"] = 'false' elif 'full_reset_app' in scenario.tags: os.environ["AppiumCapabilities_noReset"] = 'false' os.environ["AppiumCapabilities_fullReset"] = 'true' # Force to reset driver before each scenario if it has @reset_driver tag if 'reset_driver' in scenario.tags: DriverWrappersPool.close_drivers_and_download_videos('multiple tests', context.global_status['test_passed']) context.global_status['test_passed'] = True # Skip android_only or ios_only scenarios if 'android_only' in scenario.tags and context.driver_wrapper.is_ios_test(): scenario.skip('Android scenario') return elif 'ios_only' in scenario.tags and context.driver_wrapper.is_android_test(): scenario.skip('iOS scenario') return # Read @no_driver tag no_driver = 'no_driver' in scenario.tags or 'no_driver' in scenario.feature.tags bdd_common_before_scenario(context, scenario, no_driver) # Behave dynamic environment context.dyn_env.execute_before_scenario_steps(context)
def setUp(self): # Remove previous visual path visual_path = os.path.join(self.root_path, 'output', 'visualtests') if os.path.exists(visual_path): shutil.rmtree(visual_path) # 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 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) self.driver_wrapper.config.set('VisualTests', 'enabled', 'true') # Create a new VisualTest instance self.visual = VisualTest(self.driver_wrapper)
def __init__(self, by, value, parent=None): """Initialize the PageElement object with the given locator components. If parent is not None, find_element will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) """ super(PageElement, self).__init__() self.locator = (by, value) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.driver_wrapper = DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self._web_element = None
def __init__(self, by, value, parent=None): """Initialize the PageElement object with the given locator components. If parent is not None, find_element will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) """ super(PageElement, self).__init__() self.locator = (by, value ) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.driver_wrapper = DriverWrappersPool.get_default_wrapper( ) #: driver wrapper instance self._web_element = None
def __init__(self, by, value, parent=None, order=None, wait=False): """Initialize the PageElement object with the given locator components. If parent is not None, find_element will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param order: index value if the locator returns more than one element :param wait: True if the page element must be loaded in wait_until_loaded method of the container page object """ super(PageElement, self).__init__() self.locator = (by, value) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.wait = wait #: True if it must be loaded in wait_until_loaded method of the container page object self.driver_wrapper = DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.reset_object(self.driver_wrapper)
def __init__(self, by, value, parent=None, driver_wrapper=None, order=None): """Initialize the Group object with the given locator components. If parent is not None, find_elements will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param order: index value if the locator returns more than one element :param driver_wrapper: driver wrapper instance """ self.logger = logging.getLogger(__name__) #: logger instance self.locator = (by, value) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.init_page_elements() self.reset_object(self.driver_wrapper)
def create_and_configure_wrapper(context_or_world): """Create and configure driver wrapper in behave or lettuce tests :param context_or_world: behave context or lettuce world """ # Create default driver wrapper context_or_world.driver_wrapper = DriverWrappersPool.get_default_wrapper() context_or_world.utils = context_or_world.driver_wrapper.utils # Configure wrapper context_or_world.driver_wrapper.configure(True, context_or_world.config_files) # Override properties with behave userdata properties context_or_world.driver_wrapper.config.update_from_behave_properties(context_or_world) # Copy config object context_or_world.toolium_config = context_or_world.driver_wrapper.config # Configure logger context_or_world.logger = logging.getLogger(__name__)
def before_all(context): """Initialization method that will be executed before the test execution :param context: behave context """ if not hasattr(context, 'config_files'): context.config_files = ConfigFiles() # By default config directory is located in environment path if not context.config_files.config_directory: context.config_files.set_config_directory(DriverWrappersPool.get_default_config_directory()) # Get 'env' property from user input (e.g. -D env=ios) env = context.config.userdata.get('env') if env: context.config_files.set_config_properties_filenames('properties.cfg', '{}-properties.cfg'.format(env), 'local-{}-properties.cfg'.format(env)) context.config_files.set_output_log_filename('toolium_{}.log'.format(env)) create_and_configure_wrapper(context)
def bdd_common_after_scenario(context_or_world, scenario, status): """Clean method that will be executed after each scenario in behave or lettuce :param context_or_world: behave context or lettuce world :param scenario: running scenario :param status: scenario status (passed, failed or skipped) """ # Get scenario name without spaces and behave data separator scenario_file_name = scenario.name.replace(' -- @', '_').replace(' ', '_') if status == 'skipped': return elif status == 'passed': test_status = 'Pass' test_comment = None context_or_world.logger.info("The scenario '%s' has passed", scenario.name) else: test_status = 'Fail' test_comment = "The scenario '%s' has failed" % scenario.name context_or_world.logger.error("The scenario '%s' has failed", scenario.name) # Capture screenshot on error DriverWrappersPool.capture_screenshots(scenario_file_name) # Save webdriver logs on error or if it is enabled test_passed = status == 'passed' DriverWrappersPool.save_all_webdriver_logs(scenario.name, test_passed) # Close browser and stop driver if it must not be reused restart_driver_fail = context_or_world.toolium_config.getboolean_optional( 'Driver', 'restart_driver_fail') maintain_default = context_or_world.reuse_driver and ( test_passed or not restart_driver_fail) DriverWrappersPool.close_drivers_and_download_videos( scenario_file_name, test_passed, maintain_default) # Start driver if it has been closed due to a failed test if context_or_world.reuse_driver and not test_passed and restart_driver_fail: start_driver(context_or_world) # Save test status to be updated later previous_status = context_or_world.global_status[ 'test_passed'] if context_or_world.reuse_driver else True context_or_world.global_status[ 'test_passed'] = previous_status and test_passed add_jira_status(get_jira_key_from_scenario(scenario), test_status, test_comment)
def __init__(self, by, value, parent=None, page_element_class=None, order=None): """Initialize the PageElements object with the given locator components. If parent is not None, find_elements will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param order: index value if the locator returns more than one element :param page_element_class: class of page elements (PageElement, Button...) """ super(PageElements, self).__init__() self.locator = (by, value) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.driver_wrapper = DriverWrappersPool.get_default_wrapper() #: driver wrapper instance # update instance element class or use PageElement class if page_element_class: self.page_element_class = page_element_class self._page_elements = [] self.reset_object(self.driver_wrapper)
def create_and_configure_wrapper(context_or_world): """Create and configure driver wrapper in behave or lettuce tests :param context_or_world: behave context or lettuce world """ # Create default driver wrapper context_or_world.driver_wrapper = DriverWrappersPool.get_default_wrapper() context_or_world.utils = context_or_world.driver_wrapper.utils # Configure wrapper context_or_world.driver_wrapper.configure(True, context_or_world.config_files) # Override properties with behave userdata properties context_or_world.driver_wrapper.config.update_from_behave_properties( context_or_world) # Copy config object context_or_world.toolium_config = context_or_world.driver_wrapper.config # Configure logger context_or_world.logger = logging.getLogger(__name__)
def before_all(context): """Initialization method that will be executed before the test execution :param context: behave context """ if not hasattr(context, 'config_files'): context.config_files = ConfigFiles() # By default config directory is located in environment path if not context.config_files.config_directory: context.config_files.set_config_directory( DriverWrappersPool.get_default_config_directory()) # Get 'env' property from user input (e.g. -D env=ios) env = context.config.userdata.get('env') if env: context.config_files.set_config_properties_filenames( 'properties.cfg', '{}-properties.cfg'.format(env), 'local-{}-properties.cfg'.format(env)) context.config_files.set_output_log_filename( 'toolium_{}.log'.format(env)) create_and_configure_wrapper(context)
def bdd_common_before_scenario(context_or_world, scenario): """Common scenario initialization in behave or lettuce :param context_or_world: behave context or lettuce world :param scenario: running scenario """ # Initialize and connect driver wrapper if not DriverWrappersPool.get_default_wrapper().driver: create_and_configure_wrapper(context_or_world) connect_wrapper(context_or_world) # Add assert screenshot methods with scenario configuration add_assert_screenshot_methods(context_or_world, scenario) # Configure Jira properties save_jira_conf() # Add implicitly wait implicitly_wait = context_or_world.toolium_config.get_optional('Driver', 'implicitly_wait') if context_or_world.driver and implicitly_wait: context_or_world.driver.implicitly_wait(implicitly_wait) context_or_world.logger.info("Running new scenario: {0}".format(scenario.name))
def __init__(self, by, value, parent=None, driver_wrapper=None, order=None, wait=False): """Initialize the Group object with the given locator components. If parent is not None, find_elements will be performed over it, instead of using the driver's method, so it can find nested elements. :param by: locator type :param value: locator value :param parent: parent element (WebElement, PageElement or locator tuple) :param driver_wrapper: driver wrapper instance :param order: index value if the locator returns more than one element :param wait: True if the page element must be loaded in wait_until_loaded method of the container page object :param shadowroot: CSS SELECTOR of JS element where shadowroot tag appears """ self.logger = logging.getLogger(__name__) #: logger instance self.locator = (by, value) #: tuple with locator type and locator value self.parent = parent #: element from which to find actual elements self.order = order #: index value if the locator returns more than one element self.wait = wait #: True if it must be loaded in wait_until_loaded method of the container page object self.shadowroot = None #: Not implemented for Group yet self.driver_wrapper = driver_wrapper if driver_wrapper else \ DriverWrappersPool.get_default_wrapper() #: driver wrapper instance self.init_page_elements() self.reset_object(self.driver_wrapper)