def setUp(self):
super().setUp()
self.server_room = ServerRoomFactory()
self.accessory = AccessoryFactory()
self.rack = RackFactory(server_room=self.server_room)
self.rack_accessory = RackAccessoryFactory(
accessory=self.accessory, rack=self.rack
)
def test_get_free_u_for_none_position(self):
rack = RackFactory(max_u_height=47)
asset_kwargs = {
'rack': rack,
'model__height_of_device': 47,
'position': None,
'slot_no': None,
'orientation': Orientation.front.id,
}
DataCenterAssetFactory(**asset_kwargs)
self.assertEqual(rack.get_free_u(), 47)
def setUp(self):
self.dca = DataCenterAssetFactory(rack=RackFactory(), position=1)
self.dca1 = DataCenterAssetFactory(rack=RackFactory(), position=2)
self.user = get_user_model().objects.create_superuser(
username='******',
password='******',
email='*****@*****.**'
)
result = self.client.login(username='******', password='******')
self.assertEqual(result, True)
self.factory = RequestFactory()
def test_get_free_u_for_one_asset(self, position, height, max_u_height,
expected):
rack = RackFactory(max_u_height=max_u_height)
asset_kwargs = {
'rack': rack,
'model__height_of_device': height,
'position': position,
'slot_no': None,
'orientation': Orientation.front.id,
}
DataCenterAssetFactory(**asset_kwargs)
self.assertEqual(rack.get_free_u(), expected)
def test_get_free_u_should_respect_orientation(self):
rack = RackFactory(max_u_height=48)
asset_common_kwargs = {
'rack': rack,
'model__height_of_device': 1,
'position': 35,
'slot_no': None
}
DataCenterAssetFactory(orientation=Orientation.front.id,
**asset_common_kwargs)
DataCenterAssetFactory(orientation=Orientation.back.id,
**asset_common_kwargs)
self.assertEqual(rack.get_free_u(), 47)
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 setUpClass(cls):
from ralph.data_center.tests.factories import (
DataCenterAssetFactory,
RackFactory,
)
super().setUpClass()
cls.dc_asset = DataCenterAssetFactory(
hostname='ralph0.allegro.pl',
service_env__service__name='service',
service_env__environment__name='test',
model__name='DL360',
model__manufacturer__name='Asus',
model__category__name='ATS',
rack=RackFactory(
name='Rack #100',
server_room__name='Server Room A',
server_room__data_center__name='DC1',
),
position=1,
slot_no='1',
configuration_path__class_name='www',
configuration_path__module__name='ralph',
)
cls.dc_ip = IPAddressFactory(
base_object=cls.dc_asset,
ethernet=EthernetFactory(base_object=cls.dc_asset),
)
IPAddressFactory(
base_object=cls.dc_asset,
ethernet=EthernetFactory(base_object=cls.dc_asset),
is_management=True,
)
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_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_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 test_should_raise_validation_error_when_position_in_rack_is_incorrect(
self, position, rack_max_height
):
self.dc_asset.position = position
self.dc_asset.rack = RackFactory(max_u_height=rack_max_height)
with self.assertRaises(ValidationError):
self.dc_asset._validate_position_in_rack()
def setUpClass(cls):
super().setUpClass()
cls.conf_module1 = ConfigurationModuleFactory(name='abc')
cls.conf_module2 = ConfigurationModuleFactory(parent=cls.conf_module1)
cls.conf_class = ConfigurationClassFactory(module=cls.conf_module2)
cls.dca_1 = DataCenterAssetFactory(
invoice_date=datetime.date(2015, 1, 1),
barcode='barcode_one',
status=DataCenterAssetStatus.new,
)
cls.dca_1.tags.add('tag_1')
cls.dca_2 = DataCenterAssetFactory(
invoice_date=datetime.date(2015, 2, 1),
barcode='barcode_two',
status=DataCenterAssetStatus.liquidated,
)
cls.dca_2.management_ip = '10.20.30.40'
cls.dca_2.tags.add('tag_1')
cls.dca_3 = DataCenterAssetFactory(
invoice_date=datetime.date(2015, 3, 1),
force_depreciation=True,
status=DataCenterAssetStatus.used,
)
cls.dca_3.tags.add('tag1')
cls.dca_3.tags.add('tag2')
cls.dca_4 = DataCenterAssetFactory(
invoice_date=datetime.date(2014, 3, 1),
rack=RackFactory(),
configuration_path=cls.conf_class,
)
cls.dca_4.tags.add('tag1')
cls.support_1 = SupportFactory(price=10)
cls.support_2 = SupportFactory(price=100)
def setUpClass(cls):
super().setUpClass()
cls.hypervisor = DataCenterAssetFactory()
cls.rack = RackFactory()
cls.net_env = NetworkEnvironmentFactory(
hostname_template_prefix='server_1',
hostname_template_postfix='.mydc.net',
hostname_template_counter_length=5,
)
cls.net_env_2 = NetworkEnvironmentFactory(
hostname_template_prefix='server_2',
hostname_template_postfix='.mydc2.net',
hostname_template_counter_length=5,
)
cls.net_env_3 = NetworkEnvironmentFactory(
hostname_template_prefix='server_3',
hostname_template_postfix='.mydc3.net',
hostname_template_counter_length=5,
)
cls.net = NetworkFactory(
network_environment=cls.net_env,
address='10.20.30.0/24',
# reserve 10.20.30.1, 10.20.30.2, 10.20.30.3, 10.20.30.4, 10.20.30.5
reserved_from_beginning=5)
cls.net_2 = NetworkFactory(
network_environment=cls.net_env_2,
address='11.20.30.0/24',
)
cls.net.racks.add(cls.rack)
cls.net_2.racks.add(cls.rack)
def test_update_rack_when_parent_rack_is_change(self):
rack_1, rack_2 = RackFactory.create_batch(2)
parent_asset = DataCenterAssetFactory(
rack=rack_1, model=DataCenterAssetModelFactory(has_parent=True))
dc_asset = DataCenterAssetFactory(parent=parent_asset)
parent_asset.rack = rack_2
parent_asset.save()
dc_asset.refresh_from_db()
self.assertEqual(dc_asset.rack_id, rack_2.id)
def test_update_position_when_parent_position_is_change(self):
rack = RackFactory()
parent_asset = DataCenterAssetFactory(
rack=rack,
position=1,
model=DataCenterAssetModelFactory(has_parent=True))
dc_asset = DataCenterAssetFactory(parent=parent_asset, position=2)
parent_asset.position = 4
parent_asset.save()
dc_asset.refresh_from_db()
self.assertEqual(dc_asset.position, 4)
def setUp(self):
self.rack = RackFactory()
self.asset = DataCenterAssetFactory(rack=self.rack,
position=randint(0, 100))
self.ethernets = EthernetFactory.create_batch(2,
base_object=self.asset)
self.ip = IPAddressFactory(base_object=self.asset,
is_management=False,
ethernet=self.ethernets[0])
self.management = IPAddressFactory(base_object=self.asset,
is_management=True,
ethernet=self.ethernets[1])
def _prepare_rack(self):
self.rack = RackFactory()
self.net_env = NetworkEnvironmentFactory(
hostname_template_prefix='server_1',
hostname_template_postfix='.mydc.net',
)
self.net = NetworkFactory(
network_environment=self.net_env,
address='10.20.30.0/24',
)
self.net.racks.add(self.rack)
return self.net_env
def _generate_rack_with_networks(self, num_networks=5):
nets = [
NetworkFactory(address='10.0.{}.0/24'.format(i))
for i in range(num_networks)
]
rack = RackFactory()
for net in nets:
rack.network_set.add(net)
return rack, nets
def test_should_return_only_common_networks(self):
rack100 = RackFactory()
rack101 = RackFactory()
rack_100_net = NetworkFactory(address='10.0.100.0/24')
rack_101_net = NetworkFactory(address='10.0.101.0/24')
common_net = NetworkFactory(address='10.0.0.0/24')
rack_100_net.racks = [rack100]
rack_101_net.racks = [rack101]
common_net.racks = [rack100, rack101]
self.dc_asset_2.rack = rack100
self.dc_asset_3.rack = rack101
rack_100_result = assign_additional_hostname_choices(
None, [self.dc_asset_2])
common_result = assign_additional_hostname_choices(
None, [self.dc_asset_2, self.dc_asset_3])
expected_rack100_result = [(str(rack_100_net.pk), rack_100_net),
(str(common_net.pk), common_net)]
expected_common_result = [(str(common_net.pk), common_net)]
self.assertEqual(rack_100_result, expected_rack100_result)
self.assertEqual(len(rack_100_result), 2)
self.assertEqual(common_result, expected_common_result)
self.assertEqual(len(common_result), 1)
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):
self.user = get_user_model().objects.create_superuser(
username='******', password='******', email='*****@*****.**')
result = self.client.login(username='******', password='******')
self.assertEqual(result, True)
self.factory = RequestFactory()
self.dca = DataCenterAssetFactory(hostname='ralph1.allegro.pl',
rack=RackFactory(),
position=1)
self.custom_fields_inline_prefix = 'custom_fields-customfieldvalue-content_type-object_id-' # noqa
self.custom_field_str = CustomField.objects.create(
name='test_str', type=CustomFieldTypes.STRING, default_value='xyz')
self.custom_field_choices = CustomField.objects.create(
name='test_choice',
type=CustomFieldTypes.CHOICE,
choices='qwerty|asdfgh|zxcvbn',
default_value='zxcvbn',
use_as_configuration_variable=True,
)
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 _prepare_rack(self, dc_asset, address, network_address, rack=None):
self.rack = rack or RackFactory()
self.net_env = NetworkEnvironmentFactory(
hostname_template_prefix='server_1',
hostname_template_postfix='.mydc.net',
)
self.net_env2 = NetworkEnvironmentFactory(
hostname_template_prefix='server_2',
hostname_template_postfix='.mydc.net',
)
self.net = NetworkFactory(
network_environment=self.net_env,
address=network_address,
)
self.net2 = NetworkFactory(
network_environment=self.net_env2,
address='10.20.30.0/24',
)
self.net.racks.add(self.rack)
self.net2.racks.add(self.rack)
dc_asset.rack = self.rack
dc_asset.save()
IPAddressFactory(ethernet__base_object=self.dc_asset, address=address)
def test_change_rack_in_descendants(self):
self.dc_asset.rack = RackFactory()
self.dc_asset.save()
asset = DataCenterAsset.objects.get(pk=self.dc_asset_2.pk)
self.assertEquals(self.dc_asset.rack_id, asset.rack_id)
def test_should_pass_when_position_is_passed_and_rack_requires_it(self):
self.dc_asset.position = 10
self.dc_asset.rack = RackFactory(require_position=True)
self.dc_asset._validate_position()
def test_should_pass_when_position_is_not_passed_and_rack_doesnt_require_it(
self): # noqa
self.dc_asset.position = None
self.dc_asset.rack = RackFactory(require_position=False)
self.dc_asset._validate_position()
def test_should_raise_validation_error_when_position_is_not_passed_and_rack_requires_it(
self): # noqa
self.dc_asset.position = None
self.dc_asset.rack = RackFactory(require_position=True)
with self.assertRaises(ValidationError):
self.dc_asset._validate_position()
def setUpClass(cls):
from ralph.data_center.tests.factories import (
ClusterFactory,
DataCenterAssetFactory,
RackFactory,
)
super().setUpClass()
cls.dc_asset = DataCenterAssetFactory(
hostname='ralph0.allegro.pl',
service_env__service__name='service',
service_env__environment__name='test',
model__name='DL360',
model__manufacturer__name='Asus',
model__category__name='ATS',
rack=RackFactory(
name='Rack #100',
server_room__name='Server Room A',
server_room__data_center__name='DC1',
),
position=1,
slot_no='1',
configuration_path__class_name='www',
configuration_path__module__name='ralph',
)
cls.dc_ip = IPAddressFactory(
base_object=cls.dc_asset,
ethernet=EthernetFactory(base_object=cls.dc_asset),
)
IPAddressFactory(
base_object=cls.dc_asset,
ethernet=EthernetFactory(base_object=cls.dc_asset),
is_management=True,
)
cls.virtual_server = VirtualServerFactory(
hostname='s000.local',
configuration_path=ConfigurationClassFactory(
class_name='worker',
module__name='auth'
),
service_env__service__name='service',
service_env__environment__name='prod',
type__name='Xen',
parent=DataCenterAssetFactory(
hostname='parent',
model__name='DL380p',
model__manufacturer__name='Brother',
model__category__name='Database Machine',
rack=RackFactory(
name='Rack #101',
server_room__name='Server Room B',
server_room__data_center__name='DC2',
),
position=1,
slot_no='1',
),
)
# refresh virtual server to get parent as BaseObject, not
# DataCenterAsset
cls.vs_ip = IPAddressFactory(
base_object=cls.virtual_server,
ethernet=EthernetFactory(base_object=cls.virtual_server),
)
cls.virtual_server = VirtualServer.objects.get(
pk=cls.virtual_server.id
)
cluster = ClusterFactory(
hostname='',
type__name='Application',
configuration_path__class_name='www',
configuration_path__module__name='ralph',
service_env__service__name='service',
service_env__environment__name='preprod',
)
cls.boc_1 = BaseObjectCluster.objects.create(
cluster=cluster,
base_object=DataCenterAssetFactory(
rack=RackFactory(), position=1,
)
)
cls.boc_2 = BaseObjectCluster.objects.create(
cluster=cluster,
base_object=DataCenterAssetFactory(
rack=RackFactory(
server_room__data_center__name='DC2',
server_room__name='Server Room B',
name='Rack #101',
),
position=1,
),
is_master=True
)
cls.cluster = ClusterFactory._meta.model.objects.get(pk=cluster)
cls.cluster_ip = IPAddressFactory(
base_object=cls.cluster,
ethernet=EthernetFactory(base_object=cls.cluster),
)
def test_get_free_u_in_empty_rack_should_return_max_u_height(self):
rack = RackFactory()
self.assertEqual(rack.get_free_u(), rack.max_u_height)