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)