def test_device_power(self):
device = NewDevice(
os.path.join(os.path.dirname(__file__), '../devices/bbb-01.yaml'))
self.assertNotEqual(device.hard_reset_command, '')
device = NewDevice(
os.path.join(os.path.dirname(__file__), '../devices/kvm01.yaml'))
self.assertEqual(device.hard_reset_command, '')
def test_device_constants(self):
device = NewDevice(
os.path.join(os.path.dirname(__file__), '../devices/bbb-01.yaml'))
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 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 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(TestMultiNodeOverlay, self).setUp()
factory = X86Factory()
lng1 = NewDevice(
os.path.join(os.path.dirname(__file__),
'../devices/lng-generator-01.yaml'))
lng2 = NewDevice(
os.path.join(os.path.dirname(__file__),
'../devices/lng-generator-02.yaml'))
self.server_job = factory.create_x86_job(
'sample_jobs/test_action-1.yaml', lng1)
self.client_job = factory.create_x86_job(
'sample_jobs/test_action-2.yaml', lng2)
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 test_prompt_from_job(self): # pylint: disable=too-many-locals
"""
Support setting the prompt after login via the job
Loads a known YAML, adds a prompt to the dict and re-parses the job.
Checks that the prompt is available in the expect_shell_connection action.
"""
job = self.factory.create_job('sample_jobs/ipxe-ramdisk.yaml')
job.validate()
bootloader = [action for action in job.pipeline.actions if action.name == 'bootloader-action'][0]
retry = [action for action in bootloader.internal_pipeline.actions
if action.name == 'bootloader-retry'][0]
expect = [action for action in retry.internal_pipeline.actions
if action.name == 'expect-shell-connection'][0]
check = expect.parameters
device = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/x86-01.yaml'))
extra_yaml = os.path.join(os.path.dirname(__file__), 'sample_jobs/ipxe.yaml')
with open(extra_yaml) as data:
sample_job_string = data.read()
parser = JobParser()
sample_job_data = yaml.load(sample_job_string)
boot = [item['boot'] for item in sample_job_data['actions'] if 'boot' in item][0]
self.assertIsNotNone(boot)
sample_job_string = yaml.dump(sample_job_data)
job = parser.parse(sample_job_string, device, 4212, None, "")
job.logger = DummyLogger()
job.validate()
bootloader = [action for action in job.pipeline.actions if action.name == 'bootloader-action'][0]
retry = [action for action in bootloader.internal_pipeline.actions
if action.name == 'bootloader-retry'][0]
expect = [action for action in retry.internal_pipeline.actions
if action.name == 'expect-shell-connection'][0]
def test_device_environment(self):
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.internal_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.internal_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 test_uboot_checksum(self):
device = NewDevice(
os.path.join(os.path.dirname(__file__), '../devices/bbb-01.yaml'))
bbb_yaml = os.path.join(os.path.dirname(__file__),
'sample_jobs/bbb-ramdisk-nfs.yaml')
with open(bbb_yaml) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, device, 4212, None, "")
deploy = [
action for action in job.pipeline.actions
if action.name == 'tftp-deploy'
][0]
download = [
action for action in deploy.internal_pipeline.actions
if action.name == 'download-retry'
][0]
helper = [
action for action in download.internal_pipeline.actions
if action.name == 'file-download'
][0]
remote = helper.parameters[helper.key]
md5sum = remote.get('md5sum', None)
self.assertIsNone(md5sum)
sha256sum = remote.get('sha256sum', None)
self.assertIsNotNone(sha256sum)
def test_job_protocols(self):
self.factory.ensure_tag('usb-eth')
self.factory.ensure_tag('sata')
self.factory.bbb1.tags = Tag.objects.filter(name='usb-eth')
self.factory.bbb1.save()
self.factory.cubie1.tags = Tag.objects.filter(name='sata')
self.factory.cubie1.save()
target_group = "unit-test-only"
job_dict = split_multinode_yaml(self.factory.make_vland_job(),
target_group)
client_job = job_dict['client'][0]
client_handle, client_file_name = tempfile.mkstemp()
yaml.dump(client_job, open(client_file_name, 'w'))
# YAML device file, as required by lava-dispatch --target
device_yaml_file = os.path.realpath(
os.path.join(os.path.dirname(__file__), 'devices', 'bbb-01.yaml'))
self.assertTrue(os.path.exists(device_yaml_file))
parser = JobParser()
bbb_device = NewDevice(device_yaml_file)
with open(client_file_name) as sample_job_data:
bbb_job = parser.parse(sample_job_data, bbb_device, 4212, None, "")
os.close(client_handle)
os.unlink(client_file_name)
self.assertIn('protocols', bbb_job.parameters)
self.assertIn(VlandProtocol.name, bbb_job.parameters['protocols'])
self.assertIn(MultinodeProtocol.name, bbb_job.parameters['protocols'])
def test_compatibility(self):
"""
Test compatibility support.
The class to use in the comparison will change according to which class
is related to the change which caused the compatibility to be modified.
"""
factory = Factory()
job = factory.create_kvm_job('sample_jobs/kvm.yaml')
pipe = job.describe()
self.assertEqual(pipe['compatibility'], DeployImages.compatibility)
self.assertEqual(job.compatibility, DeployImages.compatibility)
kvm_yaml = os.path.join(os.path.dirname(__file__), 'sample_jobs/kvm.yaml')
with open(kvm_yaml, 'r') as kvm_yaml:
job_def = yaml.load(kvm_yaml)
job_def['compatibility'] = job.compatibility
parser = JobParser()
device = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/kvm01.yaml'))
try:
job = parser.parse(yaml.dump(job_def), device, 4212, None, "")
except NotImplementedError:
# some deployments listed in basics.yaml are not implemented yet
pass
self.assertIsNotNone(job)
job_def['compatibility'] = job.compatibility + 1
self.assertRaises(
JobError, parser.parse, yaml.dump(job_def), device, 4212, None, ""
)
job_def['compatibility'] = 0
try:
job = parser.parse(yaml.dump(job_def), device, 4212, None, "")
except NotImplementedError:
# some deployments listed in basics.yaml are not implemented yet
pass
self.assertIsNotNone(job)
def test_uboot_checksum(self):
(rendered, _) = self.factory.create_device("bbb-01.jinja2")
device = NewDevice(yaml.safe_load(rendered))
bbb_yaml = os.path.join(os.path.dirname(__file__),
"sample_jobs/bbb-ramdisk-nfs.yaml")
with open(bbb_yaml) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, device, 4212, None, "")
deploy = [
action for action in job.pipeline.actions
if action.name == "tftp-deploy"
][0]
download = [
action for action in deploy.internal_pipeline.actions
if action.name == "download-retry"
][0]
helper = [
action for action in download.internal_pipeline.actions
if action.name == "file-download"
][0]
remote = helper.parameters[helper.key]
md5sum = remote.get("md5sum")
self.assertIsNone(md5sum)
sha256sum = remote.get("sha256sum")
self.assertIsNotNone(sha256sum)
def test_device_environment_validity(self): # pylint: disable=invalid-name
"""
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.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_panda_lxc_template(self):
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
logger = logging.getLogger("unittests")
logger.disabled = True
logger.propagate = False
logger = logging.getLogger("dispatcher")
logging.disable(logging.DEBUG)
logger.disabled = True
logger.propagate = False
data = """{% extends 'panda.jinja2' %}
{% set power_off_command = '/usr/local/lab-scripts/snmp_pdu_control --hostname pdu15 --command off --port 07' %}
{% set hard_reset_command = '/usr/local/lab-scripts/snmp_pdu_control --hostname pdu15 --command reboot --port 07' %}
{% set connection_command = 'telnet serial4 7010' %}
{% set power_on_command = '/usr/local/lab-scripts/snmp_pdu_control --hostname pdu15 --command on --port 07' %}"""
self.assertTrue(self.validate_data("staging-panda-01", data))
template_dict = prepare_jinja_template("staging-panda-01", data, raw=False)
fdesc, device_yaml = tempfile.mkstemp()
os.write(fdesc, yaml.dump(template_dict).encode())
panda = NewDevice(device_yaml)
lxc_yaml = os.path.join(
os.path.dirname(__file__), "sample_jobs", "panda-lxc-aep.yaml"
)
with open(lxc_yaml) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, panda, 4577, None, "")
os.close(fdesc)
job.logger = DummyLogger()
job.logger.disabled = True
job.logger.propagate = False
job.validate()
def create_kvm_job(self, filename, validate=False):
"""
Custom function to allow for extra exception handling.
"""
job_ctx = {
"arch": "amd64",
"no_kvm": True,
} # override to allow unit tests on all types of systems
(data, device_dict) = self.create_device("kvm01.jinja2", job_ctx)
device = NewDevice(yaml_safe_load(data))
print("####### Device configuration #######")
print(data)
print("#######")
self.validate_data("hi6220-hikey-01", device_dict)
kvm_yaml = os.path.join(os.path.dirname(__file__), filename)
parser = JobParser()
job_data = ""
with open(kvm_yaml) as sample_job_data:
job_data = yaml_safe_load(sample_job_data.read())
print("########## Test Job Submission validation #######")
if validate:
validate_job(job_data, strict=False)
try:
job = parser.parse(yaml_safe_dump(job_data), device, 4212, None,
"")
job.logger = DummyLogger()
except LAVAError as exc:
print(exc)
return None
return job
def test_lxc_without_lxctest(self):
lxc_yaml = os.path.join(os.path.dirname(__file__),
"sample_jobs/bbb-lxc-notest.yaml")
with open(lxc_yaml) as sample_job_data:
data = yaml_safe_load(sample_job_data)
parser = JobParser()
(rendered, _) = self.factory.create_device("bbb-01.jinja2")
device = NewDevice(yaml_safe_load(rendered))
job = parser.parse(yaml_safe_dump(data), device, 4577, None, "")
job.logger = DummyLogger()
job.validate()
lxc_deploy = [
action for action in job.pipeline.actions
if action.name == "lxc-deploy"
][0]
names = [action.name for action in lxc_deploy.pipeline.actions]
self.assertNotIn("prepare-tftp-overlay", names)
namespace1 = lxc_deploy.parameters.get("namespace")
tftp_deploy = [
action for action in job.pipeline.actions
if action.name == "tftp-deploy"
][0]
prepare = [
action for action in tftp_deploy.pipeline.actions
if action.name == "prepare-tftp-overlay"
][0]
overlay = [
action for action in prepare.pipeline.actions
if action.name == "lava-overlay"
][0]
test_def = [
action for action in overlay.pipeline.actions
if action.name == "test-definition"
][0]
namespace = test_def.parameters.get("namespace")
self.assertIsNotNone(namespace)
self.assertIsNotNone(namespace1)
self.assertNotEqual(namespace, namespace1)
self.assertNotEqual(self.job.pipeline.describe(False),
job.pipeline.describe(False))
test_actions = [
action for action in job.parameters["actions"] if "test" in action
]
for action in test_actions:
if "namespace" in action["test"]:
if action["test"]["namespace"] == namespace:
self.assertEqual(action["test"]["definitions"][0]["name"],
"smoke-tests-bbb")
else:
self.fail("Found a test action not from the tftp boot")
namespace_tests = [
action["test"]["definitions"] for action in test_actions
if "namespace" in action["test"]
and action["test"]["namespace"] == namespace
]
self.assertEqual(len(namespace_tests), 1)
self.assertEqual(len(test_actions), 1)
description_ref = self.pipeline_reference("bbb-lxc-notest.yaml",
job=job)
self.assertEqual(description_ref, job.pipeline.describe(False))
def create_custom_job(self,
template,
job_data,
job_ctx=None,
validate=True):
if validate:
validate_job(job_data, strict=False)
if job_ctx:
job_data["context"] = job_ctx
else:
job_ctx = job_data.get("context")
(data, device_dict) = self.create_device(template, job_ctx)
device = NewDevice(yaml_safe_load(data))
print("####### Device configuration #######")
print(data)
print("#######")
try:
parser = JobParser()
job = parser.parse(yaml_safe_dump(job_data), device, 4999, None,
"")
except (ConfigurationError, TypeError) as exc:
print("####### Parser exception ########")
print(device)
print("#######")
raise ConfigurationError("Invalid device: %s" % exc)
job.logger = DummyLogger()
return job
def test_extra_options(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-inline.yaml')
with open(kvm_yaml) as sample_job_data:
job_data = yaml.safe_load(sample_job_data)
device['actions']['boot']['methods']['qemu']['parameters']['extra'] = yaml.safe_load("""
- -smp
- 1
- -global
- virtio-blk-device.scsi=off
- -device virtio-scsi-device,id=scsi
- --append "console=ttyAMA0 root=/dev/vda rw"
""")
self.assertIsInstance(device['actions']['boot']['methods']['qemu']['parameters']['extra'][1], int)
parser = JobParser()
job = parser.parse(yaml.dump(job_data), device, 4212, None, "")
job.logger = DummyLogger()
job.validate()
boot_image = [action for action in job.pipeline.actions if action.name == 'boot-image-retry'][0]
boot_qemu = [action for action in boot_image.internal_pipeline.actions if action.name == 'boot-qemu-image'][0]
qemu = [action for action in boot_qemu.internal_pipeline.actions if action.name == 'execute-qemu'][0]
self.assertIsInstance(qemu.sub_command, list)
[self.assertIsInstance(item, str) for item in qemu.sub_command] # pylint: disable=expression-not-assigned
self.assertIn('virtio-blk-device.scsi=off', qemu.sub_command)
self.assertIn('1', qemu.sub_command)
self.assertNotIn(1, qemu.sub_command)
def create_download_job(self, filename): # pylint: disable=no-self-use
device = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/db410c-01.yaml'))
download_yaml = os.path.join(os.path.dirname(__file__), filename)
with open(download_yaml) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, device, 4212, None, "")
return job
def create_kvm_job(self, filename, check_job=False): # pylint: disable=no-self-use
"""
Custom function to allow for extra exception handling.
"""
job_ctx = {
'arch': 'amd64',
'no_kvm': True
} # override to allow unit tests on all types of systems
(data, device_dict) = self.create_device('kvm01.jinja2', job_ctx)
device = NewDevice(yaml.safe_load(data))
if self.debug:
print('####### Device configuration #######')
print(data)
print('#######')
self.validate_data('hi6220-hikey-01', device_dict)
kvm_yaml = os.path.join(os.path.dirname(__file__), filename)
parser = JobParser()
job_data = ''
with open(kvm_yaml) as sample_job_data:
job_data = yaml.safe_load(sample_job_data.read())
if self.debug:
print('########## Test Job Submission validation #######')
if check_job: # FIXME: all submissions should validate.
validate_submission(job_data)
try:
job = parser.parse(yaml.dump(job_data), device, 4212, None, "")
job.logger = DummyLogger()
except LAVAError as exc:
print(exc)
# some deployments listed in basics.yaml are not implemented yet
return None
return job
def test_configure(self):
with open(self.filename) as yaml_data:
alpha_data = yaml_safe_load(yaml_data)
self.assertIn("protocols", alpha_data)
self.assertTrue(VlandProtocol.accepts(alpha_data))
vprotocol = VlandProtocol(alpha_data, self.job_id)
vprotocol.set_up()
with open(self.filename) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, self.device, 4212, None, "")
ret = vprotocol.configure(self.device, job)
if not ret:
print(vprotocol.errors)
self.assertTrue(ret)
nodes = {}
for name in vprotocol.names:
vlan = vprotocol.params[name]
# self.assertNotIn('tags', vlan)
uid = " ".join([vlan["switch"], str(vlan["port"])])
nodes[uid] = name
self.assertEqual(len(nodes.keys()), len(vprotocol.names))
self.assertIn("vlan_one", vprotocol.names)
self.assertNotIn("vlan_two", vprotocol.names)
self.assertIn("switch", vprotocol.params["vlan_one"])
self.assertIn("port", vprotocol.params["vlan_one"])
self.assertIsNotNone(vprotocol.multinode_protocol)
(rendered, _) = self.factory.create_device("bbb-01.jinja2")
bbb2 = NewDevice(yaml_safe_load(rendered))
bbb2["parameters"]["interfaces"]["eth0"]["switch"] = "192.168.0.2"
bbb2["parameters"]["interfaces"]["eth0"]["port"] = "6"
bbb2["parameters"]["interfaces"]["eth1"]["switch"] = "192.168.0.2"
bbb2["parameters"]["interfaces"]["eth1"]["port"] = "4"
self.assertEqual(
vprotocol.params,
{
"vlan_one": {
"switch": "192.168.0.2",
"iface": "eth1",
"port": 7,
"tags": ["100M", "RJ45", "10M"],
}
},
)
# already configured the vland protocol in the same job
self.assertTrue(vprotocol.configure(bbb2, job))
self.assertEqual(
vprotocol.params,
{
"vlan_one": {
"switch": "192.168.0.2",
"iface": "eth1",
"port": 7,
"tags": ["100M", "RJ45", "10M"],
}
},
)
self.assertTrue(vprotocol.valid)
self.assertEqual(vprotocol.names, {"vlan_one": "4212vlanone"})
def test_job_parameters(self):
"""
Test that the job parameters match expected structure
"""
cubie = NewDevice(
os.path.join(os.path.dirname(__file__), '../devices/cubie1.yaml'))
job = self._check_valid_job(cubie, 'cubietruck-removable.yaml')
self._check_job_parameters(cubie, job, 'download')
def setUp(self):
super().setUp()
self.device = NewDevice(
os.path.join(os.path.dirname(__file__), '../devices/bbb-01.yaml'))
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.load(sample_job_data)
def create_job(self, sample_job, device_file): # pylint: disable=no-self-use
device = NewDevice(os.path.join(os.path.dirname(__file__), device_file))
j_yaml = os.path.join(os.path.dirname(__file__), sample_job)
with open(j_yaml) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, device, 4212, None, "")
job.logger = DummyLogger()
return job
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 create_k64f_job_with_power(self, filename): # pylint: disable=no-self-use
device = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/frdm-k64f-01-with-power.yaml'))
y_file = os.path.join(os.path.dirname(__file__), filename)
with open(y_file) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, device, 5999, None, "")
job.logger = DummyLogger()
return job
def create_job(self, filename): # pylint: disable=no-self-use
device = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/x86-01.yaml'))
y_file = os.path.join(os.path.dirname(__file__), filename)
with open(y_file) as sample_job_data:
parser = JobParser()
job = parser.parse(sample_job_data, device, 4212, None, "")
job.logger = DummyLogger()
return job
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_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 create_b2260_job(self, filename):
# FIXME: b2260 Jinja2 template does not have flasher support.
device = NewDevice(
os.path.join(os.path.dirname(__file__), "devices/b2260-01.yaml"))
with open(os.path.join(os.path.dirname(__file__), filename)) as f_in:
parser = JobParser()
job = parser.parse(f_in, device, 456, None, "")
job.logger = DummyLogger()
return job
def test_device_parameters(self):
"""
Test that the correct parameters have been set for the device
"""
cubie = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/cubie1.yaml'))
self.assertIsNotNone(cubie['parameters']['media'].get('usb', None))
self.assertIsNotNone(cubie.get('commands', None))
self.assertIsNotNone(cubie.get('actions', None))
self.assertIsNotNone(cubie['actions'].get('deploy', None))
self.assertIsNotNone(cubie['actions']['deploy'].get('methods', None))
self.assertIn('usb', cubie['actions']['deploy']['methods'])
self.assertIsNotNone(cubie['actions'].get('boot', None))
self.assertIsNotNone(cubie['actions']['boot'].get('methods', None))
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('boot_message', u_boot_params['parameters'])
self.assertIn('bootloader_prompt', u_boot_params['parameters'])
def test_device_constants(self):
device = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/bbb-01.yaml'))
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 test_substitutions(self):
"""
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()
cubie = NewDevice(os.path.join(os.path.dirname(__file__), '../devices/cubie1.yaml'))
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].internal_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.internal_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', None))
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)
self.assertEqual(
commands,
[
'usb start',
'usb info',
'setenv autoload no',
"setenv initrd_high '0xffffffff'",
"setenv fdt_high '0xffffffff'",
'setenv initrd_addr_r ${ramdisk_addr_r}',
"setenv loadkernel 'load usb 0:1 ${kernel_addr_r} /boot/vmlinuz-3.16.0-4-armmp-lpae'",
"setenv loadinitrd 'load usb 0:1 ${initrd_addr_r} /boot/initrd.img-3.16.0-4-armmp-lpae.u-boot; setenv initrd_size ${filesize}'",
"setenv loadfdt 'load usb 0:1 ${fdt_addr_r} /boot/dtb-3.16.0-4-armmp-lpae'",
"setenv bootargs 'console=ttyS0,115200n8 root=UUID=159d17cc-697c-4125-95a0-a3775e1deabe ip=dhcp'",
"setenv bootcmd 'run loadkernel; run loadinitrd; run loadfdt; bootz 0x42000000 0x43300000 0x43000000'", 'boot'
]
)
