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'],
models.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='******'),
}
# Token is excluded, because it is not available for OpenStack
self.credentials = ('backend_url', 'username', 'password')
def setUp(self):
manager.register(
offering_type='TEST_TYPE',
create_resource_processor=utils.TestCreateProcessor,
)
self.service_settings = structure_factories.ServiceSettingsFactory(
type='Test', shared=True)
def shared_settings(self):
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_service_settings_should_be_disabled_if_offering_is_archived(
self, ):
marketplace_handlers.connect_resource_metadata_handlers(
structure_tests_models.TestNewInstance)
instance = structure_factories.TestNewInstanceFactory()
resource: marketplace_models.Resource = factories.ResourceFactory(
scope=instance)
offering: marketplace_models.Offering = resource.offering
service_settings = structure_factories.ServiceSettingsFactory()
offering.scope = service_settings
offering.save()
resource.set_state_terminated()
resource.save()
service_settings.refresh_from_db()
self.assertTrue(service_settings.is_active)
offering.archive()
offering.save()
service_settings.refresh_from_db()
self.assertFalse(service_settings.is_active)
def setUp(self):
fixture = structure_fixtures.ProjectFixture()
service_settings = structure_factories.ServiceSettingsFactory(type='SLURM')
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME, scope=service_settings)
plan = marketplace_factories.PlanFactory(offering=offering)
self.allocation = slurm_factories.AllocationFactory()
self.resource = marketplace_models.Resource.objects.create(
scope=self.allocation,
offering=offering,
plan=plan,
project=fixture.project,
)
self.plan_period = marketplace_models.ResourcePlanPeriod.objects.create(
resource=self.resource,
plan=plan,
start=timezone.make_aware(datetime.datetime.now())
)
for component in manager.get_components(PLUGIN_NAME):
offering_component = marketplace_models.OfferingComponent.objects.create(
offering=offering,
type=component.type,
name=component.name,
measured_unit=component.measured_unit,
billing_type=marketplace_models.OfferingComponent.BillingTypes.USAGE,
)
marketplace_models.PlanComponent.objects.create(
component=offering_component,
plan=plan,
price=3
)
marketplace_models.ResourcePlanPeriod.objects.create(
start=datetime.date(2017, 1, 1),
resource=self.resource,
plan=plan)
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 setUp(self):
super(BaseDropletProvisionTest, self).setUp()
self.customer = structure_factories.CustomerFactory()
self.settings = structure_factories.ServiceSettingsFactory(
customer=self.customer,
type=DigitalOceanConfig.service_name,
token='VALID_TOKEN',
)
self.region = factories.RegionFactory()
self.image = factories.ImageFactory()
self.size = factories.SizeFactory()
self.image.regions.add(self.region)
self.size.regions.add(self.region)
self.project = structure_factories.ProjectFactory(customer=self.customer)
self.customer_owner = structure_factories.UserFactory()
self.customer.add_user(self.customer_owner, CustomerRole.OWNER)
self.client.force_authenticate(user=self.customer_owner)
self.url = factories.DropletFactory.get_list_url()
self.ssh_public_key = structure_factories.SshPublicKeyFactory(
user=self.customer_owner
)
self.ssh_url = structure_factories.SshPublicKeyFactory.get_url(
self.ssh_public_key
)
self.mock_backend()
DropletViewSet.async_executor = False
def setUp(self):
self.customers = {
'owned': structure_factories.CustomerFactory(),
'has_admined_project': structure_factories.CustomerFactory(),
'has_managed_project': structure_factories.CustomerFactory(),
}
self.users = {
'customer_owner': structure_factories.UserFactory(),
'project_admin': structure_factories.UserFactory(),
'project_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']),
}
self.services = {
'owned': factories.DigitalOceanServiceFactory(customer=self.customers['owned']),
'admined': factories.DigitalOceanServiceFactory(customer=self.customers['has_admined_project']),
'managed': factories.DigitalOceanServiceFactory(customer=self.customers['has_managed_project']),
'not_in_project': factories.DigitalOceanServiceFactory(),
}
self.settings = structure_factories.ServiceSettingsFactory(type='DigitalOcean', shared=True)
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)
factories.DigitalOceanServiceProjectLinkFactory(service=self.services['admined'], project=self.projects['admined'])
factories.DigitalOceanServiceProjectLinkFactory(service=self.services['managed'], project=self.projects['managed'])
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 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 instance(self):
settings = structure_factories.ServiceSettingsFactory(
customer=self.customer)
service = structure_factories.TestServiceFactory(
customer=self.customer, settings=settings)
spl = structure_factories.TestServiceProjectLinkFactory(
service=service, project=self.project)
return structure_factories.TestNewInstanceFactory(
service_project_link=spl)
def setUp(self):
init_args = []
self.init_args = init_args
class NewInstanceSerializer(structure_test_serializers.NewInstanceSerializer):
def __init__(self, *args, **kwargs):
init_args.extend([self, args, kwargs])
super(NewInstanceSerializer, self).__init__(*args, **kwargs)
class Meta(structure_test_serializers.NewInstanceSerializer.Meta):
fields = (
structure_test_serializers.NewInstanceSerializer.Meta.fields
+ ('cores',)
)
class TestNewInstanceViewSet(structure_test_views.TestNewInstanceViewSet):
serializer_class = NewInstanceSerializer
class TestNewInstanceCreateProcessor(utils.TestCreateProcessor):
viewset = TestNewInstanceViewSet
fields = ['name', 'cores']
manager.register(
offering_type='TEST_TYPE',
create_resource_processor=TestNewInstanceCreateProcessor,
)
self.service_settings = structure_factories.ServiceSettingsFactory(type='Test')
self.fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=self.fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=self.fixture.project
)
self.offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
type='TEST_TYPE',
scope=self.service_settings,
)
structure_models.Project.add_quota_field(
name='test_cpu_count',
quota_field=TotalQuotaField(
target_models=[test_models.TestNewInstance],
path_to_scope='service_project_link.project',
target_field='cores',
),
)
quotas_models.Quota.objects.update_or_create(
name='test_cpu_count',
content_type=ContentType.objects.get_for_model(self.fixture.project),
object_id=self.fixture.project.id,
defaults={'limit': 1},
)
def test_settings_name_is_update_when_tenant_is_renamed(self):
tenant = factories.TenantFactory()
service_settings = structure_factories.ServiceSettingsFactory(
scope=tenant, name=tenant.name, type=apps.OpenStackConfig.service_name
)
tenant.name = 'new name'
tenant.save()
service_settings.refresh_from_db()
self.assertEqual(service_settings.name, tenant.name)
def private_settings(self):
return structure_factories.ServiceSettingsFactory(
type=tenant_apps.OpenStackTenantConfig.service_name,
customer=self.customer,
scope=self.tenant,
options={
'availability_zone': self.tenant.availability_zone,
'tenant_id': self.tenant.backend_id,
'external_network_id': self.tenant.external_network_id,
'internal_network_id': self.tenant.internal_network_id,
})
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):
manager.register(
offering_type='TEST_TYPE',
create_resource_processor=utils.TestCreateProcessor,
can_update_limits=True,
)
self.service_settings = structure_factories.ServiceSettingsFactory(
type='Test', shared=True)
self.fixture = fixtures.ProjectFixture()
self.offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
type='TEST_TYPE',
scope=self.service_settings,
)
def setUp(self):
manager.register(offering_type='TEST_TYPE',
create_resource_processor=utils.TestCreateProcessor)
self.service_settings = structure_factories.ServiceSettingsFactory(
type='Test')
self.fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=self.fixture.customer)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=self.fixture.project)
self.offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
type='TEST_TYPE',
scope=self.service_settings)
def test_exception_must_include_setting_name_and_type(self):
service_settings = factories.ServiceSettingsFactory()
class Backend:
def pull_resources(self):
raise KeyError('test error')
backend = Backend()
service_settings.get_backend = lambda: backend
task = tasks.ServiceResourcesPullTask()
error_message = '\'test error\', Service settings: %s, %s' % (
service_settings.name,
service_settings.type,
)
self.assertRaisesRegex(KeyError, error_message, task.pull,
service_settings)
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 openstack_package(self):
return factories.OpenStackPackageFactory(
tenant=self.openstack_tenant,
template=self.openstack_template,
service_settings=structure_factories.ServiceSettingsFactory(
customer=self.customer,
type=openstack_tenant_apps.OpenStackTenantConfig.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):
fixture = structure_fixtures.ProjectFixture()
service_settings = structure_factories.ServiceSettingsFactory(type='SLURM')
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME, scope=service_settings)
plan = marketplace_factories.PlanFactory(offering=offering)
self.allocation = slurm_factories.AllocationFactory()
self.resource = marketplace_models.Resource.objects.create(
scope=self.allocation,
offering=offering,
plan=plan,
project=fixture.project,
)
for component in manager.get_components(PLUGIN_NAME):
marketplace_models.OfferingComponent.objects.create(
offering=offering,
type=component.type,
name=component.name,
measured_unit=component.measured_unit,
billing_type=marketplace_models.OfferingComponent.BillingTypes.USAGE,
)
def test_create_slurm_package(self):
fixture = structure_fixtures.ProjectFixture()
url = marketplace_factories.OfferingFactory.get_list_url()
self.client.force_authenticate(fixture.staff)
service_settings = structure_factories.ServiceSettingsFactory(
type=SlurmConfig.service_name)
category = marketplace_factories.CategoryFactory()
payload = {
'name':
'offering',
'type':
PLUGIN_NAME,
'scope':
structure_factories.ServiceSettingsFactory.get_url(
settings=service_settings),
'category':
marketplace_factories.CategoryFactory.get_url(category=category),
'customer':
structure_factories.CustomerFactory.get_url(
customer=fixture.customer),
'plans': [{
'name': 'default',
'description': 'default plan',
'unit': UnitPriceMixin.Units.QUANTITY,
'unit_price': 100,
'prices': {
'cpu': 10,
'gpu': 100,
'ram': 1000,
},
}]
}
response = self.client.post(url, payload)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
package = slurm_invoices_models.SlurmPackage.objects.last()
self.assertEqual(package.service_settings, service_settings)
self.assertEqual(package.cpu_price, 10)
self.assertEqual(package.gpu_price, 100)
self.assertEqual(package.ram_price, 1000)
def test_if_limit_is_reached_provisioning_is_delayed(self, params):
service_settings = factories.ServiceSettingsFactory()
project = factories.ProjectFactory()
factories.TestNewInstanceFactory.create_batch(
size=params['size'],
state=models.TestNewInstance.States.CREATING,
service_settings=service_settings,
project=project,
)
vm = factories.TestNewInstanceFactory(
state=models.TestNewInstance.States.CREATION_SCHEDULED,
service_settings=service_settings,
project=project,
)
serialized_vm = utils.serialize_instance(vm)
mocked_retry = mock.Mock()
tasks.ThrottleProvisionTask.retry = mocked_retry
tasks.ThrottleProvisionTask().si(
serialized_vm, 'create',
state_transition='begin_starting').apply()
self.assertEqual(mocked_retry.called, params['retried'])
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 service_settings(self):
return structure_factories.ServiceSettingsFactory(
type=JiraConfig.service_name,
backend_url='http://jira/',
customer=self.customer)
def setUp(self):
self.shared_service_settings = factories.ServiceSettingsFactory(
shared=True)
def _create_new_test_instance(self, customer):
settings = structure_factories.ServiceSettingsFactory(customer=customer)
service = structure_factories.TestServiceFactory(customer=customer, settings=settings)
spl = structure_factories.TestServiceProjectLinkFactory(service=service, project=self.fixture.project)
return structure_factories.TestNewInstanceFactory(service_project_link=spl)
def test_cache_populated_when_tag_added(self):
settings = structure_factories.ServiceSettingsFactory()
settings.tags.add('IAAS')
self.assertEqual(settings.get_tags(), ['IAAS'])
def test_cache_cleaned_when_tag_removed(self):
settings = structure_factories.ServiceSettingsFactory()
settings.tags.add('IAAS')
settings.tags.remove('IAAS')
self.assertEqual(settings.get_tags(), [])
