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()
