def test_new_creates_nodegroup_with_interface(self):
name = factory.make_name('nodegroup')
uuid = factory.getRandomUUID()
ip = factory.getRandomIPAddress()
nodegroup = NodeGroup.objects.new(name, uuid, ip)
interface = get_one(nodegroup.nodegroupinterface_set.all())
self.assertEqual((name, uuid, ip),
(nodegroup.name, nodegroup.uuid, interface.ip))
def test_populates_cluster_name(self):
cluster_name = factory.make_name('cluster_name')
uuid = factory.getRandomUUID()
form = NodeGroupWithInterfacesForm(
status=NODEGROUP_STATUS.ACCEPTED,
data={'cluster_name': cluster_name, 'uuid': uuid})
self.assertTrue(form.is_valid(), form._errors)
nodegroup = form.save()
self.assertEqual(cluster_name, nodegroup.cluster_name)
def test_creates_nodegroup_with_status(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
form = NodeGroupWithInterfacesForm(
status=NODEGROUP_STATUS.ACCEPTED,
data={'name': name, 'uuid': uuid})
self.assertTrue(form.is_valid(), form._errors)
nodegroup = form.save()
self.assertEqual(NODEGROUP_STATUS.ACCEPTED, nodegroup.status)
def test_new_creates_nodegroup_with_interface(self):
name = factory.make_name('nodegroup')
uuid = factory.getRandomUUID()
ip = factory.getRandomIPAddress()
nodegroup = NodeGroup.objects.new(name, uuid, ip)
interface = get_one(nodegroup.nodegroupinterface_set.all())
self.assertEqual(
(name, uuid, ip),
(nodegroup.name, nodegroup.uuid, interface.ip))
def test_registers_as_master_if_master_not_configured(self):
reset_master()
uuid = factory.getRandomUUID()
request = make_register_request(uuid)
nodegroup = api.register_nodegroup(request, uuid)
self.assertEqual(uuid, nodegroup.uuid)
self.assertEqual(NODEGROUP_STATUS.PENDING, nodegroup.status)
self.assertEqual(NodeGroup.objects.ensure_master().id, nodegroup.id)
def test_creates_pending_nodegroup_by_default(self):
create_configured_master()
uuid = factory.getRandomUUID()
request = make_register_request(uuid)
nodegroup = api.register_nodegroup(request, uuid)
self.assertEqual(uuid, nodegroup.uuid)
self.assertEqual(NODEGROUP_STATUS.PENDING, nodegroup.status)
self.assertNotEqual(NodeGroup.objects.ensure_master().id, nodegroup.id)
def test_rejects_invalid_list_interfaces(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
invalid_interfaces = json.dumps('invalid interface list')
form = NodeGroupWithInterfacesForm(
data={
'name': name, 'uuid': uuid, 'interfaces': invalid_interfaces})
self.assertFalse(form.is_valid())
self.assertEquals(
{'interfaces': [INTERFACES_VALIDATION_ERROR_MESSAGE]},
form._errors)
def test_rejects_invalid_json_interfaces(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
invalid_interfaces = factory.make_name('invalid_json_interfaces')
form = NodeGroupWithInterfacesForm(
data={
'name': name, 'uuid': uuid, 'interfaces': invalid_interfaces})
self.assertFalse(form.is_valid())
self.assertEquals(
{'interfaces': ['Invalid json value.']},
form._errors)
def test_updates_and_accepts_local_master_if_master_not_configured(self):
reset_master()
uuid = factory.getRandomUUID()
create_local_cluster_config(self, uuid)
request = make_register_request(uuid)
nodegroup = api.register_nodegroup(request, uuid)
self.assertEqual(uuid, nodegroup.uuid)
self.assertEqual(NODEGROUP_STATUS.ACCEPTED, nodegroup.status)
self.assertEqual(NodeGroup.objects.ensure_master().id, nodegroup.id)
def test_keeps_local_cluster_controller_pending_if_master_configured(self):
create_configured_master()
uuid = factory.getRandomUUID()
create_local_cluster_config(self, uuid)
request = make_register_request(uuid)
nodegroup = api.register_nodegroup(request, uuid)
self.assertEqual(uuid, nodegroup.uuid)
self.assertEqual(NODEGROUP_STATUS.PENDING, nodegroup.status)
self.assertNotEqual(NodeGroup.objects.ensure_master().id, nodegroup.id)
def test_rejects_invalid_interface(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
interface = make_interface_settings()
# Make the interface invalid.
interface['ip_range_high'] = 'invalid IP address'
interfaces = json.dumps([interface])
form = NodeGroupWithInterfacesForm(
data={'name': name, 'uuid': uuid, 'interfaces': interfaces})
self.assertFalse(form.is_valid())
self.assertIn(
"Enter a valid IPv4 or IPv6 address",
form._errors['interfaces'][0])
def test_register_nodegroup_uses_default_zone_name(self):
uuid = factory.getRandomUUID()
create_local_cluster_config(self, uuid)
response = self.client.post(reverse('nodegroups_handler'), {
'op': 'register',
'uuid': uuid,
})
self.assertEqual(httplib.OK, response.status_code, response)
master = NodeGroup.objects.ensure_master()
self.assertEqual((NODEGROUP_STATUS.ACCEPTED, DEFAULT_DNS_ZONE_NAME),
(master.status, master.name))
def test_creates_interface_from_params(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
interface = make_interface_settings()
interfaces = json.dumps([interface])
form = NodeGroupWithInterfacesForm(
data={'name': name, 'uuid': uuid, 'interfaces': interfaces})
self.assertTrue(form.is_valid(), form._errors)
form.save()
nodegroup = NodeGroup.objects.get(uuid=uuid)
self.assertThat(
nodegroup.nodegroupinterface_set.all()[0],
MatchesStructure.byEquality(**interface))
def test_register_new_nodegroup_does_not_record_maas_url(self):
# When registering a cluster, the URL with which the call was made
# (i.e. from the perspective of the cluster) is *not* recorded.
create_configured_master()
name = factory.make_name('cluster')
uuid = factory.getRandomUUID()
update_maas_url = self.patch(api, "update_nodegroup_maas_url")
response = self.client.post(reverse('nodegroups_handler'), {
'op': 'register',
'name': name,
'uuid': uuid
})
self.assertEqual(httplib.ACCEPTED, response.status_code, response)
self.assertEqual([], update_maas_url.call_args_list)
def test_creates_multiple_interfaces(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
interface1 = make_interface_settings()
# Only one interface at most can be 'managed'.
interface2 = make_interface_settings()
interface2['management'] = NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED
interfaces = json.dumps([interface1, interface2])
form = NodeGroupWithInterfacesForm(
data={'name': name, 'uuid': uuid, 'interfaces': interfaces})
self.assertTrue(form.is_valid(), form._errors)
form.save()
nodegroup = NodeGroup.objects.get(uuid=uuid)
self.assertEqual(2, nodegroup.nodegroupinterface_set.count())
def test_register_nodegroup_validates_data(self):
create_configured_master()
response = self.client.post(
reverse('nodegroups_handler'), {
'op': 'register',
'name': factory.make_name('cluster'),
'uuid': factory.getRandomUUID(),
'interfaces': 'invalid data',
})
self.assertEqual((
httplib.BAD_REQUEST,
{
'interfaces': ['Invalid json value.']
},
), (response.status_code, json.loads(response.content)))
def test_creates_pending_nodegroup(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
form = NodeGroupWithInterfacesForm(
data={'name': name, 'uuid': uuid})
self.assertTrue(form.is_valid(), form._errors)
nodegroup = form.save()
self.assertEqual(
(uuid, name, NODEGROUP_STATUS.PENDING, 0),
(
nodegroup.uuid,
nodegroup.name,
nodegroup.status,
nodegroup.nodegroupinterface_set.count(),
))
def test_register_returns_compose_nodegroup_register_response(self):
# register() returns whatever compose_nodegroup_register_response()
# tells it to return.
expected_response = factory.getRandomString()
self.patch(api, 'compose_nodegroup_register_response',
Mock(return_value=expected_response))
response = self.client.post(
reverse('nodegroups_handler'), {
'op': 'register',
'name': factory.make_name('cluster'),
'uuid': factory.getRandomUUID(),
})
self.assertIn('application/json', response['Content-Type'])
self.assertEqual(expected_response, json.loads(response.content))
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_creates_unmanaged_interfaces(self):
name = factory.make_name('name')
uuid = factory.getRandomUUID()
interface = make_interface_settings()
del interface['management']
interfaces = json.dumps([interface])
form = NodeGroupWithInterfacesForm(
data={'name': name, 'uuid': uuid, 'interfaces': interfaces})
self.assertTrue(form.is_valid(), form._errors)
form.save()
nodegroup = NodeGroup.objects.get(uuid=uuid)
self.assertEqual(
[NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED],
[
nodegroup.management for nodegroup in
nodegroup.nodegroupinterface_set.all()
])
def test_register_master_nodegroup_does_not_update_maas_url(self):
# When registering the master cluster, the MAAS URL we give it in
# the future is *not* updated to the one on which the call was made.
reset_master()
name = factory.make_name('cluster')
uuid = factory.getRandomUUID()
create_local_cluster_config(self, uuid)
update_maas_url = self.patch(api, "update_nodegroup_maas_url")
response = self.client.post(reverse('nodegroups_handler'), {
'op': 'register',
'name': name,
'uuid': uuid
})
self.assertEqual(httplib.OK, response.status_code, response)
# This really did configure the master.
master = NodeGroup.objects.ensure_master()
self.assertEqual(uuid, master.uuid)
self.assertEqual([], update_maas_url.call_args_list)
# The master's maas_url field remains empty.
self.assertEqual("", master.maas_url)
def test_register_auto_accepts_local_master(self):
reset_master()
name = factory.make_name('cluster')
uuid = factory.getRandomUUID()
create_local_cluster_config(self, uuid)
patch_broker_url(self)
response = self.client.post(reverse('nodegroups_handler'), {
'op': 'register',
'name': name,
'uuid': uuid,
})
self.assertEqual(httplib.OK, response.status_code, response)
master = NodeGroup.objects.ensure_master()
# The cluster controller that made the request is registered as the
# master, since there was none.
self.assertEqual((uuid, name), (master.uuid, master.name))
# It is also auto-accepted.
self.assertEqual(NODEGROUP_STATUS.ACCEPTED, master.status)
def test_register_creates_nodegroup_and_interfaces(self):
create_configured_master()
name = factory.make_name('cluster')
uuid = factory.getRandomUUID()
interface = make_interface_settings()
response = self.client.post(
reverse('nodegroups_handler'), {
'op': 'register',
'name': name,
'uuid': uuid,
'interfaces': json.dumps([interface]),
})
nodegroup = NodeGroup.objects.get(uuid=uuid)
# The nodegroup was created with its interface. Its status is
# 'PENDING'.
self.assertEqual((name, NODEGROUP_STATUS.PENDING),
(nodegroup.name, nodegroup.status))
self.assertThat(nodegroup.nodegroupinterface_set.all()[0],
MatchesStructure.byEquality(**interface))
# The response code is 'ACCEPTED': the nodegroup now needs to be
# validated by an admin.
self.assertEqual(httplib.ACCEPTED, response.status_code)
def test_register_configures_master_if_unconfigured(self):
reset_master()
name = factory.make_name('cluster')
uuid = factory.getRandomUUID()
create_local_cluster_config(self, uuid)
interface = make_interface_settings()
response = self.client.post(
reverse('nodegroups_handler'), {
'op': 'register',
'name': name,
'uuid': uuid,
'interfaces': json.dumps([interface]),
})
self.assertEqual(httplib.OK, response.status_code, response)
master = NodeGroup.objects.ensure_master()
self.assertEqual(NODEGROUP_STATUS.ACCEPTED, master.status)
self.assertThat(
master.nodegroupinterface_set.get(
interface=interface['interface']),
MatchesStructure.byEquality(**interface))
def test_register_accepts_only_one_managed_interface(self):
create_configured_master()
name = factory.make_name('cluster')
uuid = factory.getRandomUUID()
# This will try to create 2 "managed" interfaces.
interface1 = make_interface_settings()
interface1['management'] = NODEGROUPINTERFACE_MANAGEMENT.DHCP
interface2 = interface1.copy()
response = self.client.post(
reverse('nodegroups_handler'), {
'op': 'register',
'name': name,
'uuid': uuid,
'interfaces': json.dumps([interface1, interface2]),
})
self.assertEqual((
httplib.BAD_REQUEST,
{
'interfaces': [
"Only one managed interface can be configured for "
"this cluster"
]
},
), (response.status_code, json.loads(response.content)))
def test_get_local_cluster_UUID_returns_cluster_UUID(self):
uuid = factory.getRandomUUID()
file_name = self.make_file(contents='CLUSTER_UUID="%s"' % uuid)
self.patch(settings, 'LOCAL_CLUSTER_CONFIG', file_name)
self.assertEqual(uuid, get_local_cluster_UUID())
def create_configured_master():
"""Set up a master, already configured."""
master = NodeGroup.objects.ensure_master()
master.uuid = factory.getRandomUUID()
master.save()
def test_get_local_cluster_UUID_returns_cluster_UUID(self):
uuid = factory.getRandomUUID()
file_name = self.make_file(contents='CLUSTER_UUID="%s"' % uuid)
self.patch(settings, 'LOCAL_CLUSTER_CONFIG', file_name)
self.assertEqual(uuid, get_local_cluster_UUID())
