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()
