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 setUp(self):
self.users = {
'owner': structure_factories.UserFactory(),
'admin': structure_factories.UserFactory(),
'manager': structure_factories.UserFactory(),
'no_role': structure_factories.UserFactory(),
'not_connected': structure_factories.UserFactory(),
}
# a single customer
self.customer = structure_factories.CustomerFactory()
self.customer.add_user(self.users['owner'], CustomerRole.OWNER)
# that has 3 users connected: admin, manager
self.connected_project = structure_factories.ProjectFactory(
customer=self.customer)
self.connected_project.add_user(self.users['admin'],
ProjectRole.ADMINISTRATOR)
self.connected_project.add_user(self.users['manager'],
ProjectRole.MANAGER)
# has defined a service and connected service to a project
self.service = factories.OpenStackServiceFactory(
customer=self.customer)
self.service_project_link = factories.OpenStackServiceProjectLinkFactory(
project=self.connected_project, service=self.service)
# the customer also has another project with users but without a permission link
self.not_connected_project = structure_factories.ProjectFactory(
customer=self.customer)
self.not_connected_project.add_user(self.users['not_connected'],
ProjectRole.ADMINISTRATOR)
self.not_connected_project.save()
self.url = factories.OpenStackServiceProjectLinkFactory.get_list_url()
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 setUp(self):
self.users = {
'owner': factories.UserFactory(),
'admin': factories.UserFactory(),
'manager': factories.UserFactory(),
'no_role': factories.UserFactory(),
'multirole': factories.UserFactory(),
}
self.projects = {
'owner': factories.ProjectFactory(),
'admin': factories.ProjectFactory(),
'manager': factories.ProjectFactory(),
'inaccessible': factories.ProjectFactory(),
}
self.projects['admin'].add_user(self.users['admin'],
ProjectRole.ADMINISTRATOR)
self.projects['manager'].add_user(self.users['manager'],
ProjectRole.MANAGER)
self.projects['admin'].add_user(self.users['multirole'],
ProjectRole.ADMINISTRATOR)
self.projects['manager'].add_user(self.users['multirole'],
ProjectRole.MANAGER)
self.projects['owner'].customer.add_user(self.users['owner'],
CustomerRole.OWNER)
def setUp(self):
running_customer = factories.CustomerFactory(
accounting_start_date=datetime.now() - timedelta(days=7))
not_running_customer = factories.CustomerFactory(
accounting_start_date=datetime.now() + timedelta(days=7))
self.running_project = factories.ProjectFactory(
customer=running_customer)
self.not_running_project = factories.ProjectFactory(
customer=not_running_customer)
def test_ssh_key_will_not_be_removed_if_user_still_has_connection_to_service_settings(self, mocked_task_call):
project = structure_factories.ProjectFactory(customer=self.service.customer)
project.add_user(self.user, structure_models.ProjectRole.ADMINISTRATOR)
self.service.customer.add_user(self.user, structure_models.CustomerRole.OWNER)
project.remove_user(self.user)
self.assertFalse(mocked_task_call.called)
def setUp(self):
self.staff = structure_factories.UserFactory(is_staff=True)
self.customer_owner = structure_factories.UserFactory()
self.project_admin = structure_factories.UserFactory()
self.project_manager = structure_factories.UserFactory()
self.user = structure_factories.UserFactory()
self.customer = structure_factories.CustomerFactory()
self.second_customer = structure_factories.CustomerFactory()
self.customer.add_user(self.customer_owner,
structure_models.CustomerRole.OWNER)
self.customer_role = structure_models.CustomerRole.OWNER
self.customer_invitation = factories.CustomerInvitationFactory(
customer=self.customer, customer_role=self.customer_role)
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.project.add_user(self.project_admin,
structure_models.ProjectRole.ADMINISTRATOR)
self.project.add_user(self.project_manager,
structure_models.ProjectRole.MANAGER)
self.project_role = structure_models.ProjectRole.ADMINISTRATOR
self.project_invitation = factories.ProjectInvitationFactory(
project=self.project, project_role=self.project_role)
def test_if_service_became_available_it_connects_to_all_projects_of_customer(
self):
customer = factories.CustomerFactory()
service = self.create_service(customer, available_for_all=False)
project = factories.ProjectFactory(customer=customer)
other_customer = factories.CustomerFactory()
other_project = factories.ProjectFactory(customer=other_customer)
# Act
service.available_for_all = True
service.save()
# Assert
self.assertTrue(self.link_exists(project, service))
self.assertFalse(self.link_exists(other_project, service))
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.tenant = openstack_factories.TenantFactory()
self.project = self.tenant.service_project_link.project
self.resource = marketplace_factories.ResourceFactory(
project=self.project)
self.resource.scope = self.tenant
self.resource.save()
self.order = marketplace_factories.OrderFactory(project=self.project)
marketplace_factories.OrderItemFactory(resource=self.resource,
order=self.order)
self.new_project = structure_factories.ProjectFactory()
self.start_invoice = invoices_factories.InvoiceFactory(
customer=self.project.customer,
year=2020,
month=1,
state=invoices_models.Invoice.States.PENDING,
)
invoices_factories.InvoiceItemFactory(
invoice=self.start_invoice,
project=self.project,
scope=self.resource,
)
self.target_invoice = invoices_factories.InvoiceFactory(
customer=self.new_project.customer,
year=2020,
month=1,
state=invoices_models.Invoice.States.PENDING,
)
def setUp(self):
self.fixture = ServiceFixture()
self.project = self.fixture.project
self.resource = marketplace_factories.ResourceFactory(
project=self.project)
self.resource.scope = self.fixture.volume
self.resource.save()
resource_offering = self.resource.offering
resource_offering.scope = self.fixture.service_settings
resource_offering.save()
self.order = marketplace_factories.OrderFactory(project=self.project)
marketplace_factories.OrderItemFactory(resource=self.resource,
order=self.order)
self.new_project = structure_factories.ProjectFactory()
self.start_invoice = invoices_factories.InvoiceFactory(
customer=self.project.customer,
year=2020,
month=1,
state=invoices_models.Invoice.States.PENDING,
)
invoices_factories.InvoiceItemFactory(
invoice=self.start_invoice,
project=self.project,
resource=self.resource,
)
self.target_invoice = invoices_factories.InvoiceFactory(
customer=self.new_project.customer,
year=2020,
month=1,
state=invoices_models.Invoice.States.PENDING,
)
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_target_model_instance_deletion_decreases_scope_counter_quota(
self):
customer = structure_factories.CustomerFactory()
project = structure_factories.ProjectFactory(customer=customer)
project.delete()
self.assertEqual(customer.quotas.get(name='nc_project_count').usage, 0)
def test_it_is_not_possible_to_increase_project_limit_if_all_customer_projects_limit_reached_customer_limit(
self):
self.client.force_authenticate(self.fixture.staff)
self.project_estimate.limit = 10
self.project_estimate.save()
self.customer_estimate.limit = 100
self.customer_estimate.save()
new_project = structure_factories.ProjectFactory(
customer=self.fixture.customer)
new_project_estimate = models.PriceEstimate.objects.get(
scope=new_project)
new_project_estimate.limit = self.customer_estimate.limit - self.project_estimate.limit
new_project_estimate.save()
# less than customer limit, projects total larger than customer limit
new_limit = self.project_estimate.limit + 10
response = self.client.put(self.project_estimate_url,
{'limit': new_limit})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('limit', response.data)
self.project_estimate.refresh_from_db()
self.assertNotEqual(self.project_estimate.limit, new_limit)
def test_customer_quota_is_not_increased_on_adding_owner_as_manager(self):
user = factories.UserFactory()
project = factories.ProjectFactory(customer=self.customer)
self.customer.add_user(user, CustomerRole.OWNER)
project.add_user(user, ProjectRole.ADMINISTRATOR)
self.assert_quota_usage('nc_user_count', 1)
def test_anonymous_user_cannot_create_project(self):
for old_project in self.projects.values():
project = factories.ProjectFactory(customer=old_project.customer)
response = self.client.post(reverse('project-list'),
self._get_valid_payload(project))
self.assertEqual(response.status_code,
status.HTTP_401_UNAUTHORIZED)
def setUp(self):
self.project = structure_factories.ProjectFactory()
self.staff = get_user_model().objects.create_superuser(
username='******', password='******', email='*****@*****.**')
self.alert = factories.AlertFactory(scope=self.project)
self.admin = structure_factories.UserFactory()
self.project.add_user(self.admin, structure_models.ProjectRole.ADMINISTRATOR)
def test_counter_quota_recalculation(self):
customer = structure_factories.CustomerFactory()
structure_factories.ProjectFactory(customer=customer)
customer.quotas.filter(name='nc_project_count').update(usage=10)
call_command('recalculatequotas')
self.assertEqual(customer.quotas.get(name='nc_project_count').usage, 1)
def test_project_global_quota_increased_after_project_creation(self):
quota = models.Quota.objects.get(
name=structure_models.Project.GLOBAL_COUNT_QUOTA_NAME)
structure_factories.ProjectFactory()
reread_quota = models.Quota.objects.get(pk=quota.pk)
self.assertEqual(reread_quota.usage, quota.usage + 1)
def test_project_administrator_cannot_see_other_projects_events(self):
user = structure_factories.UserFactory()
structure_factories.ProjectFactory()
self.client.force_authenticate(user=user)
self._get_events_by_scope_type(structure_models.Project)
self.assertEqual(self.must_terms, {'project_uuid': []})
def setUp(self):
self.fixture = structure_fixtures.ProjectFixture()
self.expert_request = factories.ExpertRequestFactory()
self.expert_team = structure_factories.ProjectFactory()
self.expert_contract = models.ExpertContract.objects.create(
request=self.expert_request,
team=self.expert_team,
)
def test_ssh_key_will_be_removed_if_user_lost_connection_to_service_settings(self, mocked_task_call):
project = structure_factories.ProjectFactory(customer=self.service.customer)
project.add_user(self.user, structure_models.ProjectRole.ADMINISTRATOR)
project.remove_user(self.user)
serialized_settings = core_utils.serialize_instance(self.service.settings)
mocked_task_call.assert_called_once_with(
serialized_settings, 'remove_ssh_key', self.ssh_key.name, self.ssh_key.fingerprint)
def test_project_administrator_cannot_see_related_customer_events(self):
project = structure_factories.ProjectFactory()
admin = structure_factories.UserFactory()
project.add_user(admin, structure_models.ProjectRole.ADMINISTRATOR)
self.client.force_authenticate(user=admin)
self._get_events_by_scope_type(structure_models.Customer)
self.assertEqual(self.must_terms, {'customer_uuid': []})
def setUp(self):
user = factories.UserFactory()
self.client.force_authenticate(user)
customer = factories.CustomerFactory()
customer.add_user(user, models.CustomerRole.OWNER)
self.project = factories.ProjectFactory(customer=customer)
def test_project_permission_deleting_is_not_available_for_blocked_organization(
self, ):
project = factories.ProjectFactory(customer=self.customer)
permission = factories.ProjectPermissionFactory(project=project)
url = factories.ProjectPermissionFactory.get_url(permission)
self.client.force_authenticate(user=self.user)
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_filter_when_creating_missing_support_offerings(self):
offering = support_factories.OfferingFactory()
category = marketplace_factories.CategoryFactory()
customer = structure_factories.CustomerFactory()
new_project = structure_factories.ProjectFactory()
marketplace_factories.ResourceFactory(scope=offering, project=new_project)
marketplace_support_utils.init_offerings_and_resources(category, customer)
self.assertFalse(marketplace_models.Resource.objects.filter(scope=offering, project=offering.project).exists())
def test_customer_users_quota_decreases_when_one_project_is_deleted(self):
project = factories.ProjectFactory(customer=self.customer)
user = factories.UserFactory()
project.add_user(user, ProjectRole.ADMINISTRATOR)
self.assert_quota_usage('nc_user_count', 1)
project.delete()
self.assert_quota_usage('nc_user_count', 0)
def test_project_alert_is_not_returned_when_its_scope_belongs_to_another_customer(
self):
alert = logging_factories.AlertFactory(
scope=factories.ProjectFactory())
result = self._make_aggregate_request('customer',
self.customer.uuid.hex)
self.assertFalse(result.filter(uuid=alert.uuid).exists())
def test_user_can_create_project_within_customer_he_owns(self):
self.client.force_authenticate(user=self.users['owner'])
customer = self.projects['owner'].customer
project = factories.ProjectFactory(customer=customer)
response = self.client.post(reverse('project-list'),
self._get_valid_payload(project))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_customer_owner_can_see_alert_about_his_project(self):
project = structure_factories.ProjectFactory(customer=self.customer)
alert = factories.AlertFactory(scope=project)
self.client.force_authenticate(self.owner)
response = self.client.get(factories.AlertFactory.get_list_url())
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn(alert.uuid.hex, [a['uuid'] for a in response.data])
