class TestsDispatchAction(Action): ACTION = "tests" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self._logger = LoggingHelper(__name__) self.tests_dump_action = None self.tests_list_action = None self.tests_show_action = None self.tests_generate_configuration = None Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.tests_list_action = TestsListAction(parsers) self.tests_show_action = TestsShowAction(parsers) self.tests_generate_configuration = TestsGenerateConfiguration(parsers) self.tests_dump_action = TestsDumpAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") { TestsListAction.ACTION: self.tests_list_action, TestsShowAction.ACTION: self.tests_show_action, TestsGenerateConfiguration.ACTION: self.tests_generate_configuration, TestsDumpAction.ACTION: self.tests_dump_action }[configuration.TESTS_CMD].process_action(configuration)
class StatusDispatchAction(Action): ACTION = "status" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.status_list_action = StatusListAction(parsers) self.status_show_action = StatusShowAction(parsers) self.status_delete_action = StatusDeleteAction(parsers) self.status_dump_action = StatusDumpAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") { StatusListAction.ACTION: self.status_list_action, StatusShowAction.ACTION: self.status_show_action, StatusDeleteAction.ACTION: self.status_delete_action, StatusDumpAction.ACTION: self.status_dump_action }[configuration.STATUS_TYPE].process_action(configuration)
class TestsDispatchAction(Action): ACTION = "tests" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self._logger = LoggingHelper(__name__) self.tests_dump_action = None self.tests_list_action = None self.tests_show_action = None self.tests_generate_configuration = None Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.tests_list_action = TestsListAction(parsers) self.tests_show_action = TestsShowAction(parsers) self.tests_generate_configuration = TestsGenerateConfiguration(parsers) self.tests_dump_action = TestsDumpAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") {TestsListAction.ACTION: self.tests_list_action, TestsShowAction.ACTION: self.tests_show_action, TestsGenerateConfiguration.ACTION: self.tests_generate_configuration, TestsDumpAction.ACTION: self.tests_dump_action}[ configuration.TESTS_CMD].process_action(configuration)
def __init__(self, *params, **kwargs): self._logger = LoggingHelper(__name__) self.tests_dump_action = None self.tests_list_action = None self.tests_show_action = None self.tests_generate_configuration = None Action.__init__(self, *params, **kwargs)
class MetadataDispatchAction(Action): ACTION = "metadata" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self.metadata_diff_action = None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.metadata_diff_action = MetadataDiffAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") {MetadataDiffAction.ACTION: self.metadata_diff_action}[configuration.EXECUTE_TYPE]\ .process_action(configuration)
class MetadataDispatchAction(Action): ACTION = "metadata" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self.metadata_diff_action, self.metadata_report_action = None, None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.metadata_diff_action = MetadataDiffAction(parsers) self.metadata_report_action = MetadataReportAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") {MetadataDiffAction.ACTION: self.metadata_diff_action, MetadataReportAction.ACTION: self.metadata_report_action}[configuration.EXECUTE_TYPE]\ .process_action(configuration)
class ScenarioDispatchAction(Action): ACTION = "scenario" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self.scenario_list_action = None self.scenario_run_action = None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.scenario_list_action = ScenarioListAction(parsers) self.scenario_run_action = ScenarioAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") {ScenarioListAction.ACTION: self.scenario_list_action, ScenarioAction.ACTION: self.scenario_run_action}[configuration.EXECUTE_TYPE].process_action(configuration)
class StatusDispatchAction(Action): ACTION = "status" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.status_list_action = StatusListAction(parsers) self.status_show_action = StatusShowAction(parsers) self.status_delete_action = StatusDeleteAction(parsers) self.status_dump_action = StatusDumpAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") {StatusListAction.ACTION: self.status_list_action, StatusShowAction.ACTION: self.status_show_action, StatusDeleteAction.ACTION: self.status_delete_action, StatusDumpAction.ACTION: self.status_dump_action}[ configuration.STATUS_TYPE].process_action(configuration)
class ExecuteDispatchAction(Action): ACTION = "execute" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self.execute_running_list_action = None self.execute_test_scripts_action = None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.execute_running_list_action = ExecuteRunningListAction(parsers) self.execute_test_scripts_action = ExecuteTestScriptsAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") {ExecuteRunningListAction.ACTION: self.execute_running_list_action, ExecuteTestScriptsAction.ACTION: self.execute_test_scripts_action}[configuration.EXECUTE_TYPE]\ .process_action(configuration)
def initialize_db_connection_handler(): logger = LoggingHelper(__name__) logger.log_debug("initializing database") try: DatabaseConnectionHandler._connection_string = ConfigurationFileReader( ).read_file()[GENERAL][SQL_CONNECTION_STRING] DatabaseConnectionHandler.engine = create_engine( DatabaseConnectionHandler._connection_string, echo=False) Base.metadata.create_all(DatabaseConnectionHandler.engine) logger.log_debug("database initialization success") except KeyError: message = "Unable to read %s flag from section %s" % ( SQL_CONNECTION_STRING, GENERAL) print message logger.log_critical(message) exit(1)
class ScenarioDispatchAction(Action): ACTION = "scenario" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): self.scenario_list_action = None self.scenario_run_action = None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs) def fill_parser_arguments(self): parsers = self.parser.add_subparsers() self.scenario_list_action = ScenarioListAction(parsers) self.scenario_run_action = ScenarioAction(parsers) def process_action(self, configuration): self._logger.log_debug("Processing user request") { ScenarioListAction.ACTION: self.scenario_list_action, ScenarioAction.ACTION: self.scenario_run_action }[configuration.EXECUTE_TYPE].process_action(configuration)
def initialize_db_connection_handler(): logger = LoggingHelper(__name__) logger.log_debug("initializing database") try: DatabaseConnectionHandler._connection_string = ConfigurationFileReader().read_file()[GENERAL][ SQL_CONNECTION_STRING] DatabaseConnectionHandler.engine = create_engine(DatabaseConnectionHandler._connection_string, echo=False) Base.metadata.create_all(DatabaseConnectionHandler.engine) logger.log_debug("database initialization success") except KeyError: message = "Unable to read %s flag from section %s" % (SQL_CONNECTION_STRING, GENERAL) print message logger.log_critical(message) exit(1)
def __init__(self, *params, **kwargs): self._logger = LoggingHelper(__name__) self.tests_manager = TestsManager() Action.__init__(self, *params, **kwargs)
class ScenarioAction(Action): ACTION = "scenario" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): Action.__init__(self, *params, **kwargs) self._logger = LoggingHelper(__name__) def fill_parser_arguments(self): self.parser.add_argument("-u", "--usecase", help="Use case to execute", type=str, nargs=1) self.parser.add_argument("-c", "--config_files", help="Configuration files for test scripts", required=True, nargs="+") self.parser.add_argument("-t", "--test_scripts", type=str, nargs="+", help="Test scripts to execute", default="validate_use_case") self.parser.add_argument("-T", "--timeout", help="Timeout for scripts", type=int, nargs=1) self.parser.add_argument( "-g", "--debug", default=False, action="store_true", help= "Enables debugging mode which will stop tests execution after first failed test" ) self.parser.add_argument( "-x", "--return_tests_status_as_exit_code", action="store_true", default=False, help= "When flag set CTS framework will return calculate exit code basing on tests results." ) def process_action(self, configuration): print "Using CTS in version %s" % (ColorPrinter.format_text( BuildInformation.BUILD_VERSION, bold=True)) tests_manager = TestsManager() configuration_files = configuration.config_files test_scripts_configuration = get_configuration_from_files( configuration_files) if not configuration.usecase: print('\nMissing --usecase argument\n') JsonLoader().print_available_actions() sys.exit(64) # EX_USAGE = 64 command line usage error test_scripts_configuration['UseCase'] = configuration.usecase[0] if test_scripts_configuration is None: sys.exit(-1) if not certificates_files_are_valid(test_scripts_configuration): sys.exit(-1) test_plan = TestsPackagesContainer() if configuration.test_scripts: test_scripts_found = tests_manager.get_packages() test_scripts_found.filter(scripts=configuration.test_scripts, remove_empty=True) test_plan += test_scripts_found else: test_plan += tests_manager.get_packages() if not test_plan.packages: print('No script selected to execute') exit(64) # EX_USAGE = 64 command line usage error message = "Executing " print('Executing:') for package in test_plan.packages: for suite in package.suites: for script in suite.scripts: print "\t* %s from suite %s from package %s" % ( script.name, suite.name, package.name) message += "%s from suite %s from package %s, " % ( script.name, suite.name, package.name) self._logger.log_debug(message) if configuration.timeout is not None: message = "setting timeout execution to %s" % configuration.timeout[ 0] self._logger.log_debug(message) print "\n%s" % message test_plan.set_scripts_timeout(configuration.timeout[0]) execution_feed = ExecutionFeed(test_plan, test_scripts_configuration) for case in configuration.usecase: if not self.check_use_case_exist(case): print('\nUse Case was not found: %s ' % case) exit(64) # EX_USAGE = 64 command line usage error ScenarioAction.execute_configuration_group( execution_feed, test_status_as_exit_code=configuration. return_tests_status_as_exit_code)
def __init__(self, *params, **kwargs): self.scenario_list_action = None self.scenario_run_action = None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs)
class ExecuteTestScriptsAction(Action): ACTION = "tests" PARAM_NAME = "EXECUTE_TYPE" def __init__(self, *params, **kwargs): Action.__init__(self, *params, **kwargs) self._logger = LoggingHelper(__name__) def fill_parser_arguments(self): self.parser.add_argument("package", help="Test package to execute", type=str, nargs=1) self.parser.add_argument("-s", "--test_suites", type=str, nargs="+", help="Test suites to execute") self.parser.add_argument("-t", "--test_scripts", type=str, nargs="+", help="Test scripts to execute") self.parser.add_argument("-c", "--config_files", help="Configuration files for test scripts", required=True, nargs="+") self.parser.add_argument("-T", "--timeout", help="Timeout for scripts", type=int, nargs=1) self.parser.add_argument("-g", "--debug", default=False, action="store_true", help="Enables debugging mode which will stop tests execution after first failed test") self.parser.add_argument("-x", "--return_tests_status_as_exit_code", action="store_true", default=False, help="When flag set CTS framework will return calculate exit code basing on tests results.") # self.parser.add_argument("-m", "--metadata", help="Choose metadata", choices=['RSD', 'redfish'], default='RSD') def process_action(self, configuration): print "Using CTS in version %s" % (ColorPrinter.format_text(BuildInformation.BUILD_VERSION, bold=True)) tests_manager = TestsManager() configuration_files = configuration.config_files test_scripts_configuration = get_configuration_from_files(configuration_files) if test_scripts_configuration is None: sys.exit(-1) if not certificates_files_are_valid(test_scripts_configuration): sys.exit(-1) test_plan = TestsPackagesContainer() if configuration.test_suites or configuration.test_scripts: if configuration.test_suites: test_suites_found = tests_manager.get_packages() test_suites_found.filter(packages=configuration.package, suites=configuration.test_suites, remove_empty=True) test_plan += test_suites_found if configuration.test_scripts: test_scripts_found = tests_manager.get_packages() test_scripts_found.filter(packages=configuration.package, scripts=configuration.test_scripts, remove_empty=True) test_plan += test_scripts_found else: test_plan += tests_manager.get_packages() test_plan.filter(packages=configuration.package) if not test_plan.packages: print "No script selected to execute" exit(64) # EX_USAGE = 64 command line usage error message = "Executing " print "Executing:" for package in test_plan.packages: for suite in package.suites: for script in suite.scripts: print "\t* %s from suite %s from package %s" % (script.name, suite.name, package.name) message += "%s from suite %s from package %s, " % (script.name, suite.name, package.name) self._logger.log_debug(message) if configuration.timeout is not None: message = "setting timeout execution to %s" % configuration.timeout[0] self._logger.log_debug(message) print "\n%s" % message test_plan.set_scripts_timeout(configuration.timeout[0]) execution_feed = ExecutionFeed(test_plan, test_scripts_configuration) ExecuteTestScriptsAction.execute_configuration_group(execution_feed, test_status_as_exit_code=configuration.return_tests_status_as_exit_code) @staticmethod def execute_configuration_group(configuration_group, test_status_as_exit_code=None): """ :type configuration_group: cts_framework.tests_running.execution_feed.ExecutionFeed :type test_status_as_exit_code: bool """ test_run = TestRun() test_run.add_execution_feed(configuration_group) test_run.register_all() execution_status = test_run.run_all() if not execution_status and test_status_as_exit_code: print "Tests finished with status failed, exit code set to 4" exit(4)
def __init__(self, *params, **kwargs): self.execute_running_list_action = None self.execute_test_scripts_action = None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs)
class ReplayTestRunAction(Action): ACTION = "replay" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): Action.__init__(self, *params, **kwargs) self._logger = LoggingHelper(__name__) def fill_parser_arguments(self): self.parser.add_argument("replay_id", help="ID of the test script run to replay", type=str, nargs=1) def process_action(self, configuration): replay_id = configuration.replay_id[0] print "Using CTS in version %s to replay execution %s" \ % (ColorPrinter.format_text(BuildInformation.BUILD_VERSION, bold=True), replay_id) error, script_execution_id = split_replay_id(replay_id) if error: return # TODO: warn user when he tries to replay using newer CTS script_execution = ScriptDAO.get_script_execution_details( script_execution_id) if script_execution is None: cts_error( "Recording for script execution id={id:ignore} not found", id=script_execution_id) return script_path = script_execution.script_path configuration = self._configuration_from_string( script_execution.configuration) test_plan = self._prepare_test_plan(script_path) environ[ReplayController.CTS_REPLAY_SCRIPT_EXECUTION_ID] = str( script_execution_id) self._execute(configuration, test_plan) def _configuration_from_string(self, configuration_str): configuration = { b[0]: b[1] for b in (a.strip().split(' ', 1) for a in filter(None, configuration_str.split('--'))) } return configuration def _prepare_test_plan(self, script_path): test_plan = TestsPackagesContainer() tests_manager = TestsManager() test_scripts_found = tests_manager.get_packages() test_scripts_found.filter(script_paths=[script_path], remove_empty=True) test_plan += test_scripts_found if not test_plan.packages: print "Script to execute not found in any package" sys.exit(0) return test_plan def _execute(self, configuration, test_plan): """ :type configuration: dict :type test_plan: cts_framework.tests_managing.test_package.tests_packages_container.TestsPackagesContainer """ message = "Executing " print "Executing:" for package in test_plan.packages: for suite in package.suites: for script in suite.scripts: print "\t* %s from suite %s from package %s" % ( script.name, suite.name, package.name) message += "%s from suite %s from package %s, " % ( script.name, suite.name, package.name) self._logger.log_debug(message) execution_feed = ExecutionFeed(test_plan, configuration) ExecuteTestScriptsAction.execute_configuration_group(execution_feed)
class ExecuteTestScriptsAction(Action): ACTION = "tests" PARAM_NAME = "EXECUTE_TYPE" def __init__(self, *params, **kwargs): Action.__init__(self, *params, **kwargs) self._logger = LoggingHelper(__name__) def fill_parser_arguments(self): self.parser.add_argument("package", help="Test package to execute", type=str, nargs=1) self.parser.add_argument("-s", "--test_suites", type=str, nargs="+", help="Test suites to execute") self.parser.add_argument("-t", "--test_scripts", type=str, nargs="+", help="Test scripts to execute") self.parser.add_argument("-c", "--config_files", help="Configuration files for test scripts", required=True, nargs="+") self.parser.add_argument("-T", "--timeout", help="Timeout for scripts", type=int, nargs=1) self.parser.add_argument( "-g", "--debug", default=False, action="store_true", help= "Enables debugging mode which will stop tests execution after first failed test" ) self.parser.add_argument( "-x", "--return_tests_status_as_exit_code", action="store_true", default=False, help= "When flag set CTS framework will return calculate exit code basing on tests results." ) # self.parser.add_argument("-m", "--metadata", help="Choose metadata", choices=['RSD', 'redfish'], default='RSD') def process_action(self, configuration): print "Using CTS in version %s" % (ColorPrinter.format_text( BuildInformation.BUILD_VERSION, bold=True)) tests_manager = TestsManager() configuration_files = configuration.config_files test_scripts_configuration = get_configuration_from_files( configuration_files) if test_scripts_configuration is None: sys.exit(-1) if not certificates_files_are_valid(test_scripts_configuration): sys.exit(-1) test_plan = TestsPackagesContainer() if configuration.test_suites or configuration.test_scripts: if configuration.test_suites: test_suites_found = tests_manager.get_packages() test_suites_found.filter(packages=configuration.package, suites=configuration.test_suites, remove_empty=True) test_plan += test_suites_found if configuration.test_scripts: test_scripts_found = tests_manager.get_packages() test_scripts_found.filter(packages=configuration.package, scripts=configuration.test_scripts, remove_empty=True) test_plan += test_scripts_found else: test_plan += tests_manager.get_packages() test_plan.filter(packages=configuration.package) if not test_plan.packages: print "No script selected to execute" exit(64) # EX_USAGE = 64 command line usage error message = "Executing " print "Executing:" for package in test_plan.packages: for suite in package.suites: for script in suite.scripts: print "\t* %s from suite %s from package %s" % ( script.name, suite.name, package.name) message += "%s from suite %s from package %s, " % ( script.name, suite.name, package.name) self._logger.log_debug(message) if configuration.timeout is not None: message = "setting timeout execution to %s" % configuration.timeout[ 0] self._logger.log_debug(message) print "\n%s" % message test_plan.set_scripts_timeout(configuration.timeout[0]) execution_feed = ExecutionFeed(test_plan, test_scripts_configuration) ExecuteTestScriptsAction.execute_configuration_group( execution_feed, test_status_as_exit_code=configuration. return_tests_status_as_exit_code) @staticmethod def execute_configuration_group(configuration_group, test_status_as_exit_code=None): """ :type configuration_group: cts_framework.tests_running.execution_feed.ExecutionFeed :type test_status_as_exit_code: bool """ test_run = TestRun() test_run.add_execution_feed(configuration_group) test_run.register_all() execution_status = test_run.run_all() if not execution_status and test_status_as_exit_code: print "Tests finished with status failed, exit code set to 4" exit(4)
def __init__(self, *params, **kwargs): Action.__init__(self, *params, **kwargs) self._logger = LoggingHelper(__name__)
class ScenarioAction(Action): ACTION = "scenario" PARAM_NAME = "ACTION" def __init__(self, *params, **kwargs): Action.__init__(self, *params, **kwargs) self._logger = LoggingHelper(__name__) def fill_parser_arguments(self): self.parser.add_argument("-u", "--usecase", help="Use case to execute", type=str, nargs=1) self.parser.add_argument("-c", "--config_files", help="Configuration files for test scripts", required=True, nargs="+") self.parser.add_argument("-t", "--test_scripts", type=str, nargs="+", help="Test scripts to execute", default="validate_use_case") self.parser.add_argument("-T", "--timeout", help="Timeout for scripts", type=int, nargs=1) self.parser.add_argument("-g", "--debug", default=False, action="store_true", help="Enables debugging mode which will stop tests execution after first failed test") self.parser.add_argument("-x", "--return_tests_status_as_exit_code", action="store_true", default=False, help="When flag set CTS framework will return calculate exit code basing on tests results.") def process_action(self, configuration): print "Using CTS in version %s" % (ColorPrinter.format_text(BuildInformation.BUILD_VERSION, bold=True)) tests_manager = TestsManager() configuration_files = configuration.config_files test_scripts_configuration = get_configuration_from_files(configuration_files) if not configuration.usecase: print('\nMissing --usecase argument\n') JsonLoader().print_available_actions() sys.exit(64) # EX_USAGE = 64 command line usage error test_scripts_configuration['UseCase'] = configuration.usecase[0] if test_scripts_configuration is None: sys.exit(-1) if not certificates_files_are_valid(test_scripts_configuration): sys.exit(-1) test_plan = TestsPackagesContainer() if configuration.test_scripts: test_scripts_found = tests_manager.get_packages() test_scripts_found.filter(scripts=configuration.test_scripts, remove_empty=True) test_plan += test_scripts_found else: test_plan += tests_manager.get_packages() if not test_plan.packages: print('No script selected to execute') exit(64) # EX_USAGE = 64 command line usage error message = "Executing " print('Executing:') for package in test_plan.packages: for suite in package.suites: for script in suite.scripts: print "\t* %s from suite %s from package %s" % (script.name, suite.name, package.name) message += "%s from suite %s from package %s, " % (script.name, suite.name, package.name) self._logger.log_debug(message) if configuration.timeout is not None: message = "setting timeout execution to %s" % configuration.timeout[0] self._logger.log_debug(message) print "\n%s" % message test_plan.set_scripts_timeout(configuration.timeout[0]) execution_feed = ExecutionFeed(test_plan, test_scripts_configuration) for case in configuration.usecase: if not self.check_use_case_exist(case): print('\nUse Case was not found: %s ' % case) exit(64) # EX_USAGE = 64 command line usage error ScenarioAction.execute_configuration_group(execution_feed, test_status_as_exit_code=configuration.return_tests_status_as_exit_code) @staticmethod def execute_configuration_group(configuration_group, test_status_as_exit_code=None): """ :type configuration_group: cts_framework.tests_running.execution_feed.ExecutionFeed :type test_status_as_exit_code: bool """ test_run = TestRun() test_run.add_execution_feed(configuration_group) test_run.register_all() execution_status = test_run.run_all() if not execution_status and test_status_as_exit_code: print "Tests finished with status failed, exit code set to 4" exit(4) @staticmethod def check_use_case_exist(sought_case): """ :param sought_case: use case name :return: bool """ use_cases, _ = JsonLoader().retrieve_available_actions() for case in use_cases: case_name = case['name'] if case_name == sought_case: return True elif case_name.lower() == sought_case.lower(): print('\nDo you mean use case: %s? (%s was not found)' % (case_name, sought_case)) exit(64) return False
def __init__(self, *params, **kwargs): self.metadata_diff_action, self.metadata_report_action = None, None self._logger = LoggingHelper(__name__) Action.__init__(self, *params, **kwargs)