def test_if_mail_notification_is_send_when_dca_is_updated_through_gui( self): old_service = ServiceFactory(name='test') new_service = ServiceFactory(name='prod') old_service.business_owners.add(UserFactory(email='*****@*****.**')) new_service.business_owners.add(UserFactory(email='*****@*****.**')) old_service_env = ServiceEnvironmentFactory(service=old_service) new_service_env = ServiceEnvironmentFactory(service=new_service) # update without triggering signals DataCenterAsset.objects.filter(pk=self.dca.pk).update( service_env=old_service_env) data_custom_fields = { 'TOTAL_FORMS': 3, 'INITIAL_FORMS': 0, } self._update_dca(dca_data={'service_env': new_service_env.id}, inline_data=data_custom_fields) self.dca.refresh_from_db() self.assertEqual(len(mail.outbox), 1) self.assertEqual( 'Device has been assigned to Service: {} ({})'.format( new_service, self.dca), mail.outbox[0].subject) self.assertCountEqual(mail.outbox[0].to, ['*****@*****.**', '*****@*****.**'])
def test_filtering_queryset(self): DataCenterAssetFullFactory.create_batch( 2, service_env__service__name='ServiceA', ) DataCenterAssetFullFactory.create_batch( 1, service_env__service__name='ServiceB', ) DataCenterAssetFullFactory.create_batch( 3, service_env__service__name='ServiceC', ) ServiceEnvironmentFactory.create(service__name='ServiceD') graph = GraphFactory( aggregate_type=AggregateType.aggregate_count.id, params={ 'series': 'id', 'labels': 'service_env__service__name', }, ) dca_qs = DataCenterAsset.objects.all() filtered_qs = graph.get_queryset_for_filter( dca_qs, { 'service_env__service__name': 'ServiceA', }) self.assertEqual(filtered_qs.count(), 2) self.assertEqual( list( filtered_qs.values_list('service_env__service__name', flat=True)), ['ServiceA', 'ServiceA'])
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_filtering_queryset_with_additional_filters(self): service_env_a = ServiceEnvironmentFactory(service__name='ServiceA') DataCenterAssetFullFactory.create_batch(2, service_env=service_env_a, scmstatuscheck=None) DataCenterAssetFullFactory.create_batch( 3, service_env=service_env_a, scmstatuscheck__check_result=SCMCheckResult.scm_error) DataCenterAssetFullFactory.create_batch(4, service_env=service_env_a, scmstatuscheck__ok=True) DataCenterAssetFullFactory.create_batch( 1, service_env__service__name='ServiceB', ) DataCenterAssetFullFactory.create_batch( 3, service_env__service__name='ServiceC', ) ServiceEnvironmentFactory.create(service__name='ServiceD') graph = GraphFactory( aggregate_type=AggregateType.aggregate_sum_bool_negated_values.id, params={ 'series': 'id', 'labels': 'service__name', 'target': { 'model': 'DataCenterAsset', 'filter': 'service_env__service__name__in', 'value': 'service__name', 'additional_filters': { 'scmstatuscheck__ok': False }, } }, model=ContentType.objects.get_for_model(ServiceEnvironment), ) dca_qs = DataCenterAsset.objects.all() filtered_qs = graph.get_queryset_for_filter( dca_qs, {'service__name': 'ServiceA'}) self.assertEqual(filtered_qs.count(), 3) self.assertEqual( list( filtered_qs.values_list('service_env__service__name', 'scmstatuscheck__ok')), [('ServiceA', False)] * 3)
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_create_new_licence(self): service_env = ServiceEnvironmentFactory() data = { 'licence_type': self.licence.licence_type.id, 'software': self.licence.software.id, 'niw': '111', 'region': self.licence.region.id, 'price_0': 100, 'price_1': 'PLN', 'number_bought': 3, 'service_env': service_env.id, 'custom_fields-customfieldvalue-content_type-object_id-TOTAL_FORMS': 3, 'custom_fields-customfieldvalue-content_type-object_id-INITIAL_FORMS': 0, 'custom_fields-customfieldvalue-content_type-object_id-MIN_NUM_FORMS': 0, 'custom_fields-customfieldvalue-content_type-object_id-MAX_NUM_FORMS': 1000, } response = self.client.post( reverse('admin:licences_licence_add'), data=data, follow=True ) new_licence = Licence.objects.get(niw='111') self.assertEqual(response.status_code, 200) self.assertNotIn('errors', response.context_data) self.assertEqual(new_licence.licence_type, self.licence.licence_type) self.assertEqual(new_licence.software, self.licence.software) self.assertEqual(new_licence.region, self.licence.region) self.assertEqual(new_licence.price.amount, 100) self.assertEqual(new_licence.price.currency, PLN) self.assertEqual(new_licence.number_bought, 3) self.assertEqual(new_licence.service_env, service_env)
def test_create_with_valid_event_data(self): service_env = ServiceEnvironmentFactory() self.data['service']['uid'] = service_env.service.uid self.data['environment'] = service_env.environment.name self.assertEqual(VIP.objects.count(), 0) handle_create_vip_event(self.data) self.assertEqual(VIP.objects.count(), 1)
def setUp(self): super().setUp() self.cf = CustomField.objects.create( name='test_cf', use_as_configuration_variable=True) # is should be skipped in API self.bo_asset = BackOfficeAssetFactory(barcode='12345', hostname='host1') self.conf_module_1 = ConfigurationModuleFactory() self.conf_module_2 = ConfigurationModuleFactory( parent=self.conf_module_1, name='ralph') self.conf_class_1 = ConfigurationClassFactory( module=self.conf_module_2, class_name='cls1') self.dc_asset = DataCenterAssetFullFactory( service_env__service__name='test-service', service_env__service__uid='sc-123', service_env__environment__name='prod', configuration_path=self.conf_class_1, ) self.dc_asset.update_custom_field('test_cf', 'abc') self.virtual = VirtualServerFullFactory( parent=self.dc_asset, configuration_path__module__name='ralph2', service_env__service__uid='sc-222', service_env__environment__name='some_env', ) self.virtual.update_custom_field('test_cf', 'def') se = ServiceEnvironmentFactory(service__uid='sc-333') self.cloud_host = CloudHostFullFactory( configuration_path__module__name='ralph3', service_env=se, parent__service_env=se, hostname='aaaa', hypervisor=self.dc_asset) self.cloud_host.ip_addresses = ['10.20.30.40'] self.cloud_host.update_custom_field('test_cf', 'xyz')
def setUp(self): super().setUp() self.bo_asset = BackOfficeAssetFactory( barcode='12345', hostname='host1' ) self.bo_asset.tags.add('tag1') self.conf_module_1 = ConfigurationModuleFactory() self.conf_module_2 = ConfigurationModuleFactory( parent=self.conf_module_1, name='mod1' ) self.conf_class_1 = ConfigurationClassFactory( id=999999, module=self.conf_module_2, class_name='cls1' ) self.dc_asset = DataCenterAssetFactory( barcode='12543', price='9.00', service_env__service__name='test-service', service_env__service__uid='sc-123', service_env__environment__name='prod', configuration_path=self.conf_class_1, ) self.dc_asset.tags.add('tag2') self.ip = IPAddressFactory( ethernet=EthernetFactory(base_object=self.dc_asset) ) self.service = ServiceEnvironmentFactory(service__name='myservice')
def test_delete_service_when_service_assigned_to_object(self, mock_logger): service = ServiceFactory(active=True) service_env = ServiceEnvironmentFactory(service=service) DataCenterAssetFactory(service_env=service_env) data = { 'uid': service.uid, 'name': 'Service name', 'status': 'Inactive', 'isActive': False, 'environments': ['dev'], 'businessOwners': [{'username': '******'}], 'technicalOwners': [{'username': '******'}] } response = self._make_request( data, settings.HERMES_SERVICE_TOPICS['DELETE'] ) self.assertEqual(response.status_code, 204) mock_logger.error.assert_called_with( 'Can not delete service - it has assigned some base objects', extra={ 'action_type': ACTION_TYPE, 'service_uid': data['uid'], 'service_name': data['name'] } ) service.refresh_from_db() self.assertTrue(service.active)
def setUp(self): super().setUp() self.user1 = factories.UserFactory() self.user2 = factories.UserFactory() self.service_env = ServiceEnvironmentFactory() self.model = BackOfficeAssetModelFactory() self.warehouse = WarehouseFactory() self.warehouse.stocktaking_enabled = True self.warehouse.save() self.asset = BackOfficeAssetFactory( warehouse=self.warehouse, model=self.model, ) self.asset.user = self.user1 self.asset.save() self.base_tag = settings.INVENTORY_TAG if self.asset.warehouse.stocktaking_tag_suffix != '': self.base_tag = '{prefix}-{warehouse}'.format( prefix=self.base_tag, warehouse=self.asset.warehouse.stocktaking_tag_suffix, ) self.date_tag = None if settings.INVENTORY_TAG_APPEND_DATE: self.date_tag = '{base}_{date}'.format( base=self.base_tag, date=date.today().isoformat(), ) self.tags = [ self.base_tag, settings.INVENTORY_TAG_USER, self.date_tag, ]
def test_ratio_aggregation(self): service_env = ServiceEnvironmentFactory(service__name='sample-service') vulnerability = VulnerabilityFactory( patch_deadline=datetime.date(2015, 1, 1) ) for is_patched in [True, False]: for _ in range(3): dca = DataCenterAssetFactory(service_env=service_env) if is_patched: ss = SecurityScanFactory(vulnerabilities=[]) else: ss = SecurityScanFactory(vulnerabilities=[vulnerability]) dca.securityscan = ss ss.save() dca.save() graph = GraphFactory( aggregate_type=AggregateType.aggregate_ratio.id, params={ 'series': ['securityscan__is_patched', 'id'], 'labels': 'service_env__service__name', 'filters': { 'series__gt': 0, } } ) qs = graph.build_queryset() self.assertEqual(qs.get(), { 'series': 50, 'service_env__service__name': 'sample-service' })
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): super().setUp() self.service_env = ServiceEnvironmentFactory() self.model = BackOfficeAssetModelFactory() self.warehouse = WarehouseFactory() self.bo_asset = BackOfficeAssetFactory( warehouse=self.warehouse, model=self.model, ) self.bo_asset.user = self.user1 self.bo_asset.owner = self.user2 self.bo_asset.save()
def test_if_notification_is_send_when_data_center_asset_is_saved(self): old_service = ServiceFactory(name='test') new_service = ServiceFactory(name='prod') old_service.business_owners.add(UserFactory(email='*****@*****.**')) new_service.business_owners.add(UserFactory(email='*****@*****.**')) self.dca = DataCenterAssetFactory( service_env=ServiceEnvironmentFactory(service=old_service)) # fetch DCA to start with clean state in post_commit signals # (ex. invalidate call to notification handler during creating of DCA) self.dca = DataCenterAsset.objects.get(pk=self.dca.pk) self.dca.service_env = ServiceEnvironmentFactory(service=new_service) with transaction.atomic(): self.dca.save() self.assertEqual(len(mail.outbox), 1) self.assertEqual( 'Device has been assigned to Service: {} ({})'.format( new_service, self.dca), mail.outbox[0].subject) self.assertCountEqual(mail.outbox[0].to, ['*****@*****.**', '*****@*****.**'])
def setUp(self): super().setUp() self.licence1, self.licence2 = LicenceFactory.create_batch(2) region_pl = RegionFactory(name='pl') self.licence3 = LicenceFactory(region=region_pl) self.base_object = BackOfficeAssetFactory() self.base_object2 = BackOfficeAssetFactory(region=region_pl) LicenceUser.objects.create(licence=self.licence1, user=self.user1) BaseObjectLicence.objects.create(licence=self.licence2, base_object=self.base_object) self.service_env = ServiceEnvironmentFactory() self.licence4 = LicenceFactory(service_env=self.service_env)
def test_update_change_service_env(self): vip = VIPFactory() self.data['ip'] = vip.ip.address self.data['port'] = vip.port self.data['protocol'] = VIPProtocol.from_id(vip.protocol).name service_env = ServiceEnvironmentFactory() self.data['service']['uid'] = service_env.service.uid self.data['environment'] = service_env.environment.name vips = VIP.objects.all() self.assertEqual(vips.count(), 1) handle_update_vip_event(self.data) vips = VIP.objects.all() self.assertEqual(vips.count(), 1) self.assertEqual(vips[0].service_env, service_env)
def setUp(self): super().setUp() self.cluster_type = ClusterTypeFactory() self.service_env = ServiceEnvironmentFactory() self.cluster_1 = ClusterFactory() self.boc_1 = BaseObjectCluster.objects.create( cluster=self.cluster_1, base_object=DataCenterAssetFactory() ) self.master = DataCenterAssetFactory() self.boc_2 = BaseObjectCluster.objects.create( cluster=self.cluster_1, base_object=self.master, is_master=True ) self.cluster_2 = ClusterFactory() self.cluster_1.service_env.service.business_owners = [self.user1] self.cluster_1.service_env.service.technical_owners = [self.user2] self.cluster_1.service_env.save() self.cluster_1.management_ip = '10.20.30.40'
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 test_update_service_when_service_exist(self): service = ServiceFactory( business_segment__name='existing area', profit_center__name='existing PC', ) service.business_owners.add(UserFactory(username='******')) service.technical_owners.add(UserFactory(username='******')) ServiceEnvironmentFactory( service=service, environment__name='prod' ) data = { 'uid': service.uid, 'name': 'New name', 'status': 'Active', 'isActive': True, 'environments': ['dev'], 'businessOwners': [{'username': '******'}], 'technicalOwners': [{'username': '******'}], 'area': {'name': 'new area', 'profitCenter': 'new-PC'}, } response = self._make_request( data, settings.HERMES_SERVICE_TOPICS['UPDATE'] ) self.assertEqual(response.status_code, 204) service.refresh_from_db() self.assertEqual(service.name, 'New name') self.assertEqual(service.business_segment.name, 'new area') self.assertEqual(service.profit_center.name, 'new-PC') self.assertCountEqual( ['dev'], [env.name for env in service.environments.all()] ) self.assertCountEqual( ['business_user3'], [user.username for user in service.business_owners.all()] ) self.assertCountEqual( ['technical_user3'], [user.username for user in service.technical_owners.all()] )
def test_autocomplete_service_env_should_return_pk(self): asset = DataCenterAssetFactory(service_env=ServiceEnvironmentFactory()) self.assertEqual(asset.service_env.pk, autocomplete_service_env([], [asset]))
def setUp(self): super().setUp() self.service_env = ServiceEnvironmentFactory() self.support = SupportFactory(name='support1', service_env=self.service_env)
def test_if_host_update_is_published_to_hermes_when_dca_is_updated_through_gui( # noqa: E501 self, publish_mock): self.cfv1 = CustomFieldValue.objects.create( object=self.dca, custom_field=self.custom_field_str, value='sample_value', ) new_service = ServiceFactory(name='service1', uid='sc-44444') new_service_env = ServiceEnvironmentFactory(service=new_service, environment__name='dev') data_custom_fields = { 'TOTAL_FORMS': 3, 'INITIAL_FORMS': 1, '0-id': self.cfv1.id, '0-custom_field': self.custom_field_str.id, '0-value': 'sample_value22', '1-id': '', '1-custom_field': self.custom_field_choices.id, '1-value': 'qwerty', } with transaction.atomic(): self._update_dca(dca_data={ 'service_env': new_service_env.id, 'hostname': 'my-host.mydc.net', }, inline_data=data_custom_fields) # DCA is saved twice self.assertGreater(len(connection.run_on_commit), 0) self.dca.refresh_from_db() publish_data = publish_mock.call_args[0][1] publish_data.pop('modified') publish_data.pop('created') self.assertEqual( publish_data, { '__str__': 'data center asset: ' + str(self.dca), 'configuration_path': None, 'configuration_variables': { 'test_choice': 'qwerty', }, 'custom_fields': { 'test_str': 'sample_value22', 'test_choice': 'qwerty' }, 'ethernet': [], 'hostname': 'my-host.mydc.net', 'id': self.dca.id, 'ipaddresses': [], 'object_type': 'datacenterasset', 'parent': None, 'remarks': '', 'service_env': { 'id': new_service_env.id, 'service': 'service1', 'environment': 'dev', 'service_uid': 'sc-44444', 'ui_url': '' }, 'tags': [], 'securityscan': None, '_previous_state': { 'hostname': 'ralph1.allegro.pl' }, }) # Despite `save` is called twice, publish update data is called only # once self.assertEqual(publish_mock.call_count, 1) # check if on_commit callbacks are removed from current db connections self.assertEqual(connection.run_on_commit, [])