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, )