def test__validates_against_unsupported_parameter_types(self):
unsupported_type = factory.make_name("unsupported")
form = ParametersForm(data={"storage": {"type": unsupported_type}})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"parameters": [
"%s: type must be either storage, interface, url, or "
"runtime" % unsupported_type
]
},
form.errors,
)
def test_input_string_required(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,
"required": True
}})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertFalse(form.is_valid())
self.assertEqual({param_type: ["Field is required"]}, form.errors)
def test__validates_parameter_field_argument_format_non_runtime_type(self):
form = ParametersForm(
data={
"runtime": {
"type": "runtime",
"argument_format": factory.make_name("argument_format"),
}
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{"parameters": ["runtime: argument_format must contain {input}"]},
form.errors,
)
def test__input_interface_validates_required(self):
script = factory.make_Script(
parameters={
"interface": {
"type": "interface",
"required": True,
"default": None,
}
}
)
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertFalse(form.is_valid())
self.assertDictEqual({"interface": ["Field is required"]}, form.errors)
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__input_runtime_validates_min(self):
min_runtime = random.randint(1, 100)
script = factory.make_Script(
parameters={"runtime": {"type": "runtime", "min": min_runtime}}
)
value = random.randint(-min_runtime, min_runtime - 1)
form = ParametersForm(
data={"runtime": value}, script=script, node=factory.make_Node()
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{"runtime": ["Must be greater than %s" % min_runtime]}, form.errors
)
def test__input_runtime_validates_max(self):
max_runtime = random.randint(0, 100)
script = factory.make_Script(
parameters={"runtime": {"type": "runtime", "max": max_runtime}}
)
value = random.randint(max_runtime + 1, max_runtime + 10)
form = ParametersForm(
data={"runtime": value}, script=script, node=factory.make_Node()
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{"runtime": ["Must be less than %s" % max_runtime]}, form.errors
)
def test__input_storage_validates_required(self):
script = factory.make_Script(parameters={
'storage': {
'type': 'storage',
'required': True,
'default': None,
}
})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertFalse(form.is_valid())
self.assertDictEqual({
'storage': ["Field is required"],
}, 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.assertEquals(1, len(form.cleaned_data["input"]))
self.assertDictEqual(
{"runtime": {"type": "runtime", "value": value}},
form.cleaned_data["input"][0],
)
def test__validates_min_less_than_max(self):
form = ParametersForm(
data={
"runtime": {
"type": "runtime",
"min": random.randint(500, 1000),
"max": random.randint(0, 500),
}
}
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{"parameters": ["min must be less than max"]}, form.errors
)
def test__validates_parameter_field_allow_list_is_boolean(self):
param_allow_list = factory.make_name("allow_list")
form = ParametersForm(
data={"url": {"type": "url", "allow_list": param_allow_list}}
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"parameters": [
"%s: allow_list must be a boolean" % param_allow_list
]
},
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_url_allows_ipv6_url(self):
script = factory.make_Script(parameters={'url': {
'type': 'url',
}})
input = "%s://[%s]:%d/%s" % (
self.pick_scheme(), factory.make_ipv6_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__validates_parameter_field_required_is_boolean(self):
param_required = factory.make_name('required')
form = ParametersForm(data={
'storage': {
'type': 'storage',
'required': param_required,
},
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'parameters': [
"%s: required must be a boolean" % param_required]
}, form.errors)
def test__validates_against_unsupported_parameter_types(self):
unsupported_type = factory.make_name('unsupported')
form = ParametersForm(data={
'storage': {
'type': unsupported_type,
},
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'parameters': [
"%s: type must be either storage or runtime"
% unsupported_type]
}, form.errors)
def test_input_url_allows_ipv6(self):
script = factory.make_Script(parameters={"url": {"type": "url"}})
input = factory.make_ipv6_address()
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__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__validates_parameter_field_allow_list_is_boolean(self):
param_allow_list = factory.make_name('allow_list')
form = ParametersForm(data={
'url': {
'type': 'url',
'allow_list': param_allow_list,
},
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'parameters':
["%s: allow_list must be a boolean" % param_allow_list]
}, form.errors)
def test_input_interface_name_errors_on_unconfigured_or_disabled(self):
node = factory.make_Node()
bad_interface = random.choice([
factory.make_Interface(node=node, enabled=False),
factory.make_Interface(node=node, link_connected=False),
])
script = factory.make_Script(
parameters={"interface": {
"type": "interface"
}})
form = ParametersForm(data={"interface": bad_interface.name},
script=script,
node=node)
self.assertFalse(form.is_valid())
def test__validates_parameter_field_required_is_boolean(self):
param_required = factory.make_name("required")
form = ParametersForm(
data={"storage": {"type": "storage", "required": param_required}}
)
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
"parameters": [
"%s: required must be a boolean" % param_required
]
},
form.errors,
)
def test__input_storage_defaults_all_with_no_disks(self):
script = factory.make_Script(parameters={
'runtime': {'type': 'runtime'},
'storage': {'type': 'storage'},
})
form = ParametersForm(
data={}, script=script,
node=factory.make_Node(with_boot_disk=False))
self.assertTrue(form.is_valid(), form.errors)
self.assertEquals(1, len(form.cleaned_data['input']))
self.assertDictEqual({
'runtime': {'type': 'runtime', 'value': script.timeout.seconds},
'storage': {'type': 'storage', 'value': 'all'},
}, form.cleaned_data['input'][0])
def test_input_choice_required(self):
choices = [factory.make_name("choice") for _ in range(3)]
script = factory.make_Script(parameters={
"choice": {
"type": "choice",
"choices": choices,
"required": True,
}
})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertFalse(form.is_valid())
self.assertEqual({"choice": ["Field is required"]}, form.errors)
def test_input_runtime_gets_default_from_script_timeout(self):
script = factory.make_Script(
parameters={"runtime": {
"type": "runtime"
}})
form = ParametersForm(data={}, 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": script.timeout.seconds
}},
form.cleaned_data["input"][0],
)
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 test_input_string_default_maas_config(self):
maas_auto_ipmi_user = factory.make_name("maas_auto_ipmi_user")
Config.objects.set_config("maas_auto_ipmi_user", maas_auto_ipmi_user)
script = factory.make_Script(
parameters={"maas_auto_ipmi_user": {
"type": "string"
}})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEqual(
maas_auto_ipmi_user,
form.cleaned_data["input"][0]["maas_auto_ipmi_user"]["value"],
)
def test_input_string_default(self):
# String and password fields are identical from the forms POV.
param_type = random.choice(["string", "password"])
default = factory.make_string()
script = factory.make_Script(
parameters={param_type: {
"type": param_type,
"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][param_type]["value"])
def test__input_runtime_gets_default_from_script_timeout(self):
script = factory.make_Script(
parameters={'runtime': {
'type': 'runtime'
}})
form = ParametersForm(data={}, script=script, node=factory.make_Node())
self.assertTrue(form.is_valid(), form.errors)
self.assertEquals(1, len(form.cleaned_data['input']))
self.assertDictEqual(
{
'runtime': {
'type': 'runtime',
'value': script.timeout.seconds,
}
}, form.cleaned_data['input'][0])
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.assertEquals(1, len(form.cleaned_data['input']))
self.assertDictEqual({'runtime': {
'type': 'runtime',
'value': value
}}, form.cleaned_data['input'][0])
def test__validates_parameter_field_allow_list_only_for_url(self):
ptype = random.choice(['storage', 'interface', 'runtime'])
form = ParametersForm(data={
ptype: {
'type': ptype,
'allow_list': factory.pick_bool(),
},
})
self.assertFalse(form.is_valid())
self.assertDictEqual(
{
'parameters': [
"allow_list only supported with the url type."
]
}, 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)
