def test_predownloaded_job_validation():
factory = Factory()
factory.validate_job_strict = True
job = factory.create_job(
"kvm01.jinja2", "sample_jobs/qemu-download-postprocess.yaml"
)
job.validate()
def setUp(self):
super().setUp()
self.testdef = os.path.join(
os.path.dirname(__file__), "testdefs", "params.yaml"
)
self.res_data = os.path.join(
os.path.dirname(__file__), "testdefs", "result-data.txt"
)
factory = Factory()
self.job = factory.create_kvm_job("sample_jobs/qemu-reboot.yaml", validate=True)
self.job.logger = DummyLogger()
self.job.validate()
self.ret = False
test_retry = [
action
for action in self.job.pipeline.actions
if action.name == "lava-test-retry"
][0]
self.skipped_shell = [
action
for action in test_retry.pipeline.actions
if action.name == "lava-test-shell"
][0]
print(self.skipped_shell.parameters["timeout"])
self.skipped_shell.logger = DummyLogger()
test_retry = [
action
for action in self.job.pipeline.actions
if action.name == "lava-test-retry"
][1]
self.fatal_shell = [
action
for action in test_retry.pipeline.actions
if action.name == "lava-test-shell"
][0]
def test_device_environment_validity(self):
"""
Use non-YAML syntax a bit like existing device config syntax.
Ensure this syntax is picked up as invalid.
"""
data = """
# YAML syntax.
overrides:
DEBEMAIL = "*****@*****.**"
DEBFULLNAME: "Neil Williams"
"""
factory = Factory()
job_parser = JobParser()
(rendered, _) = factory.create_device("bbb-01.jinja2")
device = NewDevice(yaml_safe_load(rendered))
sample_job_file = os.path.join(os.path.dirname(__file__),
"sample_jobs/uboot-ramdisk.yaml")
with open(sample_job_file) as sample_job_data:
job = job_parser.parse(sample_job_data,
device,
4212,
None,
"",
env_dut=data)
job.logger = DummyLogger()
self.assertEqual(job.parameters["env_dut"], data)
with self.assertRaises(JobError):
job.validate()
def test_overlay_noramdisk(self, which_mock):
parameters = {
"dispatcher": {}, # fake dispatcher parameter. Normally added by parser
"device_type": "beaglebone-black",
"job_name": "uboot-pipeline",
"job_timeout": "15m",
"action_timeout": "5m",
"priority": "medium",
"actions": {
"boot": {
"namespace": "common",
"method": "u-boot",
"commands": "ramdisk",
"prompts": ["linaro-test", "root@debian:~#"],
},
"deploy": {
"namespace": "common",
"ramdisk": {"url": ""},
"kernel": {"url": "zImage", "type": "zimage"},
"dtb": {"url": "broken.dtb"},
},
},
}
data = yaml_safe_load(Factory().create_device("bbb-01.jinja2")[0])
device = NewDevice(data)
ip_addr = dispatcher_ip(None)
parsed = []
kernel_addr = "0x83000000"
ramdisk_addr = "0x83000000"
dtb_addr = "0x88000000"
kernel = parameters["actions"]["deploy"]["kernel"]["url"]
ramdisk = parameters["actions"]["deploy"]["ramdisk"]["url"]
dtb = parameters["actions"]["deploy"]["dtb"]["url"]
substitution_dictionary = {
"{SERVER_IP}": ip_addr,
# the addresses need to be hexadecimal
"{KERNEL_ADDR}": kernel_addr,
"{DTB_ADDR}": dtb_addr,
"{RAMDISK_ADDR}": ramdisk_addr,
"{BOOTX}": "%s %s %s %s" % ("bootz", kernel_addr, ramdisk_addr, dtb_addr),
"{RAMDISK}": ramdisk,
"{KERNEL}": kernel,
"{DTB}": dtb,
}
params = device["actions"]["boot"]["methods"]
params["u-boot"]["ramdisk"]["commands"] = substitute(
params["u-boot"]["ramdisk"]["commands"], substitution_dictionary, drop=True
)
commands = params["u-boot"]["ramdisk"]["commands"]
self.assertIs(type(commands), list)
self.assertIn("tftp 0x83000000 zImage", commands)
self.assertNotIn("tftp 0x83000000 {RAMDISK}", commands)
self.assertNotIn("tftp 0x83000000 ", commands)
self.assertIn("setenv initrd_size ${filesize}", commands)
self.assertIn("tftp 0x88000000 broken.dtb", commands)
self.assertNotIn("setenv kernel_addr_r '{KERNEL_ADDR}'", commands)
self.assertNotIn("setenv initrd_addr_r '{RAMDISK_ADDR}'", commands)
self.assertNotIn("setenv fdt_addr_r '{DTB_ADDR}'", commands)
def setUp(self):
super().setUp()
data = yaml_safe_load(Factory().create_device("bbb-01.jinja2")[0])
self.device = NewDevice(data)
bbb_yaml = os.path.join(os.path.dirname(__file__),
"sample_jobs/uboot-nfs.yaml")
with open(bbb_yaml) as sample_job_data:
self.job_data = yaml_safe_load(sample_job_data)
def test_device_power(self):
factory = Factory()
(rendered, _) = factory.create_device("bbb-01.jinja2")
device = yaml_safe_load(rendered)
self.assertNotEqual(device["commands"].get("hard_reset", ""), "")
(rendered, _) = factory.create_device("kvm01.jinja2")
device = yaml_safe_load(rendered)
self.assertNotIn("commands", device)
def test_device_constants(self):
factory = Factory()
(rendered, _) = factory.create_device("bbb-01.jinja2")
device = NewDevice(yaml_safe_load(rendered))
self.assertIn("constants", device)
self.assertEqual(device.get_constant("kernel-start-message"),
"Linux version [0-9]")
self.assertRaises(ConfigurationError, device.get_constant,
("non-existing-const"))
def setUp(self):
super().setUp()
self.factory = Factory()
job_ctx = {
"arch": "amd64",
"no_kvm": True,
} # override to allow unit tests on all types of systems
self.job = self.factory.create_job("qemu01.jinja2",
"sample_jobs/kvm.yaml", job_ctx)
def test_device_parser(self):
job_parser = JobParser()
factory = Factory()
job = factory.create_job("bbb-01.jinja2",
"sample_jobs/uboot-ramdisk.yaml")
uboot_action = None
device = job.device
action = job.pipeline.actions[0]
self.assertIn("ramdisk", action.parameters)
action = job.pipeline.actions[1]
self.assertIn("method", action.parameters)
self.assertEqual("u-boot", action.parameters["method"])
methods = device["actions"]["boot"]["methods"]
self.assertIn("ramdisk", methods["u-boot"])
self.assertIn("bootloader_prompt", methods["u-boot"]["parameters"])
self.assertIsNotNone(methods[action.parameters["method"]][
action.parameters["commands"]]["commands"])
for line in methods[action.parameters["method"]][
action.parameters["commands"]]["commands"]:
self.assertIsNotNone(line)
self.assertIsInstance(action, UBootAction)
uboot_action = action
self.assertIsNotNone(uboot_action)
uboot_action.validate()
self.assertTrue(uboot_action.valid)
for action in uboot_action.pipeline.actions:
if isinstance(action, BootloaderInterruptAction):
self.assertIn("power-on", action.job.device["commands"])
self.assertIn("hard_reset", action.job.device["commands"])
self.assertIn("connect", action.job.device["commands"])
self.assertEqual(
action.job.device["commands"]["connect"].split(" ")[0],
"telnet")
self.assertTrue(action.interrupt_newline)
if isinstance(action, UBootAction):
self.assertIn("method", action.parameters)
self.assertIn("commands", action.parameters)
self.assertIn("ramdisk", action.parameters["u-boot"])
self.assertIn(
action.parameters["commands"],
action.parameters[action.parameters["method"]],
)
self.assertIn(
"commands",
action.parameters[action.parameters["method"]][
action.parameters["commands"]],
)
self.assertIsNotNone(action.parameters["u-boot"]["ramdisk"])
self.assertIsInstance(
action.parameters["u-boot"]["ramdisk"]["commands"], list)
self.assertTrue(
len(action.parameters["u-boot"]["ramdisk"]["commands"]) > 2
)
def setUp(self):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_job("qemu01.jinja2",
"sample_jobs/kvm.yaml")
with open(
os.path.join(os.path.dirname(__file__), "testdefs",
"params.yaml"), "r") as params:
self.testdef = yaml_safe_load(params)
def test_downloads_action_adds_docker_action():
factory = Factory()
factory.validate_job_strict = True
job = factory.create_job("qemu01.jinja2",
"sample_jobs/qemu-download-postprocess.yaml")
deploy = job.pipeline.actions[0]
action = deploy.pipeline.actions[-1]
assert isinstance(action, PostprocessWithDocker)
assert str(action.path) == f"{job.tmp_dir}/downloads/common"
def test_qemu_monitor_zephyr_job(self):
factory = Factory()
job = factory.create_kvm_job("sample_jobs/zephyr-qemu-test-task.yaml")
job.validate()
self.assertIsNotNone(job)
self.assertIsNotNone(job.pipeline)
self.assertIsNotNone(job.pipeline.actions)
for action in job.pipeline.actions:
action.validate()
self.assertTrue(action.valid)
self.assertFalse(find_autologin(job))
def test_qemu_notest(self):
factory = Factory()
job = factory.create_kvm_job("sample_jobs/kvm-notest.yaml")
job.validate()
self.assertIsNotNone(job)
self.assertIsNotNone(job.pipeline)
self.assertIsNotNone(job.pipeline.actions)
for action in job.pipeline.actions:
action.validate()
self.assertTrue(action.valid)
self.assertTrue(find_autologin(job))
def setUp(self):
super().setUp()
self.filename = os.path.join(
os.path.dirname(__file__), "sample_jobs/bbb-group-vland-alpha.yaml"
)
self.beta_filename = os.path.join(
os.path.dirname(__file__), "sample_jobs/bbb-group-vland-beta.yaml"
)
self.factory = Factory()
(rendered, _) = self.factory.create_device("bbb-01.jinja2")
self.device = NewDevice(yaml_safe_load(rendered))
self.job_id = "100"
def setUp(self):
data = yaml_safe_load(Factory().create_device("bbb-01.jinja2")[0])
self.device = NewDevice(data)
bbb_yaml = os.path.join(os.path.dirname(__file__),
"sample_jobs/uboot-ramdisk.yaml")
with open(bbb_yaml) as sample_job_data:
self.base_data = yaml_safe_load(sample_job_data)
self.deploy_block = [
block for block in self.base_data["actions"] if "deploy" in block
][0]["deploy"]
self.boot_block = [
block for block in self.base_data["actions"] if "boot" in block
][0]["boot"]
self.parser = JobParser()
def setUp(self):
"""
Attempt to setup a valid group with clients and test the protocol
"""
super().setUp()
factory = Factory()
self.client_job = factory.create_kvm_job(
"sample_jobs/kvm-multinode-client.yaml")
self.server_job = factory.create_kvm_job(
"sample_jobs/kvm-multinode-server.yaml")
self.client_job.logger = DummyLogger()
self.server_job.logger = DummyLogger()
self.job_id = "100"
self.coord = TestCoordinator()
def test_empty_device_environment(self):
factory = Factory()
data = None
job_parser = JobParser()
(rendered, _) = factory.create_device("bbb-01.jinja2")
device = NewDevice(yaml_safe_load(rendered))
sample_job_file = os.path.join(
os.path.dirname(__file__), "sample_jobs/uboot-ramdisk.yaml"
)
with open(sample_job_file) as sample_job_data:
job = job_parser.parse(
sample_job_data, device, 4212, None, "", env_dut=data
)
self.assertEqual(job.parameters["env_dut"], None)
def test_iot_lxc(self):
self.factory = Factory()
job = self.factory.create_job("frdm-k64f-01.jinja2",
"sample_jobs/frdm-k64f-lxc.yaml")
job.validate()
self.assertIsNotNone([
action for action in job.pipeline.actions
if action.name == "lxc-deploy"
])
self.assertIsNotNone([
action for action in job.pipeline.actions
if action.name == "lxc-boot"
])
description_ref = self.pipeline_reference("frdm-k64f-lxc.yaml",
job=job)
self.assertEqual(description_ref, job.pipeline.describe(False))
def test_new_device(self):
factory = Factory()
(rendered, _) = factory.create_device("kvm01.jinja2")
kvm01 = yaml_safe_load(rendered)
try:
self.assertIsNotNone(kvm01["actions"])
except Exception:
self.fail("missing actions block for device")
try:
self.assertIsNotNone(kvm01["actions"]["boot"])
except Exception:
self.fail("missing boot block for device")
try:
self.assertIsNotNone(kvm01["actions"]["deploy"])
except Exception:
self.fail("missing boot block for device")
self.assertTrue("qemu" in kvm01["actions"]["boot"]["methods"])
self.assertTrue("image" in kvm01["actions"]["deploy"]["methods"])
def test_tc2_uefi_job(self, which_mock):
factory = Factory()
job = factory.create_job("tc2-01.jinja2", "sample_jobs/tc2.yaml")
job.validate()
self.assertEqual([], job.pipeline.errors)
description_ref = self.pipeline_reference("tc2.yaml", job=self.job)
self.assertEqual(description_ref, self.job.pipeline.describe(False))
self.assertIn("uefi-menu", job.device["actions"]["boot"]["methods"])
uefi_menu_block = job.device["actions"]["boot"]["methods"]["uefi-menu"]
nfs_boot = uefi_menu_block["nfs"]
block = [
step for step in nfs_boot
if step["select"].get("wait") == "Description for this new Entry:"
]
self.assertIsNotNone(block)
self.assertEqual(len(block), 1)
expected_nfs_args = "console=ttyAMA0,38400n8 root=/dev/nfs rw nfsroot={NFS_SERVER_IP}:{NFSROOTFS},tcp,hard,intr,vers=3 rootwait debug systemd.log_target=null user_debug=31 loglevel=9 ip=dhcp"
self.assertEqual(block[0]["select"]["enter"], expected_nfs_args)
def test_device_environment(self, which_mock):
data = """
# YAML syntax.
overrides:
DEBEMAIL: "*****@*****.**"
DEBFULLNAME: "Neil Williams"
"""
factory = Factory()
job_parser = JobParser()
(rendered, _) = factory.create_device("bbb-01.jinja2")
device = NewDevice(yaml_safe_load(rendered))
sample_job_file = os.path.join(os.path.dirname(__file__),
"sample_jobs/uboot-ramdisk.yaml")
with open(sample_job_file) as sample_job_data:
job = job_parser.parse(sample_job_data,
device,
4212,
None,
"",
env_dut=data)
job.logger = DummyLogger()
self.assertEqual(job.parameters["env_dut"], data)
job.validate()
boot_actions = [
action.pipeline.actions for action in job.pipeline.actions
if action.name == "uboot-action"
][0]
retry = [
action for action in boot_actions if action.name == "uboot-retry"
][0]
boot_env = [
action for action in retry.pipeline.actions
if action.name == "export-device-env"
][0]
found = False
for line in boot_env.env:
if "DEBFULLNAME" in line:
found = True
# assert that the string containing a space still contains that space and is quoted
self.assertIn("\\'Neil Williams\\'", line)
self.assertTrue(found)
def setUp(self):
super().setUp()
self.testdef = os.path.join(
os.path.dirname(__file__), "testdefs", "params.yaml"
)
self.res_data = os.path.join(
os.path.dirname(__file__), "testdefs", "result-data.txt"
)
factory = Factory()
self.job = factory.create_kvm_job("sample_jobs/kvm.yaml")
self.job.logger = DummyLogger()
self.job.validate()
self.ret = False
test_retry = [
action
for action in self.job.pipeline.actions
if action.name == "lava-test-retry"
][0]
self.test_shell = [
action
for action in test_retry.pipeline.actions
if action.name == "lava-test-shell"
][0]
self.test_shell.logger = DummyLogger()
def setUp(self):
super().setUp()
factory = Factory()
self.job = factory.create_kvm_job("sample_jobs/qemu-monitor.yaml")
def setUp(self):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_job(
"db410c-01.jinja2", "sample_jobs/download.yaml"
)
def factory():
return Factory()
def setUp(self):
super().setUp()
self.factory = Factory()
def setUp(self, job="sample_jobs/fvp_foundation.yaml"):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_job("fvp-01.jinja2", job)
def setUp(self):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_kvm_job("sample_jobs/kvm-params.yaml")
def setUp(self):
super().setUp()
factory = Factory()
self.job = factory.create_kvm_job("sample_jobs/kvm-notest.yaml")
def test_overlay_action(self, which_mock):
parameters = {
"dispatcher":
{}, # fake dispatcher parameter. Normally added by parser
"device_type": "beaglebone-black",
"job_name": "uboot-pipeline",
"job_timeout": "15m",
"action_timeout": "5m",
"priority": "medium",
"actions": {
"boot": {
"namespace": "common",
"method": "u-boot",
"commands": "ramdisk",
"prompts": ["linaro-test", "root@debian:~#"],
},
"deploy": {
"namespace": "common",
"ramdisk": {
"url": "initrd.gz",
"compression": "gz"
},
"kernel": {
"url": "zImage",
"type": "zimage"
},
"dtb": {
"url": "broken.dtb"
},
},
},
}
data = yaml_safe_load(Factory().create_device("bbb-01.jinja2")[0])
device = NewDevice(data)
job = Job(4212, parameters, None)
job.device = device
pipeline = Pipeline(job=job, parameters=parameters["actions"]["boot"])
job.pipeline = pipeline
overlay = BootloaderCommandOverlay()
connection = MagicMock()
connection.timeout = MagicMock()
pipeline.add_action(overlay)
overlay.set_namespace_data(
action="uboot-prepare-kernel",
label="bootcommand",
key="bootcommand",
value="bootz",
)
overlay.validate()
overlay.run(connection, 100)
ip_addr = dispatcher_ip(None)
parsed = []
kernel_addr = job.device["parameters"][overlay.bootcommand]["ramdisk"]
ramdisk_addr = job.device["parameters"][overlay.bootcommand]["ramdisk"]
dtb_addr = job.device["parameters"][overlay.bootcommand]["dtb"]
kernel = parameters["actions"]["deploy"]["kernel"]["url"]
ramdisk = parameters["actions"]["deploy"]["ramdisk"]["url"]
dtb = parameters["actions"]["deploy"]["dtb"]["url"]
substitution_dictionary = {
"{SERVER_IP}":
ip_addr,
# the addresses need to be hexadecimal
"{KERNEL_ADDR}":
kernel_addr,
"{DTB_ADDR}":
dtb_addr,
"{RAMDISK_ADDR}":
ramdisk_addr,
"{BOOTX}":
"%s %s %s %s" %
(overlay.bootcommand, kernel_addr, ramdisk_addr, dtb_addr),
"{RAMDISK}":
ramdisk,
"{KERNEL}":
kernel,
"{DTB}":
dtb,
}
params = device["actions"]["boot"]["methods"]
params["u-boot"]["ramdisk"]["commands"] = substitute(
params["u-boot"]["ramdisk"]["commands"], substitution_dictionary)
commands = params["u-boot"]["ramdisk"]["commands"]
self.assertIs(type(commands), list)
self.assertIn("tftp 0x83000000 zImage", commands)
self.assertIn("tftp 0x83000000 initrd.gz", commands)
self.assertIn("setenv initrd_size ${filesize}", commands)
self.assertIn("tftp 0x88000000 broken.dtb", commands)
self.assertNotIn("setenv kernel_addr_r '{KERNEL_ADDR}'", commands)
self.assertNotIn("setenv initrd_addr_r '{RAMDISK_ADDR}'", commands)
self.assertNotIn("setenv fdt_addr_r '{DTB_ADDR}'", commands)
for line in params["u-boot"]["ramdisk"]["commands"]:
line = line.replace("{SERVER_IP}", ip_addr)
# the addresses need to be hexadecimal
line = line.replace("{KERNEL_ADDR}", kernel_addr)
line = line.replace("{DTB_ADDR}", dtb_addr)
line = line.replace("{RAMDISK_ADDR}", ramdisk_addr)
line = line.replace(
"{BOOTX}",
"%s %s %s %s" %
(overlay.bootcommand, kernel_addr, ramdisk_addr, dtb_addr),
)
line = line.replace("{RAMDISK}", ramdisk)
line = line.replace("{KERNEL}", kernel)
line = line.replace("{DTB}", dtb)
parsed.append(line)
self.assertNotIn("setenv kernel_addr_r '{KERNEL_ADDR}'", parsed)
self.assertNotIn("setenv initrd_addr_r '{RAMDISK_ADDR}'", parsed)
self.assertNotIn("setenv fdt_addr_r '{DTB_ADDR}'", parsed)
