def test_send_attachments_to_user_action_sends_email(self, mock_get_hook):
mock_get_hook.return_value = lambda transition_name: EmailContext(
from_email="*****@*****.**", subject="sub", body="bod")
bo_asset = BackOfficeAssetFactory(model=self.model)
_, transition, _ = self._create_transition(
model=bo_asset,
name='transition name',
source=[BackOfficeAssetStatus.new.id],
target=BackOfficeAssetStatus.used.id,
actions=['return_report'])
attachment = Attachment.objects.create(
file=SimpleUploadedFile('test_file.pdf',
b'some content',
content_type='application/pdf'),
uploaded_by=self.user_pl,
)
bo_asset.send_attachments_to_user(self.user_pl,
transition.id,
attachments=[attachment])
mock_get_hook.assert_called_once_with(
'back_office.transition_action.email_context')
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].from_email, "*****@*****.**")
def generate_back_office(self):
self.stdout.write('Generating Back Office assets')
back_office_status = BackOfficeAssetStatus()
status_count = len(back_office_status)
per_page = self.object_limit / status_count
parent_category = CategoryFactory(name='BACK OFFICE',
imei_required=False)
for i in range(3):
ProfitCenterFactory()
for status_id, name in back_office_status:
for i in range(int(per_page)):
BackOfficeAssetFactory(
status=status_id,
user=self.get_user(),
owner=self.get_user(),
model=BackOfficeAssetModelFactory(category=CategoryFactory(
parent=parent_category)))
BackOfficeAssetFactory(status=status_id,
user=self.get_user(),
owner=self.get_user(),
model=BackOfficeAssetModelFactory(
category=CategoryFactory(
name='Mobile Phone',
imei_required=True,
parent=parent_category),
name='Phone'),
imei=get_imei(15))
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_assign_hostname_assigns_hostname_when_its_empty(self):
hostname = ''
self.bo_asset = BackOfficeAssetFactory(
model=self.model,
hostname=hostname,
region=self.region_us,
)
_, transition, _ = self._create_transition(
model=self.bo_asset,
name='assign_hostname_if_empty_or_country_not_match',
source=[BackOfficeAssetStatus.new.id],
target=BackOfficeAssetStatus.used.id,
actions=['assign_hostname_if_empty_or_country_not_match']
)
self.assertEquals(self.bo_asset.hostname, hostname)
run_field_transition(
[self.bo_asset],
field='status',
transition_obj_or_name=transition,
data={},
requester=self.request.user
)
self.assertNotEquals(self.bo_asset.hostname, hostname)
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 setUp(self):
super().setUp()
self.asset = BackOfficeAssetFactory()
self.user = UserFactory()
self.user.is_superuser = False
self.user.is_staff = True
self.passwd = 'ralph'
self.user.set_password(self.passwd)
# Grant all permissions to the user
permissions = Permission.objects.exclude(
codename__in=[
'view_backofficeasset_hostname_field',
'view_backofficeasset_service_env_field',
'change_backofficeasset_hostname_field',
'change_backofficeasset_service_env_field',
]
).all()
self.user.user_permissions.add(*permissions)
self.user.regions.add(self.asset.region)
self.user.save()
self.login_as_user(user=self.user, password=self.passwd)
self.data = {
'hostname': self.asset.hostname,
'model': self.asset.model.pk,
'status': self.asset.status,
'warehouse': self.asset.warehouse.pk,
'region': self.asset.region.pk,
'barcode': self.asset.barcode,
'depreciation_rate': 0,
'custom_fields-customfieldvalue-content_type-object_id-INITIAL_FORMS': '0', # noqa: E501
'custom_fields-customfieldvalue-content_type-object_id-MAX_NUM_FORMS': '1000', # noqa: E501
'custom_fields-customfieldvalue-content_type-object_id-MIN_NUM_FORMS': '0', # noqa: E501
'custom_fields-customfieldvalue-content_type-object_id-TOTAL_FORMS': '3', # noqa: E501fhtml
}
def test_assign_hostname_skips_hostname_when_its_already_set(self):
# hostname must include country-code to be skipped during assigning
hostname = 'the-same-hostname-across-transitions-{}'.format('USA')
self.bo_asset = BackOfficeAssetFactory(
model=self.model,
hostname=hostname,
region=self.region_us,
)
_, transition, _ = self._create_transition(
model=self.bo_asset,
name='assign_hostname_if_empty_or_country_not_match',
source=[BackOfficeAssetStatus.new.id],
target=BackOfficeAssetStatus.used.id,
actions=['assign_hostname_if_empty_or_country_not_match']
)
self.assertEquals(self.bo_asset.hostname, hostname)
run_field_transition(
[self.bo_asset],
field='status',
transition_obj_or_name=transition,
data={},
requester=self.request.user
)
self.assertEquals(self.bo_asset.hostname, hostname)
def setUp(self): # noqa
super().setUp()
self.login_as_user()
region_pl = RegionFactory(name='pl')
region_de = RegionFactory(name='de')
self.licence = LicenceFactory(region=region_pl)
self.bo_1 = BackOfficeAssetFactory(region=region_pl)
self.bo_2 = BackOfficeAssetFactory(region=region_de)
class StockTakingTests(TestCase, ClientMixin):
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_tag_asset(self):
self.assertTrue(self.login_as_user(self.user1))
response = self.client.post(reverse('inventory_tag'), {
'asset_id': self.asset.id,
'confirm_button': 'Yes',
'answer': 'yes'
},
follow=True)
self.assertEquals(response.status_code, 200)
for t in self.tags:
self.assertIn(t, self.asset.tags.names())
def test_ownership_verification(self):
self.assertTrue(self.login_as_user(self.user2))
response = self.client.post(reverse('inventory_tag'), {
'asset_id': self.asset.id,
'confirm_button': 'Yes',
'answer': 'yes'
},
follow=True)
self.assertEquals(response.status_code, 403)
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
)
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_send_attachments_to_user_action_dont_send_email_without_attachments(
self): # noqa: E501
bo_asset = BackOfficeAssetFactory(model=self.model)
_, transition, _ = self._create_transition(
model=self.bo_asset,
name='transition name',
source=[BackOfficeAssetStatus.new.id],
target=BackOfficeAssetStatus.used.id,
actions=['return_report'])
bo_asset.send_attachments_to_user(self.user_pl, transition.id)
self.assertEqual(len(mail.outbox), 0)
def test_generate_next_hostname_out_of_range(self):
category = CategoryFactory(code='PC')
model = BackOfficeAssetModelFactory(category=category)
asset = BackOfficeAssetFactory(model=model,
region=self.region_pl,
hostname='')
AssetLastHostname.objects.create(prefix='POLPC', counter=99999)
template_vars = {
'code': asset.model.category.code,
'country_code': asset.country_code,
}
asset.generate_hostname(template_vars=template_vars)
self.assertEqual(asset.hostname, 'POLPC100000')
def test_generate_first_hostname(self):
"""Scenario:
- none of assets has hostname
- after generate first of asset have XXXYY00001 in hostname field
"""
category = CategoryFactory(code='PC')
model = BackOfficeAssetModelFactory(category=category)
asset = BackOfficeAssetFactory(model=model, hostname='')
template_vars = {
'code': asset.model.category.code,
'country_code': asset.country_code,
}
asset.generate_hostname(template_vars=template_vars)
self.assertEqual(asset.hostname, 'POLPC00001')
def setUp(self):
super().setUp()
AssetLastHostname.objects.create(prefix='POLPC', counter=1000)
self.bo_asset = BackOfficeAssetFactory(
model=self.model,
hostname='abc',
region=self.region_us,
)
self.bo_asset._try_assign_hostname(commit=True, force=True)
self.request = RequestFactory().get('/assets/')
self.request.user = self.user_pl
# ugly hack from https://code.djangoproject.com/ticket/17971
setattr(self.request, 'session', 'session')
messages = FallbackStorage(self.request)
setattr(self.request, '_messages', messages)
def setUp(self):
self.dc_1 = DataCenterAssetFactory()
self.dc_2 = DataCenterAssetFactory()
self.bo_1 = BackOfficeAssetFactory()
self.bo_2 = BackOfficeAssetFactory()
self.support = SupportFactory()
for obj in [self.dc_1, self.dc_2, self.bo_1, self.bo_2]:
BaseObjectsSupport.objects.create(support=self.support,
baseobject=obj)
user = UserFactory()
self.attachment = Attachment.objects.create_from_file_path(
__file__, user)
self.attachment_item = AttachmentItem.objects.attach(
self.support.pk, get_content_type_for_model(self.support),
[self.attachment])
def test_generate_next_hostname(self):
category = CategoryFactory(code='PC')
model = BackOfficeAssetModelFactory(category=category)
asset = BackOfficeAssetFactory(model=model,
region=self.region_pl,
hostname='')
BackOfficeAssetFactory(region=self.region_pl, hostname='POLSW00003')
AssetLastHostname.increment_hostname(prefix='POLPC')
AssetLastHostname.increment_hostname(prefix='POLPC')
template_vars = {
'code': asset.model.category.code,
'country_code': asset.country_code,
}
asset.generate_hostname(template_vars=template_vars)
self.assertEqual(asset.hostname, 'POLPC00003')
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 setUp(self):
super().setUp()
self.bo_asset = BackOfficeAssetFactory(barcode='12345',
hostname='host1')
self.bo_asset.tags.add('tag1')
self.dc_asset = DataCenterAssetFactory(barcode='12543', price='10.00')
self.dc_asset.tags.add('tag2')
def setUp(self):
super().setUp()
self.warehouse_1 = WarehouseFactory(name='api_test')
self.user = UserFactory()
self.officeinfrastructure = OfficeInfrastructureFactory()
self.bo = BackOfficeAssetFactory(status=BackOfficeAssetStatus.new,
user=UserFactory(),
owner=UserFactory())
self.licence_1 = LicenceFactory()
self.licence_2 = LicenceFactory()
actions = [
'assign_user', 'assign_licence', 'assign_owner',
'assign_loan_end_date', 'assign_warehouse',
'assign_office_infrastructure', 'add_remarks', 'assign_task_url',
'change_hostname'
]
self.transition_1 = self._create_transition(
BackOfficeAsset, 'BackOffice', actions, 'status',
[BackOfficeAssetStatus.new.id],
BackOfficeAssetStatus.in_progress.id)[1]
self.transition_2 = self._create_transition(
BackOfficeAsset,
'BackOffice_Async',
actions,
'status', [BackOfficeAssetStatus.new.id],
BackOfficeAssetStatus.in_progress.id,
run_asynchronously=True)[1]
self.superuser = get_user_model().objects.create_superuser(
'test', '*****@*****.**', 'test')
self.api_client = APIClient()
self.api_client.login(username='******', password='******')
self.client = Client()
self.client.login(username='******', password='******')
def setUpClass(cls):
super().setUpClass()
cls.back_office_assets = BackOfficeAssetFactory.create_batch(4)
cls.users = [UserFactory() for i in range(4)]
cls.delete_users = UserFactory.create_batch(2)
cls.licence = LicenceFactory()
cls.licence2 = LicenceFactory()
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 test_validate_imei(self):
bo_asset_failed = BackOfficeAssetFactory(imei='failed', imei2='failed')
bo_asset = BackOfficeAssetFactory(imei='990000862471854',
imei2='990000862471854')
self.assertFalse(bo_asset_failed.validate_imei(bo_asset_failed.imei))
self.assertTrue(bo_asset.validate_imei(bo_asset.imei))
self.assertFalse(bo_asset_failed.validate_imei(bo_asset_failed.imei2))
self.assertTrue(bo_asset.validate_imei(bo_asset.imei2))
def test_should_not_publish_host_update_event_when_not_dc_host(self):
bo_asset = BackOfficeAssetFactory()
cfv = CustomFieldValue.objects.create(
object=bo_asset,
custom_field=self.custom_field_str,
value='sample_value')
with patch('ralph.assets.signals.publish_host_update') as mock:
custom_field_change(sender=bo_asset.__class__, instance=cfv)
self.assertFalse(mock.called)
def setUp(self):
super().setUp()
AssetLastHostname.objects.create(prefix='POLPC', counter=1000)
self.bo_asset = BackOfficeAssetFactory(
model=self.model,
hostname='abc',
region=self.region_pl,
)
self.bo_asset_2 = BackOfficeAssetFactory(
model=self.model,
hostname='abc2',
region=self.region_pl,
status=BackOfficeAssetStatus.liquidated.id,
invoice_date=None
)
self.bo_asset_3 = BackOfficeAssetFactory(
model=self.model,
hostname='abc3',
region=self.region_pl,
status=BackOfficeAssetStatus.liquidated.id,
invoice_date=datetime(2016, 1, 11).date(),
depreciation_rate=50
)
self.bo_asset_4 = BackOfficeAssetFactory(
model=self.model,
hostname='abc3',
region=self.region_pl,
status=BackOfficeAssetStatus.liquidated.id,
invoice_date=datetime(2016, 1, 11).date(),
depreciation_end_date=datetime(2015, 1, 11).date(),
depreciation_rate=50
)
self.category_parent = CategoryFactory(
code='Mob1', default_depreciation_rate=30
)
self.category_2 = CategoryFactory(
code='Mob2', default_depreciation_rate=25
)
self.category_3 = CategoryFactory(
code='Mob3', parent=self.category_parent,
default_depreciation_rate=0
)
def test_get_user_details(self):
region = Region.objects.create(name='EU')
self.user1.regions.add(region)
bo_asset_as_user = BackOfficeAssetFactory(user=self.user1)
bo_asset_as_owner = BackOfficeAssetFactory(owner=self.user1)
licence = LicenceFactory()
LicenceUser.objects.create(licence=licence, user=self.user1)
url = reverse('ralphuser-detail', args=(self.user1.id, ))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['username'], self.user1.username)
self.assertEqual(response.data['first_name'], self.user1.first_name)
self.assertEqual(response.data['last_name'], self.user1.last_name)
self.assertEqual(response.data['regions'][0]['id'], region.id)
self.assertEqual(response.data['assets_as_owner'][0]['id'],
bo_asset_as_owner.id)
self.assertEqual(response.data['assets_as_user'][0]['id'],
bo_asset_as_user.id)
self.assertEqual(response.data['licences'][0]['licence']['id'],
licence.id)
def setUp(self): # noqa
super().setUp()
self.login_as_user()
self.bo_admin = BackOfficeAssetAdmin(
model=BackOfficeAsset,
admin_site=ralph_site
)
self.dc_admin = BackOfficeAssetAdmin(
model=DataCenterAsset,
admin_site=ralph_site
)
self.bo_1 = BackOfficeAssetFactory()
self.dc_1 = DataCenterAssetFactory(sn='12345')
def test_bo_admin_form_with_readonly_hostname(self):
self.assertTrue(self.login_as_user())
asset = BackOfficeAssetFactory()
url = reverse('admin:back_office_backofficeasset_change',
args=(asset.pk, ))
resp = self.client.get(url, follow=True)
self.assertEqual(resp.status_code, 200)
self.assertIn('hostname', resp.context['adminform'].form.fields)
self.assertTrue(
resp.context['adminform'].form.fields['hostname'].widget.attrs.get(
'readonly'))
