def test_get_nodes_with_edit_perm_admin_lists_all_nodes(self):
admin = factory.make_admin()
owners = [
None,
factory.make_user(),
factory.make_admin(),
admin,
]
nodes = [self.make_node(owner) for owner in owners]
self.assertItemsEqual(
nodes, Node.objects.get_nodes(admin, NODE_PERMISSION.EDIT))
def test_get_nodes_with_admin_perm_returns_all_nodes_for_admin(self):
user = factory.make_user()
nodes = [self.make_node(user) for counter in range(5)]
self.assertItemsEqual(
nodes,
Node.objects.get_nodes(
factory.make_admin(), NODE_PERMISSION.ADMIN))
def test_get_action_form_creates_form_class(self):
user = factory.make_admin()
node = factory.make_node(status=NODE_STATUS.DECLARED)
form = get_action_form(user)(node)
self.assertIsInstance(form, NodeActionForm)
self.assertEqual(node, form.node)
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_save_performs_requested_action(self):
admin = factory.make_admin()
node = factory.make_node(status=NODE_STATUS.DECLARED)
form = get_action_form(admin)(
node, {NodeActionForm.input_name: AcceptAndCommission.display})
form.save()
self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
def test_compile_node_actions_includes_inhibited_actions(self):
class MyAction(FakeNodeAction):
fake_inhibition = factory.getRandomString()
actions = compile_node_actions(
factory.make_node(), factory.make_admin(), classes=[MyAction])
self.assertEqual([MyAction.display], actions.keys())
def test_save_double_checks_for_inhibitions(self):
admin = factory.make_admin()
node = factory.make_node(
status=NODE_STATUS.ALLOCATED, owner=factory.make_user())
form = get_action_form(admin)(
node, {NodeActionForm.input_name: Delete.display})
with ExpectedException(PermissionDenied, "You cannot delete.*"):
form.save()
def test_start_commissioning_clears_node_commissioning_results(self):
node = factory.make_node(status=NODE_STATUS.DECLARED)
NodeCommissionResult.objects.store_data(
node, factory.getRandomString(),
random.randint(0, 10),
factory.getRandomString())
node.start_commissioning(factory.make_admin())
self.assertItemsEqual([], node.nodecommissionresult_set.all())
def test_compile_node_actions_returns_available_actions(self):
class MyAction(FakeNodeAction):
display = factory.getRandomString()
actions = compile_node_actions(
factory.make_node(), factory.make_admin(), classes=[MyAction])
self.assertEqual([MyAction.display], actions.keys())
def test_GET_identifies_superuser_as_such(self):
user = factory.make_admin()
response = self.client.get(
reverse('user_handler', args=[user.username]))
self.assertEqual(httplib.OK, response.status_code, response.content)
self.assertTrue(json.loads(response.content)['is_superuser'])
def test_start_commissioning_sets_user_data(self):
node = factory.make_node(status=NODE_STATUS.DECLARED)
user_data = factory.getRandomString().encode('ascii')
self.patch(
commissioning.user_data, 'generate_user_data'
).return_value = user_data
node.start_commissioning(factory.make_admin())
self.assertEqual(user_data, NodeUserData.objects.get_user_data(node))
def test_get_action_form_for_admin(self):
admin = factory.make_admin()
node = factory.make_node(status=NODE_STATUS.DECLARED)
form = get_action_form(admin)(node)
self.assertItemsEqual(
[AcceptAndCommission.display, Delete.display],
form.actions)
def test_compile_node_actions_checks_node_status(self):
class MyAction(FakeNodeAction):
actionable_statuses = (NODE_STATUS.READY, )
node = factory.make_node(status=NODE_STATUS.DECLARED)
actions = compile_node_actions(
node, factory.make_admin(), classes=[MyAction])
self.assertEqual({}, actions)
def test_admin_sees_all_nodes(self):
nodes = [
make_allocated_node(),
make_unallocated_node(),
]
self.assertItemsEqual(
nodes,
Node.objects.get_nodes(
factory.make_admin(), NODE_PERMISSION.VIEW))
def test_compile_node_actions_maintains_order(self):
names = [factory.getRandomString() for counter in range(4)]
classes = [
type(b"Action%d" % counter, (FakeNodeAction,), {'name': name})
for counter, name in enumerate(names)]
actions = compile_node_actions(
factory.make_node(), factory.make_admin(), classes=classes)
self.assertSequenceEqual(names, actions.keys())
self.assertSequenceEqual(
names, [action.name for action in actions.values()])
def test_compile_node_actions_maintains_order(self):
labels = [factory.getRandomString() for counter in range(4)]
classes = [
type(b"Action%d" % counter, (FakeNodeAction,), {'display': label})
for counter, label in enumerate(labels)]
actions = compile_node_actions(
factory.make_node(), factory.make_admin(), classes=classes)
self.assertSequenceEqual(labels, actions.keys())
self.assertSequenceEqual(
labels, [action.display for action in actions.values()])
def test_Delete_redirects_to_node_delete_view(self):
node = factory.make_node()
action = Delete(node, factory.make_admin())
try:
action.execute()
except Redirect as e:
pass
self.assertEqual(
reverse('node-delete', args=[node.system_id]),
urlparse(unicode(e)).path)
def test_RetryCommissioning_starts_commissioning(self):
node = factory.make_node(
mac=True, status=NODE_STATUS.FAILED_TESTS,
power_type=POWER_TYPE.WAKE_ON_LAN)
action = RetryCommissioning(node, factory.make_admin())
action.execute()
self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
self.assertEqual(
'provisioningserver.tasks.power_on',
self.celery.tasks[0]['task'].name)
def test_start_commissioning_ignores_other_commissioning_results(self):
node = factory.make_node()
filename = factory.getRandomString()
text = factory.getRandomString()
script_result = random.randint(0, 10)
NodeCommissionResult.objects.store_data(
node, filename, script_result, text)
other_node = factory.make_node(status=NODE_STATUS.DECLARED)
other_node.start_commissioning(factory.make_admin())
self.assertEqual(
text, NodeCommissionResult.objects.get_data(node, filename))
def test_get_nodes_filters_from_nodes(self):
admin = factory.make_admin()
# Node that we want to see in the result:
wanted_node = factory.make_node()
# Node that we'll exclude from from_nodes:
factory.make_node()
self.assertItemsEqual(
[wanted_node],
Node.objects.get_nodes(
admin, NODE_PERMISSION.VIEW,
from_nodes=Node.objects.filter(id=wanted_node.id)))
def test_start_commissioning_changes_status_and_starts_node(self):
node = factory.make_node(
status=NODE_STATUS.DECLARED, power_type=POWER_TYPE.WAKE_ON_LAN)
factory.make_mac_address(node=node)
node.start_commissioning(factory.make_admin())
expected_attrs = {
'status': NODE_STATUS.COMMISSIONING,
}
self.assertAttributes(node, expected_attrs)
self.assertEqual(
['provisioningserver.tasks.power_on'],
[task['task'].name for task in self.celery.tasks])
def test_compile_node_actions_maps_display_names(self):
class Action1(FakeNodeAction):
display = factory.getRandomString()
class Action2(FakeNodeAction):
display = factory.getRandomString()
actions = compile_node_actions(
factory.make_node(), factory.make_admin(),
classes=[Action1, Action2])
for label, action in actions.items():
self.assertEqual(label, action.display)
def test_Commission_starts_commissioning(self):
statuses = (
NODE_STATUS.DECLARED, NODE_STATUS.FAILED_TESTS,
NODE_STATUS.READY)
for status in statuses:
node = factory.make_node(
mac=True, status=status,
power_type=POWER_TYPE.WAKE_ON_LAN)
action = Commission(node, factory.make_admin())
action.execute()
self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
self.assertEqual(
'provisioningserver.tasks.power_on',
self.celery.tasks[0]['task'].name)
def test_nodegroup_list_nodes_works_for_admin(self):
nodegroup = factory.make_node_group()
admin = factory.make_admin()
client = OAuthAuthenticatedClient(admin)
node = factory.make_node(nodegroup=nodegroup)
response = client.get(
reverse('nodegroup_handler', args=[nodegroup.uuid]),
{'op': 'list_nodes'})
self.assertEqual(
httplib.OK, response.status_code,
explain_unexpected_response(httplib.OK, response))
parsed_result = json.loads(response.content)
self.assertItemsEqual([node.system_id], parsed_result)
def test_add_address_record(self):
user = factory.make_admin()
handler = DomainHandler(user, {}, None)
domain = factory.make_Domain()
name = factory.make_hostname()
ttl = randint(1, 3600)
handler.create_address_record({
"domain": domain.id,
"name": name,
"address_ttl": ttl,
"ip_addresses": ["127.0.0.1"],
})
resource = DNSResource.objects.get(domain=domain, name=name)
self.assertThat(resource.address_ttl, Equals(ttl))
self.assertThat(resource.name, Equals(name))
self.assertThat(
list(resource.ip_addresses.all())[0].ip, Equals("127.0.0.1"))
def test_action_performs_action_passing_extra(self):
user = factory.make_admin()
request = HttpRequest()
request.user = user
device = self.make_device_with_ip_address(owner=user)
zone = factory.make_Zone()
handler = DeviceHandler(user, {}, request)
handler.action({
"request": request,
"system_id": device.system_id,
"action": "set-zone",
"extra": {
"zone_id": zone.id,
}
})
device = reload_object(device)
self.expectThat(device.zone, Equals(zone))
def test__add_address_record(self):
user = factory.make_admin()
handler = DomainHandler(user, {})
domain = factory.make_Domain()
name = factory.make_hostname()
ttl = randint(1, 3600)
handler.create_address_record({
'domain': domain.id,
'name': name,
'address_ttl': ttl,
'ip_addresses': ['127.0.0.1']
})
resource = DNSResource.objects.get(domain=domain, name=name)
self.assertThat(resource.address_ttl, Equals(ttl))
self.assertThat(resource.name, Equals(name))
self.assertThat(
list(resource.ip_addresses.all())[0].ip, Equals("127.0.0.1"))
def test__configure_dhcp_with_two_parameters(self):
user = factory.make_admin()
handler = VLANHandler(user, {}, None)
vlan = factory.make_VLAN()
rack = factory.make_RackController()
factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
rack2 = factory.make_RackController()
factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=rack2, vlan=vlan)
factory.make_ipv4_Subnet_with_IPRanges(vlan=vlan)
handler.configure_dhcp({
"id": vlan.id,
"controllers": [rack.system_id, rack2.system_id]
})
vlan = reload_object(vlan)
self.assertThat(vlan.dhcp_on, Equals(True))
self.assertThat(vlan.primary_rack, Equals(rack))
self.assertThat(vlan.secondary_rack, Equals(rack2))
def test_update_updates_node(self):
user = factory.make_admin()
handler = DeviceHandler(user, {}, None)
node = factory.make_Node(interface=True, node_type=NODE_TYPE.DEVICE)
node_data = self.dehydrate_device(node, user)
new_zone = factory.make_Zone()
new_hostname = factory.make_name("hostname")
new_tags = [factory.make_name("tag") for _ in range(3)]
node_data["hostname"] = new_hostname
node_data["zone"] = {
"name": new_zone.name,
}
node_data["tags"] = new_tags
updated_node = handler.update(node_data)
self.assertEqual(updated_node["hostname"], new_hostname)
self.assertEqual(updated_node["zone"]["id"], new_zone.id)
self.assertItemsEqual(updated_node["tags"], new_tags)
def test__non_superuser_reloads_user(self):
user = factory.make_admin()
handler = VLANHandler(user, {}, None)
user.is_superuser = False
user.save()
rack = factory.make_RackController()
vlan = factory.make_VLAN()
factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
vlan.dhcp_on = True
vlan.primary_rack = rack
vlan.save()
factory.make_ipv4_Subnet_with_IPRanges(vlan=vlan)
with ExpectedException(AssertionError, "Permission denied."):
handler.configure_dhcp({
"id": vlan.id,
"controllers": []
})
def test_gives_stat_when_action_is_inhibited(self):
with transaction.atomic():
node = factory.make_Node(
status=NODE_STATUS.ALLOCATED, owner=factory.make_User())
form = BulkNodeActionForm(
user=factory.make_admin(),
data=dict(
action=PowerOn.name,
system_id=[node.system_id]))
self.assertTrue(form.is_valid(), form._errors)
with transaction.atomic():
done, not_actionable, not_permitted = form.save()
self.assertEqual(
[0, 1, 0],
[done, not_actionable, not_permitted])
def test_settings_ntp_POST(self):
# Disable boot source cache signals.
self.addCleanup(bootsources.signals.enable)
bootsources.signals.disable()
self.client.login(user=factory.make_admin())
new_servers = "ntp.example.com"
response = self.client.post(
reverse('settings_network'),
get_prefixed_form_data(prefix='ntp',
data={
'ntp_servers': new_servers,
'ntp_external_only': True,
}))
self.assertEqual(http.client.FOUND, response.status_code,
response.content)
self.assertEqual(new_servers, Config.objects.get_config('ntp_servers'))
self.assertTrue(Config.objects.get_config('ntp_external_only'))
def test_AdminMachineForm_new_machine_no_deployed_no_owner(self):
hostname = factory.make_string()
user = factory.make_admin()
form = AdminMachineForm(
request=FakeRequest(user),
data={
"hostname": hostname,
"architecture": make_usable_architecture(self),
"power_type": "ipmi",
"power_parameters_field": factory.make_string(),
"power_parameters_skip_check": "true",
},
)
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertEqual(node.status, NODE_STATUS.NEW)
self.assertIsNone(node.owner)
def test_settings_commissioning_POST(self):
self.client.login(user=factory.make_admin())
ubuntu = factory.make_default_ubuntu_release_bootable()
new_commissioning = ubuntu.name.split('/')[1]
response = self.client.post(
reverse('settings_general'),
get_prefixed_form_data(prefix='commissioning',
data={
'commissioning_distro_series':
(new_commissioning),
}))
self.assertEqual(http.client.FOUND, response.status_code)
self.assertEqual(
(new_commissioning, ),
(Config.objects.get_config('commissioning_distro_series'), ))
def test__calls_start_commissioning_if_already_on(self):
node = factory.make_Node(status=NODE_STATUS.READY,
power_state=POWER_STATE.ON)
user = factory.make_admin()
mock_start_commissioning = self.patch_autospec(node,
"start_commissioning")
form = CommissionForm(instance=node, user=user, data={})
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertThat(
mock_start_commissioning,
MockCalledOnceWith(user,
enable_ssh=False,
skip_networking=False,
skip_storage=False,
commissioning_scripts=[],
testing_scripts=[]))
def test_add_user_POST(self):
self.client.login(user=factory.make_admin())
params = {
'username': factory.make_string(),
'last_name': factory.make_string(30),
'email': factory.make_email_address(),
'is_superuser': factory.pick_bool(),
}
password = factory.make_string()
params.update(make_password_params(password))
response = self.client.post(reverse('accounts-add'), params)
self.assertEqual(http.client.FOUND, response.status_code)
user = User.objects.get(username=params['username'])
self.assertAttributes(user, subset_dict(params, user_attributes))
self.assertTrue(user.check_password(password))
self.assertTrue(user.userprofile.is_local)
def test_add_user_with_external_auth_not_local(self):
admin = factory.make_admin()
# login before external auth is enabled to avoid requiring macaroons
self.client.login(user=admin)
Config.objects.set_config('external_auth_url',
'http://auth.example.com')
params = {
'username': factory.make_string(),
'last_name': factory.make_string(30),
'email': factory.make_email_address(),
'is_superuser': factory.pick_bool(),
}
password = factory.make_string()
params.update(make_password_params(password))
self.client.post(reverse('accounts-add'), params)
user = User.objects.get(username=params['username'])
self.assertFalse(user.userprofile.is_local)
def test_settings_contains_names_and_content_of_scripts(self):
self.client.login(user=factory.make_admin())
scripts = [
factory.make_Script(script_type=SCRIPT_TYPE.TESTING),
factory.make_Script(script_type=SCRIPT_TYPE.TESTING),
factory.make_Script(script_type=SCRIPT_TYPE.TESTING, default=True)
]
response = self.client.get(reverse('settings_scripts'))
names = [script.name for script in scripts[:-1]]
contents = [script.script.data for script in scripts[:-1]]
self.assertThat(
response.content,
ContainsAll(
[name.encode(settings.DEFAULT_CHARSET) for name in names]))
self.assertThat(
response.content,
ContainsAll([content.encode() for content in contents]))
def test_get_with_pod_host_determines_vlan_boot_status(self):
admin = factory.make_admin()
handler = PodHandler(admin, {}, None)
vlan = factory.make_VLAN(dhcp_on=False)
subnet = factory.make_Subnet(vlan=vlan)
node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
ip = factory.make_StaticIPAddress(interface=node.boot_interface,
subnet=subnet)
pod = self.make_pod_with_hints(ip_address=ip)
expected_data = handler.full_dehydrate(pod)
result = handler.get({"id": pod.id})
self.assertItemsEqual(expected_data.keys(), result.keys())
for key in expected_data:
self.assertEqual(expected_data[key], result[key], key)
self.assertThat(result, Equals(expected_data))
self.assertThat(result["attached_vlans"], Equals([subnet.vlan_id]))
self.assertThat(result["boot_vlans"], Equals([]))
def test_nodegroup_import_boot_images_calls_script(self):
recorder = self.patch(tasks, 'call_and_check')
proxy = factory.getRandomString()
Config.objects.set_config('http_proxy', proxy)
nodegroup = factory.make_node_group()
admin = factory.make_admin()
client = OAuthAuthenticatedClient(admin)
response = client.post(
reverse('nodegroup_handler', args=[nodegroup.uuid]),
{'op': 'import_boot_images'})
self.assertEqual(
httplib.OK, response.status_code,
explain_unexpected_response(httplib.OK, response))
recorder.assert_called_once_with(
['sudo', '-n', '-E', 'maas-import-pxe-files'], env=ANY)
def test_add_user_POST_creates_audit_event(self):
self.client.login(user=factory.make_admin())
username = factory.make_string()
params = {
'username': username,
'last_name': factory.make_string(30),
'email': factory.make_email_address(),
'is_superuser': False,
}
password = factory.make_string()
params.update(make_password_params(password))
self.client.post(reverse('accounts-add'), params)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertEquals(event.description,
"User %s" % username + " created by '%(username)s'.")
def test_calls_start_commissioning_with_options(self):
node = factory.make_Node(
status=NODE_STATUS.READY,
power_state=POWER_STATE.OFF,
interface=True,
)
user = factory.make_admin()
commissioning_scripts = [
factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING).name
for _ in range(3)
]
testing_scripts = [
factory.make_Script(script_type=SCRIPT_TYPE.TESTING).name
for _ in range(3)
]
mock_start_commissioning = self.patch_autospec(node,
"start_commissioning")
form = CommissionForm(
instance=node,
user=user,
data={
"enable_ssh": True,
"skip_bmc_config": True,
"skip_networking": True,
"skip_storage": True,
"commissioning_scripts": ",".join(commissioning_scripts),
"testing_scripts": ",".join(testing_scripts),
},
)
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertIsNotNone(node)
self.assertThat(
mock_start_commissioning,
MockCalledOnceWith(
user,
enable_ssh=True,
skip_bmc_config=True,
skip_networking=True,
skip_storage=True,
commissioning_scripts=commissioning_scripts,
testing_scripts=testing_scripts,
script_input={},
),
)
def test__class_start_testing_can_override_global_param(self):
node = factory.make_Node(status=NODE_STATUS.DEPLOYED)
bd = factory.make_PhysicalBlockDevice(node=node)
user = factory.make_admin()
global_script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING,
parameters={
'storage': {
'type': 'storage'
},
})
script = factory.make_Script(script_type=SCRIPT_TYPE.TESTING,
parameters={
'storage': {
'type': 'storage'
},
})
mock_start_testing = self.patch_autospec(node, 'start_testing')
input = random.choice([
str(bd.id), bd.name, bd.model, bd.serial,
'%s:%s' % (bd.model, bd.serial)
] + bd.tags)
form = TestForm(instance=node,
user=user,
data={
'testing_scripts':
'%s,%s' % (global_script.name, script.name),
'storage':
'all',
'%s_storage' % global_script.name:
input,
})
self.assertTrue(form.is_valid(), form.errors)
node = form.save()
self.assertIsNotNone(node)
self.assertThat(
mock_start_testing,
MockCalledOnceWith(
user, False, [global_script.name, script.name], {
script.name: {
'storage': 'all'
},
global_script.name: {
'storage': input
},
}))
def test_is_relevant_to_user(self):
make_Notification = factory.make_Notification
user = factory.make_User()
user2 = factory.make_User()
admin = factory.make_admin()
Yes, No = Is(True), Is(False)
def assertRelevance(notification, user, yes_or_no):
# Ensure that is_relevant_to and find_for_user agree, i.e. if
# is_relevant_to returns True, the notification is in the set
# returned by find_for_user. Likewise, if is_relevant_to returns
# False, the notification is not in the find_for_user set.
self.assertThat(notification.is_relevant_to(user), yes_or_no)
self.assertThat(
Notification.objects.find_for_user(user)
.filter(id=notification.id)
.exists(),
yes_or_no,
)
notification_to_user = make_Notification(user=user)
assertRelevance(notification_to_user, None, No)
assertRelevance(notification_to_user, user, Yes)
assertRelevance(notification_to_user, user2, No)
assertRelevance(notification_to_user, admin, No)
notification_to_users = make_Notification(users=True)
assertRelevance(notification_to_users, None, No)
assertRelevance(notification_to_users, user, Yes)
assertRelevance(notification_to_users, user2, Yes)
assertRelevance(notification_to_users, admin, No)
notification_to_admins = make_Notification(admins=True)
assertRelevance(notification_to_admins, None, No)
assertRelevance(notification_to_admins, user, No)
assertRelevance(notification_to_admins, user2, No)
assertRelevance(notification_to_admins, admin, Yes)
notification_to_all = make_Notification(users=True, admins=True)
assertRelevance(notification_to_all, None, No)
assertRelevance(notification_to_all, user, Yes)
assertRelevance(notification_to_all, user2, Yes)
assertRelevance(notification_to_all, admin, Yes)
def test_can_create_commissioning_script(self):
self.client.login(user=factory.make_admin())
content = factory.make_script_content().encode("ascii")
name = factory.make_name("filename")
create_link = reverse("commissioning-script-add")
filepath = self.make_file(name=name, contents=content)
with open(filepath) as fp:
response = self.client.post(create_link, {
"name": name,
"content": fp
})
self.assertEqual(
(http.client.FOUND, reverse("settings_scripts")),
(response.status_code, extract_redirect(response)),
)
new_script = Script.objects.get(name=name)
self.assertEquals(name, new_script.name)
self.assertEquals(content, new_script.script.data.encode())
def test_create_interface_creates_interface(self):
user = factory.make_admin()
node = factory.make_Node(interface=False, node_type=NODE_TYPE.DEVICE)
handler = DeviceHandler(user, {})
name = factory.make_name("eth")
mac_address = factory.make_mac_address()
handler.create_interface({
"system_id":
node.system_id,
"name":
name,
"mac_address":
mac_address,
"ip_assignment":
DEVICE_IP_ASSIGNMENT_TYPE.DYNAMIC,
})
self.assertEqual(1, node.interface_set.count(),
"Should have one interface on the node.")
def test_create_with_form_creates_node(self):
hostname = factory.make_name("hostname")
arch = make_usable_architecture(self)
handler = self.make_nodes_handler(
fields=['hostname', 'architecture'],
form=AdminMachineWithMACAddressesForm)
handler.user = factory.make_admin()
json_obj = handler.create({
"hostname":
hostname,
"architecture":
arch,
"mac_addresses": [factory.make_mac_address()],
})
self.expectThat({
"hostname": hostname,
"architecture": arch,
}, Equals(json_obj))
def test__update_address__creates_second_dnsrecord_if_name_changed(self):
user = factory.make_admin()
handler = DomainHandler(user, {}, None)
domain = factory.make_Domain()
resource = factory.make_DNSResource(
domain=domain, name="foo", ip_addresses=["127.0.0.1", "127.0.0.2"])
handler.update_address_record({
'domain': domain.id,
'dnsresource_id': resource.id,
'previous_name': resource.name,
'previous_rrdata': "127.0.0.1",
'name': "bar",
'ip_addresses': ['127.0.0.3']
})
resource = reload_object(resource)
self.assertThat(resource.get_addresses(), Equals(["127.0.0.2"]))
resource = DNSResource.objects.get(domain=domain, name="bar")
self.assertThat(resource.get_addresses(), Equals(["127.0.0.3"]))
def test__update_address__updates_single_address(self):
user = factory.make_admin()
handler = DomainHandler(user, {}, None)
domain = factory.make_Domain()
name = factory.make_hostname()
resource = factory.make_DNSResource(
domain=domain, name=name, ip_addresses=["127.0.0.1", "127.0.0.2"])
handler.update_address_record({
'domain': domain.id,
'dnsresource_id': resource.id,
'previous_name': resource.name,
'previous_rrdata': "127.0.0.1",
'name': name,
'ip_addresses': ['127.0.0.3']
})
resource = reload_object(resource)
self.assertThat(resource.get_addresses(),
Equals(["127.0.0.2", "127.0.0.3"]))
def test_create_as_admin_event_log(self):
admin_user = factory.make_admin()
handler = UserHandler(admin_user, {}, None)
params = {
"username": factory.make_string(),
"last_name": factory.make_string(30),
"email": factory.make_email_address(),
"is_superuser": False,
}
password = factory.make_string()
params.update(make_password_params(password))
handler.create(params)
event = Event.objects.get(type__level=AUDIT)
self.assertIsNotNone(event)
self.assertEqual(event.description,
"Created user '{username}'.".format(**params))
def test_create_with_form_uses_form_from_get_form_class(self):
hostname = factory.make_name("hostname")
arch = make_usable_architecture(self)
handler = self.make_nodes_handler(fields=["hostname", "architecture"])
handler.user = factory.make_admin()
self.patch(
handler, "get_form_class"
).return_value = AdminMachineWithMACAddressesForm
json_obj = handler.create(
{
"hostname": hostname,
"architecture": arch,
"mac_addresses": [factory.make_mac_address()],
}
)
self.expectThat(
{"hostname": hostname, "architecture": arch}, Equals(json_obj)
)
def test__update_dnsdata(self):
user = factory.make_admin()
handler = DomainHandler(user, {}, None)
domain = factory.make_Domain()
dnsresource = factory.make_DNSResource(domain=domain)
dnsdata = factory.make_DNSData(
dnsresource, rrtype="TXT", rrdata="original"
)
handler.update_dnsdata(
{
"domain": domain.id,
"dnsresource_id": dnsresource.id,
"dnsdata_id": dnsdata.id,
"rrdata": "updated",
}
)
dnsdata = reload_object(dnsdata)
self.assertThat(dnsdata.rrdata, Equals("updated"))
def test__scan_as_admin_logs_the_fact_that_a_scan_happened(self):
user = factory.make_admin()
handler = SubnetHandler(user, {})
subnet = factory.make_Subnet(version=4)
rack = factory.make_RackController()
factory.make_Interface(node=rack, subnet=subnet)
logger = self.useFixture(FakeLogger())
cidr = subnet.get_ipnetwork()
handler.scan({
"id": subnet.id,
})
# Use MatchesRegex here rather than DocTestMatches because usernames
# can contain characters that confuse DocTestMatches (e.g. periods).
self.assertThat(
logger.output,
MatchesRegex(
"User '%s' initiated a neighbour discovery scan against subnet: %s"
% (re.escape(user.username), re.escape(str(cidr)))))
def test_action_performs_action_passing_extra(self):
admin = factory.make_admin()
request = HttpRequest()
request.user = admin
device = factory.make_Device(owner=admin)
factory.make_Switch(node=device)
zone = factory.make_Zone()
handler = SwitchHandler(admin, {}, request)
handler.action({
"request": request,
"system_id": device.system_id,
"action": "set-zone",
"extra": {
"zone_id": zone.id,
}
})
device = reload_object(device)
self.assertEqual(device.zone, zone)
def test_settings_contains_names_and_content_of_scripts(self):
self.client.login(user=factory.make_admin())
scripts = {
factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING),
factory.make_Script(script_type=SCRIPT_TYPE.COMMISSIONING),
}
response = self.client.get(reverse("settings_scripts"))
names = [script.name for script in scripts]
contents = [script.script.data for script in scripts]
self.assertThat(
response.content,
ContainsAll(
[name.encode(settings.DEFAULT_CHARSET) for name in names]),
)
self.assertThat(
response.content,
ContainsAll([content.encode() for content in contents]),
)
def test_details_allows_admin(self):
nodegroup = factory.make_node_group()
node = factory.make_node(nodegroup=nodegroup)
user = factory.make_admin()
client = OAuthAuthenticatedClient(user)
response = client.post(
reverse('nodegroup_handler', args=[nodegroup.uuid]),
{'op': 'details', 'system_ids': [node.system_id]})
self.assertEqual(httplib.OK, response.status_code)
parsed_result = bson.BSON(response.content).decode()
self.assertDictEqual(
{
node.system_id: {
"lshw": None,
"lldp": None,
},
},
parsed_result)
def test_import_boot_images_calls_script_for_all_accepted_clusters(self):
recorder = self.patch(nodegroup_module, 'import_boot_images')
proxy = factory.make_name('proxy')
Config.objects.set_config('http_proxy', proxy)
accepted_nodegroups = [
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
]
factory.make_node_group(status=NODEGROUP_STATUS.REJECTED)
factory.make_node_group(status=NODEGROUP_STATUS.PENDING)
admin = factory.make_admin()
client = OAuthAuthenticatedClient(admin)
response = client.post(
reverse('nodegroups_handler'), {'op': 'import_boot_images'})
self.assertEqual(
httplib.OK, response.status_code,
explain_unexpected_response(httplib.OK, response))
queues = [
kwargs['queue']
for args, kwargs in recorder.apply_async.call_args_list]
self.assertItemsEqual(
[nodegroup.work_queue for nodegroup in accepted_nodegroups],
queues)
def test_Delete_does_not_inhibit_otherwise(self):
node = factory.make_node(status=NODE_STATUS.FAILED_TESTS)
action = Delete(node, factory.make_admin())
inhibition = action.inhibit()
self.assertIsNone(inhibition)
def test_not_permitted_if_already_uses_di(self):
node = factory.make_node()
node.use_traditional_installer()
user = factory.make_admin()
self.assertFalse(UseDI(node, user).is_permitted())
def test_Delete_inhibit_when_node_is_allocated(self):
node = factory.make_node(status=NODE_STATUS.ALLOCATED)
action = Delete(node, factory.make_admin())
inhibition = action.inhibit()
self.assertEqual(
"You cannot delete this node because it's in use.", inhibition)
