def test_user_which_granted_permission_is_stored(self): staff_user = factories.UserFactory(is_staff=True) self.client.force_authenticate(user=staff_user) user = factories.UserFactory() customer = factories.CustomerFactory() data = { 'customer': factories.CustomerFactory.get_url(customer), 'user': factories.UserFactory.get_url(user), 'role': CustomerRole.OWNER, } response = self.client.post(reverse('customer_permission-list'), data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) permission = CustomerPermission.objects.get(pk=response.data['pk']) self.assertEqual(permission.created_by, staff_user)
def test_allocation_import(self): allocation = slurm_factories.AllocationFactory() package = slurm_invoices_factories.SlurmPackageFactory( service_settings=allocation.service_settings, cpu_price=5, gpu_price=15, ram_price=30) allocation_usage = slurm_factories.AllocationUsageFactory( allocation=allocation, year=allocation.created.year, month=allocation.created.month, cpu_usage=1, gpu_usage=5, ram_usage=10, ) customer = structure_factories.CustomerFactory() import_slurm_service_settings(customer) import_allocation() self.assertTrue( marketplace_models.Resource.objects.filter( scope=allocation).exists()) self.assertEqual(marketplace_models.Resource.objects.count(), 1) resource = marketplace_models.Resource.objects.get(scope=allocation) self.assertEqual( resource.plan.components.get(component__type='cpu').price, package.cpu_price) self.assertEqual( resource.plan.components.get(component__type='gpu').price, package.gpu_price) self.assertEqual( resource.plan.components.get(component__type='ram').price, package.ram_price) self.assertEqual(marketplace_models.ComponentUsage.objects.count(), 3) self.assertEqual( marketplace_models.ComponentUsage.objects.get( component__type='cpu').usage, allocation_usage.cpu_usage) self.assertEqual( marketplace_models.ComponentUsage.objects.get( component__type='gpu').usage, allocation_usage.gpu_usage) self.assertEqual( marketplace_models.ComponentUsage.objects.get( component__type='ram').usage, allocation_usage.ram_usage)
def test_inactive_allocation_import(self): allocation = slurm_factories.AllocationFactory(is_active=False) slurm_invoices_factories.SlurmPackageFactory( service_settings=allocation.service_settings, cpu_price=5, gpu_price=15, ram_price=30) customer = structure_factories.CustomerFactory() import_slurm_service_settings(customer) import_allocation() self.assertTrue( marketplace_models.Resource.objects.filter( scope=allocation).exists()) self.assertEqual(marketplace_models.Resource.objects.count(), 1) resource = marketplace_models.Resource.objects.get(scope=allocation) self.assertEqual(resource.state, marketplace_models.Resource.States.TERMINATED)
def test_create_missing_support_offerings_with_changed_unit_price(self): offering = support_factories.OfferingFactory() category = marketplace_factories.CategoryFactory() customer = structure_factories.CustomerFactory() offering_plan = support_factories.OfferingPlanFactory( template=offering.template, unit_price=offering.unit_price) offering.unit_price += 10 offering.save() marketplace_support_utils.init_offerings_and_resources( category, customer) self.assertTrue( marketplace_models.Plan.objects.filter( scope=offering_plan).exists()) self.assertEqual(marketplace_models.Plan.objects.count(), 2) self.assertTrue( marketplace_models.Resource.objects.filter( scope=offering).exists()) resource = marketplace_models.Resource.objects.get(scope=offering) self.assertEqual(resource.plan.unit_price, offering.unit_price)
def test_user_cannot_change_customer_of_service_he_owns(self): user = self.users['customer_owner'] self.client.force_authenticate(user=user) service = self.services['owned'] new_customer = structure_factories.CustomerFactory() new_customer.add_user(user, CustomerRole.OWNER) payload = { 'customer': structure_factories.CustomerFactory.get_url(new_customer) } response = self.client.patch( factories.OpenStackServiceFactory.get_url(service), data=payload) self.assertEqual(response.status_code, status.HTTP_200_OK) reread_service = models.OpenStackService.objects.get(pk=service.pk) self.assertEqual(reread_service.customer, service.customer)
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 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.service = factories.DigitalOceanServiceFactory( customer=self.customer, settings=self.settings ) 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.link = factories.DigitalOceanServiceProjectLinkFactory( service=self.service, project=self.project ) 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 test_create_missing_support_offering_templates(self): offering_template = support_factories.OfferingTemplateFactory() category = marketplace_factories.CategoryFactory() customer = structure_factories.CustomerFactory() marketplace_support_utils.init_offerings_and_resources( category, customer) self.assertTrue( marketplace_models.Offering.objects.filter( scope=offering_template).exists()) self.assertTrue( marketplace_models.Offering.objects.filter( scope=offering_template).count(), 1, ) marketplace_support_utils.init_offerings_and_resources( category, customer) self.assertTrue( marketplace_models.Offering.objects.filter( scope=offering_template).count(), 1, )
def test_delete_invoice_items_if_project_customer_has_been_changed(self): fixture = fixtures.InvoiceFixture() invoice_item = fixture.invoice_item invoice_item.resource = fixture.resource invoice_item.save() new_customer = structure_factories.CustomerFactory() today = timezone.now() date = core_utils.month_start(today) ( new_customer_invoice, create, ) = registrators.RegistrationManager.get_or_create_invoice( new_customer, date) self.assertFalse( new_customer_invoice.items.filter( resource=fixture.resource).exists()) move_project(fixture.resource.project, new_customer) self.assertFalse( fixture.invoice.items.filter(resource=fixture.resource).exists()) self.assertTrue( new_customer_invoice.items.filter( resource=fixture.resource).exists())
def test_delete_invoice_items_if_project_customer_has_been_changed(self): offering = self.fixture.offering offering.state = offering.States.OK offering.save() self.assertEqual(models.Invoice.objects.count(), 1) invoice = models.Invoice.objects.first() self.assertTrue(invoice.generic_items.filter(scope=offering).exists()) new_customer = structure_factories.CustomerFactory() today = timezone.now() date = core_utils.month_start(today) ( new_customer_invoice, create, ) = registrators.RegistrationManager.get_or_create_invoice(new_customer, date) self.assertFalse( new_customer_invoice.generic_items.filter(scope=offering).exists() ) move_project(offering.project, new_customer) self.assertFalse(invoice.generic_items.filter(scope=offering).exists()) self.assertTrue( new_customer_invoice.generic_items.filter(scope=offering).exists() )
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 setUp(self): self.users = [] self.customers = [] self.projects = [] self.project_alerts = [] self.customer_alerts = [] for i in range(2): customer = factories.CustomerFactory() user = factories.UserFactory() customer.add_user(user, CustomerRole.OWNER) project = factories.ProjectFactory(customer=customer) resource = self.create_resource(customer, project) spl = resource.service_project_link service = spl.service project_alerts = (AlertFactory(scope=project), AlertFactory(scope=resource), AlertFactory(scope=spl)) customer_alerts = project_alerts + (AlertFactory(scope=service), AlertFactory(scope=customer)) self.users.append(user) self.customers.append(customer) self.projects.append(project) self.project_alerts.append(project_alerts) self.customer_alerts.append(customer_alerts) # Cleanup other alerts alert_ids = [ alert.pk for alerts in self.customer_alerts for alert in alerts ] Alert.objects.exclude(pk__in=alert_ids).delete()
def setUp(self): self.owner = structure_factories.UserFactory() self.customer = structure_factories.CustomerFactory() self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER) self.other_user = structure_factories.UserFactory() self.event_type = 'customer_update_succeeded' self.other_event = 'customer_deletion_succeeded' self.message = 'Customer {customer_name} has been updated.' self.event = EventFactory(event_type=self.event_type) self.payload = dict( created=self.event.created, message=self.event.message, context=self.event.context, event_type=self.event.event_type, ) logging_models.Feed.objects.create(scope=self.customer, event=self.event) # Create email hook for another user self.other_hook = logging_models.EmailHook.objects.create( user=self.other_user, email=self.owner.email, event_types=[self.event_type])
def test_user_can_filter_permission_by_empty_customer(self): self.client.force_authenticate(self.staff) response = self.client.get( self.url, {'customer': factories.CustomerFactory().uuid.hex}) self.assertEqual(len(response.data), 0)
def test_default_tax_percent_is_used_on_invoice_creation(self): customer = structure_factories.CustomerFactory() customer.default_tax_percent = 20 customer.save() invoice = invoices_factories.InvoiceFactory(customer=customer) self.assertEqual(invoice.tax_percent, customer.default_tax_percent)
def test_customer_can_have_unicode_name(self): factories.CustomerFactory(name="Моя организация")
def setUp(self): self.customer = factories.CustomerFactory() self.user = factories.UserFactory() self.created_by = factories.UserFactory()
def setUp(self): self.division = factories.DivisionFactory() self.customer1 = factories.CustomerFactory() self.customer2 = factories.CustomerFactory(division=self.division) self.user = fixtures.UserFixture().staff self.url = factories.CustomerFactory.get_list_url()
def setUp(self): self.customer = factories.CustomerFactory() self.project = factories.ProjectFactory() self.aggregate_filter = AggregateFilter() self.queryset = logging_models.Alert.objects
def test_target_model_instance_creation_increases_scope_counter_quota( self): customer = structure_factories.CustomerFactory() structure_factories.ProjectFactory(customer=customer) self.assertEqual(customer.quotas.get(name='nc_project_count').usage, 1)
def __init__(self, provider_customer=None): self.provider_customer = (provider_customer or structure_factories.CustomerFactory()) self.plan_component self.order_item
def setUp(self): self.user = factories.UserFactory() self.customer = factories.CustomerFactory(blocked=True) self.customer.add_user(self.user, CustomerRole.OWNER)
def setUp(self): self.customer = structure_factories.CustomerFactory() self.owner = structure_factories.UserFactory() self.customer.add_user(self.owner, structure_models.CustomerRole.OWNER)
def test_dry_run_service_settings_import(self): slurm_factories.AllocationFactory() customer = structure_factories.CustomerFactory() offerings_counter = import_slurm_service_settings(customer, True) self.assertEqual(offerings_counter, 1) self.assertEqual(marketplace_models.Offering.objects.count(), 0)
def test_user_cannot_list_other_customer(self, user): customer = factories.CustomerFactory() self.client.force_authenticate(user=getattr(self.fixture, user)) self._check_customer_in_list(customer, False)
def test_service_provider_is_not_defined(self): customer = structure_factories.CustomerFactory() self.assertFalse(self.get_value(customer))
def setUp(self): self.customer = factories.CustomerFactory() self.staff = factories.UserFactory(is_staff=True)
def setUp(self): self.customer = factories.CustomerFactory()
def setUp(self): self.customer = structure_factories.CustomerFactory() self.profile = factories.PaymentProfileFactory( organization=self.customer, is_active=True)
def setUp(self): self.fixture = fixtures.ProjectFixture() self.project = self.fixture.project self.old_customer = self.project.customer self.new_customer = factories.CustomerFactory()