def test__errors_on_bad_yaml(self):
form = ScriptForm(
data={
'name': factory.make_name('name'),
'script': factory.make_script_content('# {'),
})
self.assertFalse(form.is_valid())
def test_packages_validate(self):
apt_pkgs = [factory.make_name('apt_pkg') for _ in range(3)]
snap_pkg = {
'name': factory.make_name('snap_pkg'),
'channel': random.choice(['stable', 'edge', 'beta', 'candidate']),
'mode': random.choice(['classic', 'dev', 'jail']),
}
url = factory.make_url()
form = ScriptForm(
data={
'script':
factory.make_script_content({
'name': factory.make_name('name'),
'packages': {
'apt': apt_pkgs,
'snap': snap_pkg,
'url': url
},
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertDictEqual(
{
'apt': apt_pkgs,
'snap': [snap_pkg],
'url': [url]
}, script.packages)
def test__update_edit_default_allows_update_of_all_fields(self):
script = factory.make_Script(default=True)
for name, field in ScriptForm.base_fields.items():
if name == 'script_type':
value = factory.pick_choice(SCRIPT_TYPE_CHOICES)
elif name == 'hardware_type':
value = factory.pick_choice(HARDWARE_TYPE_CHOICES)
elif name == 'parallel':
value = factory.pick_choice(SCRIPT_PARALLEL_CHOICES)
elif name in ['destructive', 'may_reboot']:
value = factory.pick_bool()
elif name == 'packages':
value = json.dumps({'apt': [factory.make_name('package')]})
elif name == 'timeout':
value = str(random.randint(0, 1000))
elif name == 'script':
value = factory.make_script_content()
elif name == 'comment':
# A comment must be done with a script
continue
elif name in ['for_hardware', 'recommission']:
# Only available on commissioning scripts
continue
else:
value = factory.make_string()
form = ScriptForm(data={name: value},
instance=script,
edit_default=True)
self.assertTrue(form.is_valid(), form.errors)
def test__create_with_default_values(self):
name = factory.make_name('name')
script_content = factory.make_script_content()
form = ScriptForm(data={'name': name, 'script': script_content})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(name, script.name)
self.assertEquals('', script.title)
self.assertEquals('', script.description)
self.assertEquals(1, len(script.tags))
self.assertEquals(SCRIPT_TYPE.TESTING, script.script_type)
self.assertEquals(HARDWARE_TYPE.NODE, script.hardware_type)
self.assertEquals(SCRIPT_PARALLEL.DISABLED, script.parallel)
self.assertDictEqual({}, script.packages)
self.assertDictEqual({}, script.results)
self.assertDictEqual({}, script.parameters)
self.assertEquals(timedelta(0), script.timeout)
self.assertFalse(script.destructive)
self.assertEquals(script_content, script.script.data)
self.assertFalse(script.default)
self.assertItemsEqual([], script.for_hardware)
self.assertFalse(script.may_reboot)
self.assertFalse(script.recommission)
def test_converts_single_package_to_list(self):
apt_pkg = factory.make_name("apt_pkg")
snap_pkg = factory.make_name("snap_pkg")
url = factory.make_url()
form = ScriptForm(
data={
"script":
factory.make_script_content({
"name": factory.make_name("name"),
"packages": {
"apt": apt_pkg,
"snap": snap_pkg,
"url": url,
},
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertDictEqual(
{
"apt": [apt_pkg],
"snap": [snap_pkg],
"url": [url]
},
script.packages,
)
def test__update_script_doesnt_effect_other_fields(self):
script = factory.make_Script()
script_content = factory.make_script_content()
name = script.name
title = script.title
description = script.description
tags = script.tags
script_type = script.script_type
hardware_type = script.hardware_type
parallel = script.parallel
results = script.results
parameters = script.parameters
packages = script.packages
timeout = script.timeout
destructive = script.destructive
form = ScriptForm(data={'script': script_content}, instance=script)
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(name, script.name)
self.assertEquals(title, script.title)
self.assertEquals(description, script.description)
self.assertEquals(tags, script.tags)
self.assertEquals(script_type, script.script_type)
self.assertEquals(hardware_type, script.hardware_type)
self.assertDictEqual(packages, script.packages)
self.assertEquals(parallel, script.parallel)
self.assertDictEqual(results, script.results)
self.assertDictEqual(parameters, script.parameters)
self.assertEquals(timeout, script.timeout)
self.assertEquals(destructive, script.destructive)
self.assertFalse(script.default)
self.assertEquals(script_content, script.script.data)
def test_packages_validate(self):
apt_pkgs = [factory.make_name("apt_pkg") for _ in range(3)]
snap_pkg = {
"name": factory.make_name("snap_pkg"),
"channel": random.choice(["stable", "edge", "beta", "candidate"]),
"mode": random.choice(["classic", "dev", "jail"]),
}
url = factory.make_url()
form = ScriptForm(
data={
"script":
factory.make_script_content({
"name": factory.make_name("name"),
"packages": {
"apt": apt_pkgs,
"snap": snap_pkg,
"url": url,
},
})
})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertDictEqual(
{
"apt": apt_pkgs,
"snap": [snap_pkg],
"url": [url]
},
script.packages,
)
def test_errors_on_bad_yaml(self):
form = ScriptForm(
data={
"name": factory.make_name("name"),
"script": factory.make_script_content("# {"),
})
self.assertFalse(form.is_valid())
def test_POST_creates_commissioning_script(self):
# This uses Piston's built-in POST code, so there are no tests for
# corner cases (like "script already exists") here.
name = factory.make_name("script")
content = factory.make_script_content()
# Every uploaded file also has a name. But this is completely
# unrelated to the name we give to the commissioning script.
response = self.client.post(
self.get_url(),
{
"name": name,
"content": factory.make_file_upload(content=content.encode()),
},
)
self.assertThat(response, HasStatusCode(http.client.OK))
returned_script = json_load_bytes(response.content)
self.assertEquals(name, returned_script["name"])
self.assertEquals(content.encode(),
b64decode(returned_script["content"]))
stored_script = Script.objects.get(name=name)
self.assertEqual(content, stored_script.script.data)
self.assertEqual(SCRIPT_TYPE.COMMISSIONING, stored_script.script_type)
def test_title_description_of_result_must_be_strings(self):
results = {
factory.make_name("result"): {
"title": None,
"description": None
}
}
form = ScriptForm(
data={
"script":
factory.make_script_content({
"name": factory.make_name("name"),
"results": results
})
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"results": [
"title must be a string.",
"description must be a string.",
]
},
form.errors,
)
self.assertItemsEqual([], VersionedTextFile.objects.all())
def test__loads_yaml_embedded_attributes(self):
embedded_yaml = {
'name': factory.make_name('name'),
'title': factory.make_name('title'),
'description': factory.make_name('description'),
'tags': [factory.make_name('tag') for _ in range(3)],
'script_type': factory.pick_choice(SCRIPT_TYPE_CHOICES),
'hardware_type': factory.pick_choice(HARDWARE_TYPE_CHOICES),
'parallel': factory.pick_choice(SCRIPT_PARALLEL_CHOICES),
'results': ['write_speed'],
'parameters': [{'type': 'storage'}, {'type': 'runtime'}],
'packages': {'apt': [factory.make_name('package')]},
'timeout': random.randint(0, 1000),
'destructive': factory.pick_bool(),
}
script_content = factory.make_script_content(embedded_yaml)
form = ScriptForm(data={'script': script_content})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(embedded_yaml['name'], script.name)
self.assertEquals(embedded_yaml['title'], script.title)
self.assertEquals(embedded_yaml['description'], script.description)
self.assertThat(script.tags, ContainsAll(embedded_yaml['tags']))
self.assertEquals(embedded_yaml['script_type'], script.script_type)
self.assertEquals(embedded_yaml['hardware_type'], script.hardware_type)
self.assertEquals(embedded_yaml['parallel'], script.parallel)
self.assertItemsEqual(embedded_yaml['results'], script.results)
self.assertItemsEqual(embedded_yaml['parameters'], script.parameters)
self.assertDictEqual(embedded_yaml['packages'], script.packages)
self.assertEquals(
timedelta(0, embedded_yaml['timeout']), script.timeout)
self.assertEquals(embedded_yaml['destructive'], script.destructive)
self.assertFalse(script.default)
self.assertEquals(script_content, script.script.data)
def test__user_option_unable_to_over_yaml_value(self):
name = factory.make_name('name')
form = ScriptForm(data={
'name': name,
'script': factory.make_script_content(
{'name': factory.make_name('name')}),
})
self.assertFalse(form.is_valid())
def test__errors_on_reserved_name(self):
form = ScriptForm(data={
"name": "none",
"script": factory.make_script_content()
})
self.assertFalse(form.is_valid())
self.assertDictEqual({"name": ['"none" is a reserved name.']},
form.errors)
def test_propagates_script_form_errors(self):
# Regression test for LP:1712422
uploaded_file = SimpleUploadedFile(
content=factory.make_script_content().encode("ascii"), name="none")
form = TestingScriptForm(files={"content": uploaded_file})
self.assertFalse(form.is_valid())
self.assertDictEqual({"content": ['name: "none" is a reserved name.']},
form.errors)
def test_PUT_updates_contents(self):
old_content = factory.make_script_content().encode("ascii")
script = factory.make_Script(
script_type=SCRIPT_TYPE.COMMISSIONING, script=old_content
)
new_content = factory.make_script_content().encode("ascii")
response = self.client.put(
self.get_url(script.name),
{"content": factory.make_file_upload(content=new_content)},
)
self.assertThat(response, HasStatusCode(http.client.OK))
self.assertEquals(rc.ALL_OK.content, response.content)
self.assertEqual(
new_content.decode("utf-8"), reload_object(script).script.data
)
def test__errors_on_digit_name(self):
form = ScriptForm(
data={
"name": str(random.randint(0, 1000)),
"script": factory.make_script_content(),
})
self.assertFalse(form.is_valid())
self.assertDictEqual({"name": ["Cannot be a number."]}, form.errors)
def test__only_loads_when_script_updated(self):
script = factory.make_Script(script=factory.make_script_content(
{"name": factory.make_name("name")}))
name = factory.make_name("name")
form = ScriptForm(instance=script, data={"name": name})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(name, script.name)
def test__errors_on_reserved_name(self):
form = ScriptForm(data={
'name': 'none',
'script': factory.make_script_content(),
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'name': ['"none" is a reserved name.']}, form.errors)
def tests_yaml_tags_can_be_list_of_strings(self):
tags = [factory.make_name('tag') for _ in range(3)]
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'tags': tags,
})})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertThat(script.tags, ContainsAll(tags))
def test__ignores_other_version_yaml(self):
script = factory.make_Script()
name = script.name
form = ScriptForm(instance=script, data={
'script': factory.make_script_content(
{'name': factory.make_name('name')}, version='9.0')})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertEquals(name, script.name)
def test__allows_list_of_results(self):
results = [factory.make_name('result') for _ in range(3)]
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'results': results,
})})
self.assertTrue(form.is_valid(), form.errors)
script = form.save()
self.assertItemsEqual(results, script.results)
def test__errors_on_missing_comment_on_yaml(self):
form = ScriptForm(
data={
"name":
factory.make_name("name"),
"script":
factory.make_script_content(factory.make_name("bad_yaml")),
})
self.assertFalse(form.is_valid())
def test__create_setting_default_has_no_effect(self):
form = ScriptForm(data={
'name': factory.make_name('name'),
'script': factory.make_script_content(),
'default': True,
})
self.assertTrue(form.is_valid())
script = form.save()
self.assertFalse(script.default)
def test__errors_when_url_package_isnt_string(self):
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'packages': {'url': {}}
})})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'packages': ['Each url package must be a string.']},
form.errors)
self.assertItemsEqual([], VersionedTextFile.objects.all())
def test__type_aliased_to_script_type(self):
script_type = factory.pick_choice(SCRIPT_TYPE_CHOICES)
form = ScriptForm(data={
'name': factory.make_name('name'),
'script': factory.make_script_content(),
'type': script_type,
})
self.assertTrue(form.is_valid())
script = form.save()
self.assertEquals(script_type, script.script_type)
def test__snap_package_dict_requires_name(self):
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'packages': {'snap': {}},
})})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'packages': ['Snap package name must be defined.']},
form.errors)
self.assertItemsEqual([], VersionedTextFile.objects.all())
def test__snap_package_list_must_be_strings(self):
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'packages': {'snap': [[]]},
})})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'packages': ['Snap package must be a string.']},
form.errors)
self.assertItemsEqual([], VersionedTextFile.objects.all())
def test__errors_when_hardware_not_a_list(self):
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'for_hardware': {},
})})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'for_hardware': ['Must be a list or string']},
form.errors)
self.assertItemsEqual([], VersionedTextFile.objects.all())
def test__dict_of_results_requires_title(self):
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'results': {factory.make_name('result'): {}},
})})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'results': ['title must be included in a result dictionary.']},
form.errors)
self.assertItemsEqual([], VersionedTextFile.objects.all())
def test__results_list_must_be_strings(self):
form = ScriptForm(data={'script': factory.make_script_content({
'name': factory.make_name('name'),
'results': [None],
})})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{'results': ['Each result in a result list must be a string.']},
form.errors)
self.assertItemsEqual([], VersionedTextFile.objects.all())
