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'))