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)