class TestDownloadDeploy(StdoutTestCase):
def setUp(self):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_job(
"db410c-01.jinja2", "sample_jobs/download.yaml"
)
def test_deploy_job(self):
self.assertEqual(self.job.pipeline.job, self.job)
self.assertIsInstance(self.job.device["device_info"], list)
for action in self.job.pipeline.actions:
self.assertEqual(action.job, self.job)
def test_pipeline(self):
description_ref = self.pipeline_reference("download.yaml", job=self.job)
self.assertEqual(description_ref, self.job.pipeline.describe(False))
@unittest.skipIf(
infrastructure_error_multi_paths(["lxc-info", "img2simg", "simg2img"]),
"lxc or img2simg or simg2img not installed",
)
def test_validate(self):
try:
self.job.pipeline.validate_actions()
except JobError as exc:
self.fail(exc)
for action in self.job.pipeline.actions:
self.assertEqual([], action.errors)
def test_directories(self):
job = self.factory.create_job("bbb-01.jinja2", "sample_jobs/download_dir.yaml")
with self.assertRaises(JobError):
job.validate()
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 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 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_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)
class TestDefinitionHandlers(StdoutTestCase):
def setUp(self):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_kvm_job("sample_jobs/kvm.yaml")
def test_testshell(self):
testshell = None
for action in self.job.pipeline.actions:
self.assertIsNotNone(action.name)
if isinstance(action, TestShellRetry):
testshell = action.pipeline.actions[0]
break
self.assertIsInstance(testshell, TestShellAction)
self.assertTrue(testshell.valid)
if "timeout" in testshell.parameters:
time_int = Timeout.parse(testshell.parameters["timeout"])
else:
time_int = Timeout.default_duration()
self.assertEqual(
datetime.timedelta(seconds=time_int).total_seconds(),
testshell.timeout.duration,
)
def test_missing_handler(self):
(rendered, _) = self.factory.create_device("kvm01.jinja2")
device = NewDevice(yaml_safe_load(rendered))
kvm_yaml = os.path.join(os.path.dirname(__file__),
"sample_jobs/kvm.yaml")
parser = JobParser()
with open(kvm_yaml) as sample_job_data:
data = yaml_safe_load(sample_job_data)
data["actions"][2]["test"]["definitions"][0][
"from"] = "unusable-handler"
try:
job = parser.parse(yaml_safe_dump(data), device, 4212, None, "")
job.logger = DummyLogger()
except JobError:
pass
except Exception as exc:
self.fail(exc)
else:
self.fail("JobError not raised")
def test_eventpatterns(self):
testshell = None
for action in self.job.pipeline.actions:
self.assertIsNotNone(action.name)
if isinstance(action, TestShellRetry):
testshell = action.pipeline.actions[0]
break
self.assertTrue(testshell.valid)
self.assertFalse(testshell.check_patterns("exit", None, ""))
self.assertRaises(InfrastructureError, testshell.check_patterns, "eof",
None, "")
self.assertTrue(testshell.check_patterns("timeout", None, ""))
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 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_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 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))
class TestPowerAction(StdoutTestCase):
def setUp(self):
super().setUp()
self.factory = Factory()
def test_reset_nopower(self):
job = self.factory.create_job("cubie1.jinja2", "sample_jobs/uboot-ramdisk.yaml")
uboot_action = None
names = [r_action.name for r_action in job.pipeline.actions]
self.assertIn("uboot-action", names)
uboot_action = [
action for action in job.pipeline.actions if action.name == "uboot-action"
][0]
names = [r_action.name for r_action in uboot_action.pipeline.actions]
self.assertIn("uboot-retry", names)
uboot_retry = [
action
for action in uboot_action.pipeline.actions
if action.name == "uboot-retry"
][0]
names = [r_action.name for r_action in uboot_retry.pipeline.actions]
self.assertIn("reset-device", names)
reset_device = [
action
for action in uboot_retry.pipeline.actions
if action.name == "reset-device"
][0]
names = [r_action.name for r_action in reset_device.pipeline.actions]
self.assertEqual(["send-reboot-commands"], names)
def test_reset_power(self):
job = self.factory.create_job("bbb-01.jinja2", "sample_jobs/uboot-ramdisk.yaml")
uboot_action = None
names = [r_action.name for r_action in job.pipeline.actions]
self.assertIn("uboot-action", names)
uboot_action = [
action for action in job.pipeline.actions if action.name == "uboot-action"
][0]
names = [r_action.name for r_action in uboot_action.pipeline.actions]
self.assertIn("uboot-retry", names)
uboot_retry = [
action
for action in uboot_action.pipeline.actions
if action.name == "uboot-retry"
][0]
names = [r_action.name for r_action in uboot_retry.pipeline.actions]
self.assertIn("reset-device", names)
reset_device = [
action
for action in uboot_retry.pipeline.actions
if action.name == "reset-device"
][0]
names = [r_action.name for r_action in reset_device.pipeline.actions]
self.assertEqual(["pdu-reboot"], names)
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 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 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_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_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_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_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_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):
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):
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 factory():
return Factory()
def setUp(self):
super().setUp()
self.factory = Factory()
class TestRemovable(StdoutTestCase):
def setUp(self):
super().setUp()
self.factory = Factory()
def test_device_parameters(self):
"""
Test that the correct parameters have been set for the device
"""
(rendered, _) = self.factory.create_device("cubie2.jinja2")
cubie = NewDevice(yaml_safe_load(rendered))
self.assertIsNotNone(cubie["parameters"]["media"].get("usb"))
self.assertIsNotNone(cubie.get("commands"))
self.assertIsNotNone(cubie.get("actions"))
self.assertIsNotNone(cubie["actions"].get("deploy"))
self.assertIsNotNone(cubie["actions"]["deploy"].get("methods"))
self.assertIn("usb", cubie["actions"]["deploy"]["methods"])
self.assertIsNotNone(cubie["actions"].get("boot"))
self.assertIsNotNone(cubie["actions"]["boot"].get("methods"))
self.assertIn("u-boot", cubie["actions"]["boot"]["methods"])
u_boot_params = cubie["actions"]["boot"]["methods"]["u-boot"]
self.assertIn("usb", u_boot_params)
self.assertIn("commands", u_boot_params["usb"])
self.assertIn("parameters", u_boot_params)
self.assertIn("bootloader_prompt", u_boot_params["parameters"])
@patch("lava_dispatcher.actions.deploy.tftp.which",
return_value="/usr/bin/in.tftpd")
def _check_valid_job(self, device, test_file, which_mock):
self.maxDiff = None
job_parser = JobParser()
sample_job_file = os.path.join(os.path.dirname(__file__),
"sample_jobs/{}".format(test_file))
with open(sample_job_file) as sample_job_data:
job = job_parser.parse(sample_job_data, device, 4212, None, "")
job.logger = DummyLogger()
try:
job.validate()
except JobError:
self.fail(job.pipeline.errors)
description_ref = self.pipeline_reference(test_file, job=job)
self.assertEqual(description_ref, job.pipeline.describe(False))
return job
def _check_job_parameters(self, device, job, agent_key):
mass_storage = None # deploy
action = job.pipeline.actions[3]
self.assertTrue(action.valid)
agent = action.parameters[agent_key]["tool"]
self.assertTrue(
agent.startswith("/")
) # needs to be a full path but on the device, so avoid os.path
self.assertIn(action.parameters["device"],
job.device["parameters"]["media"]["usb"])
mass_storage = action
self.assertIsNotNone(mass_storage)
self.assertIn("device", mass_storage.parameters)
self.assertIn(mass_storage.parameters["device"],
device["parameters"]["media"]["usb"])
self.assertIsNotNone(
mass_storage.get_namespace_data(action="storage-deploy",
label="u-boot",
key="device"))
u_boot_params = device["actions"]["boot"]["methods"]["u-boot"]
self.assertEqual(
mass_storage.get_namespace_data(action="uboot-retry",
label="bootloader_prompt",
key="prompt"),
u_boot_params["parameters"]["bootloader_prompt"],
)
def test_job_parameters(self):
"""
Test that the job parameters match expected structure
"""
(rendered, _) = self.factory.create_device("cubie1.jinja2")
cubie = NewDevice(yaml_safe_load(rendered))
job = self._check_valid_job(cubie, "cubietruck-removable.yaml")
self._check_job_parameters(cubie, job, "download")
def test_writer_job_parameters(self):
"""
Test that the job parameters with a writer tool match expected structure
"""
(rendered, _) = self.factory.create_device("cubie1.jinja2")
cubie = NewDevice(yaml_safe_load(rendered))
job = self._check_valid_job(cubie,
"cubietruck-removable-with-writer.yaml")
self._check_job_parameters(cubie, job, "writer")
def _check_deployment(self, device, test_file):
job_parser = JobParser()
job = self._check_valid_job(device, test_file)
self.assertIn("usb", device["parameters"]["media"].keys())
deploy_params = [
methods for methods in job.parameters["actions"]
if "deploy" in methods.keys()
][1]["deploy"]
self.assertIn("device", deploy_params)
self.assertIn(deploy_params["device"],
device["parameters"]["media"]["usb"])
self.assertIn(
"uuid",
device["parameters"]["media"]["usb"][deploy_params["device"]])
self.assertIn(
"device_id",
device["parameters"]["media"]["usb"][deploy_params["device"]])
self.assertNotIn(
"boot_part",
device["parameters"]["media"]["usb"][deploy_params["device"]])
deploy_action = [
action for action in job.pipeline.actions
if action.name == "storage-deploy"
][0]
tftp_deploy_action = [
action for action in job.pipeline.actions
if action.name == "tftp-deploy"
][0]
self.assertIsNotNone(deploy_action)
test_dir = deploy_action.get_namespace_data(
action="test",
label="results",
key="lava_test_results_dir",
parameters=tftp_deploy_action.parameters,
)
self.assertIsNotNone(test_dir)
self.assertIn("/lava-", test_dir)
self.assertIsInstance(deploy_action, MassStorage)
img_params = deploy_action.parameters.get("images",
deploy_action.parameters)
self.assertIn("image", img_params)
dd_action = [
action for action in deploy_action.pipeline.actions
if action.name == "dd-image"
][0]
self.assertEqual(
dd_action.boot_params[dd_action.parameters["device"]]["uuid"],
"usb-SanDisk_Ultra_20060775320F43006019-0:0",
)
self.assertIsNotNone(
dd_action.get_namespace_data(action=dd_action.name,
label="u-boot",
key="boot_part"))
self.assertIsNotNone(
dd_action.get_namespace_data(action="uboot-from-media",
label="uuid",
key="boot_part"))
self.assertEqual(
"0",
"%s" % dd_action.get_namespace_data(
action=dd_action.name, label="u-boot", key="boot_part"),
)
self.assertIsInstance(
dd_action.get_namespace_data(action="uboot-from-media",
label="uuid",
key="boot_part"),
str,
)
self.assertEqual(
"0:1",
dd_action.get_namespace_data(action="uboot-from-media",
label="uuid",
key="boot_part"),
)
self.assertIsNotNone(
dd_action.get_namespace_data(action="uboot-prepare-kernel",
label="bootcommand",
key="bootcommand"))
def test_deployment(self):
(rendered, _) = self.factory.create_device("cubie1.jinja2")
cubie = NewDevice(yaml_safe_load(rendered))
self._check_deployment(cubie, "cubietruck-removable.yaml")
def test_writer_deployment(self):
(rendered, _) = self.factory.create_device("cubie1.jinja2")
cubie = NewDevice(yaml_safe_load(rendered))
self._check_deployment(cubie, "cubietruck-removable-with-writer.yaml")
@patch("lava_dispatcher.actions.deploy.tftp.which",
return_value="/usr/bin/in.tftpd")
def test_juno_deployment(self, which_mock):
factory = RemovableFactory()
job = factory.create_job("juno-uboot-01.jinja2",
"sample_jobs/juno-uboot-removable.yaml")
job.validate()
self.assertEqual(job.pipeline.errors, [])
self.assertIn("usb", job.device["parameters"]["media"].keys())
deploy_params = [
methods for methods in job.parameters["actions"]
if "deploy" in methods.keys()
][1]["deploy"]
self.assertIn("device", deploy_params)
self.assertIn(deploy_params["device"],
job.device["parameters"]["media"]["usb"])
self.assertIn(
"uuid",
job.device["parameters"]["media"]["usb"][deploy_params["device"]])
self.assertIn(
"device_id",
job.device["parameters"]["media"]["usb"][deploy_params["device"]],
)
self.assertNotIn(
"boot_part",
job.device["parameters"]["media"]["usb"][deploy_params["device"]],
)
tftp_deploys = [
action for action in job.pipeline.actions
if action.name == "tftp-deploy"
]
self.assertEqual(len(tftp_deploys), 2)
first_deploy = tftp_deploys[0]
second_deploy = tftp_deploys[1]
self.assertIsNotNone(first_deploy)
self.assertIsNotNone(second_deploy)
self.assertEqual("openembedded", first_deploy.parameters["namespace"])
self.assertEqual("android", second_deploy.parameters["namespace"])
self.assertNotIn("deployment_data", first_deploy.parameters)
self.assertNotIn("deployment_data", second_deploy.parameters)
storage_deploy_action = [
action for action in job.pipeline.actions
if action.name == "storage-deploy"
][0]
download_action = [
action for action in storage_deploy_action.pipeline.actions
if action.name == "download-retry"
][0]
self.assertIsNotNone(download_action)
self.assertEqual("android",
storage_deploy_action.parameters["namespace"])
@patch("lava_dispatcher.actions.deploy.tftp.which",
return_value="/usr/bin/in.tftpd")
def test_mustang_deployment(self, which_mock):
factory = RemovableFactory()
job = factory.create_job("mustang1.jinja2",
"sample_jobs/mustang-secondary-media.yaml")
job.validate()
description_ref = self.pipeline_reference("mustang-media.yaml",
job=job)
self.assertEqual(description_ref, job.pipeline.describe(False))
self.assertIn("sata", job.device["parameters"]["media"].keys())
deploy_params = [
methods for methods in job.parameters["actions"]
if "deploy" in methods.keys()
][1]["deploy"]
self.assertIn("device", deploy_params)
self.assertIn(deploy_params["device"],
job.device["parameters"]["media"]["sata"])
self.assertIn(
"uuid",
job.device["parameters"]["media"]["sata"][deploy_params["device"]])
self.assertIn(
"device_id",
job.device["parameters"]["media"]["sata"][deploy_params["device"]],
)
self.assertEqual(
"hd0",
job.device["parameters"]["media"]["sata"][deploy_params["device"]]
["grub_interface"],
)
grub_deploys = [
action for action in job.pipeline.actions
if action.name == "grub-main-action"
]
self.assertEqual(len(grub_deploys), 2)
first_deploy = grub_deploys[0]
second_deploy = grub_deploys[1]
self.assertEqual("nfsdeploy", first_deploy.parameters["namespace"])
self.assertEqual("satadeploy", second_deploy.parameters["namespace"])
@patch("lava_dispatcher.actions.deploy.tftp.which",
return_value="/usr/bin/in.tftpd")
def test_secondary_media(self, which_mock):
factory = RemovableFactory()
job = factory.create_job("mustang1.jinja2",
"sample_jobs/mustang-secondary-media.yaml")
job.validate()
grub_nfs = [
action for action in job.pipeline.actions
if action.name == "grub-main-action"
and action.parameters["namespace"] == "nfsdeploy"
][0]
media_action = [
action for action in grub_nfs.pipeline.actions
if action.name == "bootloader-from-media"
][0]
self.assertEqual(
None,
media_action.get_namespace_data(action="download-action",
label="file",
key="kernel"),
)
self.assertEqual(
None,
media_action.get_namespace_data(action="compress-ramdisk",
label="file",
key="ramdisk"),
)
self.assertEqual(
None,
media_action.get_namespace_data(action="download-action",
label="file",
key="dtb"),
)
self.assertEqual(
None,
media_action.get_namespace_data(action=media_action.name,
label="file",
key="root"),
)
grub_main = [
action for action in job.pipeline.actions
if action.name == "grub-main-action"
and action.parameters["namespace"] == "satadeploy"
][0]
media_action = [
action for action in grub_main.pipeline.actions
if action.name == "bootloader-from-media"
][0]
self.assertIsInstance(media_action, BootloaderSecondaryMedia)
self.assertIsNotNone(
media_action.get_namespace_data(action="download-action",
label="file",
key="kernel"))
self.assertIsNotNone(
media_action.get_namespace_data(action="compress-ramdisk",
label="file",
key="ramdisk"))
self.assertIsNotNone(
media_action.get_namespace_data(action="download-action",
label="file",
key="ramdisk"))
self.assertEqual(
"",
media_action.get_namespace_data(action="download-action",
label="file",
key="dtb"),
)
self.assertIsNotNone(
media_action.get_namespace_data(action=media_action.name,
label="uuid",
key="root"))
self.assertIsNotNone(
media_action.get_namespace_data(action=media_action.name,
label="uuid",
key="boot_part"))
@unittest.skipIf(infrastructure_error("mkimage"),
"u-boot-tools not installed")
@patch("lava_dispatcher.actions.deploy.tftp.which",
return_value="/usr/bin/in.tftpd")
def test_primary_media(self, which_mock):
"""
Test that definitions of secondary media do not block submissions using primary media
"""
job_parser = JobParser()
(rendered, _) = self.factory.create_device("bbb-01.jinja2")
bbb = 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, bbb, 4212, None, "")
job.logger = DummyLogger()
job.validate()
self.assertEqual(job.pipeline.errors, [])
self.assertIn("usb", bbb["parameters"]["media"].keys())
@patch("lava_dispatcher.actions.deploy.tftp.which",
return_value="/usr/bin/in.tftpd")
def test_substitutions(self, which_mock):
"""
Test substitution of secondary media values into u-boot commands
Unlike most u-boot calls, removable knows in advance all the values it needs to substitute
into the boot commands for the secondary deployment as these are fixed by the device config
and the image details from the job submission.
"""
job_parser = JobParser()
(rendered, _) = self.factory.create_device("cubie1.jinja2")
cubie = NewDevice(yaml_safe_load(rendered))
sample_job_file = os.path.join(
os.path.dirname(__file__), "sample_jobs/cubietruck-removable.yaml")
with open(sample_job_file) as sample_job_data:
job = job_parser.parse(sample_job_data, cubie, 4212, None, "")
job.logger = DummyLogger()
job.validate()
boot_params = [
methods for methods in job.parameters["actions"]
if "boot" in methods.keys()
][1]["boot"]
self.assertIn("ramdisk", boot_params)
self.assertIn("kernel", boot_params)
self.assertIn("dtb", boot_params)
self.assertIn("root_uuid", boot_params)
self.assertIn("boot_part", boot_params)
self.assertNotIn("type", boot_params)
self.assertGreater(len(job.pipeline.actions), 1)
self.assertIsNotNone(job.pipeline.actions[1].pipeline)
u_boot_action = [
action for action in job.pipeline.actions
if action.name == "uboot-action"
][1]
overlay = [
action for action in u_boot_action.pipeline.actions
if action.name == "bootloader-overlay"
][0]
self.assertIsNotNone(
overlay.get_namespace_data(action="storage-deploy",
label="u-boot",
key="device"))
methods = cubie["actions"]["boot"]["methods"]
self.assertIn("u-boot", methods)
self.assertIn("usb", methods["u-boot"])
self.assertIn("commands", methods["u-boot"]["usb"])
commands_list = methods["u-boot"]["usb"]["commands"]
device_id = u_boot_action.get_namespace_data(action="storage-deploy",
label="u-boot",
key="device")
self.assertIsNotNone(device_id)
kernel_type = u_boot_action.parameters["kernel_type"]
bootcommand = map_kernel_uboot(kernel_type,
device_params=cubie.get("parameters"))
substitutions = {
"{BOOTX}":
"%s %s %s %s" % (
bootcommand,
cubie["parameters"][bootcommand]["kernel"],
cubie["parameters"][bootcommand]["ramdisk"],
cubie["parameters"][bootcommand]["dtb"],
),
"{RAMDISK}":
boot_params["ramdisk"],
"{KERNEL}":
boot_params["kernel"],
"{DTB}":
boot_params["dtb"],
"{ROOT}":
boot_params["root_uuid"],
"{ROOT_PART}":
"%s:%s" % (
cubie["parameters"]["media"]["usb"][device_id]["device_id"],
u_boot_action.parameters["boot_part"],
),
}
self.assertEqual("bootz 0x42000000 0x43300000 0x43000000",
substitutions["{BOOTX}"])
self.assertEqual("/boot/initrd.img-3.16.0-4-armmp-lpae.u-boot",
substitutions["{RAMDISK}"])
commands = substitute(commands_list, substitutions)
print(commands)
self.assertEqual(
commands,
[
"usb start",
"setenv autoload no",
"load usb 0:0:1 {KERNEL_ADDR} /boot/vmlinuz-3.16.0-4-armmp-lpae",
"load usb 0:0:1 {RAMDISK_ADDR} /boot/initrd.img-3.16.0-4-armmp-lpae.u-boot",
"setenv initrd_size ${filesize}",
"load usb 0:0:1 {DTB_ADDR} /boot/dtb-3.16.0-4-armmp-lpae",
"console=ttyS0,115200n8 root=UUID=159d17cc-697c-4125-95a0-a3775e1deabe ip=dhcp",
"bootz 0x42000000 0x43300000 0x43000000",
],
)
class TestDefinitionHandlers(StdoutTestCase):
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_testdef(self):
testdef = overlay = None
action = self.job.pipeline.actions[0]
overlay = action.pipeline.actions[2]
testdef = overlay.pipeline.actions[2]
self.assertEqual(len(overlay.pipeline.actions), 5)
self.assertIsInstance(testdef, TestDefinitionAction)
testdef.validate()
self.assertEqual(testdef.run_levels, {
"smoke-tests": 0,
"singlenode-advanced": 0
})
if not testdef.valid:
print(testdef.errors)
self.assertTrue(testdef.valid)
for repo_action in testdef.pipeline.actions:
if isinstance(repo_action, GitRepoAction):
self.assertTrue(hasattr(repo_action, "accepts"))
self.assertTrue(hasattr(repo_action, "priority"))
elif isinstance(repo_action, TestOverlayAction):
self.assertTrue(hasattr(repo_action, "test_uuid"))
self.assertFalse(hasattr(repo_action, "accepts"))
self.assertFalse(hasattr(repo_action, "priority"))
else:
self.fail(
"%s does not match GitRepoAction or TestOverlayAction" %
type(repo_action))
repo_action.validate()
# FIXME
# if hasattr(repo_action, 'uuid'):
# repo_action.data['test'] = {repo_action.uuid: {}}
# repo_action.store_testdef(self.testdef, 'git', 'abcdef')
# self.assertEqual(
# repo_action.data['test'][repo_action.uuid]['testdef_pattern'],
# self.testdef['parse'])
self.assertTrue(repo_action.valid)
# FIXME: needs deployment_data to be visible during validation
# self.assertNotEqual(repo_action.runner, None)
self.assertIsNotNone(
testdef.parameters["deployment_data"]["lava_test_results_dir"])
def test_name(self):
deploy = [
action for action in self.job.pipeline.actions
if action.name == "deployimages"
][0]
overlay = [
action for action in deploy.pipeline.actions
if action.name == "lava-overlay"
][0]
testdef = [
action for action in overlay.pipeline.actions
if action.name == "test-definition"
][0]
testdef.validate()
self.assertEqual([], testdef.errors)
(rendered, _) = self.factory.create_device("kvm01.jinja2")
device = yaml_safe_load(rendered)
kvm_yaml = os.path.join(os.path.dirname(__file__),
"sample_jobs/kvm.yaml")
parser = JobParser()
with open(kvm_yaml, "r") as sample_job_data:
content = yaml_safe_load(sample_job_data)
data = [
block["test"] for block in content["actions"] if "test" in block
][0]
definitions = [
block for block in data["definitions"] if "path" in block
][0]
definitions["name"] = "smoke tests"
job = parser.parse(yaml_safe_dump(content), device, 4212, None, "")
deploy = [
action for action in job.pipeline.actions
if action.name == "deployimages"
][0]
overlay = [
action for action in deploy.pipeline.actions
if action.name == "lava-overlay"
][0]
testdef = [
action for action in overlay.pipeline.actions
if action.name == "test-definition"
][0]
testdef.validate()
self.assertNotEqual([], testdef.errors)
self.assertIn(
"Invalid characters found in test definition name: smoke tests",
job.pipeline.errors,
)
def test_vcs_parameters(self):
deploy = [
action for action in self.job.pipeline.actions
if action.name == "deployimages"
][0]
overlay = [
action for action in deploy.pipeline.actions
if action.name == "lava-overlay"
][0]
testdef = [
action for action in overlay.pipeline.actions
if action.name == "test-definition"
][0]
git_repos = [
action for action in testdef.pipeline.actions
if action.name == "git-repo-action"
]
for git_repo in git_repos:
if (git_repo.parameters["repository"] ==
"http://git.linaro.org/lava-team/lava-functional-tests.git"
):
self.assertIn("revision", git_repo.parameters)
self.assertIn("branch", git_repo.parameters)
else:
self.assertNotIn("revision", git_repo.parameters)
self.assertNotIn("branch", git_repo.parameters)
def test_overlay(self):
script_list = [
"lava-add-keys",
"lava-add-sources",
"lava-background-process-start",
"lava-background-process-stop",
"lava-echo-ipv4",
"lava-install-packages",
"lava-installed-packages",
"lava-os-build",
"lava-probe-channel",
"lava-probe-ip",
"lava-target-ip",
"lava-target-mac",
"lava-target-storage",
"lava-test-case",
"lava-test-event",
"lava-test-feedback",
"lava-test-reference",
"lava-test-runner",
"lava-test-set",
"lava-test-shell",
"lava-test-raise",
"lava-common-functions",
]
overlay = None
action = self.job.pipeline.actions[0]
for child in action.pipeline.actions:
if isinstance(child, OverlayAction):
overlay = child
break
self.assertIsInstance(overlay, OverlayAction)
# Generic scripts
scripts_to_copy = glob.glob(
os.path.join(overlay.lava_test_dir, "lava-*"))
distro_support_dir = "%s/distro/%s" % (overlay.lava_test_dir, "debian")
for script in glob.glob(os.path.join(distro_support_dir, "lava-*")):
scripts_to_copy.append(script)
check_list = list(
set([os.path.basename(scr) for scr in scripts_to_copy]))
self.assertCountEqual(check_list, script_list)
self.assertEqual(
overlay.xmod,
stat.S_IRWXU | stat.S_IXGRP | stat.S_IRGRP | stat.S_IXOTH
| stat.S_IROTH,
)
def test_overlay_override(self):
job = self.factory.create_job("qemu01.jinja2",
"sample_jobs/kvm-context.yaml")
deploy = [
action for action in job.pipeline.actions
if action.name == "deployimages"
][0]
overlay = [
action for action in deploy.pipeline.actions
if action.name == "lava-overlay"
][0]
self.assertEqual(
"/sysroot/lava-%s",
overlay.get_constant("lava_test_results_dir", "posix"))
def setUp(self):
super().setUp()
self.factory = Factory()
self.job = self.factory.create_kvm_job("sample_jobs/kvm-params.yaml")
