def test_PUT_updates_power_type_default_rejects_params(self):
# If one sets power_type to DEFAULT, on cannot set power_parameters.
self.become_admin()
power_parameters = factory.getRandomString()
node = factory.make_node(
owner=self.logged_in_user,
power_type=POWER_TYPE.WAKE_ON_LAN,
power_parameters=power_parameters)
new_param = factory.getRandomString()
response = self.client_put(
self.get_node_uri(node),
{
'power_type': POWER_TYPE.DEFAULT,
'power_parameters_address': new_param,
})
node = reload_object(node)
self.assertEqual(
(
httplib.BAD_REQUEST,
{'power_parameters': ["Unknown parameter(s): address."]}
),
(response.status_code, json.loads(response.content)))
self.assertEqual(
power_parameters, reload_object(node).power_parameters)
def test_give(self):
user1 = factory.make_user()
user2 = factory.make_user()
profile = user1.get_profile()
consumer, token = profile.create_authorisation_token()
give_api_credentials_to_user(user1, user2)
self.assertEqual(user2, reload_object(consumer).user)
self.assertEqual(user2, reload_object(token).user)
def test_migrate_all_nodes_to_new_legacy_user_when_multiple_users(self):
factory.make_file_storage(owner=None)
user1 = factory.make_user()
node1 = factory.make_node(owner=user1)
user2 = factory.make_user()
node2 = factory.make_node(owner=user2)
migrate()
self.assertNotIn(reload_object(node1).owner, {user1, user2, None})
self.assertNotIn(reload_object(node2).owner, {user1, user2, None})
def test_POST_release_combines_with_acquire(self):
node = factory.make_node(status=NODE_STATUS.READY)
response = self.client.post(
reverse('nodes_handler'), {'op': 'acquire'})
self.assertEqual(NODE_STATUS.ALLOCATED, reload_object(node).status)
node_uri = json.loads(response.content)['resource_uri']
response = self.client.post(node_uri, {'op': 'release'})
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
def test_routers_can_append(self):
node = factory.make_node()
mac1 = MAC('aa:bb:cc:dd:ee:ff')
mac2 = MAC('00:11:22:33:44:55')
node.routers = [mac1]
node.save()
node = reload_object(node)
node.routers.append(mac2)
node.save()
self.assertEqual([mac1, mac2], reload_object(node).routers)
def test_migrate_all_nodes_to_bootstrap_owner_when_multiple_users(self):
user1 = factory.make_user()
node1 = factory.make_node(owner=user1)
user2 = factory.make_user()
node2 = factory.make_node(owner=user2)
make_provider_state_file(node1)
migrate()
self.assertEqual(
(user1, user1),
(reload_object(node1).owner,
reload_object(node2).owner))
def test_hardware_updates_memory_lenovo(self):
node = factory.make_node()
xmlbytes = (
'<node>'
'<node id="memory:0" class="memory">'
'<node id="bank:0" class="memory" handle="DMI:002D">'
'<size units="bytes">4294967296</size>'
'</node>'
'<node id="bank:1" class="memory" handle="DMI:002E">'
'<size units="bytes">3221225472</size>'
'</node>'
'</node>'
'<node id="memory:1" class="memory">'
'<node id="bank:0" class="memory" handle="DMI:002F">'
'<size units="bytes">536870912</size>'
'</node>'
'</node>'
'<node id="memory:2" class="memory"></node>'
'</node>'
)
node.set_hardware_details(xmlbytes)
node = reload_object(node)
mega = 2 ** 20
expected = (4294967296 + 3221225472 + 536879812) / mega
self.assertEqual(expected, node.memory)
def test_signaling_commissioning_success_is_idempotent(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = make_node_client(node=node)
call_signal(client, status='OK')
response = call_signal(client, status='OK')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
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__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_POST_release_rejects_request_from_unauthorized_user(self):
node = factory.make_node(
status=NODE_STATUS.ALLOCATED, owner=factory.make_user())
response = self.client.post(
self.get_node_uri(node), {'op': 'release'})
self.assertEqual(httplib.FORBIDDEN, response.status_code)
self.assertEqual(NODE_STATUS.ALLOCATED, reload_object(node).status)
def test_power_parameters(self):
node = factory.make_node(power_type=POWER_TYPE.DEFAULT)
parameters = dict(user="******", address="10.1.2.3")
node.power_parameters = parameters
node.save()
node = reload_object(node)
self.assertEqual(parameters, node.power_parameters)
def test_signaling_accepts_WORKING_status(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = self.make_node_client(node=node)
response = self.call_signal(client, status='WORKING')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(
NODE_STATUS.COMMISSIONING, reload_object(node).status)
def test_signaling_commissioning_failure_sets_node_error(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = make_node_client(node=node)
error_text = factory.getRandomString()
response = call_signal(client, status='FAILED', error=error_text)
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(error_text, reload_object(node).error)
def test_set_node_routers_updates_node(self):
node = factory.make_node(routers=None)
macs = ["11:22:33:44:55:66", "aa:bb:cc:dd:ee:ff"]
lldp_output = make_lldp_output(macs)
set_node_routers(node, lldp_output, 0)
self.assertItemsEqual(
[MAC(mac) for mac in macs], reload_object(node).routers)
def test_netboot_on(self):
node = factory.make_node(netboot=False)
client = self.make_node_client(node=node)
url = reverse('metadata-version', args=['latest'])
response = client.post(url, {'op': 'netboot_on'})
node = reload_object(node)
self.assertTrue(node.netboot, response)
def test_other_user_than_node_cannot_signal_commissioning_result(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = OAuthAuthenticatedClient(factory.make_user())
response = self.call_signal(client)
self.assertEqual(httplib.FORBIDDEN, response.status_code)
self.assertEqual(
NODE_STATUS.COMMISSIONING, reload_object(node).status)
def test_set_node_routers_updates_node(self):
node = factory.make_node(routers=None)
macs = ["11:22:33:44:55:66", "aa:bb:cc:dd:ee:ff"]
lldp_output = make_lldp_output(macs)
set_node_routers(node, lldp_output, 0)
self.assertItemsEqual([MAC(mac) for mac in macs],
reload_object(node).routers)
def test_signaling_no_error_clears_existing_error(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING,
error=factory.getRandomString())
client = make_node_client(node=node)
response = call_signal(client)
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual('', reload_object(node).error)
def test_signaling_commissioning_failure_is_idempotent(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = self.make_node_client(node=node)
self.call_signal(client, status='FAILED')
response = self.call_signal(client, status='FAILED')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.FAILED_TESTS, reload_object(node).status)
def test_signaling_commissioning_failure_sets_node_error(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = self.make_node_client(node=node)
error_text = factory.getRandomString()
response = self.call_signal(client, status='FAILED', error=error_text)
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(error_text, reload_object(node).error)
def test_power_parameters(self):
node = factory.make_node(power_type=POWER_TYPE.DEFAULT)
parameters = dict(user="******", address="10.1.2.3")
node.power_parameters = parameters
node.save()
node = reload_object(node)
self.assertEqual(parameters, node.power_parameters)
def test_hardware_updates_memory_lenovo(self):
node = factory.make_node()
xmlbytes = dedent("""\
<node>
<node id="memory:0" class="memory">
<node id="bank:0" class="memory" handle="DMI:002D">
<size units="bytes">4294967296</size>
</node>
<node id="bank:1" class="memory" handle="DMI:002E">
<size units="bytes">3221225472</size>
</node>
</node>
<node id="memory:1" class="memory">
<node id="bank:0" class="memory" handle="DMI:002F">
<size units="bytes">536870912</size>
</node>
</node>
<node id="memory:2" class="memory"></node>
</node>
""").encode("utf-8")
update_hardware_details(node, xmlbytes, 0)
node = reload_object(node)
mega = 2**20
expected = (4294967296 + 3221225472 + 536879812) / mega
self.assertEqual(expected, node.memory)
def test_signaling_commissioning_result_does_not_affect_other_node(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = make_node_client(node=factory.make_node(
status=NODE_STATUS.COMMISSIONING))
response = call_signal(client, status='OK')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.COMMISSIONING, reload_object(node).status)
def test_check_with_commissioning_but_not_expired_node(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
response = self.client.post(reverse('nodes_handler'),
{'op': 'check_commissioning'})
node = reload_object(node)
self.assertEqual((httplib.OK, NODE_STATUS.COMMISSIONING),
(response.status_code, node.status))
def make_node(self, mac=False, hostname=None, status=None,
architecture=ARCHITECTURE.i386, updated=None,
created=None, nodegroup=None, routers=None, zone=None,
**kwargs):
# hostname=None is a valid value, hence the set_hostname trick.
if hostname is None:
hostname = self.getRandomString(20)
if status is None:
status = NODE_STATUS.DEFAULT_STATUS
if nodegroup is None:
nodegroup = self.make_node_group()
if routers is None:
routers = [self.make_MAC()]
if zone is None:
zone = self.make_zone()
node = Node(
hostname=hostname, status=status, architecture=architecture,
nodegroup=nodegroup, routers=routers, zone=zone, **kwargs)
self._save_node_unchecked(node)
if mac:
self.make_mac_address(node=node)
# Update the 'updated'/'created' fields with a call to 'update'
# preventing a call to save() from overriding the values.
if updated is not None:
Node.objects.filter(id=node.id).update(updated=updated)
if created is not None:
Node.objects.filter(id=node.id).update(created=created)
return reload_object(node)
def test_migrate_all_files_to_new_legacy_user_when_multiple_users(self):
stored = factory.make_file_storage(owner=None)
user1 = factory.make_user()
user2 = factory.make_user()
migrate()
stored = reload_object(stored)
self.assertNotIn(stored.owner, {user1, user2, None})
def test_netboot_on(self):
node = factory.make_node(netboot=False)
client = make_node_client(node=node)
url = reverse('metadata-version', args=['latest'])
response = client.post(url, {'op': 'netboot_on'})
node = reload_object(node)
self.assertTrue(node.netboot, response)
def test_signaling_commissioning_failure_is_idempotent(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = make_node_client(node=node)
call_signal(client, status='FAILED')
response = call_signal(client, status='FAILED')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.FAILED_TESTS, reload_object(node).status)
def test_POST_release_does_nothing_for_unowned_node(self):
node = factory.make_node(
status=NODE_STATUS.READY, owner=self.logged_in_user)
response = self.client.post(
self.get_node_uri(node), {'op': 'release'})
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
def test_signaling_no_error_clears_existing_error(self):
node = factory.make_node(
status=NODE_STATUS.COMMISSIONING, error=factory.getRandomString())
client = self.make_node_client(node=node)
response = self.call_signal(client)
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual('', reload_object(node).error)
def test_check_with_no_action(self):
node = factory.make_node(status=NODE_STATUS.READY)
response = self.client.post(reverse('nodes_handler'),
{'op': 'check_commissioning'})
# Anything that's not commissioning should be ignored.
node = reload_object(node)
self.assertEqual((httplib.OK, NODE_STATUS.READY),
(response.status_code, node.status))
def test_POST_release_allows_admin_to_release_anyones_node(self):
node = factory.make_node(
status=NODE_STATUS.ALLOCATED, owner=factory.make_user())
self.become_admin()
response = self.client.post(
self.get_node_uri(node), {'op': 'release'})
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
def test_POST_commission_commissions_node(self):
node = factory.make_node(
status=NODE_STATUS.READY, owner=factory.make_user())
self.become_admin()
response = self.client.post(
self.get_node_uri(node), {'op': 'commission'})
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.COMMISSIONING, reload_object(node).status)
def test_accepts_unchanged_name(self):
nodegroup, node = make_unrenamable_nodegroup_with_node()
original_name = nodegroup.name
form = NodeGroupEdit(
instance=nodegroup, data=self.make_form_data(nodegroup))
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(original_name, reload_object(nodegroup).name)
def test_signaling_commissioning_failure_clears_owner(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
node.owner = factory.make_user()
node.save()
client = make_node_client(node=node)
response = call_signal(client, status='FAILED')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(None, reload_object(node).owner)
def test_signaling_commissioning_failure_clears_owner(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
node.owner = factory.make_user()
node.save()
client = self.make_node_client(node=node)
response = self.call_signal(client, status='FAILED')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(None, reload_object(node).owner)
def test_set_node_routers_does_nothing_if_script_failed(self):
node = factory.make_node()
routers_before = node.routers
macs = ["11:22:33:44:55:66", "aa:bb:cc:dd:ee:ff"]
lldp_output = make_lldp_output(macs)
set_node_routers(node, lldp_output, exit_status=1)
routers_after = reload_object(node).routers
self.assertItemsEqual(routers_before, routers_after)
def test_signaling_commissioning_result_does_not_affect_other_node(self):
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = self.make_node_client(
node=factory.make_node(status=NODE_STATUS.COMMISSIONING))
response = self.call_signal(client, status='OK')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(
NODE_STATUS.COMMISSIONING, reload_object(node).status)
def test_ensure_dhcp_key_creates_key(self):
nodegroup = factory.make_node_group(dhcp_key='')
nodegroup.ensure_dhcp_key()
# Check that the dhcp_key is not empty and looks
# valid.
self.assertThat(nodegroup.dhcp_key, EndsWith("=="))
# The key is persisted.
self.assertThat(reload_object(nodegroup).dhcp_key, EndsWith("=="))
def test_set_node_routers_does_nothing_if_script_failed(self):
node = factory.make_node()
routers_before = node.routers
macs = ["11:22:33:44:55:66", "aa:bb:cc:dd:ee:ff"]
lldp_output = make_lldp_output(macs)
set_node_routers(node, lldp_output, exit_status=1)
routers_after = reload_object(node).routers
self.assertItemsEqual(routers_before, routers_after)
def test_hardware_updates_tags_match(self):
tag1 = factory.make_tag(factory.getRandomString(10), "/node")
tag2 = factory.make_tag(factory.getRandomString(10), "//node")
node = factory.make_node()
xmlbytes = '<node/>'
node.set_hardware_details(xmlbytes)
node = reload_object(node)
self.assertEqual([tag1, tag2], list(node.tags.all()))
def test_POST_release_resets_agent_name(self):
agent_name = factory.make_name('agent-name')
node = factory.make_node(
status=NODE_STATUS.ALLOCATED, owner=self.logged_in_user,
distro_series=factory.getRandomEnum(DISTRO_SERIES),
agent_name=agent_name)
self.client.post(self.get_node_uri(node), {'op': 'release'})
self.assertEqual('', reload_object(node).agent_name)
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_edit_user_POST_updates_password(self):
user = factory.make_user()
new_password = factory.getRandomString()
params = make_password_params(new_password)
response = self.client.post(
reverse('accounts-edit', args=[user.username]),
get_prefixed_form_data('password', params))
self.assertEqual(httplib.FOUND, response.status_code)
self.assertTrue(reload_object(user).check_password(new_password))
def test_hardware_updates_memory(self):
node = factory.make_node()
xmlbytes = (
'<node id="memory">'
'<size units="bytes">4294967296</size>'
'</node>')
node.set_hardware_details(xmlbytes)
node = reload_object(node)
self.assertEqual(4096, node.memory)
def test_signaling_WORKING_keeps_owner(self):
user = factory.make_user()
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
node.owner = user
node.save()
client = self.make_node_client(node=node)
response = self.call_signal(client, status='WORKING')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(user, reload_object(node).owner)
def test_ensure_dhcp_key_creates_key(self):
nodegroup = factory.make_node_group(dhcp_key='')
nodegroup.ensure_dhcp_key()
# Check that the dhcp_key is not empty and looks
# valid.
self.assertThat(nodegroup.dhcp_key, EndsWith("=="))
# The key is persisted.
self.assertThat(
reload_object(nodegroup).dhcp_key, EndsWith("=="))
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_anonymous_netboot_off(self):
node = factory.make_node(netboot=True)
anon_netboot_off_url = reverse('metadata-node-by-id',
args=['latest', node.system_id])
response = self.client.post(anon_netboot_off_url,
{'op': 'netboot_off'})
node = reload_object(node)
self.assertEqual((httplib.OK, False),
(response.status_code, node.netboot), response)
def test_signaling_commissioning_OK_repopulates_tags(self):
populate_tags_for_single_node = self.patch(
api, "populate_tags_for_single_node")
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
client = make_node_client(node)
response = call_signal(client, status='OK', script_result='0')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
populate_tags_for_single_node.assert_called_once_with(ANY, node)
def test_signaling_WORKING_keeps_owner(self):
user = factory.make_user()
node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
node.owner = user
node.save()
client = make_node_client(node=node)
response = call_signal(client, status='WORKING')
self.assertEqual(httplib.OK, response.status_code)
self.assertEqual(user, reload_object(node).owner)
