def test_settings_commissioning_POST(self):
new_after_commissioning = factory.getRandomEnum(
NODE_AFTER_COMMISSIONING_ACTION)
new_check_compatibility = factory.getRandomBoolean()
new_commissioning_distro_series = factory.getRandomEnum(DISTRO_SERIES)
response = self.client.post(
reverse('settings'),
get_prefixed_form_data(
prefix='commissioning',
data={
'after_commissioning': new_after_commissioning,
'check_compatibility': new_check_compatibility,
'commissioning_distro_series': (
new_commissioning_distro_series),
}))
self.assertEqual(httplib.FOUND, response.status_code)
self.assertEqual(
(
new_after_commissioning,
new_check_compatibility,
new_commissioning_distro_series,
),
(
Config.objects.get_config('after_commissioning'),
Config.objects.get_config('check_compatibility'),
Config.objects.get_config('commissioning_distro_series'),
))
def test_settings_commissioning_POST(self):
new_after_commissioning = factory.getRandomEnum(
NODE_AFTER_COMMISSIONING_ACTION)
new_check_compatibility = factory.getRandomBoolean()
new_commissioning_distro_series = factory.getRandomEnum(DISTRO_SERIES)
response = self.client.post(
reverse('settings'),
get_prefixed_form_data(
prefix='commissioning',
data={
'after_commissioning': new_after_commissioning,
'check_compatibility': new_check_compatibility,
'commissioning_distro_series':
new_commissioning_distro_series,
}))
self.assertEqual(httplib.FOUND, response.status_code)
self.assertEqual(
(
new_after_commissioning,
new_check_compatibility,
new_commissioning_distro_series,
),
(
Config.objects.get_config('after_commissioning'),
Config.objects.get_config('check_compatibility'),
Config.objects.get_config('commissioning_distro_series'),
))
def test_get_curtin_installer_url(self):
# Exclude DISTRO_SERIES.default. It's a special value that defers
# to a run-time setting which we don't provide in this test.
series = factory.getRandomEnum(DISTRO_SERIES,
but_not=DISTRO_SERIES.default)
arch = factory.getRandomEnum(ARCHITECTURE)
node = factory.make_node(architecture=arch, distro_series=series)
installer_url = get_curtin_installer_url(node)
self.assertEqual(
'http://%s/MAAS/static/images/%s/%s/xinstall/root.tar.gz' %
(node.nodegroup.get_managed_interface().ip, arch, series),
installer_url)
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_settings_ubuntu_POST(self):
new_main_archive = 'http://test.example.com/archive'
new_ports_archive = 'http://test2.example.com/archive'
new_cloud_images_archive = 'http://test3.example.com/archive'
new_default_distro_series = factory.getRandomEnum(DISTRO_SERIES)
response = self.client.post(
reverse('settings'),
get_prefixed_form_data(
prefix='ubuntu',
data={
'main_archive': new_main_archive,
'ports_archive': new_ports_archive,
'cloud_images_archive': new_cloud_images_archive,
'default_distro_series': new_default_distro_series,
}))
self.assertEqual(httplib.FOUND, response.status_code, response.content)
self.assertEqual(
(
new_main_archive,
new_ports_archive,
new_cloud_images_archive,
new_default_distro_series,
),
(
Config.objects.get_config('main_archive'),
Config.objects.get_config('ports_archive'),
Config.objects.get_config('cloud_images_archive'),
Config.objects.get_config('default_distro_series'),
))
def test_settings_ubuntu_POST(self):
new_main_archive = 'http://test.example.com/archive'
new_ports_archive = 'http://test2.example.com/archive'
new_cloud_images_archive = 'http://test3.example.com/archive'
new_default_distro_series = factory.getRandomEnum(DISTRO_SERIES)
response = self.client.post(
reverse('settings'),
get_prefixed_form_data(
prefix='ubuntu',
data={
'main_archive': new_main_archive,
'ports_archive': new_ports_archive,
'cloud_images_archive': new_cloud_images_archive,
'default_distro_series': new_default_distro_series,
}))
self.assertEqual(httplib.FOUND, response.status_code, response.content)
self.assertEqual(
(
new_main_archive,
new_ports_archive,
new_cloud_images_archive,
new_default_distro_series,
),
(
Config.objects.get_config('main_archive'),
Config.objects.get_config('ports_archive'),
Config.objects.get_config('cloud_images_archive'),
Config.objects.get_config('default_distro_series'),
))
def test_initialize_node_group_initializes_nodegroup_to_form_value(self):
node = Node(
NODE_STATUS.DECLARED,
architecture=factory.getRandomEnum(ARCHITECTURE))
nodegroup = factory.make_node_group()
initialize_node_group(node, nodegroup)
self.assertEqual(nodegroup, node.nodegroup)
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_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__mass_change_status_calls_post_save_signal(self):
old_status = factory.getRandomEnum(NODEGROUP_STATUS)
nodegroup = factory.make_node_group(status=old_status)
recorder = Mock()
def post_save_NodeGroup(sender, instance, created, **kwargs):
recorder(instance)
django.dispatch.Signal.connect(
post_save, post_save_NodeGroup, sender=NodeGroup)
self.addCleanup(
django.dispatch.Signal.disconnect, post_save,
receiver=post_save_NodeGroup, sender=NodeGroup)
NodeGroup.objects._mass_change_status(
old_status, factory.getRandomEnum(NODEGROUP_STATUS))
self.assertEqual(
[call(nodegroup)], recorder.call_args_list)
def test_pxeconfig_returns_success_for_detailed_but_unknown_node(self):
architecture = factory.getRandomEnum(ARCHITECTURE)
arch, subarch = architecture.split('/')
params = dict(self.get_default_params(),
mac=factory.getRandomMACAddress(delimiter='-'),
arch=arch,
subarch=subarch)
response = self.client.get(reverse('pxeconfig'), params)
self.assertEqual(httplib.OK, response.status_code)
def test_getRandomEnum_returns_enum_value(self):
random_value = randint(0, 99999)
class Enum:
VALUE = random_value
OTHER_VALUE = random_value + 3
self.assertIn(factory.getRandomEnum(Enum),
[Enum.VALUE, Enum.OTHER_VALUE])
def test__mass_change_status_calls_post_save_signal(self):
old_status = factory.getRandomEnum(NODEGROUP_STATUS)
nodegroup = factory.make_node_group(status=old_status)
recorder = Mock()
def post_save_NodeGroup(sender, instance, created, **kwargs):
recorder(instance)
django.dispatch.Signal.connect(post_save,
post_save_NodeGroup,
sender=NodeGroup)
self.addCleanup(django.dispatch.Signal.disconnect,
post_save,
receiver=post_save_NodeGroup,
sender=NodeGroup)
NodeGroup.objects._mass_change_status(
old_status, factory.getRandomEnum(NODEGROUP_STATUS))
self.assertEqual([call(nodegroup)], recorder.call_args_list)
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_getRandomEnum_returns_enum_value(self):
random_value = randint(0, 99999)
class Enum:
VALUE = random_value
OTHER_VALUE = random_value + 3
self.assertIn(
factory.getRandomEnum(Enum), [Enum.VALUE, Enum.OTHER_VALUE])
def test_pxeconfig_returns_success_for_detailed_but_unknown_node(self):
architecture = factory.getRandomEnum(ARCHITECTURE)
arch, subarch = architecture.split('/')
params = dict(
self.get_default_params(),
mac=factory.getRandomMACAddress(delimiter='-'),
arch=arch,
subarch=subarch)
response = self.client.get(reverse('pxeconfig'), params)
self.assertEqual(httplib.OK, response.status_code)
def test_getRandomEnum_can_exclude_choices(self):
random_value = randint(0, 99999)
class Enum:
FIRST_VALUE = random_value
SECOND_VALUE = random_value + 1
THIRD_VALUE = random_value + 2
self.assertEqual(
Enum.FIRST_VALUE,
factory.getRandomEnum(
Enum, but_not=(Enum.SECOND_VALUE, Enum.THIRD_VALUE)))
def test_NodeWithMACAddressesForm_valid(self):
architecture = factory.getRandomEnum(ARCHITECTURE)
form = NodeWithMACAddressesForm(
self.make_params(
mac_addresses=['aa:bb:cc:dd:ee:ff', '9a:bb:c3:33:e5:7f'],
architecture=architecture))
self.assertTrue(form.is_valid())
self.assertEqual(
['aa:bb:cc:dd:ee:ff', '9a:bb:c3:33:e5:7f'],
form.cleaned_data['mac_addresses'])
self.assertEqual(architecture, form.cleaned_data['architecture'])
def test_can_edit_cluster(self):
nodegroup = factory.make_node_group()
edit_link = reverse('cluster-edit', args=[nodegroup.uuid])
data = {
'cluster_name': factory.make_name('cluster_name'),
'name': factory.make_name('name'),
'status': factory.getRandomEnum(NODEGROUP_STATUS),
}
response = self.client.post(edit_link, data)
self.assertEqual(httplib.FOUND, response.status_code, response.content)
self.assertThat(
reload_object(nodegroup),
MatchesStructure.byEquality(**data))
def make_interface_settings():
"""Create a dict of arbitrary interface configuration parameters."""
network = factory.getRandomNetwork()
return {
'ip': factory.getRandomIPInNetwork(network),
'interface': factory.make_name('interface'),
'subnet_mask': str(network.netmask),
'broadcast_ip': str(network.broadcast),
'router_ip': factory.getRandomIPInNetwork(network),
'ip_range_low': factory.getRandomIPInNetwork(network),
'ip_range_high': factory.getRandomIPInNetwork(network),
'management': factory.getRandomEnum(NODEGROUPINTERFACE_MANAGEMENT),
}
def test_getRandomEnum_can_exclude_choices(self):
random_value = randint(0, 99999)
class Enum:
FIRST_VALUE = random_value
SECOND_VALUE = random_value + 1
THIRD_VALUE = random_value + 2
self.assertEqual(
Enum.FIRST_VALUE,
factory.getRandomEnum(Enum,
but_not=(Enum.SECOND_VALUE,
Enum.THIRD_VALUE)))
def test_POST_start_sets_distro_series(self):
node = factory.make_node(
owner=self.logged_in_user, mac=True,
power_type=POWER_TYPE.WAKE_ON_LAN)
distro_series = factory.getRandomEnum(DISTRO_SERIES)
response = self.client.post(
self.get_node_uri(node),
{'op': 'start', 'distro_series': distro_series})
self.assertEqual(
(httplib.OK, node.system_id),
(response.status_code, json.loads(response.content)['system_id']))
self.assertEqual(
distro_series, reload_object(node).distro_series)
def test_user_can_edit_his_nodes(self):
node = factory.make_node(owner=self.logged_in_user)
node_edit_link = reverse('node-edit', args=[node.system_id])
params = {
'hostname': factory.getRandomString(),
'architecture': factory.getRandomChoice(ARCHITECTURE_CHOICES),
'after_commissioning_action': factory.getRandomEnum(
NODE_AFTER_COMMISSIONING_ACTION),
}
response = self.client.post(node_edit_link, params)
node = reload_object(node)
self.assertEqual(httplib.FOUND, response.status_code)
self.assertAttributes(node, params)
def test_pxeconfig_returns_global_kernel_params_for_enlisting_node(self):
# An 'enlisting' node means it looks like a node with details but we
# don't know about it yet. It should still receive the global
# kernel options.
value = factory.getRandomString()
Config.objects.set_config("kernel_opts", value)
architecture = factory.getRandomEnum(ARCHITECTURE)
arch, subarch = architecture.split('/')
params = dict(self.get_default_params(),
mac=factory.getRandomMACAddress(delimiter='-'),
arch=arch,
subarch=subarch)
response = self.client.get(reverse('pxeconfig'), params)
response_dict = json.loads(response.content)
self.assertEqual(value, response_dict['extra_opts'])
def test_pxeconfig_returns_global_kernel_params_for_enlisting_node(self):
# An 'enlisting' node means it looks like a node with details but we
# don't know about it yet. It should still receive the global
# kernel options.
value = factory.getRandomString()
Config.objects.set_config("kernel_opts", value)
architecture = factory.getRandomEnum(ARCHITECTURE)
arch, subarch = architecture.split('/')
params = dict(
self.get_default_params(),
mac=factory.getRandomMACAddress(delimiter='-'),
arch=arch,
subarch=subarch)
response = self.client.get(reverse('pxeconfig'), params)
response_dict = json.loads(response.content)
self.assertEqual(value, response_dict['extra_opts'])
def make_params(self, mac_addresses=None, architecture=None,
hostname=None, nodegroup=None):
if mac_addresses is None:
mac_addresses = [factory.getRandomMACAddress()]
if architecture is None:
architecture = factory.getRandomEnum(ARCHITECTURE)
if hostname is None:
hostname = factory.make_name('hostname')
params = {
'mac_addresses': mac_addresses,
'architecture': architecture,
'hostname': hostname,
}
if nodegroup is not None:
params['nodegroup'] = nodegroup
return self.get_QueryDict(params)
def test_checks_presence_of_other_managed_interfaces(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
interfaces = []
for index in range(2):
interface = make_interface_settings()
interface['management'] = factory.getRandomEnum(
NODEGROUPINTERFACE_MANAGEMENT,
but_not=(NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED, ))
interfaces.append(interface)
interfaces = json.dumps(interfaces)
form = NodeGroupWithInterfacesForm(
data={'name': name, 'uuid': uuid, 'interfaces': interfaces})
self.assertFalse(form.is_valid())
self.assertIn(
"Only one managed interface can be configured for this cluster",
form._errors['interfaces'][0])
def test_initialize_node_group_defaults_to_master(self):
node = Node(
NODE_STATUS.DECLARED,
architecture=factory.getRandomEnum(ARCHITECTURE))
initialize_node_group(node)
self.assertEqual(NodeGroup.objects.ensure_master(), node.nodegroup)
def test_accept_node_changes_status(self):
nodegroup = factory.make_node_group(
status=factory.getRandomEnum(NODEGROUP_STATUS))
nodegroup.accept()
self.assertEqual(nodegroup.status, NODEGROUP_STATUS.ACCEPTED)
def test_reject_node_changes_status(self):
nodegroup = factory.make_node_group(
status=factory.getRandomEnum(NODEGROUP_STATUS))
nodegroup.reject()
self.assertEqual(nodegroup.status, NODEGROUP_STATUS.REJECTED)
def test_reject_node_changes_status(self):
nodegroup = factory.make_node_group(
status=factory.getRandomEnum(NODEGROUP_STATUS))
nodegroup.reject()
self.assertEqual(nodegroup.status, NODEGROUP_STATUS.REJECTED)
def test_accept_node_changes_status(self):
nodegroup = factory.make_node_group(
status=factory.getRandomEnum(NODEGROUP_STATUS))
nodegroup.accept()
self.assertEqual(nodegroup.status, NODEGROUP_STATUS.ACCEPTED)
