def setUp(self):
self.users = {
'staff':
structure_factories.UserFactory(username='******', is_staff=True),
'owner':
structure_factories.UserFactory(username='******'),
'administrator':
structure_factories.UserFactory(username='******'),
'manager':
structure_factories.UserFactory(username='******'),
}
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.users['owner'],
structure_models.CustomerRole.OWNER)
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project.add_user(self.users['administrator'],
structure_models.ProjectRole.ADMINISTRATOR)
self.project.add_user(self.users['manager'],
structure_models.ProjectRole.MANAGER)
self.service = structure_factories.TestServiceFactory(
customer=self.customer)
self.service_project_link = structure_factories.TestServiceProjectLinkFactory(
project=self.project, service=self.service)
CostTrackingRegister.register_strategy(
factories.TestNewInstanceCostTrackingStrategy)
models.DefaultPriceListItem.init_from_registered_resources()
def test_customer_and_project_service_project_link_quota_updated(self):
self.assert_quota_usage('nc_service_project_link_count', 0)
service = factories.TestServiceFactory(customer=self.customer)
project1 = factories.ProjectFactory(customer=self.customer)
factories.TestServiceProjectLinkFactory(service=service,
project=project1)
project2 = factories.ProjectFactory(customer=self.customer)
factories.TestServiceProjectLinkFactory(service=service,
project=project2)
self.assertEqual(
project1.quotas.get(name='nc_service_project_link_count').usage, 1)
self.assertEqual(
project2.quotas.get(name='nc_service_project_link_count').usage, 1)
self.assert_quota_usage('nc_service_project_link_count', 2)
self.assert_quota_usage('nc_service_count', 1)
project2.delete()
project1.delete()
self.assert_quota_usage('nc_service_count', 1)
self.assert_quota_usage('nc_service_project_link_count', 0)
def test_order_gets_approved_if_all_offerings_are_private(self, role, mocked_task):
fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=fixture.project
)
offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=False,
billable=False,
customer=fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
self.client.force_authenticate(getattr(fixture, role))
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering': factories.OfferingFactory.get_url(offering),
'project': structure_factories.ProjectFactory.get_url(fixture.project),
'attributes': {'name': 'test'},
},
)
response = self.submit(fixture.project)
self.assertEqual(response.data['state'], 'executing')
mocked_task.delay.assert_not_called()
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 test_service_alert_is_returned_when_aggregate_customer_is_the_same_as_its_scope_customer(
self):
scope = factories.TestServiceFactory(customer=self.customer)
alert = logging_factories.AlertFactory(scope=scope)
result = self._make_aggregate_request('customer',
self.customer.uuid.hex)
self.assertEqual(len(result), 1)
self.assertTrue(result.filter(uuid=alert.uuid).exists())
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 submit_public_and_private(self, role):
provider_fixture = fixtures.ProjectFixture()
consumer_fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=consumer_fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=consumer_fixture.project
)
private_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=False,
billable=False,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
private_offering.allowed_customers.add(consumer_fixture.customer)
public_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=True,
billable=True,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
)
public_offering.allowed_customers.add(consumer_fixture.customer)
self.client.force_authenticate(getattr(consumer_fixture, role))
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering': factories.OfferingFactory.get_url(private_offering),
'project': structure_factories.ProjectFactory.get_url(
consumer_fixture.project
),
'attributes': {'name': 'test'},
},
)
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering': factories.OfferingFactory.get_url(public_offering),
'project': structure_factories.ProjectFactory.get_url(
consumer_fixture.project
),
'attributes': {'name': 'test'},
},
)
return self.submit(consumer_fixture.project)
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_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 test_only_alerts_where_scopes_customer_is_the_aggregated_one_are_returned(
self):
customer_related_alerts = []
logging_factories.AlertFactory(scope=factories.ProjectFactory())
spl = factories.TestServiceProjectLinkFactory(
service__customer=self.customer)
customer_related_alerts.append(
logging_factories.AlertFactory(scope=spl))
service = factories.TestServiceFactory(customer=self.customer)
customer_related_alerts.append(
logging_factories.AlertFactory(scope=service))
expected_alerts_ids = [alert.uuid for alert in customer_related_alerts]
result = self._make_aggregate_request('customer',
self.customer.uuid.hex)
actual_alerts_ids = [alert.uuid for alert in result]
self.assertItemsEqual(expected_alerts_ids, actual_alerts_ids)
def test_public_offering_is_approved_in_the_same_organization(
self, auto_approve_in_service_provider_projects, mocked_task
):
consumer_fixture = provider_fixture = fixtures.ProjectFixture()
service = structure_factories.TestServiceFactory(
settings=self.service_settings, customer=consumer_fixture.customer
)
structure_factories.TestServiceProjectLinkFactory(
service=service, project=consumer_fixture.project
)
public_offering = factories.OfferingFactory(
state=models.Offering.States.ACTIVE,
shared=True,
billable=True,
customer=provider_fixture.customer,
type='TEST_TYPE',
scope=self.service_settings,
plugin_options={
'auto_approve_in_service_provider_projects': auto_approve_in_service_provider_projects
},
)
self.client.force_authenticate(getattr(consumer_fixture, 'admin'))
self.client.post(
factories.CartItemFactory.get_list_url(),
{
'offering': factories.OfferingFactory.get_url(public_offering),
'project': structure_factories.ProjectFactory.get_url(
consumer_fixture.project
),
'attributes': {'name': 'test'},
},
)
response = self.submit(consumer_fixture.project)
self.assertEqual(
response.data['state'],
auto_approve_in_service_provider_projects
and 'executing'
or 'requested for approval',
)
if auto_approve_in_service_provider_projects:
mocked_task.delay.assert_not_called()
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 test_customer_services_quota_decreases_on_service_deletion(self):
service = factories.TestServiceFactory(customer=self.customer)
service.delete()
self.assert_quota_usage('nc_service_count', 0)
def test_customer_services_quota_increases_on_service_creation(self):
factories.TestServiceFactory(customer=self.customer)
self.assert_quota_usage('nc_service_count', 1)
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)
