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 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 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 setUp(self):
self.cloud = factories.CloudFactory()
self.flavor = factories.FlavorFactory(cloud=self.cloud)
self.image = factories.ImageFactory(cloud=self.cloud)
self.template = template_factories.TemplateFactory()
self.iaas_template_service = factories.IaasTemplateServiceFactory(
template=self.template,
service=self.cloud,
flavor=self.flavor,
image=self.image)
def setUp(self):
self.template = factories.TemplateFactory()
self.flavor = factories.FlavorFactory()
self.project = structure_factories.ProjectFactory()
self.ssh_public_key = factories.SshPublicKeyFactory()
self.membership = factories.CloudProjectMembershipFactory(
cloud=self.flavor.cloud,
project=self.project,
)
factories.ImageFactory(template=self.template, cloud=self.flavor.cloud)
factories.FloatingIPFactory(status='DOWN',
cloud_project_membership=self.membership,
address='10.10.10.10')
def test_licenses_stats_filtering_by_customer_without_instances(self):
self.client.force_authenticate(self.staff)
# other customer is connected with same template, but doesn't have any instances
other_customer = structure_factories.CustomerFactory()
other_cloud = factories.CloudFactory(customer=other_customer)
factories.ImageFactory(cloud=other_cloud, template=self.template)
# when
response = self.client.get(self.url, {
'customer': other_customer.uuid,
'aggregate': 'project'
})
# then: response should return data for first_instance and second_instance, but not other_instance
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertFalse(
response.data,
"Customer doesn't have any instances response data should be empty"
)
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)
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 setUp(self):
self.user = structure_factories.UserFactory.create()
self.client.force_authenticate(self.user)
self.instance = factories.InstanceFactory(
state=models.Instance.States.OFFLINE)
membership = self.instance.cloud_project_membership
membership.project.add_user(self.user,
structure_models.ProjectRole.ADMINISTRATOR)
factories.ImageFactory(
template=self.instance.template,
cloud=self.instance.cloud_project_membership.cloud)
self.instance_security_groups = factories.InstanceSecurityGroupFactory.create_batch(
2, instance=self.instance)
self.cloud_security_groups = [
g.security_group for g in self.instance_security_groups
]
def metadata(self, create, extracted, **kwargs):
if not create:
return
self.metadata = {}
cloud = self.backup_source.cloud_project_membership.cloud
template = self.backup_source.template
# check if image connecting template and cloud already exists, otherwise link them
if not iaas_models.Image.objects.filter(cloud=cloud,
template=template).exists():
iaas_factories.ImageFactory(
cloud=cloud,
template=template,
)
self.metadata.update({
'cloud_project_membership':
self.backup_source.cloud_project_membership.pk,
'name':
'original.vm.name',
'template':
template.pk,
'system_snapshot_id':
self.backup_source.system_volume_id,
'system_snapshot_size':
self.backup_source.system_volume_size,
'data_snapshot_id':
self.backup_source.data_volume_id,
'data_snapshot_size':
self.backup_source.data_volume_size,
'key_name':
self.backup_source.key_name,
'key_fingerprint':
self.backup_source.key_name,
'agreed_sla':
self.backup_source.agreed_sla,
})
if extracted:
self.metadata.update(extracted)
def test_instance_with_flavor_and_template_connected_to_different_clouds_raises_validation_error(
self):
attrs = {
'template': factories.TemplateFactory(),
'project': structure_factories.ProjectFactory(),
'flavor': factories.FlavorFactory()
}
factories.ImageFactory(template=attrs['template'])
attrs[
'cloud_project_membership'] = factories.CloudProjectMembershipFactory(
cloud=attrs['flavor'].cloud,
project=attrs['project'],
)
with self.assertRaises(ValidationError) as er:
self.serializer.validate(attrs)
self.assertEquals(er.message, [
"Template %s is not available on cloud %s" %
(attrs['template'], attrs['flavor'].cloud)
])
def setUp(self):
self.glance_client = mock.Mock()
# C
# ^
# |
# (I0)
# |
# v
# T0 T1 T2
# ^ ^ ^
# | \ | \ |
# | \ | \ |
# | \ | \ |
# v v v v v
# TM0 TM1 TM2 TM3 TM4
#
self.cloud_account = factories.CloudFactory()
self.templates = factories.TemplateFactory.create_batch(3)
self.template_mappings = (
factories.TemplateMappingFactory.create_batch(
2, template=self.templates[0]) +
factories.TemplateMappingFactory.create_batch(
2, template=self.templates[1]) +
factories.TemplateMappingFactory.create_batch(
1, template=self.templates[2]))
self.image = factories.ImageFactory(
cloud=self.cloud_account,
template=self.template_mappings[0].template,
backend_id=self.template_mappings[0].backend_image_id,
)
# Mock low level non-AbstractCloudBackend api methods
self.backend = OpenStackBackend()
self.backend.create_session = mock.Mock()
self.backend.create_glance_client = mock.Mock(
return_value=self.glance_client)
def setUp(self):
self.users = {
'staff': structure_factories.UserFactory(is_staff=True),
'admin': structure_factories.UserFactory(is_staff=False),
'group_manager': structure_factories.UserFactory(is_staff=False),
'non_staff': structure_factories.UserFactory(is_staff=False),
}
self.templates = {
'active': factories.TemplateFactory.create_batch(4,
is_active=True),
'inactive': [factories.TemplateFactory(is_active=False)],
}
# Uadmin<-->P0 P1<--->Umgr
# ^ ^
# | |
# +---------+ +---------+
# | | | |
# v v v v
# C0 C1 C2 C3
# ^ ^ ^ ^
# | |\ /| |
# | |(I) (I)| |
# | | \ / | |
# (I) (I) x (I) (I)
# | | / \ | |
# | | / \ | |
# | |/ \| |
# v v v v
# T0 T1 T2 T3
project1 = structure_factories.ProjectFactory()
project1.add_user(self.users['admin'], ProjectRole.ADMINISTRATOR)
project2 = structure_factories.ProjectFactory(
customer=project1.customer)
project_group = structure_factories.ProjectGroupFactory()
project_group.projects.add(project2)
project_group.add_user(self.users['group_manager'],
ProjectGroupRole.MANAGER)
self.clouds = factories.CloudFactory.create_batch(
4, customer=project1.customer)
factories.CloudProjectMembershipFactory(project=project1,
cloud=self.clouds[0])
factories.CloudProjectMembershipFactory(project=project1,
cloud=self.clouds[1])
factories.CloudProjectMembershipFactory(project=project2,
cloud=self.clouds[2])
factories.CloudProjectMembershipFactory(project=project2,
cloud=self.clouds[3])
for t, c in (
(0, 0),
(1, 1),
(1, 2),
(2, 1),
(2, 2),
(3, 3),
):
factories.ImageFactory(template=self.templates['active'][t],
cloud=self.clouds[c])
