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))
