def test_update_leases_combines_additions_deletions_and_replacements(self): nodegroup = factory.make_node_group() mac1 = factory.getRandomMACAddress() mac2 = factory.getRandomMACAddress() obsolete_lease = factory.make_dhcp_lease( nodegroup=nodegroup, mac=mac1) # The obsolete lease won't be in the update, so it'll disappear. ignore_unused(obsolete_lease) unchanged_lease = factory.make_dhcp_lease( nodegroup=nodegroup, mac=mac1) reassigned_lease = factory.make_dhcp_lease( nodegroup=nodegroup, mac=mac1) new_ip = factory.getRandomIPAddress() DHCPLease.objects.update_leases(nodegroup, { reassigned_lease.ip: mac2, unchanged_lease.ip: mac1, new_ip: mac1, }) self.assertEqual( { reassigned_lease.ip: mac2, unchanged_lease.ip: mac1, new_ip: mac1, }, map_leases(nodegroup))
def test_MACAddressForm_creates_mac_address(self): node = factory.make_node() mac = factory.getRandomMACAddress() form = MACAddressForm(node=node, data={'mac_address': mac}) form.save() self.assertTrue( MACAddress.objects.filter(node=node, mac_address=mac).exists())
def test_saves_to_db_by_default(self): node = factory.make_node() mac = factory.getRandomMACAddress() form = MACAddressForm(node=node, data={'mac_address': mac}) form.save() self.assertEqual( mac, MACAddress.objects.get(mac_address=mac).mac_address)
def test_get_effective_power_parameters_provides_usable_defaults(self): # For some power types at least, the defaults provided by # get_effective_power_parameters are enough to get a basic setup # working. configless_power_types = [ POWER_TYPE.WAKE_ON_LAN, POWER_TYPE.VIRSH, ] # We don't actually want to fire off power events, but we'll go # through the motions right up to the point where we'd normally # run shell commands. self.patch(PowerAction, 'run_shell', lambda *args, **kwargs: ('', '')) user = factory.make_admin() nodes = [ factory.make_node(power_type=power_type) for power_type in configless_power_types] for node in nodes: node.add_mac_address(factory.getRandomMACAddress()) node_power_types = { node: node.get_effective_power_type() for node in nodes} started_nodes = Node.objects.start_nodes( [node.system_id for node in list(node_power_types.keys())], user) successful_types = [node_power_types[node] for node in started_nodes] self.assertItemsEqual(configless_power_types, successful_types)
def test_update_leases_replaces_reassigned_ip(self): nodegroup = factory.make_node_group() ip = factory.getRandomIPAddress() factory.make_dhcp_lease(nodegroup=nodegroup, ip=ip) new_mac = factory.getRandomMACAddress() DHCPLease.objects.update_leases(nodegroup, {ip: new_mac}) self.assertEqual({ip: new_mac}, map_leases(nodegroup))
def test_created_node_has_domain_from_cluster(self): hostname_without_domain = factory.make_name('hostname') hostname_with_domain = '%s.%s' % (hostname_without_domain, factory.getRandomString()) domain = factory.make_name('domain') factory.make_node_group( status=NODEGROUP_STATUS.ACCEPTED, name=domain, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS) response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname_with_domain, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'after_commissioning_action': (NODE_AFTER_COMMISSIONING_ACTION.DEFAULT), 'mac_addresses': [factory.getRandomMACAddress()], }) self.assertEqual(httplib.OK, response.status_code, response.content) parsed_result = json.loads(response.content) expected_hostname = '%s.%s' % (hostname_without_domain, domain) self.assertEqual(expected_hostname, parsed_result.get('hostname'))
def test_POST_new_creates_node_with_power_parameters(self): # We're setting power parameters so we disable start_commissioning to # prevent anything from attempting to issue power instructions. self.patch(Node, "start_commissioning") hostname = factory.make_name("hostname") architecture = factory.getRandomChoice(ARCHITECTURE_CHOICES) power_type = POWER_TYPE.IPMI power_parameters = { "power_user": factory.make_name("power-user"), "power_pass": factory.make_name("power-pass"), } response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': architecture, 'mac_addresses': factory.getRandomMACAddress(), 'power_parameters': json.dumps(power_parameters), 'power_type': power_type, }) self.assertEqual(httplib.OK, response.status_code) [node] = Node.objects.filter(hostname=hostname) self.assertEqual(power_parameters, node.power_parameters) self.assertEqual(power_type, node.power_type)
def test_get_effective_power_parameters_provides_usable_defaults(self): # For some power types at least, the defaults provided by # get_effective_power_parameters are enough to get a basic setup # working. configless_power_types = [ POWER_TYPE.WAKE_ON_LAN, POWER_TYPE.VIRSH, ] # We don't actually want to fire off power events, but we'll go # through the motions right up to the point where we'd normally # run shell commands. self.patch(PowerAction, 'run_shell', lambda *args, **kwargs: ('', '')) user = factory.make_admin() nodes = [ factory.make_node(power_type=power_type) for power_type in configless_power_types] for node in nodes: node.add_mac_address(factory.getRandomMACAddress()) node_power_types = { node: node.get_effective_power_type() for node in nodes} started_nodes = Node.objects.start_nodes( [node.system_id for node in list(node_power_types.keys())], user) successful_types = [node_power_types[node] for node in started_nodes] self.assertItemsEqual(configless_power_types, successful_types)
def test_NodeWithMACAddressesForm_empty(self): # Empty values in the list of MAC addresses are simply ignored. form = NodeWithMACAddressesForm( self.make_params( mac_addresses=[factory.getRandomMACAddress(), ''])) self.assertTrue(form.is_valid())
def test_is_registered_returns_False_if_node_not_registered(self): mac_address = factory.getRandomMACAddress() response = self.client.get( reverse('nodes_handler'), {'op': 'is_registered', 'mac_address': mac_address}) self.assertEqual( (httplib.OK, "false"), (response.status_code, response.content))
def test_remove_mac_address(self): mac = factory.getRandomMACAddress() node = factory.make_node() node.add_mac_address(mac) node.remove_mac_address(mac) self.assertItemsEqual( [], MACAddress.objects.filter(node=node, mac_address=mac))
def test_is_registered_returns_False_if_node_not_registered(self): mac_address = factory.getRandomMACAddress() response = self.client.get(reverse('nodes_handler'), { 'op': 'is_registered', 'mac_address': mac_address }) self.assertEqual((httplib.OK, "false"), (response.status_code, response.content))
def test_update_leases_adds_new_ip_to_mac(self): nodegroup = factory.make_node_group() mac = factory.getRandomMACAddress() ip1 = factory.getRandomIPAddress() ip2 = factory.getRandomIPAddress() factory.make_dhcp_lease(nodegroup=nodegroup, mac=mac, ip=ip1) DHCPLease.objects.update_leases(nodegroup, {ip1: mac, ip2: mac}) self.assertEqual({ip1: mac, ip2: mac}, map_leases(nodegroup))
def test_remove_mac_address(self): mac = factory.getRandomMACAddress() node = factory.make_node() node.add_mac_address(mac) node.remove_mac_address(mac) self.assertItemsEqual( [], MACAddress.objects.filter(node=node, mac_address=mac))
def test_node_delete_not_found_if_node_does_not_exist(self): # This returns a 404 rather than returning to the node page # with a nice error message because the node could not be found. node_id = factory.getRandomString() mac = factory.getRandomMACAddress() mac_delete_link = reverse('mac-delete', args=[node_id, mac]) response = self.client.get(mac_delete_link) self.assertEqual(httplib.NOT_FOUND, response.status_code)
def test_pxeconfig_returns_success_for_detailed_but_unknown_node(self): architecture = factory.getRandomEnum(ARCHITECTURE) arch, subarch = architecture.split('/') params = dict(self.get_default_params(), mac=factory.getRandomMACAddress(delimiter='-'), arch=arch, subarch=subarch) response = self.client.get(reverse('pxeconfig'), params) self.assertEqual(httplib.OK, response.status_code)
def test_update_leases_deletes_only_obsolete_ips(self): nodegroup = factory.make_node_group() mac = factory.getRandomMACAddress() obsolete_ip = factory.getRandomIPAddress() current_ip = factory.getRandomIPAddress() factory.make_dhcp_lease(nodegroup=nodegroup, mac=mac, ip=obsolete_ip) factory.make_dhcp_lease(nodegroup=nodegroup, mac=mac, ip=current_ip) DHCPLease.objects.update_leases(nodegroup, {current_ip: mac}) self.assertEqual({current_ip: mac}, map_leases(nodegroup))
def test_get_primary_mac_returns_oldest_mac(self): node = factory.make_node() macs = [factory.getRandomMACAddress() for counter in range(3)] offset = timedelta(0) for mac in macs: mac_address = node.add_mac_address(mac) mac_address.created += offset mac_address.save() offset += timedelta(1) self.assertEqual(macs[0], node.get_primary_mac().mac_address)
def test_node_delete_redirects_if_mac_does_not_exist(self): # If the MAC address does not exist, the user is redirected # to the node edit page. node = factory.make_node(owner=self.logged_in_user) mac = factory.getRandomMACAddress() mac_delete_link = reverse('mac-delete', args=[node.system_id, mac]) response = self.client.get(mac_delete_link) self.assertEqual( reverse('node-edit', args=[node.system_id]), extract_redirect(response))
def test_get_primary_mac_returns_oldest_mac(self): node = factory.make_node() macs = [factory.getRandomMACAddress() for counter in range(3)] offset = timedelta(0) for mac in macs: mac_address = node.add_mac_address(mac) mac_address.created += offset mac_address.save() offset += timedelta(1) self.assertEqual(macs[0], node.get_primary_mac().mac_address)
def test_node_add_mac_POST_adds_mac(self): node = factory.make_node(owner=self.logged_in_user) mac_add_link = reverse('mac-add', args=[node.system_id]) mac = factory.getRandomMACAddress() response = self.client.post(mac_add_link, {'mac_address': mac}) self.assertEqual( reverse('node-edit', args=[node.system_id]), extract_redirect(response)) self.assertTrue( MACAddress.objects.filter(node=node, mac_address=mac).exists())
def test_node_add_mac_POST_displays_message(self): node = factory.make_node(owner=self.logged_in_user) mac_add_link = reverse('mac-add', args=[node.system_id]) mac = factory.getRandomMACAddress() response = self.client.post(mac_add_link, {'mac_address': mac}) redirect = extract_redirect(response) response = self.client.get(redirect) self.assertEqual( ["MAC address added."], [message.message for message in response.context['messages']])
def test_pxeconfig_returns_success_for_detailed_but_unknown_node(self): architecture = factory.getRandomEnum(ARCHITECTURE) arch, subarch = architecture.split('/') params = dict( self.get_default_params(), mac=factory.getRandomMACAddress(delimiter='-'), arch=arch, subarch=subarch) response = self.client.get(reverse('pxeconfig'), params) self.assertEqual(httplib.OK, response.status_code)
def test_POST_with_no_hostname_auto_populates_hostname(self): architecture = factory.getRandomChoice(ARCHITECTURE_CHOICES) response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'architecture': architecture, 'mac_addresses': [factory.getRandomMACAddress()], }) node = Node.objects.get( system_id=json.loads(response.content)['system_id']) self.assertEqual(5, len(strip_domain(node.hostname)))
def test_POST_new_initializes_nodegroup_to_master_by_default(self): hostname = factory.make_name('host') self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'mac_addresses': [factory.getRandomMACAddress()], }) self.assertEqual(NodeGroup.objects.ensure_master(), Node.objects.get(hostname=hostname).nodegroup)
def test_is_registered_returns_False_if_mac_registered_node_retired(self): mac_address = factory.getRandomMACAddress() mac = factory.make_mac_address(mac_address) mac.node.status = NODE_STATUS.RETIRED mac.node.save() response = self.client.get( reverse('nodes_handler'), {'op': 'is_registered', 'mac_address': mac_address}) self.assertEqual( (httplib.OK, "false"), (response.status_code, response.content))
def test_MACAddressForm_displays_error_message_if_mac_already_used(self): mac = factory.getRandomMACAddress() node = factory.make_mac_address(address=mac) node = factory.make_node() form = MACAddressForm(node=node, data={'mac_address': mac}) self.assertFalse(form.is_valid()) self.assertEquals( {'mac_address': ['This MAC address is already registered.']}, form._errors) self.assertFalse( MACAddress.objects.filter(node=node, mac_address=mac).exists())
def test_is_registered_returns_False_if_mac_registered_node_retired(self): mac_address = factory.getRandomMACAddress() mac = factory.make_mac_address(mac_address) mac.node.status = NODE_STATUS.RETIRED mac.node.save() response = self.client.get(reverse('nodes_handler'), { 'op': 'is_registered', 'mac_address': mac_address }) self.assertEqual((httplib.OK, "false"), (response.status_code, response.content))
def test_POST_with_no_hostname_auto_populates_hostname(self): architecture = factory.getRandomChoice(ARCHITECTURE_CHOICES) response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'architecture': architecture, 'mac_addresses': [factory.getRandomMACAddress()], }) node = Node.objects.get( system_id=json.loads(response.content)['system_id']) self.assertEqual(5, len(strip_domain(node.hostname)))
def test_init(self): nodegroup = factory.make_node_group() ip = factory.getRandomIPAddress() mac = factory.getRandomMACAddress() lease = DHCPLease(nodegroup=nodegroup, ip=ip, mac=mac) lease.save() self.assertItemsEqual([lease], get_leases(nodegroup)) self.assertEqual(nodegroup, lease.nodegroup) self.assertEqual(ip, lease.ip) self.assertEqual(mac, lease.mac)
def test_POST_new_initializes_nodegroup_to_master_by_default(self): hostname = factory.make_name('host') self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'mac_addresses': [factory.getRandomMACAddress()], }) self.assertEqual( NodeGroup.objects.ensure_master(), Node.objects.get(hostname=hostname).nodegroup)
def test_pxeconfig_returns_global_kernel_params_for_enlisting_node(self): # An 'enlisting' node means it looks like a node with details but we # don't know about it yet. It should still receive the global # kernel options. value = factory.getRandomString() Config.objects.set_config("kernel_opts", value) architecture = factory.getRandomEnum(ARCHITECTURE) arch, subarch = architecture.split('/') params = dict(self.get_default_params(), mac=factory.getRandomMACAddress(delimiter='-'), arch=arch, subarch=subarch) response = self.client.get(reverse('pxeconfig'), params) response_dict = json.loads(response.content) self.assertEqual(value, response_dict['extra_opts'])
def test_pxeconfig_returns_global_kernel_params_for_enlisting_node(self): # An 'enlisting' node means it looks like a node with details but we # don't know about it yet. It should still receive the global # kernel options. value = factory.getRandomString() Config.objects.set_config("kernel_opts", value) architecture = factory.getRandomEnum(ARCHITECTURE) arch, subarch = architecture.split('/') params = dict( self.get_default_params(), mac=factory.getRandomMACAddress(delimiter='-'), arch=arch, subarch=subarch) response = self.client.get(reverse('pxeconfig'), params) response_dict = json.loads(response.content) self.assertEqual(value, response_dict['extra_opts'])
def test_POST_updates_power_parameters_rejects_unknown_param(self): hostname = factory.getRandomString() response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'power_type': POWER_TYPE.WAKE_ON_LAN, 'power_parameters_unknown_param': factory.getRandomString(), 'mac_addresses': [factory.getRandomMACAddress()], }) self.assertEqual((httplib.BAD_REQUEST, { 'power_parameters': ["Unknown parameter(s): unknown_param."] }), (response.status_code, json.loads(response.content))) self.assertFalse(Node.objects.filter(hostname=hostname).exists())
def test_PUT_updates_power_parameters_field(self): # The api allows the updating of a Node's power_parameters field. self.become_admin() node = factory.make_node( owner=self.logged_in_user, power_type=POWER_TYPE.WAKE_ON_LAN) # Create a power_parameter valid for the selected power_type. new_power_address = factory.getRandomMACAddress() response = self.client_put( self.get_node_uri(node), {'power_parameters_mac_address': new_power_address}) self.assertEqual(httplib.OK, response.status_code) self.assertEqual( {'mac_address': new_power_address}, reload_object(node).power_parameters)
def make_params(self, mac_addresses=None, architecture=None, hostname=None, nodegroup=None): if mac_addresses is None: mac_addresses = [factory.getRandomMACAddress()] if architecture is None: architecture = factory.getRandomEnum(ARCHITECTURE) if hostname is None: hostname = factory.make_name('hostname') params = { 'mac_addresses': mac_addresses, 'architecture': architecture, 'hostname': hostname, } if nodegroup is not None: params['nodegroup'] = nodegroup return self.get_QueryDict(params)
def test_created_node_uses_default_nodegroup_if_origin_not_found(self): unknown_host = factory.make_name('host') response = self.client.post( reverse('nodes_handler'), data={ 'op': 'new', 'hostname': factory.make_name('hostname'), 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'after_commissioning_action': ( NODE_AFTER_COMMISSIONING_ACTION.DEFAULT), 'mac_addresses': [factory.getRandomMACAddress()], }, HTTP_HOST=unknown_host) self.assertEqual(httplib.OK, response.status_code, response.content) parsed_result = json.loads(response.content) node = Node.objects.get(system_id=parsed_result.get('system_id')) self.assertEqual(NodeGroup.objects.ensure_master(), node.nodegroup)
def test_start_nodes_wakeonlan_prefers_power_parameters(self): # If power_parameters is set we should prefer it to sifting # through related MAC addresses. user = factory.make_user() preferred_mac = factory.getRandomMACAddress() node, mac = self.make_node_with_mac( user, power_type=POWER_TYPE.WAKE_ON_LAN, power_parameters=dict(mac_address=preferred_mac)) output = Node.objects.start_nodes([node.system_id], user) self.assertItemsEqual([node], output) self.assertEqual( (1, 'provisioningserver.tasks.power_on', preferred_mac), ( len(self.celery.tasks), self.celery.tasks[0]['task'].name, self.celery.tasks[0]['kwargs']['mac_address'], ))
def test_start_nodes_wakeonlan_prefers_power_parameters(self): # If power_parameters is set we should prefer it to sifting # through related MAC addresses. user = factory.make_user() preferred_mac = factory.getRandomMACAddress() node, mac = self.make_node_with_mac( user, power_type=POWER_TYPE.WAKE_ON_LAN, power_parameters=dict(mac_address=preferred_mac)) output = Node.objects.start_nodes([node.system_id], user) self.assertItemsEqual([node], output) self.assertEqual( (1, 'provisioningserver.tasks.power_on', preferred_mac), ( len(self.celery.tasks), self.celery.tasks[0]['task'].name, self.celery.tasks[0]['kwargs']['mac_address'], ))
def test_POST_new_sets_power_parameters_field(self): # The api allows the setting of a Node's power_parameters field. # Create a power_parameter valid for the selected power_type. new_mac_address = factory.getRandomMACAddress() response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'power_type': POWER_TYPE.WAKE_ON_LAN, 'power_parameters_mac_address': new_mac_address, 'mac_addresses': ['AA:BB:CC:DD:EE:FF'], }) node = Node.objects.get( system_id=json.loads(response.content)['system_id']) self.assertEqual(httplib.OK, response.status_code) self.assertEqual({'mac_address': new_mac_address}, reload_object(node).power_parameters)
def test_POST_new_generates_hostname_if_ip_based_hostname(self): hostname = '192-168-5-19.domain' response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'after_commissioning_action': ( NODE_AFTER_COMMISSIONING_ACTION.DEFAULT), 'mac_addresses': [factory.getRandomMACAddress()], }) parsed_result = json.loads(response.content) self.assertEqual(httplib.OK, response.status_code) system_id = parsed_result.get('system_id') node = Node.objects.get(system_id=system_id) self.assertNotEqual(hostname, node.hostname)
def test_POST_updates_power_parameters_rejects_unknown_param(self): hostname = factory.getRandomString() response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'power_type': POWER_TYPE.WAKE_ON_LAN, 'power_parameters_unknown_param': factory.getRandomString(), 'mac_addresses': [factory.getRandomMACAddress()], }) self.assertEqual( ( httplib.BAD_REQUEST, {'power_parameters': ["Unknown parameter(s): unknown_param."]} ), (response.status_code, json.loads(response.content))) self.assertFalse(Node.objects.filter(hostname=hostname).exists())
def test_POST_new_sets_power_parameters_field(self): # The api allows the setting of a Node's power_parameters field. # Create a power_parameter valid for the selected power_type. new_mac_address = factory.getRandomMACAddress() response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'power_type': POWER_TYPE.WAKE_ON_LAN, 'power_parameters_mac_address': new_mac_address, 'mac_addresses': ['AA:BB:CC:DD:EE:FF'], }) node = Node.objects.get( system_id=json.loads(response.content)['system_id']) self.assertEqual(httplib.OK, response.status_code) self.assertEqual( {'mac_address': new_mac_address}, reload_object(node).power_parameters)
def test_created_node_uses_default_nodegroup_if_origin_not_found(self): unknown_host = factory.make_name('host') response = self.client.post( reverse('nodes_handler'), data={ 'op': 'new', 'hostname': factory.make_name('hostname'), 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'after_commissioning_action': (NODE_AFTER_COMMISSIONING_ACTION.DEFAULT), 'mac_addresses': [factory.getRandomMACAddress()], }, HTTP_HOST=unknown_host) self.assertEqual(httplib.OK, response.status_code, response.content) parsed_result = json.loads(response.content) node = Node.objects.get(system_id=parsed_result.get('system_id')) self.assertEqual(NodeGroup.objects.ensure_master(), node.nodegroup)
def test_POST_new_generates_hostname_if_ip_based_hostname(self): hostname = '192-168-5-19.domain' response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'after_commissioning_action': (NODE_AFTER_COMMISSIONING_ACTION.DEFAULT), 'mac_addresses': [factory.getRandomMACAddress()], }) parsed_result = json.loads(response.content) self.assertEqual(httplib.OK, response.status_code) system_id = parsed_result.get('system_id') node = Node.objects.get(system_id=system_id) self.assertNotEqual(hostname, node.hostname)
def test_created_node_nodegroup_is_inferred_from_origin_network(self): network = IPNetwork('192.168.0.3/24') origin_ip = factory.getRandomIPInNetwork(network) NodeGroup.objects.ensure_master() nodegroup = factory.make_node_group(network=network) response = self.client.post( reverse('nodes_handler'), data={ 'op': 'new', 'hostname': factory.make_name('hostname'), 'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES), 'after_commissioning_action': (NODE_AFTER_COMMISSIONING_ACTION.DEFAULT), 'mac_addresses': [factory.getRandomMACAddress()], }, REMOTE_ADDR=origin_ip) self.assertEqual(httplib.OK, response.status_code, response.content) parsed_result = json.loads(response.content) node = Node.objects.get(system_id=parsed_result.get('system_id')) self.assertEqual(nodegroup, node.nodegroup)
def test_POST_new_creates_node_with_power_parameters(self): # We're setting power parameters so we disable start_commissioning to # prevent anything from attempting to issue power instructions. self.patch(Node, "start_commissioning") hostname = factory.make_name("hostname") architecture = factory.getRandomChoice(ARCHITECTURE_CHOICES) power_type = POWER_TYPE.IPMI power_parameters = { "power_user": factory.make_name("power-user"), "power_pass": factory.make_name("power-pass"), } response = self.client.post( reverse('nodes_handler'), { 'op': 'new', 'hostname': hostname, 'architecture': architecture, 'mac_addresses': factory.getRandomMACAddress(), 'power_parameters': json.dumps(power_parameters), 'power_type': power_type, }) self.assertEqual(httplib.OK, response.status_code) [node] = Node.objects.filter(hostname=hostname) self.assertEqual(power_parameters, node.power_parameters) self.assertEqual(power_type, node.power_type)
def test_getquoted_punches_through_double_wrapping(self): addr = factory.getRandomMACAddress() self.assertEqual("'%s'::macaddr" % addr, MAC(MAC(addr)).getquoted())
def test_mac_equals_identical_mac(self): addr = factory.getRandomMACAddress() self.assertTrue(MAC(addr) == MAC(addr))
def test_identical_macs_hash_identically(self): addr = factory.getRandomMACAddress() self.assertItemsEqual( set([MAC(addr), MAC(addr), MAC(MAC(addr)), addr]), [addr])
def test_get_node_for_mac_raises_404_for_unknown_mac(self): self.assertRaises(MAASAPINotFound, get_node_for_mac, factory.getRandomMACAddress())
def test_get_node_for_mac_refuses_if_anonymous_access_disabled(self): self.patch(settings, 'ALLOW_UNSAFE_METADATA_ACCESS', False) self.assertRaises(PermissionDenied, get_node_for_mac, factory.getRandomMACAddress())
def test_get_raw_returns_wrapped_address(self): addr = factory.getRandomMACAddress() self.assertEqual(addr, MAC(addr).get_raw())
def test_get_raw_punches_through_double_wrapping(self): addr = factory.getRandomMACAddress() self.assertEqual(addr, MAC(MAC(addr)).get_raw())