def execute_preparation_steps(self, iut, preparation_steps):
"""Execute the preparation steps for the environment provider on an IUT.
:param iut: IUT to prepare for execution.
:type iut: :obj:`environment_provider.lib.iut.Iut`
:param preparation_steps: Steps to execute to prepare an IUT.
:type preparation_steps: dict
"""
FORMAT_CONFIG.identifier = self.config.get("SUITE_ID")
try:
with self.lock:
dataset = self.dataset.copy()
dataset.add("config", self.config)
jsontas = JsonTas(dataset=dataset)
steps = {}
dataset.add("iut", iut)
dataset.add("steps", steps)
for step, definition in preparation_steps.items():
definition = OrderedDict(**definition)
self.logger.info("Executing step %r", step)
step_result = jsontas.run(json_data=definition)
self.logger.info("%r", step_result)
if not step_result:
self.logger.error("Failed to execute step %r", step)
return False, iut
steps[step] = step_result
except Exception as exception: # pylint:disable=broad-except
self.logger.error("Failure when preparing IUT %r", iut)
self.logger.error("%r", exception)
return False, iut
return True, iut
def main(args):
"""Entry point allowing external calls.
Args:
args ([str]): command line parameter list
"""
args = parse_args(args)
setup_logging(args.loglevel)
jsontas = JsonTas()
if args.dataset:
with open(args.dataset) as json_file:
dataset = json.load(json_file)
jsontas.dataset.merge(dataset)
data = jsontas.run(json_file=args.json_file)
if args.output:
with open(args.output, "w") as output_file:
json.dump(data, output_file)
else:
pprint(data)
class Iut: # pylint: disable=too-few-public-methods
"""Data object for IUTs."""
logger = logging.getLogger(__name__)
def __init__(self, product):
"""Initialize.
:param product: Dictionary to set attributes from.
Should be the response from pool plugin list.
:type product: dict
"""
self.test_runner = {}
self.config = Config()
self.config.set("scripts", [])
self.steps = {
"environment": self.load_environment,
"commands": self.commands
}
product["identity"] = PackageURL.from_string(product["identity"])
for key, value in product.items():
setattr(self, key, value)
self._product_dict = product
self.jsontas = JsonTas()
self.jsontas.dataset.add("iut", self._product_dict)
self.prepare()
def prepare(self):
"""Prepare IUT for testing."""
self.logger.info("Preparing IUT %r", self)
for step, definition in self.test_runner.get("steps", {}).items():
step_method = self.steps.get(step)
if step_method is None:
self.logger.error("Step %r does not exist. Available %r", step,
self.steps)
continue
self.logger.info("Executing step %r", step)
self.logger.info("Definition: %r", definition)
if isinstance(definition, list):
for sub_definition in definition:
sub_definition = OrderedDict(**sub_definition)
step_result = self.jsontas.run(json_data=sub_definition)
step_method(step_result)
else:
definition = OrderedDict(**definition)
step_result = self.jsontas.run(json_data=definition)
step_method(step_result)
@staticmethod
def load_environment(environment):
"""Load and set environment variables from IUT definition.
:param environment: Environment variables to set.
:type environment: dict
"""
for key, value in environment.items():
os.environ[key] = value
def commands(self, command):
"""Create scripts from commands and add them to IUT monitoring.
:param command: A command dictionary to prepare.
:type command: dict
"""
script_name = str(Path.cwd().joinpath(command.get("name")))
parameters = command.get("parameters", [])
with open(script_name, "w", encoding="utf-8") as script:
for line in command.get("script"):
script.write(f"{line}\n")
self.config.get("scripts").append({
"name": script_name,
"parameters": parameters
})
@property
def as_dict(self):
"""Return IUT as a dictionary."""
return self._product_dict
def __repr__(self):
"""Represent IUT as string."""
try:
return self._product_dict.get("identity").to_string()
except: # noqa pylint:disable=bare-except
return "Unknown"