def test_job_multi(self):
MetaType.objects.all().delete()
multi_test_file = os.path.join(os.path.dirname(__file__),
'multi-test.yaml')
self.assertTrue(os.path.exists(multi_test_file))
with open(multi_test_file, 'r') as test_support:
data = test_support.read()
job = TestJob.from_yaml_and_user(data, self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(
job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition,
obj,
job.id,
None,
"",
output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
map_metadata(yaml.dump(pipeline), job)
def test_validate(self):
try:
allow_missing_path(self.job.pipeline.validate_actions, self, 'qemu-system-x86_64')
except JobError as exc:
self.fail(exc)
for action in self.job.pipeline.actions:
self.assertEqual([], action.errors)
def test_multinode_jobs(self):
self.assertIsNotNone(self.client_job)
self.assertIsNotNone(self.server_job)
allow_missing_path(self.client_job.validate, self, 'qemu-system-x86_64')
allow_missing_path(self.server_job.validate, self, 'qemu-system-x86_64')
self.assertEqual(self.client_job.pipeline.errors, [])
self.assertEqual(self.server_job.pipeline.errors, [])
def test_parameter_support(self): # pylint: disable=too-many-locals
data = self.factory.make_job_data()
test_block = [block for block in data['actions'] if 'test' in block][0]
smoke = test_block['test']['definitions'][0]
smoke['parameters'] = {
'VARIABLE_NAME_1': "first variable value",
'VARIABLE_NAME_2': "second value"
}
job = TestJob.from_yaml_and_user(yaml.dump(data), self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition, obj, job.id, None, "", output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
device_values = _get_device_metadata(pipeline['device'])
try:
testdata, _ = TestData.objects.get_or_create(testjob=job)
except (MultipleObjectsReturned):
self.fail('multiple objects')
for key, value in device_values.items():
if not key or not value:
continue
testdata.attributes.create(name=key, value=value)
retval = _get_job_metadata(pipeline['job']['actions'])
self.assertIn('test.0.common.definition.parameters.VARIABLE_NAME_2', retval)
self.assertIn('test.0.common.definition.parameters.VARIABLE_NAME_1', retval)
self.assertEqual(retval['test.0.common.definition.parameters.VARIABLE_NAME_1'], 'first variable value')
self.assertEqual(retval['test.0.common.definition.parameters.VARIABLE_NAME_2'], 'second value')
def test_multinode_jobs(self):
self.assertIsNotNone(self.client_job)
self.assertIsNotNone(self.server_job)
allow_missing_path(self.client_job.validate, self, 'qemu-system-x86_64')
allow_missing_path(self.server_job.validate, self, 'qemu-system-x86_64')
self.assertEqual(self.client_job.pipeline.errors, [])
self.assertEqual(self.server_job.pipeline.errors, [])
def test_repositories(self): # pylint: disable=too-many-locals
job = TestJob.from_yaml_and_user(self.factory.make_job_yaml(),
self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
job_ctx.update(
{'no_kvm':
True}) # override to allow unit tests on all types of systems
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(
job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition,
obj,
job.id,
None,
"",
output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
device_values = _get_device_metadata(pipeline['device'])
self.assertEqual(device_values, {'target.device_type': 'qemu'})
del pipeline['device']['device_type']
self.assertNotIn('device_type', pipeline['device'])
device_values = _get_device_metadata(pipeline['device'])
try:
testdata, _ = TestData.objects.get_or_create(testjob=job)
except (MultipleObjectsReturned):
self.fail('multiple objects')
for key, value in device_values.items():
if not key or not value:
continue
testdata.attributes.create(name=key, value=value)
retval = _get_job_metadata(pipeline['job']['actions'])
if 'lava-server-version' in retval:
del retval['lava-server-version']
self.assertEqual(
retval, {
'test.1.common.definition.from':
'git',
'test.0.common.definition.repository':
'git://git.linaro.org/qa/test-definitions.git',
'test.0.common.definition.name':
'smoke-tests',
'test.1.common.definition.repository':
'http://git.linaro.org/lava-team/lava-functional-tests.git',
'boot.0.common.method':
'qemu',
'test.1.common.definition.name':
'singlenode-advanced',
'test.0.common.definition.from':
'git',
'test.0.common.definition.path':
'ubuntu/smoke-tests-basic.yaml',
'test.1.common.definition.path':
'lava-test-shell/single-node/singlenode03.yaml'
})
def test_multinode_description(self):
self.assertIsNotNone(self.client_job)
allow_missing_path(self.client_job.validate, self, 'qemu-system-x86_64')
# check that the description can be re-loaded as valid YAML
for action in self.client_job.pipeline.actions:
data = action.explode()
data_str = yaml.dump(data)
yaml.load(data_str)
def test_validate(self):
try:
allow_missing_path(self.job.pipeline.validate_actions, self,
'qemu-system-x86_64')
except JobError as exc:
self.fail(exc)
for action in self.job.pipeline.actions:
self.assertEqual([], action.errors)
def test_multinode_description(self):
self.assertIsNotNone(self.client_job)
allow_missing_path(self.client_job.validate, self, 'qemu-system-x86_64')
# check that the description can be re-loaded as valid YAML
for action in self.client_job.pipeline.actions:
data = action.explode()
data_str = yaml.dump(data)
yaml.load(data_str)
def test_job(self):
MetaType.objects.all().delete()
TestJob.objects.all().delete()
job = TestJob.from_yaml_and_user(self.factory.make_job_yaml(),
self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
job_ctx.update(
{'no_kvm':
True}) # override to allow unit tests on all types of systems
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(
job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition,
obj,
job.id,
None,
"",
output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
map_metadata(yaml.dump(pipeline), job)
self.assertEqual(
MetaType.objects.filter(metatype=MetaType.DEPLOY_TYPE).count(), 1)
self.assertEqual(
MetaType.objects.filter(metatype=MetaType.BOOT_TYPE).count(), 1)
count = ActionData.objects.all().count()
self.assertEqual(TestData.objects.all().count(), 1)
testdata = TestData.objects.all()[0]
self.assertEqual(testdata.testjob, job)
for actionlevel in ActionData.objects.all():
self.assertEqual(actionlevel.testdata, testdata)
action_levels = []
for testdata in job.testdata_set.all():
action_levels.extend(testdata.actionlevels.all())
self.assertEqual(count, len(action_levels))
count = ActionData.objects.filter(
meta_type__metatype=MetaType.DEPLOY_TYPE).count()
self.assertNotEqual(
ActionData.objects.filter(
meta_type__metatype=MetaType.BOOT_TYPE).count(), 0)
self.assertEqual(
ActionData.objects.filter(
meta_type__metatype=MetaType.UNKNOWN_TYPE).count(), 0)
for actionlevel in ActionData.objects.filter(
meta_type__metatype=MetaType.BOOT_TYPE):
self.assertEqual(actionlevel.testdata.testjob.id, job.id)
self.assertEqual(
ActionData.objects.filter(meta_type__metatype=MetaType.DEPLOY_TYPE,
testdata__testjob=job).count(), count)
def test_parameter_support(self): # pylint: disable=too-many-locals
data = self.factory.make_job_data()
test_block = [block for block in data['actions'] if 'test' in block][0]
smoke = test_block['test']['definitions'][0]
smoke['parameters'] = {
'VARIABLE_NAME_1': "first variable value",
'VARIABLE_NAME_2': "second value"
}
job = TestJob.from_yaml_and_user(yaml.dump(data), self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
job_ctx.update(
{'no_kvm':
True}) # override to allow unit tests on all types of systems
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(
job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition,
obj,
job.id,
None,
"",
output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
device_values = _get_device_metadata(pipeline['device'])
try:
testdata, _ = TestData.objects.get_or_create(testjob=job)
except (MultipleObjectsReturned):
self.fail('multiple objects')
for key, value in device_values.items():
if not key or not value:
continue
testdata.attributes.create(name=key, value=value)
retval = _get_job_metadata(pipeline['job']['actions'])
self.assertIn('test.0.common.definition.parameters.VARIABLE_NAME_2',
retval)
self.assertIn('test.0.common.definition.parameters.VARIABLE_NAME_1',
retval)
self.assertEqual(
retval['test.0.common.definition.parameters.VARIABLE_NAME_1'],
'first variable value')
self.assertEqual(
retval['test.0.common.definition.parameters.VARIABLE_NAME_2'],
'second value')
def test_inline(self):
"""
Test inline can be parsed without run steps
"""
data = self.factory.make_job_data()
test_block = [block for block in data['actions'] if 'test' in block][0]
smoke = [{
"path": "inline/smoke-tests-basic.yaml",
"from": "inline",
"name": "smoke-tests-inline",
"repository": {
"install": {
"steps": [
"apt",
]
},
"metadata": {
"description":
"Basic system test command for Linaro Ubuntu images",
"format": "Lava-Test Test Definition 1.0",
"name": "smoke-tests-basic"
}
}
}]
test_block['test']['definitions'] = smoke
job = TestJob.from_yaml_and_user(yaml.dump(data), self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
job_ctx.update(
{'no_kvm':
True}) # override to allow unit tests on all types of systems
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(
job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition,
obj,
job.id,
None,
"",
output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
map_metadata(yaml.dump(pipeline), job)
def test_repositories(self): # pylint: disable=too-many-locals
job = TestJob.from_yaml_and_user(
self.factory.make_job_yaml(), self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition, obj, job.id, None, "", output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
device_values = _get_device_metadata(pipeline['device'])
self.assertEqual(
device_values,
{'target.device_type': 'qemu'}
)
del pipeline['device']['device_type']
self.assertNotIn('device_type', pipeline['device'])
device_values = _get_device_metadata(pipeline['device'])
try:
testdata, _ = TestData.objects.get_or_create(testjob=job)
except (MultipleObjectsReturned):
self.fail('multiple objects')
for key, value in device_values.items():
if not key or not value:
continue
testdata.attributes.create(name=key, value=value)
retval = _get_job_metadata(pipeline['job']['actions'])
if 'lava-server-version' in retval:
del retval['lava-server-version']
self.assertEqual(
retval,
{
'test.1.common.definition.from': 'git',
'test.0.common.definition.repository': 'git://git.linaro.org/qa/test-definitions.git',
'test.0.common.definition.name': 'smoke-tests',
'test.1.common.definition.repository': 'http://git.linaro.org/lava-team/lava-functional-tests.git',
'boot.0.common.method': 'qemu',
'test.1.common.definition.name': 'singlenode-advanced',
'test.0.common.definition.from': 'git',
'test.0.common.definition.path': 'ubuntu/smoke-tests-basic.yaml',
'test.1.common.definition.path': 'lava-test-shell/single-node/singlenode03.yaml'}
)
def test_job_multi(self):
MetaType.objects.all().delete()
multi_test_file = os.path.join(os.path.dirname(__file__), 'multi-test.yaml')
self.assertTrue(os.path.exists(multi_test_file))
with open(multi_test_file, 'r') as test_support:
data = test_support.read()
job = TestJob.from_yaml_and_user(data, self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition, obj, job.id, None, "", output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
map_metadata(yaml.dump(pipeline), job)
def test_inline(self):
"""
Test inline can be parsed without run steps
"""
data = self.factory.make_job_data()
test_block = [block for block in data['actions'] if 'test' in block][0]
smoke = [
{
"path": "inline/smoke-tests-basic.yaml",
"from": "inline",
"name": "smoke-tests-inline",
"repository": {
"install": {
"steps": [
"apt",
]
},
"metadata": {
"description": "Basic system test command for Linaro Ubuntu images",
"format": "Lava-Test Test Definition 1.0",
"name": "smoke-tests-basic"
}
}
}
]
test_block['test']['definitions'] = smoke
job = TestJob.from_yaml_and_user(yaml.dump(data), self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition, obj, job.id, None, "", output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
map_metadata(yaml.dump(pipeline), job)
def test_job(self):
MetaType.objects.all().delete()
TestJob.objects.all().delete()
job = TestJob.from_yaml_and_user(
self.factory.make_job_yaml(), self.user)
job_def = yaml.load(job.definition)
job_ctx = job_def.get('context', {})
device = Device.objects.get(hostname='fakeqemu1')
device_config = device.load_device_configuration(job_ctx, system=False) # raw dict
parser = JobParser()
obj = PipelineDevice(device_config, device.hostname)
pipeline_job = parser.parse(job.definition, obj, job.id, None, "", output_dir='/tmp')
allow_missing_path(pipeline_job.pipeline.validate_actions, self,
'qemu-system-x86_64')
pipeline = pipeline_job.describe()
map_metadata(yaml.dump(pipeline), job)
self.assertEqual(MetaType.objects.filter(metatype=MetaType.DEPLOY_TYPE).count(), 1)
self.assertEqual(MetaType.objects.filter(metatype=MetaType.BOOT_TYPE).count(), 1)
count = ActionData.objects.all().count()
self.assertEqual(TestData.objects.all().count(), 1)
testdata = TestData.objects.all()[0]
self.assertEqual(testdata.testjob, job)
for actionlevel in ActionData.objects.all():
self.assertEqual(actionlevel.testdata, testdata)
action_levels = []
for testdata in job.testdata_set.all():
action_levels.extend(testdata.actionlevels.all())
self.assertEqual(count, len(action_levels))
count = ActionData.objects.filter(meta_type__metatype=MetaType.DEPLOY_TYPE).count()
self.assertNotEqual(ActionData.objects.filter(meta_type__metatype=MetaType.BOOT_TYPE).count(), 0)
self.assertEqual(ActionData.objects.filter(meta_type__metatype=MetaType.UNKNOWN_TYPE).count(), 0)
for actionlevel in ActionData.objects.filter(meta_type__metatype=MetaType.BOOT_TYPE):
self.assertEqual(actionlevel.testdata.testjob.id, job.id)
self.assertEqual(ActionData.objects.filter(
meta_type__metatype=MetaType.DEPLOY_TYPE,
testdata__testjob=job
).count(), count)
def test_basic_structure(self):
self.assertIsNotNone(self.job)
allow_missing_path(self.job.validate, self, 'qemu-system-x86_64')
self.assertEqual([], self.job.pipeline.errors)
description_ref = self.pipeline_reference('kvm-repeat.yaml')
self.assertEqual(description_ref, self.job.pipeline.describe(False))
def test_basic_structure(self):
self.assertIsNotNone(self.job)
allow_missing_path(self.job.validate, self, 'qemu-system-x86_64')
self.assertEqual([], self.job.pipeline.errors)
description_ref = pipeline_reference('kvm-repeat.yaml')
self.assertEqual(description_ref, self.job.pipeline.describe(False))
