def generate_licence(self):
self.stdout.write('Generating Licences')
for i in range(self.object_limit):
licence = LicenceFactory()
LicenceUser.objects.create(
licence=licence,
user=self.get_user()
)
for j in range(3):
back_office_asset = BaseObjectLicenceFactory(
licence=licence
).base_object
back_office_asset.owner = self.get_user()
back_office_asset.user = self.get_user()
back_office_asset.save()
licence = LicenceFactory()
LicenceUser.objects.create(
licence=licence,
user=self.get_user()
)
for j in range(3):
DataCenterAssetLicenceFactory(
licence=licence
)
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.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): # 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)
def setUp(self):
self.licence = LicenceFactory()
DataCenterAssetLicenceFactory.create_batch(3, licence=self.licence)
self.base_objects_ids = [
bo.pk for bo in self.licence.base_objects.all()
]
self.widget = ManyToManyThroughWidget(model=BaseObjectLicence,
related_model=BaseObject,
through_field='base_object')
def test_invalid_hypervisor_type(self):
form_data = self._get_basic_form_data()
for obj in (BaseObjectFactory(), ServiceEnvironmentFactory(),
VirtualServerFactory(), LicenceFactory()):
form_data['parent'] = obj.pk
response = self.client.post(self.url, form_data)
self.assertTrue(response.context and response.context['errors'])
errors = response.context['form'].errors
self.assertEquals(response.status_code, 200, repr(errors))
self.assertIn('parent', errors.keys())
self.assertEquals(
errors['parent'],
["Hypervisor must be one of DataCenterAsset or CloudHost"])
def test_assign_many_licences(self):
asset = BackOfficeAssetFactory()
licences = [LicenceFactory() for i in range(2)]
self.assertFalse(asset.licences.all())
BackOfficeAsset.assign_licence(
instances=[asset], request=None, licences=licences,
)
self.assertCountEqual(
[base_obj_lic.licence.id for base_obj_lic in asset.licences.all()],
[licence.id for licence in licences],
)
def test_depreciation_rate_not_required(self):
self.assertTrue(self.login_as_user())
licence = LicenceFactory()
url = reverse(
'admin:licences_licence_change',
args=(licence.pk,)
)
resp = self.client.get(url, follow=True)
self.assertEqual(resp.status_code, 200)
form = resp.context['adminform'].form
self.assertIn('depreciation_rate', form.fields)
self.assertFalse(
form.fields['depreciation_rate'].required
)
def test_reversion_history_for_intermediary_model(self):
region_pl = RegionFactory()
bo_asset = BackOfficeAssetFactory(region=region_pl)
licence = LicenceFactory(region=region_pl)
url = reverse('baseobjectlicence-list')
response = self.client.post(url, data={
'base_object': bo_asset.id,
'licence': licence.id
})
base_object_licence = BaseObjectLicence.objects.get(
pk=response.data['id']
)
history = reversion.get_for_object(base_object_licence)
self.assertEqual(len(history), 1)
self.assertIn(
'"licence": {}'.format(licence.id), history[0].serialized_data
)
def setUp(self):
self.model = DataCenterAssetModelFactory(
category=CategoryFactory(name="Keyboard"),
type=ObjectModelType.data_center,
name='Keyboard1',
manufacturer=ManufacturerFactory(name='M1'))
self.dc_1 = DataCenterAssetFactory(
force_depreciation=False,
model=self.model,
)
self.dc_1.tags.add('tag1', 'tag2')
self.licence = LicenceFactory(
number_bought=1,
niw='N/A',
software__name='Project Info',
software__asset_type=ObjectModelType.data_center,
region__name='US',
)
BaseObjectLicence.objects.create(licence=self.licence,
base_object=self.dc_1.baseobject_ptr)
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):
super().setUp()
self.licence_1 = LicenceFactory(number_bought=3)
self.licence_2 = LicenceFactory(number_bought=1)
self.user_1 = UserFactory()
self.bo_asset = BackOfficeAssetFactory()
def setUp(self):
super().setUp()
self.region_pl = RegionFactory(name='pl')
self.region_de = RegionFactory(name='de')
self.licence_de = LicenceFactory(region=self.region_de)
self.bo_asset = BackOfficeAssetFactory(region=self.region_pl)
def _init(self, num=10):
self.licences = LicenceFactory.create_batch(num)
for licence in self.licences:
DataCenterAssetLicenceFactory.create_batch(3, licence=licence)
BackOfficeAssetLicenceFactory.create_batch(2, licence=licence)
LicenceUserFactory.create_batch(3, licence=licence)
