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 = { 'message': self.message, 'type': self.event_type, 'context': event_logger.customer.compile_context(customer=self.customer), 'timestamp': time.time() } # 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 setUp(self): self.staff = structure_factories.UserFactory(is_staff=True) self.author = structure_factories.UserFactory() self.other_user = structure_factories.UserFactory() self.valid_event_types = loggers.get_valid_events()[:3] self.valid_event_groups = loggers.get_event_groups_keys()[:3]
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 test_user_list_can_be_filtered(self): supported_filters = [ 'full_name', 'native_name', 'organization', 'email', 'phone_number', 'description', 'job_title', 'username', 'civil_number', 'is_active', ] user = factories.UserFactory(is_staff=True) user_that_should_be_found = factories.UserFactory( native_name='', organization='', email='*****@*****.**', phone_number='', description='', job_title='', username='', civil_number='', is_active=False, ) self.client.force_authenticate(user) url = factories.UserFactory.get_list_url() user_url = factories.UserFactory.get_url(user) user_that_should_not_be_found_url = factories.UserFactory.get_url( user_that_should_be_found) for field in supported_filters: response = self.client.get(url, data={field: getattr(user, field)}) self.assertContains(response, user_url) self.assertNotContains(response, user_that_should_not_be_found_url)
def setUp(self): self.users = { 'staff': factories.UserFactory(is_staff=True), 'owner': factories.UserFactory(), 'not_owner': factories.UserFactory(), } self.customers = { 'owned': factories.CustomerFactory(), 'inaccessible': factories.CustomerFactory(), } self.customers['owned'].add_user(self.users['owner'], models.CustomerRole.OWNER) self.settings = { 'shared': factories.ServiceSettingsFactory(shared=True), 'inaccessible': factories.ServiceSettingsFactory( customer=self.customers['inaccessible']), 'owned': factories.ServiceSettingsFactory(customer=self.customers['owned'], backend_url='bk.url', password='******'), } # Token is excluded, because it is not available for OpenStack self.credentials = ('backend_url', 'username', 'password')
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): 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): # customers self.old_customer = factories.CustomerFactory( created=timezone.now() - timedelta(days=10) ) self.new_customer = factories.CustomerFactory( created=timezone.now() - timedelta(days=1) ) # projects self.old_projects = factories.ProjectFactory.create_batch( 3, created=timezone.now() - timedelta(days=10), customer=self.old_customer ) self.new_projects = factories.ProjectFactory.create_batch( 3, created=timezone.now() - timedelta(days=1), customer=self.new_customer ) # users self.staff = factories.UserFactory(is_staff=True) self.old_customer_owner = factories.UserFactory() self.old_customer.add_user(self.old_customer_owner, models.CustomerRole.OWNER) self.all_projects_admin = factories.UserFactory() for p in self.old_projects + self.new_projects: p.add_user(self.all_projects_admin, models.ProjectRole.ADMINISTRATOR) self.url = reverse('stats_creation_time') self.default_data = { 'from': core_utils.datetime_to_timestamp( timezone.now() - timedelta(days=12) ), 'datapoints': 2, }
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 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_user_may_have_only_one_role_in_the_same_customer(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() # Act with self.assertRaises(ValueError): self.change_customer(support_users=[user1.pk, user2.pk], owners=[user1.pk, user2.pk])
def test_user_may_have_only_one_role_in_the_same_project(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() # Act with self.assertRaises(ValueError): self.change_project(members=[user1.pk, user2.pk], managers=[user1.pk, user2.pk])
def setUp(self): self.admin = structure_factories.UserFactory() self.manager = structure_factories.UserFactory() self.staff = structure_factories.UserFactory(is_staff=True) self.admined_volume = factories.VolumeFactory(state=models.Volume.States.OK) admined_project = self.admined_volume.service_project_link.project admined_project.add_user(self.admin, ProjectRole.ADMINISTRATOR) admined_project.add_user(self.manager, ProjectRole.MANAGER)
def test_filter_by_roles(self): walter = factories.UserFactory(full_name='', username='******', email='*****@*****.**') admin = factories.UserFactory(full_name='admin', username='******', email='*****@*****.**') alice = factories.UserFactory(full_name='', username='******', email='*****@*****.**') self.fixture.customer.add_user(walter, CustomerRole.SUPPORT) self.fixture.project.add_user(walter, ProjectRole.MANAGER) self.fixture.customer.add_user(admin, CustomerRole.OWNER) self.fixture.project.add_user(admin, ProjectRole.ADMINISTRATOR) self.fixture.customer.add_user(alice, CustomerRole.SUPPORT) self.fixture.project.add_user(alice, ProjectRole.MEMBER) self.client.force_authenticate(self.fixture.staff) response = self.client.get(self.url) self.assertEqual(len(response.data), 3) response = self.client.get( self.url, {'project_role': [ProjectRole.ADMINISTRATOR, ProjectRole.MANAGER]}) usernames = [item['username'] for item in response.data] self.assertEqual(len(usernames), 2) self.assertTrue(admin.username in usernames) self.assertTrue(walter.username in usernames) response = self.client.get( self.url, {'organization_role': [CustomerRole.SUPPORT]}) usernames = [item['username'] for item in response.data] self.assertEqual(len(usernames), 2) self.assertTrue(walter.username in usernames) self.assertTrue(alice.username in usernames) response = self.client.get(self.url, {'organization_role': [CustomerRole.OWNER]}) usernames = [item['username'] for item in response.data] self.assertEqual(len(usernames), 1) self.assertTrue(admin.username in usernames) response = self.client.get( self.url, { 'organization_role': [CustomerRole.OWNER], 'project_role': [ProjectRole.MEMBER], }, ) usernames = [item['username'] for item in response.data] self.assertEqual(len(usernames), 2) self.assertTrue(admin.username in usernames) self.assertTrue(alice.username in usernames)
def setUp(self): self.users = { 'staff': factories.UserFactory(is_staff=True, agreement_date=timezone.now()), 'owner': factories.UserFactory(agreement_date=timezone.now()), 'other': factories.UserFactory(agreement_date=timezone.now()), }
def setUp(self): self.staff = factories.UserFactory(is_staff=True) self.user1 = factories.UserFactory() self.user2 = factories.UserFactory() self.customer1 = factories.CustomerFactory() self.customer2 = factories.CustomerFactory() self.customer1.add_user(self.user1, CustomerRole.OWNER) self.customer2.add_user(self.user1, CustomerRole.OWNER) self.customer2.add_user(self.user2, CustomerRole.OWNER)
def test_new_customer_owners_are_added(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() # Act customer = self.change_customer(owners=[user1.pk, user2.pk]) # Asset self.assertTrue(customer.has_user(user1, structure_models.CustomerRole.OWNER)) self.assertTrue(customer.has_user(user2, structure_models.CustomerRole.OWNER))
def test_new_users_are_added(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() # Act project = self.change_project(members=[user1.pk, user2.pk]) # Asset self.assertTrue(project.has_user(user1, structure_models.ProjectRole.MEMBER)) self.assertTrue(project.has_user(user2, structure_models.ProjectRole.MEMBER))
def setUp(self): self.expert_user = structure_factories.UserFactory() self.request_user = structure_factories.UserFactory() self.expert_permission = structure_factories.ProjectPermissionFactory( user=self.expert_user) request_permission = structure_factories.ProjectPermissionFactory( user=self.request_user) self.request = factories.ExpertRequestFactory( project=request_permission.project, user=self.request_user) self.other_user = structure_factories.UserFactory() self.url = structure_factories.UserFactory.get_list_url()
def test_old_users_are_deleted_and_existing_are_preserved(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() self.customer.add_user(user1, structure_models.CustomerRole.SUPPORT) # Act customer = self.change_customer(support_users=[user2.pk]) # Asset self.assertFalse(customer.has_user(user1, structure_models.CustomerRole.SUPPORT)) self.assertTrue(customer.has_user(user2, structure_models.CustomerRole.SUPPORT))
def test_old_users_are_deleted_and_existing_are_preserved(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() self.project.add_user(user1, structure_models.ProjectRole.MEMBER) # Act project = self.change_project(members=[user2.pk]) # Asset self.assertFalse(project.has_user(user1, structure_models.ProjectRole.MEMBER)) self.assertTrue(project.has_user(user2, structure_models.ProjectRole.MEMBER))
def setUp(self) -> None: with freeze_time('2021-01-01'): self.user = structure_factories.UserFactory(is_staff=True) with freeze_time('2021-02-01'): self.user2 = structure_factories.UserFactory(is_staff=True) event = factories.EventFactory() factories.FeedFactory(scope=self.user, event=event) self.client.force_login(self.user) self.url = factories.EventFactory.get_stats_list_url()
def test_new_service_managers_are_added(self): # Arrange user1 = factories.UserFactory() user2 = factories.UserFactory() # Act customer = self.change_customer(service_managers=[user1.pk, user2.pk]) # Asset self.assertTrue( customer.has_user(user1, structure_models.CustomerRole.SERVICE_MANAGER) ) self.assertTrue( customer.has_user(user2, structure_models.CustomerRole.SERVICE_MANAGER) )
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.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_staff_can_enable_profile_for_any_user(self, mock_client): staff = structure_factories.UserFactory(is_staff=True) self.client.force_authenticate(staff) response = self.client.post(self.url) self.assertEqual(status.HTTP_200_OK, response.status_code) mock_client().user_enable.assert_called_once()
def test_filter_by_role_if_permission_is_not_active(self): user = factories.UserFactory() self.client.force_authenticate(self.fixture.staff) response = self.client.get(self.url, {'organization_role': 'service_manager'}) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 0) self.fixture.customer.add_user(user, role=CustomerRole.SERVICE_MANAGER) response = self.client.get(self.url, {'organization_role': 'service_manager'}) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['is_service_manager'], True) permission = CustomerPermission.objects.get( customer=self.fixture.customer, user=user, role=CustomerRole.SERVICE_MANAGER) permission.is_active = False permission.save() response = self.client.get(self.url, {'organization_role': 'service_manager'}) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.data), 0)
def test_profile_can_not_enable_profile_for_other_user(self, mock_client): other_user = structure_factories.UserFactory() self.client.force_authenticate(other_user) response = self.client.post(self.url) self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code) mock_client().user_enable.assert_not_called()
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 setUp(self): self.link = factories.DigitalOceanServiceProjectLinkFactory() self.import_url = factories.DigitalOceanServiceFactory.get_url( self.link.service, 'link') self.project_url = structure_factories.ProjectFactory.get_url( self.link.project) self.client.force_authenticate(user=structure_factories.UserFactory( is_staff=True)) Droplet = collections.namedtuple('Droplet', ( 'name', 'vcpus', 'memory', 'disk', 'ip_address', 'status', 'created_at', 'size', 'size_slug', 'image', )) self.mocked_droplet = Droplet( name='Webserver', vcpus=1, memory=1, disk=1, ip_address='10.0.0.1', status='active', size={'transfer': 1}, size_slug='832959fe-4a87-4d0c-bf6b-b09d468daeb6', created_at=timezone.now().isoformat(), image={ 'distribution': 'CentOS', 'name': '7.1 x64' })