def setUp(self):
self.system_volume_snapshot_id = '350b81e1-f991-401c-99b1-ebccc5a517a6'
self.data_volume_snapshot_id = 'dba9b361-277c-46b2-99ca-1136b3eba6ed'
self.template = factories.TemplateFactory()
factories.TemplateLicenseFactory(templates=(self.template, ))
self.instance = factories.InstanceFactory(template=self.template)
self.backup = backup_factories.BackupFactory(
backup_source=self.instance,
metadata={
'system_snapshot_id': self.system_volume_snapshot_id,
'data_snapshot_id': self.data_volume_snapshot_id,
})
self.flavor = factories.FlavorFactory(
cloud=self.backup.backup_source.cloud_project_membership.cloud)
self.user_input = {
'name': 'new_name',
'flavor': factories.FlavorFactory.get_url(self.flavor),
}
self.metadata = InstanceBackupStrategy._get_instance_metadata(
self.instance)
self.metadata['system_snapshot_id'] = self.system_volume_snapshot_id
self.metadata['data_snapshot_id'] = self.data_volume_snapshot_id
self.agreed_sla = Decimal('99.9')
self.metadata['agreed_sla'] = self.agreed_sla
self.mocked_backed = Mock()
InstanceBackupStrategy._get_backend = Mock(
return_value=self.mocked_backed)
self.mocked_backed.create_snapshots = Mock(return_value=(
[self.system_volume_snapshot_id, self.data_volume_snapshot_id]))
self.mocked_backed.promote_snapshots_to_volumes = Mock(return_value=(
[self.system_volume_snapshot_id, self.data_volume_snapshot_id]))
def setUp(self):
# project, customer and project_group
self.customer = structure_factories.CustomerFactory()
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project_group = structure_factories.ProjectGroupFactory()
self.project_group.projects.add(self.project)
# cloud and template
self.cloud = factories.CloudFactory(customer=self.customer)
factories.CloudProjectMembershipFactory(cloud=self.cloud,
project=self.project)
self.template = factories.TemplateFactory(os='OS')
factories.ImageFactory(cloud=self.cloud, template=self.template)
# license
self.license = factories.TemplateLicenseFactory()
self.license.templates.add(self.template)
# users
self.staff = structure_factories.UserFactory(is_superuser=True,
is_staff=True)
self.manager = structure_factories.UserFactory()
self.project.add_user(self.manager,
structure_models.ProjectRole.MANAGER)
self.group_manager = structure_factories.UserFactory()
self.project_group.add_user(self.group_manager,
structure_models.ProjectGroupRole.MANAGER)
def setUp(self):
# project, customer and project_group
self.customer = structure_factories.CustomerFactory()
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project_group = structure_factories.ProjectGroupFactory()
self.project_group.projects.add(self.project)
# cloud and template
self.cloud = factories.CloudFactory()
factories.CloudProjectMembershipFactory(cloud=self.cloud,
project=self.project)
template = factories.TemplateFactory()
factories.ImageFactory(cloud=self.cloud, template=template)
# license
self.license = factories.TemplateLicenseFactory()
self.license.templates.add(template)
# users
self.staff = structure_factories.UserFactory(username='******',
is_superuser=True,
is_staff=True)
self.manager = structure_factories.UserFactory(username='******')
self.project.add_user(self.manager,
structure_models.ProjectRole.MANAGER)
self.administrator = structure_factories.UserFactory(
username='******')
self.project.add_user(self.administrator,
structure_models.ProjectRole.ADMINISTRATOR)
self.owner = structure_factories.UserFactory(username='******')
self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER)
self.group_manager = structure_factories.UserFactory()
self.project_group = structure_factories.ProjectGroupFactory()
self.project_group.projects.add(self.project)
self.project_group.add_user(self.group_manager,
structure_models.ProjectGroupRole.MANAGER)
def test_licenses_stats_filtering_by_customer_with_instances(self):
self.client.force_authenticate(self.staff)
# other customer is connected with another template and has one instance connected to it
other_customer = structure_factories.CustomerFactory()
other_project = structure_factories.ProjectFactory(
customer=other_customer)
other_cloud = factories.CloudFactory(customer=other_customer)
other_template = factories.TemplateFactory()
factories.ImageFactory(cloud=other_cloud, template=self.template)
other_template_license = factories.TemplateLicenseFactory()
other_template.template_licenses.add(other_template_license)
factories.InstanceFactory(
template=other_template,
cloud_project_membership__project=other_project,
)
# when
response = self.client.get(self.url, {
'customer': other_customer.uuid,
'aggregate': 'project'
})
# then: response should return data for other_instance, but not first_instance and second_instance
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1,
"Response should contain data only for one project")
self.assertEqual(response.data[0]['project_uuid'],
other_project.uuid.hex)
self.assertEqual(
response.data[0]['count'], 1,
"Customer should have only one instance with one license")
def test_init_instance_licenses(self):
template = factories.TemplateFactory()
template_license = factories.TemplateLicenseFactory()
template.template_licenses.add(template_license)
instance = factories.InstanceFactory(template=template)
self.assertEqual(instance.instance_licenses.count(), 1)
instance_license = instance.instance_licenses.all()[0]
self.assertEqual(instance_license.template_license, template_license)
def setUp(self):
self.url = _template_license_stats_url()
self.customer = structure_factories.CustomerFactory()
# we have 2 projects groups:
self.first_group = structure_factories.ProjectGroupFactory(
customer=self.customer)
self.second_group = structure_factories.ProjectGroupFactory(
customer=self.customer)
# and 2 template licenses:
self.first_template_license = factories.TemplateLicenseFactory(
name='first_template_license', license_type='first license type')
self.second_template_license = factories.TemplateLicenseFactory(
name='second_template_license', license_type='second license type')
self.cloud = factories.CloudFactory(customer=self.customer)
self.template = factories.TemplateFactory()
factories.ImageFactory(cloud=self.cloud, template=self.template)
self.template.template_licenses.add(self.first_template_license)
self.template.template_licenses.add(self.second_template_license)
# every group has 1 projects:
self.first_project = structure_factories.ProjectFactory(
customer=self.customer, name='first_project')
self.first_project.project_groups.add(self.first_group)
self.second_project = structure_factories.ProjectFactory(
customer=self.customer, name='second_project')
self.second_project.project_groups.add(self.second_group)
# every project has 1 instance with first and second template licenses:
self.first_instance = factories.InstanceFactory(
template=self.template,
cloud_project_membership__project=self.first_project,
)
self.second_instance = factories.InstanceFactory(
template=self.template,
cloud_project_membership__project=self.second_project,
)
# also first group has manger:
self.admin = structure_factories.UserFactory()
self.first_project.add_user(self.admin,
structure_models.ProjectRole.ADMINISTRATOR)
self.group_manager = structure_factories.UserFactory()
self.first_group.add_user(self.group_manager,
structure_models.ProjectGroupRole.MANAGER)
self.staff = structure_factories.UserFactory(is_staff=True)
self.owner = structure_factories.UserFactory()
self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER)
def get_urls_configs(self):
yield {'url': _template_license_list_url(), 'method': 'GET'}
yield {'url': _template_license_list_url(), 'method': 'POST'}
license = factories.TemplateLicenseFactory()
yield {'url': _template_license_url(license), 'method': 'GET'}
yield {'url': _template_license_url(license), 'method': 'PATCH'}
yield {'url': _template_license_url(license), 'method': 'DELETE'}
template = factories.TemplateFactory()
yield {'url': _template_url(template), 'method': 'PATCH'}
yield {'url': _template_license_stats_url(), 'method': 'GET'}
def test_licenses_list(self):
# another license:
factories.TemplateLicenseFactory()
# as staff without filter
self.client.force_authenticate(self.staff)
response = self.client.get(_template_license_list_url())
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertItemsEqual(
[c['uuid'] for c in response.data],
[str(l.uuid) for l in models.TemplateLicense.objects.all()])
# as staff with filter
response = self.client.get(_template_license_list_url(),
{'customer': self.customer.uuid})
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['uuid'], str(self.license.uuid))
def setUp(self):
"""
In setup we will create:
license, template, instance, project and project role.
"""
# license and template
self.license = factories.TemplateLicenseFactory()
self.template = factories.TemplateFactory()
self.license.templates.add(self.template)
# project and project group
self.project = structure_factories.ProjectFactory()
self.project_group = structure_factories.ProjectGroupFactory()
self.project_group.projects.add(self.project)
# cloud and image
self.cloud = factories.CloudFactory()
factories.CloudProjectMembershipFactory(cloud=self.cloud, project=self.project)
self.image = factories.ImageFactory(cloud=self.cloud, template=self.template)
