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, [])
