def test_get_available_networks_dc_asset(self):
rack, nets = self._generate_rack_with_networks()
vm = VirtualServerFullFactory(parent=DataCenterAssetFullFactory(
rack=rack))
self.assertNetworksTheSame(nets, vm._get_available_networks())
def setUp(self):
super().setUp()
self.cf = CustomField.objects.create(
name='test_cf', use_as_configuration_variable=True)
# is should be skipped in API
self.bo_asset = BackOfficeAssetFactory(barcode='12345',
hostname='host1')
self.conf_module_1 = ConfigurationModuleFactory()
self.conf_module_2 = ConfigurationModuleFactory(
parent=self.conf_module_1, name='ralph')
self.conf_class_1 = ConfigurationClassFactory(
module=self.conf_module_2, class_name='cls1')
self.dc_asset = DataCenterAssetFullFactory(
service_env__service__name='test-service',
service_env__service__uid='sc-123',
service_env__environment__name='prod',
configuration_path=self.conf_class_1,
)
self.dc_asset.update_custom_field('test_cf', 'abc')
self.virtual = VirtualServerFullFactory(
parent=self.dc_asset,
configuration_path__module__name='ralph2',
service_env__service__uid='sc-222',
service_env__environment__name='some_env',
)
self.virtual.update_custom_field('test_cf', 'def')
se = ServiceEnvironmentFactory(service__uid='sc-333')
self.cloud_host = CloudHostFullFactory(
configuration_path__module__name='ralph3',
service_env=se,
parent__service_env=se,
hostname='aaaa',
hypervisor=self.dc_asset)
self.cloud_host.ip_addresses = ['10.20.30.40']
self.cloud_host.update_custom_field('test_cf', 'xyz')
def test_get_available_networks_cloud_host(self):
rack, nets = self._generate_rack_with_networks()
vm = VirtualServerFullFactory(parent=CloudHostFactory(
hypervisor=DataCenterAssetFullFactory(rack=rack)))
self.assertNetworksTheSame(nets, vm._get_available_networks())
def test_changelist_view(self):
DataCenterAssetFullFactory.create_batch(5)
VirtualServerFullFactory.create_batch(5)
CloudHostFullFactory.create_batch(4)
ClusterFactory.create_batch(4)
with self.assertNumQueries(19):
result = self.client.get(
reverse('admin:data_center_dchost_changelist'), )
# DCAssets - 5
# VirtualServer + hypervisors - 10
# Cluster - 4
# CloudHost + hypervisors - 8
self.assertEqual(result.context_data['cl'].result_count, 27)
def setUp(self):
super().setUp()
self.hypervisor = DataCenterAssetFactory()
self.cloud_hypervisor = CloudHostFactory()
self.cluster = ClusterFactory()
self.type = VirtualServerType.objects.create(name='XEN')
self.virtual_server = VirtualServerFullFactory(
service_env__environment__name='some_env', )
self.virtual_server.parent.service_env.service.uid = 's-12345'
self.virtual_server.parent.service_env.service.save()
self.virtual_server.service_env.service.business_owners = [self.user1]
self.virtual_server.service_env.service.technical_owners = [self.user2]
self.virtual_server.service_env.save()
self.virtual_server2 = VirtualServerFullFactory()
self.ip = IPAddressFactory(ethernet=EthernetFactory(
base_object=self.virtual_server2))
def test_post_by_hostname_creates_scm_status_record(self):
v_server = VirtualServerFullFactory()
url = reverse(
'scm-info-post',
kwargs={'hostname': v_server.hostname}
)
data = {
'last_checked': datetime.now().isoformat(),
'check_result': SCMCheckResult.scm_ok.id
}
resp = self.client.post(url, data=data)
self.assertEqual(resp.status_code, 201)
self.assertEqual(
resp.data.get('base_object'),
v_server.baseobject_ptr_id
)
self.assertEqual(
resp.data.get('check_result'),
SCMCheckResult.scm_ok.raw
)
self.assertEqual(
resp.data.get('last_checked'),
data['last_checked']
)
def test_double_post_does_not_create_duplicate_scm_status_record(self):
v_server = VirtualServerFullFactory()
url = reverse(
'scm-info-post',
kwargs={'hostname': v_server.hostname}
)
data = {
'last_checked': datetime.now().isoformat(),
'check_result': SCMCheckResult.check_failed.id
}
resp = self.client.post(url, data=data)
self.assertEqual(resp.status_code, 201)
data = {
'last_checked': datetime.now().isoformat(),
'check_result': SCMCheckResult.check_failed.id
}
resp = self.client.post(url, data=data)
self.assertEqual(resp.status_code, 200)
self.assertEqual(
len(SCMStatusCheck.objects.all()), 1
)
def test_delete_non_existing_scm_status_record_returns_404(self):
v_server = VirtualServerFullFactory()
url = reverse(
'scm-info-post',
kwargs={'hostname': v_server.hostname}
)
resp = self.client.delete(url)
self.assertEqual(resp.status_code, 404)
def test_changelist_virtualserver_location(self):
VirtualServerFullFactory(parent=DataCenterAssetFullFactory(
rack__name='Rack #1',
rack__server_room__name='SR1',
rack__server_room__data_center__name='DC1',
hostname='s12345.mydc.net',
))
result = self.client.get(
reverse('admin:data_center_dchost_changelist'), )
self.assertContains(result, 'DC1 / SR1 / Rack #1 / s12345.mydc.net')
def test_creating_scm_status_record_ignores_baseobject_id_in_data(self):
v_server_1 = VirtualServerFullFactory()
v_server_2 = VirtualServerFullFactory()
url = reverse(
'scm-info-post',
kwargs={'hostname': v_server_1.hostname}
)
data = {
'last_checked': datetime.now().isoformat(),
'check_result': SCMCheckResult.check_failed.id,
'base_object': v_server_2.baseobject_ptr_id
}
resp = self.client.post(url, data=data)
self.assertEqual(resp.status_code, 201)
self.assertEqual(
resp.data.get('base_object'),
v_server_1.baseobject_ptr_id
)
def test_delete_scm_status_record(self):
v_server = VirtualServerFullFactory()
existing_scan = SCMStatusCheckFactory(
base_object=v_server.baseobject_ptr,
check_result=SCMCheckResult.scm_ok
)
url = reverse(
'scm-info-post',
kwargs={'hostname': v_server.hostname}
)
resp = self.client.delete(url)
self.assertEqual(resp.status_code, 204)
with self.assertRaises(ObjectDoesNotExist):
SCMStatusCheck.objects.get(pk=existing_scan.pk)
def test_post_by_hostname_updates_scm_status_record(self):
v_server = VirtualServerFullFactory()
existing_scan = SCMStatusCheckFactory(
base_object=v_server.baseobject_ptr,
check_result=SCMCheckResult.scm_ok
)
url = reverse(
'scm-info-post',
kwargs={'hostname': v_server.hostname}
)
data = {
'last_checked': datetime.now().isoformat(),
'check_result': SCMCheckResult.check_failed.id
}
resp = self.client.post(url, data=data)
self.assertEqual(resp.status_code, 200)
updated_scan = SCMStatusCheck.objects.get(pk=existing_scan.pk)
self.assertEqual(
updated_scan.check_result,
SCMCheckResult.check_failed
)
self.assertFalse(updated_scan.ok)
self.assertEqual(
resp.data.get('base_object'),
existing_scan.base_object_id
)
self.assertEqual(
resp.data.get('check_result'),
SCMCheckResult.check_failed.raw
)
self.assertEqual(
resp.data.get('last_checked'),
data['last_checked']
)
class DCHostAPITests(RalphAPITestCase):
def setUp(self):
super().setUp()
self.cf = CustomField.objects.create(
name='test_cf', use_as_configuration_variable=True)
# is should be skipped in API
self.bo_asset = BackOfficeAssetFactory(barcode='12345',
hostname='host1')
self.conf_module_1 = ConfigurationModuleFactory()
self.conf_module_2 = ConfigurationModuleFactory(
parent=self.conf_module_1, name='ralph')
self.conf_class_1 = ConfigurationClassFactory(
module=self.conf_module_2, class_name='cls1')
self.dc_asset = DataCenterAssetFullFactory(
service_env__service__name='test-service',
service_env__service__uid='sc-123',
service_env__environment__name='prod',
configuration_path=self.conf_class_1,
)
self.dc_asset.update_custom_field('test_cf', 'abc')
self.virtual = VirtualServerFullFactory(
parent=self.dc_asset,
configuration_path__module__name='ralph2',
service_env__service__uid='sc-222',
service_env__environment__name='some_env',
)
self.virtual.update_custom_field('test_cf', 'def')
se = ServiceEnvironmentFactory(service__uid='sc-333')
self.cloud_host = CloudHostFullFactory(
configuration_path__module__name='ralph3',
service_env=se,
parent__service_env=se,
hostname='aaaa',
hypervisor=self.dc_asset)
self.cloud_host.ip_addresses = ['10.20.30.40']
self.cloud_host.update_custom_field('test_cf', 'xyz')
def test_get_dc_hosts_list(self):
url = reverse('dchost-list')
with self.assertNumQueries(12):
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 3)
def test_filter_by_type_dc_asset(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'object_type': 'datacenterasset'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
dca = response.data['results'][0]
self.assertEqual(dca['hostname'], self.dc_asset.hostname)
self.assertEqual(len(dca['ethernet']), 3)
self.assertEqual(len(dca['ipaddresses']), 2)
self.assertCountEqual(dca['tags'], ['abc, cde', 'xyz'])
self.assertEqual(dca['configuration_path']['module']['name'], 'ralph')
self.assertEqual(dca['service_env']['service_uid'], 'sc-123')
self.assertEqual(dca['object_type'], 'datacenterasset')
self.assertEqual(dca['custom_fields'], {'test_cf': 'abc'})
self.assertEqual(dca['configuration_variables'], {'test_cf': 'abc'})
def test_filter_by_type_virtual(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'object_type': 'virtualserver'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
virt = response.data['results'][0]
self.assertEqual(virt['hostname'], self.virtual.hostname)
self.assertEqual(len(virt['ethernet']), 2)
self.assertEqual(len(virt['ipaddresses']), 1)
self.assertCountEqual(virt['tags'], ['abc, cde', 'xyz'])
self.assertEqual(virt['configuration_path']['module']['name'],
'ralph2')
self.assertEqual(virt['service_env']['service_uid'], 'sc-222')
self.assertEqual(virt['object_type'], 'virtualserver')
self.assertEqual(virt['custom_fields'], {'test_cf': 'def'})
self.assertEqual(virt['configuration_variables'], {'test_cf': 'def'})
def test_filter_by_type_cloudhost(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'object_type': 'cloudhost'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
cloud = response.data['results'][0]
self.assertEqual(cloud['hostname'], self.cloud_host.hostname)
self.assertCountEqual(cloud['tags'], ['abc, cde', 'xyz'])
self.assertEqual(cloud['configuration_path']['module']['name'],
'ralph3')
self.assertEqual(cloud['service_env']['service_uid'], 'sc-333')
self.assertEqual(cloud['object_type'], 'cloudhost')
self.assertEqual(len(cloud['ethernet']), 1)
self.assertEqual(len(cloud['ipaddresses']), 1)
self.assertEqual(cloud['custom_fields'], {'test_cf': 'xyz'})
self.assertEqual(cloud['configuration_variables'], {'test_cf': 'xyz'})
def test_filter_by_hostname(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'hostname': 'aaaa'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_name(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'name': 'aaaa'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_service_uid(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'service': 'sc-222'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_ip(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'ip': '10.20.30.40'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_configuration_path(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'configuration_path': 'ralph/cls1'}))
response = self.client.get(url, format='json')
self.assertEqual(len(response.data['results']), 1)
self.assertEqual(response.data['results'][0]['id'], self.dc_asset.id)
def test_filter_by_configuration_path_module_name(self):
url = '{}?{}'.format(
reverse('dchost-list'),
urlencode({'configuration_path__module__name': 'ralph'}))
response = self.client.get(url, format='json')
self.assertEqual(len(response.data['results']), 1)
self.assertEqual(response.data['results'][0]['id'], self.dc_asset.id)
def test_filter_by_env_name(self):
url = '{}?{}'.format(reverse('dchost-list'),
urlencode({'env': 'some_env'}))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def setUp(self):
self.vs = VirtualServerFullFactory()
self.custom_field_str = CustomField.objects.create(
name='test str', type=CustomFieldTypes.STRING, default_value='xyz')
class VirtualServerAPITestCase(RalphAPITestCase):
def setUp(self):
super().setUp()
self.hypervisor = DataCenterAssetFactory()
self.cloud_hypervisor = CloudHostFactory()
self.cluster = ClusterFactory()
self.type = VirtualServerType.objects.create(name='XEN')
self.virtual_server = VirtualServerFullFactory(
service_env__environment__name='some_env', )
self.virtual_server.parent.service_env.service.uid = 's-12345'
self.virtual_server.parent.service_env.service.save()
self.virtual_server.service_env.service.business_owners = [self.user1]
self.virtual_server.service_env.service.technical_owners = [self.user2]
self.virtual_server.service_env.save()
self.virtual_server2 = VirtualServerFullFactory()
self.ip = IPAddressFactory(ethernet=EthernetFactory(
base_object=self.virtual_server2))
def test_get_virtual_server_list(self):
url = reverse('virtualserver-list')
with self.assertNumQueries(13):
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 2)
def test_get_virtual_server_details(self):
url = reverse('virtualserver-detail', args=(self.virtual_server.id, ))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['hostname'],
self.virtual_server.hostname)
self.assertEqual(len(response.data['ethernet']), 2)
self.assertCountEqual([
eth['ipaddress']['address']
for eth in response.data['ethernet'] if eth['ipaddress']
], self.virtual_server.ipaddresses.values_list('address', flat=True))
self.assertEqual(len(response.data['memory']), 2)
self.assertEqual(response.data['memory'][0]['speed'], 1600)
self.assertEqual(response.data['memory'][0]['size'], 8192)
self.assertEqual(response.data['business_owners'][0]['username'],
'user1')
self.assertEqual(response.data['technical_owners'][0]['username'],
'user2')
def test_create_virtual_server(self):
virtual_server_count = VirtualServer.objects.count()
url = reverse('virtualserver-list')
data = {
'hostname': 's1234.local',
'type': self.type.id,
'sn': '143ed36a-3e86-457d-9e19-3dcfe4d5ed26',
'hypervisor': self.hypervisor.id,
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(VirtualServer.objects.count(),
virtual_server_count + 1)
virtual_server = VirtualServer.objects.get(pk=response.data['id'])
self.assertEqual(virtual_server.hostname, data['hostname'])
self.assertEqual(virtual_server.parent.id, self.hypervisor.id)
self.assertEqual(virtual_server.sn, data['sn'])
def test_create_virtual_server_with_cloud_host_as_parent(self):
virtual_server_count = VirtualServer.objects.count()
url = reverse('virtualserver-list')
data = {
'hostname': 's1234.local',
'type': self.type.id,
'sn': '143ed36a-3e86-457d-9e19-3dcfe4d5ed26',
'hypervisor': self.cloud_hypervisor.id,
}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(VirtualServer.objects.count(),
virtual_server_count + 1)
virtual_server = VirtualServer.objects.get(pk=response.data['id'])
self.assertEqual(virtual_server.hostname, data['hostname'])
self.assertEqual(virtual_server.parent.id, self.cloud_hypervisor.id)
self.assertEqual(virtual_server.sn, data['sn'])
def test_patch_virtual_server(self):
url = reverse('virtualserver-detail', args=(self.virtual_server.id, ))
data = {'hostname': 's111111.local'}
response = self.client.patch(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.virtual_server.refresh_from_db()
self.assertEqual(self.virtual_server.hostname, 's111111.local')
def test_filter_by_configuration_path(self):
url = reverse('virtualserver-list') + '?configuration_path={}'.format(
self.virtual_server.configuration_path.path, )
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_hostname(self):
url = reverse('virtualserver-list') + '?hostname={}'.format(
self.virtual_server.hostname, )
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_ip_address(self):
url = reverse('virtualserver-list') + '?ip={}'.format(
self.ip.address, )
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_service_uid(self):
url = reverse('virtualserver-list') + '?service={}'.format(
self.virtual_server.service_env.service.uid, )
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_service_uid2(self):
url = (reverse('virtualserver-list') +
'?service_env__service__uid={}'.format(
self.virtual_server.service_env.service.uid, ))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_service_id(self):
url = (reverse('virtualserver-list') +
'?service_env__service__id={}'.format(
self.virtual_server.service_env.service.id, ))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_service_name(self):
url = reverse('virtualserver-list') + '?service={}'.format(
self.virtual_server.service_env.service.name, )
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_service_name2(self):
url = (reverse('virtualserver-list') +
'?service_env__service__name={}'.format(
self.virtual_server.service_env.service.name, ))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_env_name(self):
url = reverse('virtualserver-list') + '?env=some_env'
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
def test_filter_by_hypervisor_service(self):
url = reverse('virtualserver-list') + '?hypervisor_service=s-12345'
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1)
self.assertEqual(response.data['results'][0]['id'],
self.virtual_server.id)
