def create_resource(self, customer, project):
settings = factories.ServiceSettingsFactory(customer=customer)
service = factories.TestServiceFactory(customer=customer,
settings=settings)
spl = factories.TestServiceProjectLinkFactory(service=service,
project=project)
resource = factories.TestNewInstanceFactory(service_project_link=spl)
return resource
def openstack_service_settings(self):
# OpenStack packages should be used only with shared settings.
return structure_factories.ServiceSettingsFactory(
type=openstack_apps.OpenStackConfig.service_name,
shared=True,
options={'external_network_id': 'test_network_id'},
state=structure_models.ServiceSettings.States.OK,
)
def test_new_shared_services_connects_to_existed_customers(self):
customer = factories.CustomerFactory()
new_shared_service_settings = factories.ServiceSettingsFactory(
type=SupportedServices.Types.OpenStack, shared=True, state=SynchronizationStates.CREATING)
new_shared_service_settings.set_in_sync()
new_shared_service_settings.save()
self.assertTrue(openstack_models.OpenStackService.objects.filter(
customer=customer, settings=new_shared_service_settings, available_for_all=True).exists())
def test_owner_cannot_unlink_service_with_shared_settings(self):
fixture = fixtures.ServiceFixture()
service_settings = factories.ServiceSettingsFactory(shared=True)
service = test_models.TestService.objects.get(customer=fixture.customer, settings=service_settings)
unlink_url = factories.TestServiceFactory.get_url(service, 'unlink')
self.client.force_authenticate(fixture.owner)
response = self.client.post(unlink_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertTrue(test_models.TestService.objects.filter(pk=service.pk).exists())
def setUp(self):
self.users = {
'staff': factories.UserFactory(is_staff=True),
'owner': factories.UserFactory(),
'not_owner': factories.UserFactory(),
}
self.customers = {
'owned': factories.CustomerFactory(),
'inaccessible': factories.CustomerFactory(),
}
self.customers['owned'].add_user(self.users['owner'], CustomerRole.OWNER)
self.settings = {
'shared': factories.ServiceSettingsFactory(shared=True),
'inaccessible': factories.ServiceSettingsFactory(customer=self.customers['inaccessible']),
'owned': factories.ServiceSettingsFactory(
customer=self.customers['owned'], backend_url='bk.url', password='******', type=SupportedServices.Types.OpenStack),
}
# Token is excluded, because it is not available for OpenStack
self.credentials = ('backend_url', 'username', 'password')
def create_service_project_link(self, customer, project):
service_type, models = SupportedServices.get_service_models().items(
)[0]
class ServiceFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service']
class ServiceProjectLinkFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service_project_link']
settings = structure_factories.ServiceSettingsFactory(
customer=customer, type=service_type, shared=False)
service = ServiceFactory(customer=customer, settings=settings)
return ServiceProjectLinkFactory(service=service, project=project)
def setUp(self):
self.customers = {
'owned': structure_factories.CustomerFactory(),
'has_admined_project': structure_factories.CustomerFactory(),
'has_managed_project': structure_factories.CustomerFactory(),
'has_managed_by_group_manager': structure_factories.CustomerFactory(),
}
self.users = {
'customer_owner': structure_factories.UserFactory(),
'project_admin': structure_factories.UserFactory(),
'project_manager': structure_factories.UserFactory(),
'group_manager': structure_factories.UserFactory(),
'no_role': structure_factories.UserFactory(),
}
self.projects = {
'owned': structure_factories.ProjectFactory(customer=self.customers['owned']),
'admined': structure_factories.ProjectFactory(customer=self.customers['has_admined_project']),
'managed': structure_factories.ProjectFactory(customer=self.customers['has_managed_project']),
'managed_by_group_manager': structure_factories.ProjectFactory(
customer=self.customers['has_managed_by_group_manager']),
}
self.services = {
'owned': factories.OpenStackServiceFactory(customer=self.customers['owned']),
'admined': factories.OpenStackServiceFactory(customer=self.customers['has_admined_project']),
'managed': factories.OpenStackServiceFactory(customer=self.customers['has_managed_project']),
'managed_by_group_manager': factories.OpenStackServiceFactory(
customer=self.customers['has_managed_by_group_manager']),
'not_in_project': factories.OpenStackServiceFactory(),
}
self.settings = structure_factories.ServiceSettingsFactory(
type=SupportedServices.Types.OpenStack, customer=self.customers['owned'])
self.customers['owned'].add_user(self.users['customer_owner'], CustomerRole.OWNER)
self.projects['admined'].add_user(self.users['project_admin'], ProjectRole.ADMINISTRATOR)
self.projects['managed'].add_user(self.users['project_manager'], ProjectRole.MANAGER)
project_group = structure_factories.ProjectGroupFactory()
project_group.projects.add(self.projects['managed_by_group_manager'])
project_group.add_user(self.users['group_manager'], ProjectGroupRole.MANAGER)
factories.OpenStackServiceProjectLinkFactory(service=self.services['admined'], project=self.projects['admined'])
factories.OpenStackServiceProjectLinkFactory(service=self.services['managed'], project=self.projects['managed'])
factories.OpenStackServiceProjectLinkFactory(
service=self.services['managed_by_group_manager'], project=self.projects['managed_by_group_manager'])
def openstack_package(self):
return factories.OpenStackPackageFactory(
tenant=self.openstack_tenant,
template=self.openstack_template,
service_settings=structure_factories.ServiceSettingsFactory(
customer=self.customer,
type=openstack_apps.OpenStackConfig.service_name,
scope=self.openstack_tenant,
options={
'availability_zone':
self.openstack_tenant.availability_zone,
'tenant_id':
self.openstack_tenant.backend_id,
'external_network_id':
self.openstack_tenant.external_network_id,
'internal_network_id':
self.openstack_tenant.internal_network_id,
}))
def setUp(self):
self.customer = factories.CustomerFactory()
self.settings = factories.ServiceSettingsFactory(shared=True)
self.service = factories.TestServiceFactory(customer=self.customer, settings=self.settings)
self.user1 = factories.UserFactory()
self.project1 = factories.ProjectFactory(customer=self.customer)
self.project1.add_user(self.user1, ProjectRole.ADMINISTRATOR)
self.spl1 = factories.TestServiceProjectLinkFactory(service=self.service, project=self.project1)
self.vm1 = factories.TestNewInstanceFactory(service_project_link=self.spl1)
self.user2 = factories.UserFactory()
self.project2 = factories.ProjectFactory(customer=self.customer)
self.project2.add_user(self.user2, ProjectRole.ADMINISTRATOR)
self.spl2 = factories.TestServiceProjectLinkFactory(service=self.service, project=self.project2)
self.vm2 = factories.TestNewInstanceFactory(service_project_link=self.spl2)
self.service_url = factories.TestServiceFactory.get_url(self.service)
def create_resource(self, customer, project):
service_type, models = SupportedServices.get_service_models().items()[0]
class ServiceFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service']
class ServiceProjectLinkFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service_project_link']
class ResourceFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['resources'][0]
settings = factories.ServiceSettingsFactory(customer=customer, type=service_type)
service = ServiceFactory(customer=customer, settings=settings)
spl = ServiceProjectLinkFactory(service=service, project=project)
resource = ResourceFactory(service_project_link=spl)
return resource
def test_when_virtual_machine_is_deleted_descendant_resources_unlinked(
self):
# Arrange
vm = factories.TestNewInstanceFactory()
settings = factories.ServiceSettingsFactory(scope=vm)
service = factories.TestServiceFactory(settings=settings)
link = factories.TestServiceProjectLinkFactory(service=service)
child_vm = factories.TestNewInstanceFactory(service_project_link=link)
other_vm = factories.TestNewInstanceFactory()
# Act
vm.delete()
# Assert
self.assertFalse(
test_models.TestNewInstance.objects.filter(
id=child_vm.id).exists())
self.assertFalse(
test_models.TestService.objects.filter(id=service.id).exists())
self.assertFalse(
ServiceSettings.objects.filter(id=settings.id).exists())
self.assertTrue(
test_models.TestNewInstance.objects.filter(
id=other_vm.id).exists())
def setUp(self):
self.openstack_shared_service_settings = factories.ServiceSettingsFactory(
type=SupportedServices.Types.OpenStack, shared=True)
def test_modify_suspended_services_and_resources(self):
self.client.force_authenticate(user=self.user)
for service_type, models in SupportedServices.get_service_models(
).items():
# XXX: quick fix for iaas cloud. Can be removed after iaas application refactoring.
if service_type == -1:
continue
settings = factories.ServiceSettingsFactory(customer=self.customer,
type=service_type,
shared=True)
class ServiceFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service']
class ServiceProjectLinkFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service_project_link']
if service_type == SupportedServices.Types.IaaS:
service = ServiceFactory(customer=self.customer,
state=SynchronizationStates.IN_SYNC)
OpenStackSettings.objects.get_or_create(
auth_url='http://example.com:5000/v2',
defaults={
'username': '******',
'password': '******',
'tenant_name': 'admin',
})
else:
service = models['service'].objects.create(
customer=self.customer,
settings=settings,
name=settings.name,
available_for_all=True)
service_url = self._get_url(
SupportedServices.get_detail_view_for_model(models['service']),
uuid=service.uuid.hex)
response = self.client.patch(service_url, {'name': 'new name'})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
response = self.client.delete(service_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
for resource_model in models['resources']:
if service_type == SupportedServices.Types.IaaS:
continue
class ResourceFactory(factory.DjangoModelFactory):
class Meta(object):
model = resource_model
project = factories.ProjectFactory(customer=self.customer)
spl = models['service_project_link'].objects.get(
service=service, project=project)
# XXX: Some resources can have more required fields and creation will fail. Lets just skip them.
try:
resource = ResourceFactory(service_project_link=spl)
except:
pass
else:
resource_url = self._get_url(
SupportedServices.get_detail_view_for_model(
resource_model),
uuid=resource.uuid.hex)
response = self.client.post(resource_url + 'start/')
self.assertEqual(response.status_code,
status.HTTP_403_FORBIDDEN)
def setUp(self):
self.shared_service_settings = factories.ServiceSettingsFactory(
shared=True)
def create_service(self, customer, available_for_all):
service_settings = factories.ServiceSettingsFactory(shared=False)
return test_models.TestService.objects.create(
customer=customer,
settings=service_settings,
available_for_all=available_for_all)
def create_service(self, customer, available_for_all):
service_settings = factories.ServiceSettingsFactory(type=SupportedServices.Types.OpenStack, shared=False)
return openstack_models.OpenStackService.objects.create(name='test',
customer=customer,
settings=service_settings,
available_for_all=available_for_all)
def test_auto_quotas_update(self):
for service_type, models in SupportedServices.get_service_models(
).items():
settings = factories.ServiceSettingsFactory(customer=self.customer,
type=service_type,
shared=False)
class ServiceFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service']
class ServiceProjectLinkFactory(factory.DjangoModelFactory):
class Meta(object):
model = models['service_project_link']
if service_type == SupportedServices.Types.IaaS:
service = ServiceFactory(customer=self.customer,
state=SynchronizationStates.IN_SYNC)
OpenStackSettings.objects.get_or_create(
auth_url='http://example.com:5000/v2',
defaults={
'username': '******',
'password': '******',
'tenant_name': 'admin',
})
else:
service = ServiceFactory(customer=self.customer,
settings=settings)
for resource_model in models['resources']:
if not hasattr(resource_model, 'update_quota_usage'):
continue
class ResourceFactory(factory.DjangoModelFactory):
class Meta(object):
model = resource_model
data = {'cores': 4, 'ram': 1024, 'disk': 20480}
service_project_link = ServiceProjectLinkFactory(
service=service, project=self.project)
resource = ResourceFactory(
service_project_link=service_project_link,
cores=data['cores'])
self.assertEqual(
service_project_link.quotas.get(name='instances').usage, 1)
self.assertEqual(
service_project_link.quotas.get(name='vcpu').usage,
data['cores'])
self.assertEqual(
service_project_link.quotas.get(name='ram').usage, 0)
self.assertEqual(
service_project_link.quotas.get(name='storage').usage, 0)
resource.ram = data['ram']
resource.disk = data['disk']
resource.save()
self.assertEqual(
service_project_link.quotas.get(name='ram').usage,
data['ram'])
self.assertEqual(
service_project_link.quotas.get(name='storage').usage,
data['disk'])
resource.delete()
self.assertEqual(
service_project_link.quotas.get(name='instances').usage, 0)
self.assertEqual(
service_project_link.quotas.get(name='vcpu').usage, 0)
self.assertEqual(
service_project_link.quotas.get(name='ram').usage, 0)
self.assertEqual(
service_project_link.quotas.get(name='storage').usage, 0)
