def test_get_available_networks(self): rack, nets = self._generate_rack_with_networks() host = CloudHostFactory(hypervisor=DataCenterAssetFullFactory( rack=rack)) self.assertNetworksTheSame(nets, host._get_available_networks())
def test_match_cloud_hosts_ignore_already_matched(self): unassigned_hypervisor = DataCenterAsset.objects.create( hostname='hypervisor', model=DataCenterAssetModelFactory(), sn='hypervisor-SN') with_hypervisor = CloudHostFullFactory(host_id='with hypervisor') with_hypervisor_modified = with_hypervisor.modified with_hypervisor_node = FakeIronicNode( serial_number=with_hypervisor.hypervisor.sn, instance_uuid=with_hypervisor.host_id) without_hypervisor = CloudHostFactory(host_id='no hypervisor') without_hypervisor_modified = without_hypervisor.modified without_hypervisor_node = FakeIronicNode( serial_number=unassigned_hypervisor.sn, instance_uuid=without_hypervisor.host_id) nodes = [with_hypervisor_node, without_hypervisor_node] self.cmd._match_nodes_to_hosts(nodes) without_hypervisor.refresh_from_db() with_hypervisor.refresh_from_db() # should not be modified by the command self.assertTrue(with_hypervisor_modified == with_hypervisor.modified) # should be modified by the command self.assertTrue( without_hypervisor_modified < without_hypervisor.modified)
def setUp(self): super().setUp() self.envs = EnvironmentFactory.create_batch(2) self.services = ServiceFactory.create_batch(2) self.service_env = [] for i in range(0, 2): self.service_env.append(ServiceEnvironment.objects.create( service=self.services[i], environment=self.envs[i] )) self.service_env[0].service.business_owners = [self.user1] self.service_env[0].service.technical_owners = [self.user2] self.service_env[0].save() self.cloud_provider = CloudProviderFactory(name='openstack') self.cloud_flavor = CloudFlavorFactory() self.cloud_project = CloudProjectFactory( service_env=self.service_env[0] ) self.cloud_host = CloudHostFactory( parent=self.cloud_project, cloudflavor=self.cloud_flavor ) self.cloud_host2 = CloudHostFactory() self.test_cpu = ComponentModel.objects.create( name='vcpu1', cores=5, family='vCPU', type=ComponentType.processor, ) self.test_mem = ComponentModel.objects.create( name='2000 MiB vMEM', size='2000', type=ComponentType.memory, ) self.test_disk = ComponentModel.objects.create( name='4 GiB vDISK', size='4096', type=ComponentType.disk, ) VirtualComponent.objects.create( base_object=self.cloud_flavor, model=self.test_cpu, ) VirtualComponent.objects.create( base_object=self.cloud_flavor, model=self.test_mem, ) VirtualComponent.objects.create( base_object=self.cloud_flavor, model=self.test_disk, )
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 setUp(self): asset_model = DataCenterAssetModelFactory() self.cloud_provider = CloudProviderFactory(name='openstack') self.cloud_flavor = CloudFlavorFactory.create_batch(3) self.test_model = ComponentModel(name='delete_test') VirtualComponent(model=self.test_model, base_object=self.cloud_flavor[0]) self.cloud_project_1 = CloudProjectFactory(project_id='project_id1') self.cloud_project_2 = CloudProjectFactory(project_id='project_id2') self.cloud_project_3 = CloudProjectFactory(project_id='project_os_id1') self.host = CloudHostFactory(host_id='host_id1', parent=self.cloud_project_1, cloudflavor=self.cloud_flavor[1]) IPAddress.objects.create(base_object=self.host, address='2.2.3.4') IPAddress.objects.create(base_object=self.host, address='1.2.3.4') DataCenterAsset.objects.create( hostname='hypervisor_os1.dcn.net', model=asset_model, ) self.ironic_serial_number_param = 'serial_number' self.ralph_serial_number_param = 'sn' self.ralph_client = RalphClient('openstack', self.ironic_serial_number_param, self.ralph_serial_number_param) self.openstack_client = RalphOpenStackInfrastructureClient( self.cloud_provider.name)
def test_match_cloud_hosts_all_matched(self): asset_model = DataCenterAssetModelFactory() num_assets = 10 assets = [ DataCenterAsset.objects.create(hostname='hostname-{}'.format(i), model=asset_model, sn='SN{}'.format(i)) for i in range(num_assets) ] hosts = [ CloudHostFactory(host_id='fake-instance-uuid-{}'.format(i)) for i in range(num_assets) ] nodes = [ FakeIronicNode(serial_number=asset.sn, instance_uuid=host.host_id) for asset, host in zip(assets, hosts) ] self.cmd._match_nodes_to_hosts(nodes) updated_hosts = CloudHost.objects.filter( id__in=[host.id for host in hosts]) for host in updated_hosts: self.assertIsNotNone(host.hypervisor) expected_serials = [asset.sn for asset in assets] expected_serials.sort() real_serials = [host.hypervisor.sn for host in updated_hosts] real_serials.sort() self.assertEqual(expected_serials, real_serials)
def test_match_cloud_hosts_host_not_found(self): host = CloudHostFactory(host_id='foo') node = FakeIronicNode(serial_number='SN0', instance_uuid='bar') self.cmd._match_nodes_to_hosts([node]) updated_host = CloudHost.objects.get(pk=host.pk) self.assertIsNone(updated_host.hypervisor)
def setUp(self): asset_model = DataCenterAssetModelFactory() self.cloud_provider = CloudProviderFactory(name='openstack') self.cloud_flavor = CloudFlavorFactory.create_batch(3) self.test_model = ComponentModel(name='delete_test') VirtualComponent(model=self.test_model, base_object=self.cloud_flavor[0]) self.cloud_project = CloudProjectFactory(project_id='project_id1') CloudProjectFactory(project_id='project_id2') CloudProjectFactory(project_id='project_os_id1') host = CloudHostFactory(host_id='host_id1', parent=self.cloud_project, cloudflavor=self.cloud_flavor[1]) IPAddress.objects.create(base_object=host, address='2.2.3.4') IPAddress.objects.create(base_object=host, address='1.2.3.4') DataCenterAsset.objects.create( hostname='hypervisor_os1.dcn.net', model=asset_model, ) self.cmd = Command() self.cmd._get_cloud_provider() self.cmd.openstack_projects = OPENSTACK_DATA self.cmd.openstack_flavors = OPENSTACK_FLAVOR self.cmd._get_ralph_data() self.cmd.ironic_serial_number_param = 'serial_number' self.cmd.ralph_serial_number_param = 'sn'
def test_filter_cloudhost_by_service_uid(self): cloud_host = CloudHostFactory() url = (reverse('cloudhost-list') + '?service_env__service__uid={}'.format( cloud_host.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_cloud_host_parent(self): form_data = self._get_basic_form_data() form_data['parent'] = CloudHostFactory().pk response = self.client.post(self.url, form_data) self.assertEquals( response.status_code, 302, (repr(response.context['form'].errors) if response.context and 'form' in response.context else ''))
def setUp(self): self.service = ServiceFactory() self.service_env = ServiceEnvironmentFactory(service=self.service) self.cloud_project = CloudProjectFactory() self.cloud_host = CloudHostFactory(parent=self.cloud_project) self.custom_field_str = CustomField.objects.create( name='test str', type=CustomFieldTypes.STRING, default_value='xyz')
def setUp(self): self.cloud_ip = IPAddressFactory( ethernet__base_object=CloudHostFactory()) # fetch "clean" ip from db to fet base object instead of final instance # (cloud host in this case) self.cloud_ip = IPAddress.objects.get(address=self.cloud_ip.address) self.dc_asset_ip = IPAddressFactory( ethernet__base_object=DataCenterAssetFactory()) self.dc_asset_ip = IPAddress.objects.get( address=self.dc_asset_ip.address)
def test_match_cloud_hosts_asset_not_found(self): asset_model = DataCenterAssetModelFactory() DataCenterAsset.objects.create(hostname='hostname-1', model=asset_model, sn='FOO') host = CloudHostFactory(host_id='buz') node = FakeIronicNode(serial_number='BAR', instance_uuid=host.host_id) self.cmd._match_nodes_to_hosts([node]) updated_host = CloudHost.objects.get(pk=host.pk) self.assertIsNone(updated_host.hypervisor)
def test_cleanup_doesnt_remove_cloud_projects_with_children(self): project = CloudProjectFactory(project_id='im_not_here') host = CloudHostFactory(host_id='host_id123', parent=project, cloudflavor=self.cloud_flavor[1]) self.cmd._get_ralph_data() self.cmd._cleanup() try: CloudProject.objects.get(project_id='im_not_here') except ObjectDoesNotExist: self.fail('Project "im_not_here" was deleted.')
def test_should_add_cloud_hosts_to_dictionary(self): cloud_host = ContentType.objects.get_for_model(CloudHost) self.view.object.cloudhost_set.add(*CloudHostFactory.create_batch(4)) related_objects = {} self.view._add_cloud_hosts(related_objects) content_type = { c_t.content_type for c_t in related_objects['cloud_hosts'] } self.assertEqual(4, len(related_objects['cloud_hosts'])) self.assertEqual(1, len(content_type)) self.assertEqual(cloud_host, content_type.pop())
def test_used_cloud_flavor_can_be_deleted_with_force(self): # given cloud_flavor = CloudFlavorFactory() CloudHostFactory(cloudflavor=cloud_flavor) # when url = reverse('cloudflavor-detail', args=(cloud_flavor.pk, )) data = {'force': True} resp = self.client.delete(url, data=data) # then self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT) self.assertRaises(CloudFlavor.DoesNotExist, cloud_flavor.refresh_from_db)
def test_delete_cloud_flavor_returns_409_if_is_used_by_cloud_hosts(self): # given cloud_flavor = CloudFlavorFactory() CloudHostFactory(cloudflavor=cloud_flavor) # when url = reverse('cloudflavor-detail', args=(cloud_flavor.pk, )) resp = self.client.delete(url) # then self.assertEqual(resp.status_code, status.HTTP_409_CONFLICT) self.assertIn('Cloud flavor is in use and hence is not deletable.', resp.data['detail']) self.assertTrue( CloudFlavor.objects.filter(pk=cloud_flavor.pk).exists())
def test_match_cloud_hosts_asset_duplicate_sn(self): asset_model = DataCenterAssetModelFactory() assets = [ DataCenterAsset.objects.create(hostname='hostname-{}'.format(i), model=asset_model, sn=None) for i in range(2) ] host = CloudHostFactory(host_id='bar') node = FakeIronicNode(serial_number=assets[0].sn, instance_uuid=host.host_id) self.cmd._match_nodes_to_hosts([node]) updated_host = CloudHost.objects.get(pk=host.pk) self.assertIsNone(updated_host.hypervisor)
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_cleanup_doesnt_remove_cloud_flavours_with_assignments(self): flavor = CloudFlavorFactory(flavor_id='im_not_here', name='im_not_here') CloudHostFactory(host_id='host_id123', cloudflavor=flavor) openstack_flavors = copy(OPENSTACK_FLAVORS) openstack_flavors.update({flavor.flavor_id: {"name": flavor.name}}) ralph_projects = self.ralph_client.get_ralph_servers_data( self.ralph_client.get_ralph_projects()) ralph_flavors = self.ralph_client.get_ralph_flavors() servers_to_delete = self.ralph_client.calculate_servers_to_delete( OPENSTACK_DATA, ralph_projects, incremental=True) self.ralph_client.perform_delete(OPENSTACK_DATA, OPENSTACK_FLAVORS, ralph_projects, ralph_flavors, servers_to_delete) try: CloudFlavor.objects.get(flavor_id='im_not_here') except ObjectDoesNotExist: self.fail('Flavor "im_not_here" was deleted.')
def setUp(self): self.envs = EnvironmentFactory.create_batch(2) self.services = ServiceFactory.create_batch(2) self.service_env = [] for i in range(0, 2): self.service_env.append( ServiceEnvironment.objects.create(service=self.services[i], environment=self.envs[i])) self.cloud_provider = CloudProviderFactory(name='openstack') self.cloud_flavor = CloudFlavorFactory() self.cloud_project = CloudProjectFactory() self.cloud_host = CloudHostFactory(parent=self.cloud_project) self.test_cpu = ComponentModel.objects.create( name='vcpu1', cores=4, family='vCPU', type=ComponentType.processor, ) self.test_mem = ComponentModel.objects.create( name='1024 MiB vMEM', size='1024', type=ComponentType.memory, ) self.test_disk = ComponentModel.objects.create( name='4 GiB vDISK', size='4096', type=ComponentType.disk, ) VirtualComponent.objects.create( base_object=self.cloud_flavor, model=self.test_cpu, ) VirtualComponent.objects.create( base_object=self.cloud_flavor, model=self.test_mem, ) VirtualComponent.objects.create( base_object=self.cloud_flavor, model=self.test_disk, )
def test_get_data_center_asset_details_related_hosts(self): dc_asset_3 = DataCenterAssetFullFactory() cloud_host = CloudHostFactory( hypervisor=dc_asset_3 ) virtual_server = VirtualServerFactory( parent=dc_asset_3 ) virtual_server_2 = VirtualServerFactory( parent=dc_asset_3, hostname='random_test_hostname' ) dc_asset_4 = DataCenterAssetFullFactory( parent=dc_asset_3 ) url = reverse('datacenterasset-detail', args=(dc_asset_3.id,)) response = self.client.get(url, format='json') self.assertEqual( len(response.data['related_hosts']['cloud_hosts']), 1 ) self.assertEqual( len(response.data['related_hosts']['virtual_servers']), 2 ) self.assertIn( response.data['related_hosts']['virtual_servers'][0]['hostname'], (virtual_server.hostname, virtual_server_2.hostname) ) self.assertIn( response.data['related_hosts']['virtual_servers'][1]['hostname'], (virtual_server.hostname, virtual_server_2.hostname) ) self.assertEqual( response.data['related_hosts']['cloud_hosts'][0]['hostname'], cloud_host.hostname ) self.assertEqual( len(response.data['related_hosts']['physical_servers']), 1 ) self.assertEqual( response.data['related_hosts']['physical_servers'][0]['hostname'], dc_asset_4.hostname )
def test_cleanup_doesnt_remove_cloud_projects_with_children(self): project = CloudProjectFactory(project_id='im_not_here') CloudHostFactory(host_id='host_id123', parent=project, cloudflavor=self.cloud_flavor[1]) ralph_projects = self.ralph_client.get_ralph_servers_data( self.ralph_client.get_ralph_projects()) ralph_flavors = self.ralph_client.get_ralph_flavors() servers_to_delete = self.ralph_client.calculate_servers_to_delete( OPENSTACK_DATA, ralph_projects, ) self.ralph_client.perform_delete(OPENSTACK_DATA, OPENSTACK_FLAVORS, ralph_projects, ralph_flavors, servers_to_delete) try: CloudProject.objects.get(project_id='im_not_here') except ObjectDoesNotExist: self.fail('Project "im_not_here" was deleted.')
def test_check_ralph_delete_incremental(self): # Create server to be deleted in Ralph host_to_delete = CloudHostFactory(host_id='deleted', parent=self.cloud_project_3, cloudflavor=self.cloud_flavor[1]) ralph_projects = self.ralph_client.get_ralph_servers_data( self.ralph_client.get_ralph_projects()) ralph_flavors = self.ralph_client.get_ralph_flavors() servers_to_delete = self.ralph_client.calculate_servers_to_delete( OPENSTACK_DATA, ralph_projects, incremental=True) self.ralph_client.perform_delete(OPENSTACK_DATA, OPENSTACK_FLAVORS, ralph_projects, ralph_flavors, servers_to_delete) self.assertRaises(ObjectDoesNotExist, CloudHost.objects.get, host_id=host_to_delete.host_id) try: CloudHost.objects.get(host_id=self.host.host_id) except ObjectDoesNotExist: self.fail("Removed host that should have been kept.")
def test_service_env_inheritance_on_host_creation(self): self.cloud_project.service_env = self.service_env[1] self.cloud_project.save() new_host = CloudHostFactory(host_id="new_host_id", parent=self.cloud_project) self.assertEqual(new_host.service_env, self.service_env[1])