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