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)