def test_input_errors_on_unknown_paramater(self):
script = factory.make_Script()
bad_param = factory.make_name("bad_param")
form = ParametersForm(
data={bad_param: factory.make_name("bad_input")},
script=script,
node=factory.make_Node(),
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"input":
["Unknown parameter '%s' for %s" % (bad_param, script.name)]
},
form.errors,
)
def test_input_string_int(self):
# String and password fields are identical from the forms POV.
param_type = random.choice(["string", "password"])
script = factory.make_Script(
parameters={param_type: {
"type": param_type
}})
input = random.randint(0, 100)
form = ParametersForm(data={param_type: input},
script=script,
node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(input,
form.cleaned_data["input"][0][param_type]["value"])
def test_input_interface_id_errors(self):
node = factory.make_Node()
for _ in range(3):
factory.make_Interface(node=node)
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
form = ParametersForm(
data={"interface": random.randint(1000, 2000)},
script=script,
node=node,
)
self.assertFalse(form.is_valid())
self.assertDictEqual({"interface": ["Interface id does not exist"]},
form.errors)
def create_testing_script_set(self, node, scripts=[], input={}):
"""Create a new testing ScriptSet with ScriptResults.
Optionally a list of user scripts and tags can be given to create
ScriptResults for. If None all Scripts tagged 'commissioning' will be
assumed. Script may also have parameters passed to them."""
# Avoid circular dependencies.
from metadataserver.models import ScriptResult
if scripts == []:
scripts.append('commissioning')
ids = [
int(id) for id in scripts if isinstance(id, int) or id.isdigit()
]
qs = Script.objects.filter(Q(name__in=scripts)
| Q(tags__overlap=scripts) | Q(id__in=ids),
script_type=SCRIPT_TYPE.TESTING)
# A ScriptSet should never be empty. If an empty script set is set as a
# node's current_testing_script_set the UI will show an empty table and
# the node-results API will not output any test results.
if not qs.exists():
raise NoScriptsFound()
script_set = self.create(
node=node,
result_type=RESULT_TYPE.TESTING,
power_state_before_transition=node.power_state)
for script in qs:
form = ParametersForm(data=input.get(script.name, {}),
script=script,
node=node)
if not form.is_valid():
script_set.delete()
raise ValidationError(form.errors)
for param in form.cleaned_data['input']:
ScriptResult.objects.create(script_set=script_set,
status=SCRIPT_STATUS.PENDING,
script=script,
script_name=script.name,
parameters=param)
self._clean_old(node, RESULT_TYPE.TESTING, script_set)
return script_set
def test__input_storage_name_errors(self):
node = factory.make_Node()
for _ in range(3):
factory.make_PhysicalBlockDevice(node=node)
script = factory.make_Script(parameters={
'runtime': {'type': 'runtime'},
'storage': {'type': 'storage'},
})
form = ParametersForm(
data={'storage': factory.make_name('bad_name')},
script=script, node=node)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'storage': ['Unknown storage device for %s(%s)' % (
node.fqdn, node.system_id)],
}, form.errors)
def test_checks_for_supported_parameter_types(self):
form = ParametersForm(
data={
"storage": {
"type": "storage"
},
"interface": {
"type": "interface"
},
"url": {
"type": "url"
},
"runtime": {
"type": "runtime"
},
})
self.assertTrue(form.is_valid(), form.errors)
def test__checks_for_supported_parameter_types(self):
form = ParametersForm(
data={
'storage': {
'type': 'storage'
},
'interface': {
'type': 'interface'
},
'url': {
'type': 'url'
},
'runtime': {
'type': 'runtime'
},
})
self.assertTrue(form.is_valid())
def test_input_interface_defaults_all_with_no_nics(self):
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
form = ParametersForm(data={},
script=script,
node=factory.make_Node(interface=False))
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(1, len(form.cleaned_data["input"]))
self.assertDictEqual(
{"interface": {
"type": "interface",
"value": "all"
}},
form.cleaned_data["input"][0],
)
def test_input_choice(self):
# Validates a choice parameter can be made using a list of strings.
choices = [factory.make_name("choice") for _ in range(3)]
script = factory.make_Script(
parameters={"choice": {
"type": "choice",
"choices": choices
}})
choice = random.choice(choices)
form = ParametersForm(data={"choice": choice},
script=script,
node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(choice,
form.cleaned_data["input"][0]["choice"]["value"])
def test_input_string_max(self):
# String and password fields are identical from the forms POV.
param_type = random.choice(["string", "password"])
script = factory.make_Script(
parameters={param_type: {
"type": param_type,
"max": 3
}})
form = ParametersForm(
data={param_type: factory.make_string()},
script=script,
node=factory.make_Node(),
)
self.assertFalse(form.is_valid())
self.assertEqual({param_type: ["Input too long"]}, form.errors)
def test_input_storage_list(self):
node = factory.make_Node()
for _ in range(10):
factory.make_PhysicalBlockDevice(node=node)
script = factory.make_Script(parameters={
"runtime": {
"type": "runtime"
},
"storage": {
"type": "storage"
},
})
bds = list(node.physicalblockdevice_set.all())
selected_scripts = {
bds[0]: "%s:%s" % (bds[0].model, bds[0].serial),
bds[1]: bds[1].name,
bds[2]: "/dev/%s" % bds[2].name,
bds[3]: bds[3].model,
bds[4]: bds[4].serial,
bds[5]: random.choice(bds[5].tags),
}
form = ParametersForm(
data={"storage": ",".join(selected_scripts.values())},
script=script,
node=node,
)
self.assertTrue(form.is_valid(), form.errors)
input = form.cleaned_data["input"]
self.assertEqual(len(selected_scripts), len(input))
for bd in selected_scripts.keys():
for i in input:
if bd.name == i["storage"]["value"]["name"]:
break
self.assertEqual(script.timeout.seconds, i["runtime"]["value"])
self.assertDictEqual(
{
"id": bd.id,
"name": bd.name,
"id_path": bd.id_path,
"model": bd.model,
"serial": bd.serial,
"physical_blockdevice": bd,
},
i["storage"]["value"],
)
def test__input_interface_defaults_all_with_no_nics(self):
script = factory.make_Script(parameters={
'interface': {
'type': 'interface'
},
})
form = ParametersForm(data={},
script=script,
node=factory.make_Node(interface=False))
self.assertTrue(form.is_valid(), form.errors)
self.assertEquals(1, len(form.cleaned_data['input']))
self.assertDictEqual(
{
'interface': {
'type': 'interface',
'value': 'all'
},
}, form.cleaned_data['input'][0])
def test_validates_parameter_field_argument_format_for_storage_type(self):
form = ParametersForm(
data={
"storage": {
"type": "storage",
"argument_format": factory.make_name("argument_format"),
}
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"parameters": [
"storage: argument_format must contain one of {input}, "
"{name}, {path}, {model}, {serial}"
]
},
form.errors,
)
def test_input_runtime(self):
script = factory.make_Script(
parameters={"runtime": {
"type": "runtime"
}})
value = random.randint(0, 100)
form = ParametersForm(data={"runtime": value},
script=script,
node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(1, len(form.cleaned_data["input"]))
self.assertDictEqual(
{"runtime": {
"type": "runtime",
"value": value
}},
form.cleaned_data["input"][0],
)
def test_input_interface_id_errors_on_parent(self):
node = factory.make_Node(interface=False)
parents = [factory.make_Interface(node=node) for _ in range(2)]
factory.make_Interface(node=node,
iftype=INTERFACE_TYPE.BOND,
parents=parents)
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
form = ParametersForm(
data={"interface": random.choice(parents).id},
script=script,
node=node,
)
self.assertFalse(form.is_valid())
self.assertDictEqual({"interface": ["Interface id does not exist"]},
form.errors)
def test_validates_parameter_field_argument_format_for_interface(self):
form = ParametersForm(
data={
"storage": {
"type": "interface",
"argument_format": factory.make_name("argument_format"),
}
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"parameters": [
"interface: argument_format must contain one of {input}, "
"{name}, {mac}, {vendor}, {product}"
]
},
form.errors,
)
def test_input_password_default_maas_config(self):
maas_auto_ipmi_k_g_bmc_key = factory.make_name(
"maas_auto_ipmi_k_g_bmc_key")
Config.objects.set_config("maas_auto_ipmi_k_g_bmc_key",
maas_auto_ipmi_k_g_bmc_key)
script = factory.make_Script(
parameters={"maas_auto_ipmi_k_g_bmc_key": {
"type": "password"
}})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(
maas_auto_ipmi_k_g_bmc_key,
form.cleaned_data["input"][0]["maas_auto_ipmi_k_g_bmc_key"]
["value"],
)
def test_input_default(self):
# Validates a choice parameter can be made using a Django choice list.
choices = [(factory.make_name("choice"),
factory.make_name("pretty_name")) for _ in range(3)]
default = factory.pick_choice(choices)
script = factory.make_Script(parameters={
"choice": {
"type": "choice",
"choices": choices,
"default": default,
}
})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(default,
form.cleaned_data["input"][0]["choice"]["value"])
def test_input_choice_bad(self):
choices = [factory.make_name("choice") for _ in range(3)]
script = factory.make_Script(
parameters={"choice": {
"type": "choice",
"choices": choices
}})
bad_choice = factory.make_name("bad_choice")
form = ParametersForm(
data={"choice": bad_choice},
script=script,
node=factory.make_Node(),
)
self.assertFalse(form.is_valid())
self.assertEqual({"choice": [f'Invalid choice "{bad_choice}"']},
form.errors)
def test__input_interface_name_errors(self):
node = factory.make_Node()
for _ in range(3):
factory.make_Interface(node=node)
script = factory.make_Script(parameters={
'interface': {
'type': 'interface'
},
})
form = ParametersForm(
data={'interface': factory.make_name('bad_name')},
script=script,
node=node)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'interface':
['Unknown interface for %s(%s)' % (node.fqdn, node.system_id)],
}, form.errors)
def add_pending_script(self, script, input=None):
"""Create and add a new ScriptResult for the given Script.
Creates a new ScriptResult for the given script and assoicates it with
this ScriptSet. Raises a ValidationError if ParametersForm validation
fails.
"""
# Avoid circular dependencies.
from metadataserver.models import ScriptResult
if input is None:
input = {}
form = ParametersForm(
data=input.get(script.name, {}), script=script, node=self.node)
if not form.is_valid():
raise ValidationError(form.errors)
for param in form.cleaned_data['input']:
ScriptResult.objects.create(
script_set=self, status=SCRIPT_STATUS.PENDING,
script=script, script_name=script.name, parameters=param)
def test_input_url_allows_ipv4_url(self):
script = factory.make_Script(parameters={"url": {"type": "url"}})
input = "%s://%s:%d/%s" % (
self.pick_scheme(),
factory.make_ipv4_address(),
random.randint(0, 65535),
factory.make_name(),
)
form = ParametersForm(data={"url": input},
script=script,
node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertDictEqual(
{"url": {
"type": "url",
"value": input
}},
form.cleaned_data["input"][0],
)
def test__input_storage_id_errors(self):
node = factory.make_Node()
for _ in range(3):
factory.make_PhysicalBlockDevice(node=node)
script = factory.make_Script(
parameters={
"runtime": {"type": "runtime"},
"storage": {"type": "storage"},
}
)
form = ParametersForm(
data={"storage": random.randint(1000, 2000)},
script=script,
node=node,
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{"storage": ["Physical block id does not exist"]}, form.errors
)
def test_input_interface_list(self):
node = factory.make_Node()
subnet = factory.make_Subnet()
for _ in range(10):
factory.make_Interface(node=node, subnet=subnet)
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
nics = list(node.interface_set.all())
selected_scripts = {
nics[0]: "%s:%s" % (nics[0].vendor, nics[0].product),
nics[1]: nics[1].name,
nics[2]: nics[2].vendor,
nics[3]: nics[3].product,
nics[4]: str(nics[4].mac_address),
nics[4]: random.choice(nics[4].tags),
}
form = ParametersForm(
data={"interface": ",".join(selected_scripts.values())},
script=script,
node=node,
)
self.assertTrue(form.is_valid(), form.errors)
input = form.cleaned_data["input"]
self.assertEqual(len(selected_scripts), len(input))
for nic in selected_scripts.keys():
for i in input:
if (str(nic.mac_address) == i["interface"]["value"]
["mac_address"]):
break
self.assertDictEqual(
{
"id": nic.id,
"name": nic.name,
"mac_address": str(nic.mac_address),
"vendor": nic.vendor,
"product": nic.product,
"interface": nic,
},
i["interface"]["value"],
)
def test__input_url_list_requires_allow_list(self):
script = factory.make_Script(parameters={'url': {
'type': 'url',
}})
inputs = ','.join([
factory.make_ipv4_address(),
"%s://%s:%d/%s" % (self.pick_scheme(), factory.make_ipv4_address(),
random.randint(0, 65535), factory.make_name()),
factory.make_ipv6_address(),
"%s://[%s]:%d/%s" %
(self.pick_scheme(), factory.make_ipv6_address(),
random.randint(0, 65535), factory.make_name()),
factory.make_hostname(),
factory.make_url(scheme=self.pick_scheme()),
])
form = ParametersForm(data={'url': inputs},
script=script,
node=factory.make_Node())
self.assertFalse(form.is_valid())
self.assertDictEqual({'url': ['Invalid URL']}, form.errors)
def test__input_storage_id_errors(self):
node = factory.make_Node()
for _ in range(3):
factory.make_PhysicalBlockDevice(node=node)
script = factory.make_Script(parameters={
'runtime': {
'type': 'runtime'
},
'storage': {
'type': 'storage'
},
})
form = ParametersForm(data={'storage': random.randint(1000, 2000)},
script=script,
node=node)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'storage': ['Physical block id does not exist'],
}, form.errors)
def test__input_interface_defaults_boot_interface_during_commiss(self):
node = factory.make_Node_with_Interface_on_Subnet(
status=NODE_STATUS.COMMISSIONING)
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
form = ParametersForm(data={}, script=script, node=node)
self.assertTrue(form.is_valid(), form.errors)
self.assertEquals(1, len(form.cleaned_data["input"]))
self.assertDictEqual(
{
"name": node.boot_interface.name,
"mac_address": str(node.boot_interface.mac_address),
"vendor": node.boot_interface.vendor,
"product": node.boot_interface.product,
"interface": node.boot_interface,
},
form.cleaned_data["input"][0]["interface"]["value"],
)
def test__input_interface_name_errors_on_parent(self):
node = factory.make_Node(interface=False)
parents = [factory.make_Interface(node=node) for _ in range(2)]
factory.make_Interface(node=node,
iftype=INTERFACE_TYPE.BOND,
parents=parents)
script = factory.make_Script(parameters={
'interface': {
'type': 'interface'
},
})
form = ParametersForm(data={'interface': random.choice(parents).name},
script=script,
node=node)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'interface':
['Unknown interface for %s(%s)' % (node.fqdn, node.system_id)],
}, form.errors)
def test__input_storage_list(self):
node = factory.make_Node()
for _ in range(10):
factory.make_PhysicalBlockDevice(node=node)
script = factory.make_Script(parameters={
'runtime': {
'type': 'runtime'
},
'storage': {
'type': 'storage'
},
})
bds = list(node.physicalblockdevice_set.all())
selected_scripts = {
bds[0]: '%s:%s' % (bds[0].model, bds[0].serial),
bds[1]: bds[1].name,
bds[2]: '/dev/%s' % bds[2].name,
bds[3]: bds[3].model,
bds[4]: bds[4].serial,
bds[5]: random.choice(bds[5].tags),
}
form = ParametersForm(
data={'storage': ','.join(selected_scripts.values())},
script=script,
node=node)
self.assertTrue(form.is_valid(), form.errors)
input = form.cleaned_data['input']
self.assertEquals(len(selected_scripts), len(input))
for bd in selected_scripts.keys():
for i in input:
if bd.name == i['storage']['value']['name']:
break
self.assertEquals(script.timeout.seconds, i['runtime']['value'])
self.assertDictEqual(
{
'name': bd.name,
'id_path': bd.id_path,
'model': bd.model,
'serial': bd.serial,
'physical_blockdevice': bd,
}, i['storage']['value'])
def test_input_interface_name_errors(self):
node = factory.make_Node()
for _ in range(3):
factory.make_Interface(node=node)
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
form = ParametersForm(
data={"interface": factory.make_name("bad_name")},
script=script,
node=node,
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"interface":
["Unknown interface for %s(%s)" % (node.fqdn, node.system_id)]
},
form.errors,
)
