def generate_data_center(self): self.stdout.write('Generating Data Center assets') data_center_status = DataCenterAssetStatus() parent_category = DataCenterCategoryFactory(name='DATA CENTER', imei_required=False) for i in range(2): server_room = ServerRoomFactory() visualization_col = 1 visualization_row = 1 for j in range(10): rack = RackFactory(server_room=server_room, visualization_row=visualization_row, visualization_col=visualization_col) visualization_row += 1 if (visualization_row > server_room.data_center.visualization_rows_num): visualization_row = 1 visualization_col += 1 accessory = AccessoryFactory() RackAccessoryFactory(rack=rack, accessory=accessory) position = 1 for status_id, name in data_center_status: for i in range(2): asset_model = DataCenterAssetModelFactory( category=DataCenterCategoryFactory( parent=parent_category)) DataCenterAssetFactory( rack=rack, status=status_id, position=position, slot_no='', service_env=ServiceEnvironmentFactory(), model=asset_model) position += asset_model.height_of_device if position > rack.max_u_height: position = 1 chassis = DataCenterAssetFactory( rack=rack, status=DataCenterAssetStatus.used.id, position=38, slot_no=None, service_env=ServiceEnvironmentFactory(), model=DataCenterAssetModelFactory( name='Chassis', category=DataCenterCategoryFactory(parent=parent_category), height_of_device=5)) for i in range(5): DataCenterAssetFactory(rack=rack, status=DataCenterAssetStatus.used.id, position=None, service_env=ServiceEnvironmentFactory(), slot_no=i, parent=chassis, model=DataCenterAssetModelFactory( name='Blade', has_parent=True, category=DataCenterCategoryFactory( parent=parent_category)))
def test_convert_to_data_center_asset_preserves_status_name(self): bo_asset = BackOfficeAssetFactory( status=BackOfficeAssetStatus.from_name('damaged')) transition = Transition.objects.create( name='transition', model=TransitionModel.get_for_field(bo_asset, 'status'), source=0, target=0, ) bo_asset_pk = bo_asset.pk bo_asset_status_name = BackOfficeAssetStatus.from_id( bo_asset.status).name rack = RackFactory() BackOfficeAsset.convert_to_data_center_asset( instances=[bo_asset], rack=rack.id, service_env=ServiceEnvironmentFactory().id, position=1, model=DataCenterAssetModelFactory().id, request=None, transition_id=transition.pk, ) dc_asset = DataCenterAsset.objects.get(pk=bo_asset_pk) dc_asset_status_name = DataCenterAssetStatus.from_id( dc_asset.status).name self.assertEqual(bo_asset_status_name, dc_asset_status_name)
def test_convert_to_data_center_asset(self): bo_asset = BackOfficeAssetFactory() transition = Transition.objects.create( name='transition', model=TransitionModel.get_for_field(bo_asset, 'status'), source=0, target=0, ) bo_asset_pk = bo_asset.pk hostname = bo_asset.hostname rack = RackFactory() BackOfficeAsset.convert_to_data_center_asset( instances=[bo_asset], rack=rack.id, service_env=ServiceEnvironmentFactory().id, position=1, model=DataCenterAssetModelFactory().id, request=None, transition_id=transition.pk, ) dc_asset = DataCenterAsset.objects.get(pk=bo_asset_pk) self.assertEqual(dc_asset.rack.id, rack.id) self.assertFalse( BackOfficeAsset.objects.filter(pk=bo_asset_pk).exists()) self.assertEqual(dc_asset.hostname, hostname)
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_convert_to_data_center_asset_uses_default_from_settings(self): target_status_id = DataCenterAssetStatus.from_id( settings.CONVERT_TO_DATACENTER_ASSET_DEFAULT_STATUS_ID).id bo_asset = BackOfficeAssetFactory( status=BackOfficeAssetStatus.from_name('damaged')) transition = Transition.objects.create( name='transition', model=TransitionModel.get_for_field(bo_asset, 'status'), source=0, target=target_status_id, ) bo_asset_pk = bo_asset.pk target_status_name = BackOfficeAssetStatus.from_id( target_status_id).name rack = RackFactory() BackOfficeAsset.convert_to_data_center_asset( instances=[bo_asset], rack=rack.id, service_env=ServiceEnvironmentFactory().id, position=1, model=DataCenterAssetModelFactory().id, request=None, transition_id=transition.pk, ) dc_asset = DataCenterAsset.objects.get(pk=bo_asset_pk) dc_asset_status_name = DataCenterAssetStatus.from_id( dc_asset.status).name self.assertEqual(target_status_name, dc_asset_status_name)
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): 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_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_model_asset_type_back_office_shall_pass(self): back_office_model = DataCenterAssetModelFactory( type=ObjectModelType.from_name('back_office')) self.data.update({'model': back_office_model.pk}) response = self.client.post(self.asset.get_absolute_url(), self.data) self.asset.refresh_from_db() self.assertEqual(response.status_code, 302) self.assertEqual(self.asset.model, back_office_model)
def test_model_asset_type_data_center_asset_shall_not_pass(self): back_office_model = DataCenterAssetModelFactory( type=ObjectModelType.from_name('data_center')) self.data.update({'model': back_office_model.pk}) response = self.client.post(self.asset.get_absolute_url(), self.data) self.asset.refresh_from_db() self.assertIn('Model must be of', response.content.decode('utf-8')) self.assertNotEqual(self.asset.model, back_office_model) self.assertEqual(response.status_code, 200)
class AssetModelAPITests(RalphAPITestCase): def setUp(self): super().setUp() self.manufacturer = ManufacturerFactory() self.asset_model = DataCenterAssetModelFactory() def test_get_asset_model_list(self): url = reverse('assetmodel-list') 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]['name'], self.asset_model.name ) def test_get_asset_model_details(self): url = reverse('assetmodel-detail', args=(self.asset_model.id,)) response = self.client.get(url, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data['name'], self.asset_model.name) def test_create_asset_model(self): url = reverse('assetmodel-list') data = { 'name': 'MacBook Pro', 'manufacturer': self.manufacturer.id, 'type': ObjectModelType.back_office.id, } response = self.client.post(url, data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(AssetModel.objects.count(), 2) asset_model = AssetModel.objects.get(pk=response.data['id']) self.assertEqual(asset_model.name, 'MacBook Pro') self.assertEqual(asset_model.manufacturer, self.manufacturer) def test_patch_asset_model(self): url = reverse('assetmodel-detail', args=(self.asset_model.id,)) data = { 'name': 'Iphone 6' } response = self.client.patch(url, data, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.asset_model.refresh_from_db() self.assertEqual(self.asset_model.name, 'Iphone 6')
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_model_asset_type_data_center_shall_pass(self): data_center_model = DataCenterAssetModelFactory( type=ObjectModelType.from_name('data_center') ) data = self._get_initial_data() data.update({ 'model': data_center_model.pk }) response = self.client.post( self.dca.get_absolute_url(), data ) self.dca.refresh_from_db() self.assertEqual(response.status_code, 302) self.assertEqual(self.dca.model, data_center_model)
def setUp(self): get_user_model().objects.create_superuser( 'test', '*****@*****.**', 'test' ) self.client = APIClient() self.client.login(username='******', password='******') environment = EnvironmentFactory() service = ServiceFactory(name='Service1') service_env = ServiceEnvironment.objects.create( service=service, environment=environment ) asset_model = DataCenterAssetModelFactory( type=ObjectModelType.data_center ) self.server_room = ServerRoomFactory() self.accesory_1 = AccessoryFactory() self.rack_1 = RackFactory( server_room=self.server_room, max_u_height=3 ) self.asset_1 = DataCenterAssetFactory( service_env=service_env, position=1, slot_no='', force_depreciation=False, model=asset_model, rack=self.rack_1, ) self.asset_1.management_ip = '10.15.25.45' self.pdu_1 = DataCenterAssetFactory( service_env=service_env, rack=self.rack_1, orientation=Orientation.left, force_depreciation=False, model=asset_model, position=0, ) self.rack1_accessory = RackAccessoryFactory( rack=self.rack_1, orientation=Orientation.front, accessory=self.accesory_1, position=1 )
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 test_queries_number(self): for _ in range(0, 10): rack = RackFactory() for position in range(1, 6): model = DataCenterAssetModelFactory(has_parent=True) asset = DataCenterAssetFactory(rack=rack, position=position, model=model) ethernets = EthernetFactory.create_batch(2, base_object=asset) IPAddressFactory(base_object=asset, is_management=False, ethernet=ethernets[0]) IPAddressFactory(base_object=asset, is_management=True, ethernet=ethernets[1]) with self.assertNumQueries(103): DataCenterAssetTextResource().export()
def setUp(self): super().setUp() self.service_env = ServiceEnvironmentFactory() self.model = DataCenterAssetModelFactory() self.rack = RackFactory() self.dc_asset = DataCenterAssetFullFactory( rack=self.rack, position=10, model=self.model, service_env__environment__name='some_env' ) self.dc_asset.service_env.service.business_owners = [self.user1] self.dc_asset.service_env.service.technical_owners = [self.user2] self.dc_asset.service_env.save() self.ip = IPAddressFactory( ethernet=EthernetFactory(base_object=self.dc_asset) ) self.dc_asset.tags.add('db', 'test') self.dc_asset_2 = DataCenterAssetFullFactory()
def setUp(self): self.model = DataCenterAssetModelFactory( category=CategoryFactory(name="Keyboard"), type=ObjectModelType.data_center, name='Keyboard1', manufacturer=ManufacturerFactory(name='M1')) self.dc_1 = DataCenterAssetFactory( force_depreciation=False, model=self.model, ) self.dc_1.tags.add('tag1', 'tag2') self.licence = LicenceFactory( number_bought=1, niw='N/A', software__name='Project Info', software__asset_type=ObjectModelType.data_center, region__name='US', ) BaseObjectLicence.objects.create(licence=self.licence, base_object=self.dc_1.baseobject_ptr)
def _create_models(self): self.keyboard_model = DataCenterAssetModelFactory( category=CategoryFactory(name="Keyboard"), type=ObjectModelType.data_center, name='Keyboard1', ) self.mouse_model = DataCenterAssetModelFactory( category=CategoryFactory(name="Mouse"), type=ObjectModelType.data_center, name='Mouse1', ) self.pendrive_model = DataCenterAssetModelFactory( category=CategoryFactory(name="Pendrive"), type=ObjectModelType.data_center, name='Pendrive1', ) self.model_monitor = DataCenterAssetModelFactory( category=CategoryFactory(name="Monitor"), type=ObjectModelType.data_center, name='Monitor1', ) self.navigation_model = DataCenterAssetModelFactory( category=CategoryFactory(name="Navigation"), type=ObjectModelType.data_center, name='Navigation1', ) self.scanner_model = DataCenterAssetModelFactory( category=CategoryFactory(name="Scanner"), type=ObjectModelType.data_center, name='Scanner1', ) self.shredder_model = DataCenterAssetModelFactory( category=CategoryFactory(name="Shredder"), type=ObjectModelType.data_center, name='Shredder1', )
def setUp(self): super().setUp() self.manufacturer = ManufacturerFactory() self.asset_model = DataCenterAssetModelFactory()