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(), [])