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