def all_tests(self, key: str, config: Configuration) -> List[TestDefinition]: if not config: return [] includes = config.pop_optional(list, 'include') or [] excludes = config.pop_optional(list, 'exclude') or [] parameters = config.pop_optional(Configuration, 'parameters') or Configuration() all_tests = self.find_python_tests() PythonTestsProvider.validate_match_strings(all_tests, includes + excludes) # Instantiate tests selected for test in all_tests: test.selected = PythonTestsProvider.test_selected( test.name, includes, excludes) test_parameters_list = parameters.pop_raw(test.name) # If no parameters used, just create one empty set if test.selected and not test_parameters_list: test_parameters_list = [{}] if not isinstance(test_parameters_list, list): test_parameters_list = [test_parameters_list] for test_parameters in test_parameters_list: test.parameter_sets.append(test_parameters) parameters.ensure_consumed() config.ensure_consumed() return all_tests
def _create_test_controller(self, board: Board, settings: Configuration) -> TestController: tests = TestsConfig.create_tests(self.selected_tests(), board) testrunner = TestRunner( board=board, tests=tests, email_on_fail=settings.pop_optional(bool, 'email_on_fail', default=False), continue_on_fail=settings.pop_optional(bool, 'continue_on_fail', default=True)) controller = TestController(testrunner, log_func=log.info, verbose_log_func=log.notice, debug_log_func=log.debug) iterations = settings.pop_optional(int, 'iterations') if iterations: controller.run_condition = sc_run_n_iterations( ntimes=int(iterations)) return controller
def test_Configuration_pop_int_fails_if_not_int(): attribute = 'att' value = 'abc' config = Configuration({attribute: value}) with pytest.raises(ConfigurationError): config.pop(int, attribute)
def create_consoles(config: Optional[Configuration], system: SystemContext) -> Dict[str, ConsoleBase]: if not config: return {} consoles = {} serial = TargetFactory.create_serial( config.pop_optional(Configuration, 'serial'), system) if serial: consoles['serial'] = serial ssh = TargetFactory.create_ssh( config.pop_optional(Configuration, 'ssh'), system) if ssh: consoles['ssh'] = ssh while (config): console_name, console_dict = config.popitem() console_config = Configuration(console_dict) console_type = console_config.pop(str, 'type') if console_type == 'ssh': console = TargetFactory.create_ssh(console_config, system) elif console_type == 'serial': console = TargetFactory.create_serial(console_config, system) else: raise TargetConfigError( f'Unknown console type {console_type}. ' 'Console type must be "ssh" or "serial"') consoles[console_name] = console config.ensure_consumed() return consoles
def test_Configuration_pop_configuration(): attribute = 'att' value = {'a': 2} config = Configuration({attribute: value}) expected_value = Configuration(value) assert len(expected_value) == 1 assert config.pop(Configuration, attribute) == Configuration(value)
def create_consoles(config: Configuration, system: SystemContext) -> List[ConsoleBase]: if not config: return None, None serial = TargetFactory.create_serial(config.pop('serial'), system) ssh = TargetFactory.create_ssh(config.pop('ssh'), system) config.ensure_consumed() return serial, ssh
def parse_system_context(system_config: Configuration) -> SystemContext: if not system_config: return SystemContext() credentials = TargetFactory.parse_credentials(system_config.pop('credentials')) system = SystemContext(prompt_regex=system_config.pop('prompt_regex'), credentials=credentials) system_config.ensure_consumed() return system
def parse_credentials(credentials_config: Configuration) -> Credentials: if not credentials_config: return Credentials() credentials = Credentials( credentials_config.pop('login'), credentials_config.pop('password')) credentials_config.ensure_consumed() return credentials
def create_context(config: Configuration) -> PlumaContext: if not isinstance(config, Configuration): raise ValueError('Invalid configuration: The configuration passed ' 'should be a Configuration instance.') try: context = TargetConfig._create_context(config) except ConfigurationError as e: raise TargetConfigError(e) else: TargetConfig.print_context_settings(context) config.ensure_consumed() return context
def create_serial(serial_config: Configuration, system: SystemContext) -> ConsoleBase: if not serial_config: return None log.debug(f'Serial config = {serial_config}') port = serial_config.pop('port') if not port: raise TargetConfigError( 'Missing "port" attributes for serial console in the configuration file') serial = SerialConsole(port=port, baud=int(serial_config.pop('baud') or 115200), system=system) serial_config.ensure_consumed() return serial
def __populate_tests(self, tests_config: Configuration): self.tests = [] sequence = tests_config.pop('sequence') if sequence: self.tests = self.tests_from_sequence(sequence, self.test_providers)
def test_TargetFactory_create_ssh_should_use_password(ssh_config): password = '******' ssh_config['password'] = password console = TargetFactory.create_ssh(Configuration(ssh_config), SystemContext()) assert console.system.credentials.password == password
def test_TargetFactory_create_serial(serial_config): port = serial_config['port'] baudrate = serial_config['baud'] config = Configuration(copy.deepcopy(serial_config)) console = TargetFactory.create_serial(config, SystemContext()) assert console.port == port assert console.baud == baudrate
def test_TargetFactory_parse_credentials(): login = '******' password = '******' config = Configuration({'login': login, 'password': password}) creds = TargetFactory.parse_credentials(config) assert creds.login == login assert creds.password == password
def test_TargetFactory_create_ssh(ssh_config): target = ssh_config['target'] login = ssh_config['login'] config = Configuration(copy.deepcopy(ssh_config)) console = TargetFactory.create_ssh(config, SystemContext()) assert console.target == target assert console.system.credentials.login == login assert console.system.credentials.password is None
def __populate_tests(self, tests_config: Configuration): self.tests = [] sequence = tests_config.pop_optional(list, 'sequence', context='test config') if sequence: self.tests = self.tests_from_sequence(sequence, self.test_providers)
def test_TargetFactory_create_ssh_should_default_to_credentials(ssh_config): ssh_config.pop('login') credslogin = '******' credspassword = '******' system = SystemContext(credentials=Credentials(credslogin, credspassword)) console = TargetFactory.create_ssh(Configuration(ssh_config), system) assert console.system.credentials.login == credslogin assert console.system.credentials.password == credspassword
def test_TargetFactory_parse_variables_should_allow_variables_access(): var1 = 'abc' var1_value = 'def' var2 = 'def' var2_value = 3 vars_config = Configuration({var1: var1_value, var2: var2_value}) variables = TargetFactory.parse_variables(variables_config=vars_config) assert variables.get(var1) == var1_value assert variables.get(var2) == var2_value
def __init__(self, config: Configuration, test_providers: List[TestsProvider]): if not config or not isinstance(config, Configuration): raise ValueError( f'Null or invalid \'config\', which must be of type \'{Configuration}\'' ) if not test_providers: raise ValueError('Null test providers passed') if not isinstance(test_providers, list): test_providers = [test_providers] self.settings_config = config.pop(SETTINGS_SECTION, Configuration()) self.test_providers = test_providers self.tests = None self.__populate_tests(config) config.ensure_consumed()
def test_TargetFactory_create_ssh_should_prefer_ssh_credentials(ssh_config): sshlogin = ssh_config['login'] sshpassword = '******' ssh_config['password'] = sshpassword credslogin = '******' credspassword = '******' system = SystemContext(credentials=Credentials(credslogin, credspassword)) console = TargetFactory.create_ssh(Configuration(ssh_config), system) assert console.system.credentials.login == sshlogin assert console.system.credentials.password == sshpassword
def _create_test_controller(self, board: Board, settings: Configuration) -> TestController: testrunner = TestRunner( board=board, tests=TestsConfig.create_tests(self.selected_tests(), board), sequential=True, email_on_fail=settings.pop('email_on_fail', default=False), continue_on_fail=settings.pop('continue_on_fail', default=True), skip_tasks=settings.pop('skip_tasks', default=[]), use_testcore=settings.pop('board_test_sequence', default=False)) controller = TestController( testrunner, log_func=partial(log.log, level=LogLevel.INFO), verbose_log_func=partial(log.log, level=LogLevel.NOTICE), debug_log_func=partial(log.log, level=LogLevel.DEBUG)) iterations = settings.pop('iterations') if iterations: controller.run_condition = sc_run_n_iterations( ntimes=int(iterations)) return controller
def all_tests(self, key: str, config: Configuration) -> List[TestDefinition]: parameter_set = None if config: if not isinstance(config, Configuration): parameter_set = config else: parameter_set = config.content() return [ TestDefinition(key, testclass=DeviceActionRegistry.action_class(key), test_provider=self, parameter_sets=[parameter_set], selected=True) ]
def tests_from_action(action_key: str, action_config: Union[dict, Configuration], supported_actions: dict) -> List[TestDefinition]: '''Return a list of all test definitions for a specific action and action providers''' provider = supported_actions.get(action_key) if not provider: raise TestsConfigError( f'No test provider was found for sequence action "{action_key}".' f' Supported actions: {supported_actions.keys()}') if isinstance(action_config, dict): tests = provider.all_tests(key=action_key, config=Configuration(action_config)) else: tests = provider.all_tests(key=action_key, config=action_config) return tests
def test_TargetFactory_SoftPower_parameters_can_be_specified(mock_console): on_cmd = 'foo' off_cmd = 'bar' reboot_delay = 42 config = Configuration({ 'soft': { 'on_cmd': on_cmd, 'off_cmd': off_cmd, 'reboot_delay': reboot_delay } }) power = TargetFactory.create_power_control(config, mock_console) assert isinstance(power, SoftPower) assert power.on_cmd == on_cmd assert power.off_cmd == off_cmd assert power.reboot_delay == reboot_delay
def test_TargetFactory_create_power_control_should_create_ipp9258( mock_console): host = 'hosttest' outlet = 3 login = '******' password = '******' ipp_config = Configuration({ 'ippower9258': { 'host': host, 'outlet': outlet, 'login': login, 'password': password } }) power = TargetFactory.create_power_control(ipp_config, mock_console) assert isinstance(power, IPPowerPDU) assert power.host == host assert power.port == outlet assert power.username == login assert power.password == password
def all_tests(self, key: str, config: Configuration) -> List[TestDefinition]: if not config: return [] config_dict = config.content() selected_tests = [] for test_name in config_dict: try: test_parameters = config_dict[test_name] test_parameters['name'] = test_name test = TestDefinition(test_name, testclass=ShellTest, test_provider=self, parameter_sets=[test_parameters], selected=True) selected_tests.append(test) except Exception as e: raise TestsConfigError( f'Failed to parse script test "{test_name}":{os.linesep} {e}' ) return selected_tests
def create_ssh(ssh_config: Configuration, system: SystemContext) -> ConsoleBase: if not ssh_config: return None log.debug('SSH config = ' + json.dumps(ssh_config.content())) target = ssh_config.pop('target') login = ssh_config.pop('login', system.credentials.login) if not target or not login: raise TargetConfigError( 'Missing "target" or "login" attributes for SSH console in the configuration file') password = ssh_config.pop('password', system.credentials.password) ssh_config.ensure_consumed() # Create a new system config to override default credentials ssh_system = deepcopy(system) ssh_system.credentials.login = login ssh_system.credentials.password = password return SSHConsole(target, system=ssh_system)
def _create_context(config: Configuration) -> PlumaContext: variables = TargetFactory.parse_variables(config.pop('variables')) system = TargetFactory.parse_system_context(config.pop('system')) serial, ssh = TargetFactory.create_consoles(config.pop('console'), system) if not serial and not ssh: log.warning("No console defined in the device configuration file") power = TargetFactory.create_power_control( config.pop('power'), ssh) config.ensure_consumed() consoles = {} if serial: consoles['serial'] = serial if ssh: consoles['ssh'] = ssh board = Board('Test board', console=consoles, power=power, system=system) return PlumaContext(board, variables=variables)
def _create_context(config: Configuration) -> PlumaContext: variables = TargetFactory.parse_variables( config.pop_optional(Configuration, 'variables')) system = TargetFactory.parse_system_context( config.pop_optional(Configuration, 'system')) consoles = TargetFactory.create_consoles( config.pop_optional(Configuration, 'console'), system) serial = consoles.get('serial') ssh = consoles.get('ssh') if not serial and not ssh: log.warning("No console defined in the device configuration file") power = TargetFactory.create_power_control( config.pop_optional(Configuration, 'power'), ssh or serial) config.ensure_consumed() board = Board('Test board', console=consoles, power=power, system=system) return PlumaContext(board, variables=variables)
def test_TargetConfig_create_context_should_work_with_minimal_config( target_config): TargetConfig.create_context(Configuration(target_config))