def test_refresh_workers_skips_unaccepted_cluster_controllers(self):
self.patch(nodegroup_module, 'refresh_worker')
for status in map_enum(NODEGROUP_STATUS).values():
if status != NODEGROUP_STATUS.ACCEPTED:
factory.make_node_group(status=status)
NodeGroup.objects.refresh_workers()
self.assertEqual(0, nodegroup_module.refresh_worker.call_count)
def test_find_nodegroup_errors_if_multiple_matches(self):
self.patch(nodegroupinterface, "MINIMUM_NETMASK_BITS", 1)
factory.make_node_group(network=IPNetwork("10/8"))
factory.make_node_group(network=IPNetwork("10.1.1/24"))
self.assertRaises(
NodeGroup.MultipleObjectsReturned,
find_nodegroup, get_request('10.1.1.2'))
def test_update_leases_leaves_other_nodegroups_alone(self):
innocent_nodegroup = factory.make_node_group()
innocent_lease = factory.make_dhcp_lease(nodegroup=innocent_nodegroup)
DHCPLease.objects.update_leases(
factory.make_node_group(), factory.make_random_leases())
self.assertItemsEqual(
[innocent_lease], get_leases(innocent_nodegroup))
def test_refresh_workers_skips_unaccepted_cluster_controllers(self):
self.patch(nodegroup_module, 'refresh_worker')
for status in map_enum(NODEGROUP_STATUS).values():
if status != NODEGROUP_STATUS.ACCEPTED:
factory.make_node_group(status=status)
NodeGroup.objects.refresh_workers()
self.assertEqual(0, nodegroup_module.refresh_worker.call_count)
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_find_nodegroup_looks_up_only_configured_interfaces(self):
network = IPNetwork("192.168.41.0/24")
factory.make_node_group(
network=network,
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
ip = factory.getRandomIPInNetwork(network)
self.assertIsNone(find_nodegroup(get_request(ip)))
def test_get_managed_interface_does_not_return_unrelated_interface(self):
nodegroup = factory.make_node_group()
# Create another nodegroup with a managed interface.
factory.make_node_group()
interface = nodegroup.nodegroupinterface_set.all()[0]
interface.management = NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED
interface.save()
self.assertIsNone(nodegroup.get_managed_interface())
def test_get_managed_interface_does_not_return_unrelated_interface(self):
nodegroup = factory.make_node_group()
# Create another nodegroup with a managed interface.
factory.make_node_group()
interface = nodegroup.nodegroupinterface_set.all()[0]
interface.management = NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED
interface.save()
self.assertIsNone(nodegroup.get_managed_interface())
def test_more_than_1_unmanaged_interface(self):
nodegroup1 = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
network=IPNetwork("192.168.41.0/16"))
factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
network=IPNetwork("192.168.41.0/24"))
self.assertEqual(
nodegroup1, find_nodegroup(get_request('192.168.41.199')))
def test_more_than_1_unmanaged_interface(self):
nodegroup1 = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
network=IPNetwork("192.168.41.0/16"))
factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
network=IPNetwork("192.168.41.0/24"))
self.assertEqual(nodegroup1,
find_nodegroup(get_request('192.168.41.199')))
def test_node_list_lists_nodes_from_different_nodegroups(self):
# Bug 1084443.
nodegroup1 = factory.make_node_group()
nodegroup2 = factory.make_node_group()
factory.make_node(nodegroup=nodegroup1)
factory.make_node(nodegroup=nodegroup2)
factory.make_node(nodegroup=nodegroup2)
response = self.client.get(reverse('node-list'))
self.assertEqual(httplib.OK, response.status_code)
def test_AdminForm_does_not_permit_nodegroup_change(self):
# We had to make Node.nodegroup editable to get Django to
# validate it as non-blankable, but that doesn't mean that we
# actually want to allow people to edit it through API or UI.
old_nodegroup = factory.make_node_group()
node = factory.make_node(nodegroup=old_nodegroup)
new_nodegroup = factory.make_node_group()
form = AdminNodeForm(data={'nodegroup': new_nodegroup}, instance=node)
self.assertRaises(ValueError, form.save)
def test_report_boot_images_ignores_non_accepted_groups(self):
nodegroup = factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED)
factory.make_node_group(status=NODEGROUP_STATUS.PENDING)
factory.make_node_group(status=NODEGROUP_STATUS.REJECTED)
recorder = self.patch(api, 'register_persistent_error')
client = make_worker_client(nodegroup)
image = make_boot_image_params()
response = self.report_images(nodegroup, [image], client=client)
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(0, recorder.call_count)
def test_leaves_nodegroup_alone_if_unset_on_existing_node(self):
# Selecting a node group for a node is only supported on new
# nodes. You can't change it later.
original_nodegroup = factory.make_node_group()
node = factory.make_node(nodegroup=original_nodegroup)
factory.make_node_group(network=IPNetwork("192.168.1.0/24"))
form = NodeWithMACAddressesForm(
self.make_params(nodegroup='192.168.1.0'), instance=node)
form.save()
self.assertEqual(original_nodegroup, reload_object(node).nodegroup)
def test_report_boot_images_ignores_non_accepted_groups(self):
nodegroup = factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED)
factory.make_node_group(status=NODEGROUP_STATUS.PENDING)
factory.make_node_group(status=NODEGROUP_STATUS.REJECTED)
recorder = self.patch(api, 'register_persistent_error')
client = make_worker_client(nodegroup)
image = make_boot_image_params()
response = self.report_images(nodegroup, [image], client=client)
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(0, recorder.call_count)
def test_settings_rejects_all_pending_nodegroups_POST(self):
nodegroups = {
factory.make_node_group(status=NODEGROUP_STATUS.PENDING),
factory.make_node_group(status=NODEGROUP_STATUS.PENDING),
}
response = self.client.post(
reverse('settings'), {'mass_reject_submit': 1})
self.assertEqual(httplib.FOUND, response.status_code)
self.assertEqual(
[reload_object(nodegroup).status for nodegroup in nodegroups],
[NODEGROUP_STATUS.REJECTED] * 2)
def test_1_managed_interface_and_1_unmanaged(self):
# The managed nodegroup is chosen in preference to the unmanaged
# nodegroup.
nodegroup = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
network=IPNetwork("192.168.41.0/24"))
factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
network=IPNetwork("192.168.41.0/16"))
self.assertEqual(nodegroup,
find_nodegroup(get_request('192.168.41.199')))
def test_1_managed_interface_and_1_unmanaged(self):
# The managed nodegroup is chosen in preference to the unmanaged
# nodegroup.
nodegroup = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
network=IPNetwork("192.168.41.0/24"))
factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
network=IPNetwork("192.168.41.0/16"))
self.assertEqual(
nodegroup, find_nodegroup(get_request('192.168.41.199')))
def test_anonymous_get_enlist_preseed_detects_request_origin(self):
ng_url = 'http://%s' % factory.make_name('host')
network = IPNetwork("10.1.1/24")
ip = factory.getRandomIPInNetwork(network)
factory.make_node_group(maas_url=ng_url, network=network)
anon_enlist_preseed_url = reverse('metadata-enlist-preseed',
args=['latest'])
response = self.client.get(anon_enlist_preseed_url,
{'op': 'get_enlist_preseed'},
REMOTE_ADDR=ip)
self.assertThat(response.content, Contains(ng_url))
def test_anonymous_get_enlist_preseed_detects_request_origin(self):
ng_url = 'http://%s' % factory.make_name('host')
network = IPNetwork("10.1.1/24")
ip = factory.getRandomIPInNetwork(network)
factory.make_node_group(maas_url=ng_url, network=network)
anon_enlist_preseed_url = reverse(
'metadata-enlist-preseed', args=['latest'])
response = self.client.get(
anon_enlist_preseed_url, {'op': 'get_enlist_preseed'},
REMOTE_ADDR=ip)
self.assertThat(response.content, Contains(ng_url))
def test_settings_rejects_all_pending_nodegroups_POST(self):
nodegroups = {
factory.make_node_group(status=NODEGROUP_STATUS.PENDING),
factory.make_node_group(status=NODEGROUP_STATUS.PENDING),
}
response = self.client.post(
reverse('settings'), {'mass_reject_submit': 1})
self.assertEqual(httplib.FOUND, response.status_code)
self.assertEqual(
[reload_object(nodegroup).status for nodegroup in nodegroups],
[NODEGROUP_STATUS.REJECTED] * 2)
def test_get_hostname_ip_mapping_considers_given_nodegroup(self):
nodegroup = factory.make_node_group()
node = factory.make_node(
nodegroup=nodegroup)
mac = factory.make_mac_address(node=node)
factory.make_dhcp_lease(
nodegroup=nodegroup, mac=mac.mac_address)
another_nodegroup = factory.make_node_group()
mapping = DHCPLease.objects.get_hostname_ip_mapping(
another_nodegroup)
self.assertEqual({}, mapping)
def test_get_userdata_detects_request_origin(self):
nodegroup_url = 'http://%s' % factory.make_name('host')
maas_url = 'http://%s' % factory.make_hostname()
self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
network = IPNetwork("10.1.1/24")
ip = factory.getRandomIPInNetwork(network)
factory.make_node_group(maas_url=nodegroup_url, network=network)
url = reverse('enlist-metadata-user-data', args=['latest'])
response = self.client.get(url, REMOTE_ADDR=ip)
self.assertThat(
response.content,
MatchesAll(Contains(nodegroup_url), Not(Contains(maas_url))))
def test_get_userdata_detects_request_origin(self):
nodegroup_url = 'http://%s' % factory.make_name('host')
maas_url = 'http://%s' % factory.make_hostname()
self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
network = IPNetwork("10.1.1/24")
ip = factory.getRandomIPInNetwork(network)
factory.make_node_group(maas_url=nodegroup_url, network=network)
url = reverse('enlist-metadata-user-data', args=['latest'])
response = self.client.get(url, REMOTE_ADDR=ip)
self.assertThat(
response.content,
MatchesAll(Contains(nodegroup_url), Not(Contains(maas_url))))
def test_update_leases_does_not_let_worker_update_other_nodegroup(self):
requesting_nodegroup = factory.make_node_group()
about_nodegroup = factory.make_node_group()
client = make_worker_client(requesting_nodegroup)
response = client.post(
reverse('nodegroup_handler', args=[about_nodegroup.uuid]),
{'op': 'update_leases', 'leases': json.dumps({})})
self.assertEqual(
httplib.FORBIDDEN, response.status_code,
explain_unexpected_response(httplib.FORBIDDEN, response))
def test_report_boot_images_warns_if_any_nodegroup_has_no_images(self):
nodegroup = NodeGroup.objects.ensure_master()
# Second nodegroup with no images.
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED)
recorder = self.patch(api, 'register_persistent_error')
client = make_worker_client(nodegroup)
image = make_boot_image_params()
response = self.report_images(nodegroup, [image], client=client)
self.assertEqual((httplib.OK, "OK"),
(response.status_code, response.content))
self.assertIn(COMPONENT.IMPORT_PXE_FILES,
[args[0][0] for args in recorder.call_args_list])
def test_update_leases_does_not_let_worker_update_other_nodegroup(self):
requesting_nodegroup = factory.make_node_group()
about_nodegroup = factory.make_node_group()
client = make_worker_client(requesting_nodegroup)
response = client.post(
reverse('nodegroup_handler', args=[about_nodegroup.uuid]), {
'op': 'update_leases',
'leases': json.dumps({})
})
self.assertEqual(
httplib.FORBIDDEN, response.status_code,
explain_unexpected_response(httplib.FORBIDDEN, response))
def test_POST_report_download_progress_does_work_for_other_cluster(self):
filename = factory.getRandomString()
client = make_worker_client(factory.make_node_group())
response = client.post(
reverse('nodegroup_handler',
args=[factory.make_node_group().uuid]), {
'op': 'report_download_progress',
'filename': filename,
})
self.assertEqual(
httplib.FORBIDDEN, response.status_code,
explain_unexpected_response(httplib.FORBIDDEN, response))
def test_settings_import_boot_images_calls_tasks(self):
recorder = self.patch(nodegroup_module, 'import_boot_images')
accepted_nodegroups = [
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
]
response = self.client.post(
reverse('settings'), {'import_all_boot_images': 1})
self.assertEqual(httplib.FOUND, response.status_code)
calls = [
call(queue=nodegroup.work_queue, kwargs=ANY)
for nodegroup in accepted_nodegroups
]
self.assertItemsEqual(calls, recorder.apply_async.call_args_list)
def test_settings_import_boot_images_calls_tasks(self):
recorder = self.patch(nodegroup_module, 'import_boot_images')
accepted_nodegroups = [
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
]
response = self.client.post(
reverse('settings'), {'import_all_boot_images': 1})
self.assertEqual(httplib.FOUND, response.status_code)
calls = [
call(queue=nodegroup.work_queue, kwargs=ANY)
for nodegroup in accepted_nodegroups
]
self.assertItemsEqual(calls, recorder.apply_async.call_args_list)
def test_report_boot_images_warns_if_any_nodegroup_has_no_images(self):
nodegroup = NodeGroup.objects.ensure_master()
# Second nodegroup with no images.
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED)
recorder = self.patch(api, 'register_persistent_error')
client = make_worker_client(nodegroup)
image = make_boot_image_params()
response = self.report_images(nodegroup, [image], client=client)
self.assertEqual(
(httplib.OK, "OK"),
(response.status_code, response.content))
self.assertIn(
COMPONENT.IMPORT_PXE_FILES,
[args[0][0] for args in recorder.call_args_list])
def test_write_dns_config_writes_zone_file(self):
dns_conf_dir = self.make_dir()
self.patch(conf, 'DNS_CONFIG_DIR', dns_conf_dir)
self.patch(settings, 'DNS_CONNECT', True)
# Prevent rndc task dispatch.
self.patch(tasks, "rndc_command")
domain = factory.getRandomString()
factory.make_node_group(
name=domain,
network=IPNetwork('192.168.0.1/24'),
status=NODEGROUP_STATUS.ACCEPTED,
management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
call_command('write_dns_config')
zone_file = os.path.join(dns_conf_dir, 'zone.%s' % domain)
self.assertThat(zone_file, FileExists())
def test_POST_report_download_progress_does_work_for_other_cluster(self):
filename = factory.getRandomString()
client = make_worker_client(factory.make_node_group())
response = client.post(
reverse(
'nodegroup_handler', args=[factory.make_node_group().uuid]),
{
'op': 'report_download_progress',
'filename': filename,
})
self.assertEqual(
httplib.FORBIDDEN, response.status_code,
explain_unexpected_response(httplib.FORBIDDEN, response))
def test_report_boot_images_warns_if_no_images_found(self):
nodegroup = NodeGroup.objects.ensure_master()
factory.make_node_group() # Second nodegroup with no images.
recorder = self.patch(api, 'register_persistent_error')
client = make_worker_client(nodegroup)
response = self.report_images(nodegroup, [], client=client)
self.assertEqual((httplib.OK, "OK"),
(response.status_code, response.content))
self.assertIn(COMPONENT.IMPORT_PXE_FILES,
[args[0][0] for args in recorder.call_args_list])
# Check that the persistent error message contains a link to the
# clusters listing.
self.assertIn("/settings/#accepted-clusters",
recorder.call_args_list[0][0][1])
def test_more_than_1_managed_interface(self):
factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
network=IPNetwork("192.168.41.0/16"))
factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
network=IPNetwork("192.168.41.0/24"))
exception = self.assertRaises(NodeGroupMisconfiguration,
find_nodegroup,
get_request('192.168.41.199'))
self.assertEqual(
(httplib.CONFLICT, "Multiple clusters on the same network; only "
"one cluster may manage the network of which "
"192.168.41.199 is a member."),
(exception.api_error, "%s" % exception))
def test_details_refuses_nonworker(self):
log_in_as_normal_user(self.client)
nodegroup = factory.make_node_group()
response = self.make_details_request(self.client, nodegroup)
self.assertEqual(
httplib.FORBIDDEN, response.status_code,
explain_unexpected_response(httplib.FORBIDDEN, response))
def test_POST_update_nodes_doesnt_modify_other_nodegroup_nodes(self):
tag = factory.make_tag()
nodegroup_mine = factory.make_node_group()
nodegroup_theirs = factory.make_node_group()
node_theirs = factory.make_node(nodegroup=nodegroup_theirs)
client = make_worker_client(nodegroup_mine)
response = client.post(
self.get_tag_uri(tag), {
'op': 'update_nodes',
'add': [node_theirs.system_id],
'nodegroup': nodegroup_mine.uuid,
})
self.assertEqual(httplib.OK, response.status_code)
parsed_result = json.loads(response.content)
self.assertEqual({'added': 0, 'removed': 0}, parsed_result)
self.assertItemsEqual([], tag.node_set.all())
def test_import_boot_images_on_schedule_imports_images(self):
self.patch(NodeGroup, 'import_boot_images')
nodegroup = factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED)
tasks.import_boot_images_on_schedule()
self.assertEqual(
[mock.call()],
nodegroup.import_boot_images.mock_calls)
def test_settings_contains_links_to_edit_and_delete_clusters(self):
nodegroups = {
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
factory.make_node_group(status=NODEGROUP_STATUS.PENDING),
factory.make_node_group(status=NODEGROUP_STATUS.REJECTED),
}
links = get_content_links(self.client.get(reverse('settings')))
nodegroup_edit_links = [
reverse('cluster-edit', args=[nodegroup.uuid])
for nodegroup in nodegroups]
nodegroup_delete_links = [
reverse('cluster-delete', args=[nodegroup.uuid])
for nodegroup in nodegroups]
self.assertThat(
links,
ContainsAll(nodegroup_edit_links + nodegroup_delete_links))
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_populate_tags_task_routed_to_nodegroup_worker(self):
nodegroup = factory.make_node_group()
tag = factory.make_tag()
task = self.patch(populate_tags_module, 'update_node_tags')
populate_tags(tag)
args, kwargs = task.apply_async.call_args
self.assertEqual(nodegroup.work_queue, kwargs['queue'])
def test_fires_tasks_routed_to_nodegroup_worker(self):
nodegroup = factory.make_node_group()
task = self.patch(nodegroup_module, 'add_new_dhcp_host_map')
leases = factory.make_random_leases()
nodegroup.add_dhcp_host_maps(leases)
args, kwargs = task.apply_async.call_args
self.assertEqual(nodegroup.work_queue, kwargs['queue'])
def test_write_dhcp_config_task_routed_to_nodegroup_worker(self):
nodegroup = factory.make_node_group(status=NODEGROUP_STATUS.PENDING)
self.patch(settings, "DHCP_CONNECT", True)
self.patch(dhcp, 'write_dhcp_config')
nodegroup.accept()
args, kwargs = dhcp.write_dhcp_config.apply_async.call_args
self.assertEqual(nodegroup.work_queue, kwargs['queue'])
def test__mass_change_status_changes_statuses(self):
old_status = factory.getRandomEnum(NODEGROUP_STATUS)
nodegroup1 = factory.make_node_group(status=old_status)
nodegroup2 = factory.make_node_group(status=old_status)
new_status = factory.getRandomEnum(NODEGROUP_STATUS,
but_not=[old_status])
changed = NodeGroup.objects._mass_change_status(old_status, new_status)
self.assertEqual((
reload_object(nodegroup1).status,
reload_object(nodegroup2).status,
2,
), (
new_status,
new_status,
changed,
))
def test_accept_all_pending_does_not_change_others(self):
unaffected_status = factory.getRandomEnum(
NODEGROUP_STATUS, but_not=[NODEGROUP_STATUS.PENDING])
nodegroup = factory.make_node_group(status=unaffected_status)
changed_count = NodeGroup.objects.accept_all_pending()
self.assertEqual((unaffected_status, 0),
(reload_object(nodegroup).status, changed_count))
def test_POST_update_nodes_doesnt_modify_other_nodegroup_nodes(self):
tag = factory.make_tag()
nodegroup_mine = factory.make_node_group()
nodegroup_theirs = factory.make_node_group()
node_theirs = factory.make_node(nodegroup=nodegroup_theirs)
client = make_worker_client(nodegroup_mine)
response = client.post(
self.get_tag_uri(tag), {
'op': 'update_nodes',
'add': [node_theirs.system_id],
'nodegroup': nodegroup_mine.uuid,
})
self.assertEqual(httplib.OK, response.status_code)
parsed_result = json.loads(response.content)
self.assertEqual({'added': 0, 'removed': 0}, parsed_result)
self.assertItemsEqual([], tag.node_set.all())
def test_cluster_no_boot_images_message_displayed_if_no_boot_images(self):
nodegroup = factory.make_node_group(
status=NODEGROUP_STATUS.ACCEPTED)
response = self.client.get(reverse('settings'))
document = fromstring(response.content)
nodegroup_row = document.xpath("//tr[@id='%s']" % nodegroup.uuid)[0]
self.assertIn('no boot images', nodegroup_row.text_content())
def test_add_dhcp_host_maps_adds_maps_if_managing_dhcp(self):
self.patch(Omshell, 'create', FakeMethod())
nodegroup = factory.make_node_group()
leases = factory.make_random_leases()
nodegroup.add_dhcp_host_maps(leases)
self.assertEqual([(leases.keys()[0], leases.values()[0])],
Omshell.create.extract_args())
def test_view_tag_num_queries_is_independent_of_num_nodes(self):
tag = factory.make_tag()
tag_link = reverse('tag-view', args=[tag.name])
nodegroup = factory.make_node_group()
nodes = [
factory.make_node(nodegroup=nodegroup, mac=True) for i in range(20)
]
for node in nodes[:10]:
node.tags.add(tag)
num_queries, response = self.getNumQueries(self.client.get, tag_link)
self.assertEqual(
10,
len([
link for link in get_content_links(response)
if link.startswith('/nodes/node')
]))
# Need to get the tag, and the nodes, and the macs of the nodes
self.assertTrue(num_queries > 3)
for node in nodes[10:]:
node.tags.add(tag)
num_bonus_queries, response = self.getNumQueries(
self.client.get, tag_link)
self.assertEqual(num_queries, num_bonus_queries)
self.assertEqual(
20,
len([
link for link in get_content_links(response)
if link.startswith('/nodes/node')
]))
def test_PUT_reserved_to_admin_users(self):
nodegroup = factory.make_node_group()
response = self.client_put(
reverse('nodegroup_handler', args=[nodegroup.uuid]),
{'name': factory.make_name("new-name")})
self.assertEqual(httplib.FORBIDDEN, response.status_code)
def test_returns_accepted_for_new_pending_nodegroup(self):
nodegroup = factory.make_node_group(status=NODEGROUP_STATUS.PENDING)
response = api.compose_nodegroup_register_response(
nodegroup, already_existed=False)
self.assertEqual((httplib.ACCEPTED,
"Cluster registered. Awaiting admin approval."),
(response.status_code, response.content))
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_add_dhcp_host_maps_does_nothing_if_not_managing_dhcp(self):
self.patch(Omshell, 'create', FakeMethod())
nodegroup = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
leases = factory.make_random_leases()
nodegroup.add_dhcp_host_maps(leases)
self.assertEqual([], Omshell.create.extract_args())
def test_refreshes_nodegroup_uuid(self):
refresh_functions = self.patch_refresh_functions()
nodegroup = factory.make_node_group()
refresh_worker(nodegroup)
self.assertEqual(
[(nodegroup.uuid, )],
refresh_functions['nodegroup_uuid'].extract_args())
def test_fires_tasks_routed_to_nodegroup_worker(self):
nodegroup = factory.make_node_group()
task = self.patch(nodegroup_module, 'add_new_dhcp_host_map')
leases = factory.make_random_leases()
nodegroup.add_dhcp_host_maps(leases)
args, kwargs = task.apply_async.call_args
self.assertEqual(nodegroup.work_queue, kwargs['queue'])
def test_add_dhcp_host_maps_does_nothing_if_not_managing_dhcp(self):
self.patch(Omshell, 'create', FakeMethod())
nodegroup = factory.make_node_group(
management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
leases = factory.make_random_leases()
nodegroup.add_dhcp_host_maps(leases)
self.assertEqual([], Omshell.create.extract_args())
