class TranslatedUserObjectPermissionsFormTestCase(TestCase): def setUp(self): self.obj = UserFactory() self.user = UserFactory() def test_delete_all_permissions(self): assign_perm('users.change_user', self.user, self.obj) self.assertTrue(self.user.has_perm('users.change_user', self.obj)) form = TranslatedUserObjectPermissionsForm(data={'permissions': ''}, user=self.user, obj=self.obj) self.assertTrue(form.is_valid()) form.save_obj_perms() self.assertFalse(self.user.has_perm('users.change_user', self.obj)) self.assertEqual(get_perms(self.user, self.obj), [])
class UserDetailViewTestCase(TestCase): def setUp(self): self.object = UserFactory(is_staff=False) def login(self, user=None): self.client.login(username=(user or self.object).username, password='******') def get(self): return self.client.get(self.object.get_absolute_url()) def own_resp(self): self.login() return self.get() def test_contains_username(self): self.assertContains(self.own_resp(), self.object.username) def test_contains_assigned_cases(self): url = reverse_lazy('cases:list') + '?permission=' + str(self.object.pk) self.login() self.assertNotContains(self.own_resp(), url) user = UserFactory() assign_perm('users.can_view_other', user) assign_perm('cases.can_assign', user) self.login(user=user) self.assertContains(self.get(), url)
def test_get_context_data_is_staff(self): self.client.login(username=UserFactory(is_staff=True, is_superuser=True).username, password='******') resp = self.client.get(self.url, data={'is_staff': 1}) context_data = resp.context_data self.assertIn('is_staff', context_data) self.assertEqual(context_data['is_staff']['selected'], 1) self.assertIn('choices', context_data['is_staff'])
def test_register__user_already_logged_in(self): logged_in_user = UserFactory() # Create, don't build new_user = UserFactory.build() # Build, don't create data = { "username": new_user.username, "email": new_user.email, "password": "******", } request = self.factory.post("/api/user/", data) force_authenticate(request, logged_in_user) with mock.patch("users.api.views.send_welcome_email" ) as mock_send_welcome_email: response = UserCreateAPIView.as_view()(request) response.render() self.assertEqual(response.status_code, 400) self.assertEqual(response.data, ["You have already signed up"]) self.assertEqual(mock_send_welcome_email.call_count, 0)
def setUp(self): self.url = self.reverse('api:product-create-subproducts') self.member_organisation = MemberOrganisationFactory() self.profile = ProfileFactory() self.user = UserFactory(profile=self.profile) # string token self.token = AuthTokenFactory(user=self.user) self.api_client = APIClient() self.api_client.credentials(HTTP_AUTHORIZATION=f'Token {self.token}')
def test_website_collaborator_serializer(): """ WebsiteCollaboratorSerializer should serialize a User object with correct fields """ collaborator = (User.objects.filter(id=UserFactory.create().id).annotate( role=Value(ROLE_EDITOR, CharField())).first()) serialized_data = WebsiteCollaboratorSerializer(instance=collaborator).data assert serialized_data["user_id"] == collaborator.id assert serialized_data["name"] == collaborator.name assert serialized_data["email"] == collaborator.email assert serialized_data["role"] == ROLE_EDITOR
def create_user(self, user_type: str, number_of_users_to_create: int = 1) -> None: factory_parameters = self._set_user_factory_parameters(user_type) for user_number in range(number_of_users_to_create): user_email = f"user.{user_type}{user_number + 1}@codepoets.it".lower() if not CustomUser.objects.filter(email=user_email).exists(): logging.info(f"{number_of_users_to_create - user_number} {user_type}(s) left to create") UserFactory(**factory_parameters, email=user_email)
def test_delete_user_device_wrong_user(user_api_client): other_user = UserFactory() user_device = UserDeviceFactory(user=other_user) url = get_user_device_detail_url(user_device) response = user_api_client.delete(url) assert response.status_code == 403 assert UserDevice.objects.count() == 1
def handle(self, *args, **kwargs): UserFactory.create(email="*****@*****.**", is_staff=True, is_superuser=True) dealers = [] for dealer in [("Parts Express", "https://www.parts-express.com")]: dealers.append( DealerFactory.create(name=dealer[0], website=dealer[1])) self.stdout.write("Created {0} Dealer(s)".format(len(dealers))) dealer_scrapers = [] for dealer in dealers: dealer_scrapers.append( DealerScraperFactory.create(class_name="PartsExpressScraper", dealer=dealer)) self.stdout.write("Created {0} DealerScraper(s)".format( len(dealer_scrapers)))
def test_put_fail_missing_fields(self): user = UserFactory(email="*****@*****.**") self.assertIsInstance(user, User) self.set_user(user) self.assertEqual(user.email, "*****@*****.**") data = {} path = self.get_path(id_detail=user.id) response = self.client.put(path, data, HTTP_AUTHORIZATION=self.auth) self.assertEqual( response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.data ) self.assertEqual(User.objects.count(), 1) user.refresh_from_db() self.assertEqual(user.email, "*****@*****.**")
def test_fetch_users(prop, values, db_values): """ fetch_users should return a set of Users that match some provided values which represent ids, emails, or usernames """ users = UserFactory.create_batch( len(values), **{prop: factory.Iterator(db_values or values)} ) found_users = fetch_users(values) assert set(users) == set(found_users)
def test_websites_endpoint_list_forbidden_methods(drf_client, method): """No put, patch, or delete requests allowed at this endpoint""" drf_client.force_login(UserFactory.create(is_superuser=True)) client_func = getattr(drf_client, method) resp = client_func(reverse("websites_api-list"), data={ "name": "fakename", "title": "Fake Title" }) assert resp.status_code == 405
def test_authenticated__can_post_message(self): user = UserFactory() # Create, don't build message = MessageFactory(user=user) # Create, don't build data = {"message": message.message} request = self.factory.post("/api/wall/", data) force_authenticate(request, user) response = MessageListCreateAPIView.as_view()(request, data) self.assertEqual(response.status_code, 201, response.data) self.assertEqual(response.data["message"], data["message"])
def setUp(self): self.user = UserFactory( password=PostGenerationMethodCall('set_password', 'codebuddies')) url = '/auth/obtain_token/' data = {"username": self.user.username, "password": "******"} token_response = self.client.post(url, data, format='json') self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_response.data['token'])
def test_multiple_success_blocking_user(self): """test block_users command blocking emails success with more than one user""" test_usernames = ["*****@*****.**", "*****@*****.**", "*****@*****.**"] for username in test_usernames: user = UserFactory.create(username=username, is_active=True) assert BlockList.objects.all().count() == 0 COMMAND.handle("block_users", users=test_usernames, block_users=True) assert BlockList.objects.all().count() == 3
def setUp(self): self.path = "/user/login/" self.anonymous_client = self.get_anonymous_client() self.password = "******" self.user = UserFactory(password=self.password) self.example_data = { "username": self.user.username, "password": self.password, }
def test_get_is_staff_choice(self): self.client.login(username=UserFactory(is_staff=True).username, password='******') self.assertEqual(self.get_view().get_is_staff_choice(), 0) # Default self.assertEqual(self.get_view(is_staff='a').get_is_staff_choice(), 0) # Non-num self.assertEqual(self.get_view(is_staff='5').get_is_staff_choice(), 0) # Too large self.assertEqual(self.get_view(is_staff=1).get_is_staff_choice(), 1) # Correct
def test_for_user(self): self.assertFalse( Advice.objects.for_user( UserFactory()).filter(pk=AdviceFactory().pk).exists()) # has perm user = UserFactory() assign_perm('advicer.can_view_all_advices', user) self.assertTrue( Advice.objects.for_user(user).filter( pk=AdviceFactory().pk).exists()) # advicer user = UserFactory() self.assertTrue( Advice.objects.for_user(user).filter(pk=AdviceFactory( advicer=user).pk).exists()) # created_by self.assertTrue( Advice.objects.for_user(user).filter(pk=AdviceFactory( created_by=user).pk).exists())
def test_forgot_password_availability(client): user = UserFactory( reset_password_token=User.generate_token(), reset_password_request_date=timezone.now(), ) payload = dict(email=user.email) response = client.post(reverse('users:forgot_password'), payload) assert response.status_code == 400
def test_contains_assigned_cases(self): url = reverse_lazy('cases:list') + '?permission=' + str(self.object.pk) self.login() self.assertNotContains(self.own_resp(), url) user = UserFactory() assign_perm('users.can_view_other', user) assign_perm('cases.can_assign', user) self.login(user=user) self.assertContains(self.get(), url)
def test_patch_picture(self): user = UserFactory(email="*****@*****.**") self.assertIsInstance(user, User) self.set_user(user) self.assertEqual(user.email, "*****@*****.**") data = {"picture": open(self._image_path, "rb")} path = self.get_path(id_detail=user.id) response = self.client.patch( path, data, HTTP_AUTHORIZATION=self.auth, format="multipart" ) self.assertEqual(response.status_code, status.HTTP_200_OK, msg=response.data) self.assertEqual(User.objects.count(), 1) user.refresh_from_db() self.assertEqual(user.picture.name, f"users/{user.id}/picture.jpg")
def test_projects_list_view_for_manager_should_show_only_projects_in_which_he_is_manager( self): manager_user = UserFactory(user_type=CustomUser.UserType.MANAGER.name) manager_project = ProjectFactory() manager_project.managers.add(manager_user) self.client.force_login(manager_user) response = self.client.get(self.url) self.assertEqual(response.status_code, 200) self.assertContains(response, manager_project.name) self.assertNotContains(response, self.project.name)
def test_unauthorized_user_cannot_create_product(self): user = UserFactory(is_admin=False, is_active=True) self.client.force_login(user) response = self.client.post(reverse('products:product-list'), data=self.data) self.assertEqual(response.status_code, 403) self.assertDictEqual( response.json(), {'detail': 'You do not have permission to perform this action.'})
def test_list(self): users = UserFactory.create_batch(3) self.assertEqual(User.objects.count(), 3) self.set_user(users[0]) path = self.get_path() response = self.client.get(path, HTTP_AUTHORIZATION=self.auth) self.assertEqual(response.status_code, status.HTTP_200_OK, msg=response.data) self.assertEqual(len(response.data.get("results")), 1, msg=response.data)
def test_closed_to_assigned(self): staff = UserFactory(is_staff=True) case = CaseFactory(pk=639, status=Case.STATUS.closed) assign_perm('cases.can_send_to_client', staff, case) msg = self.get_message('cc_message.eml') mail_process(sender=self.mailbox, message=msg) case.refresh_from_db() self.assertEqual(case.status, Case.STATUS.assigned)
def test_get(self): user = UserFactory(email="*****@*****.**") self.assertEqual(User.objects.count(), 1) self.set_user(user) path = self.get_path(id_detail=user.id) response = self.client.get(path, HTTP_AUTHORIZATION=self.auth) self.assertEqual(response.status_code, status.HTTP_200_OK, msg=response.data) self.assertEqual(response.data.get("email"), "*****@*****.**")
def setUp(self): cache.clear() self.api_basename = "categories:admin-category" # user self.user = UserFactory.create() self.user.set_password("test1234") self.user.save() refresh = RefreshToken.for_user(self.user) self.client.credentials( HTTP_AUTHORIZATION=f"Bearer {refresh.access_token}")
def test_cannot_see_others_consents(user_api_client): another_user = UserFactory() another_user_consent = UserConsentFactory(user=another_user) response = user_api_client.get(LIST_URL) assert response.status_code == 200 assert len(response.data['results']) == 0 response = user_api_client.get(get_detail_url(another_user_consent)) assert response.status_code == 404
def tagged_users(self, create, extracted, **kwargs): if create: if isinstance(extracted, list): for user in extracted: self.tagged_users.add(user) else: rand_int = random.randint(0, 2) for i in range(rand_int): self.tagged_users.add( UserFactory(connected_users=[], blocked_users=[]))
def test_sync_contact_with_hubspot(mock_hubspot_request): """Test that send_hubspot_request is called properly for a CONTACT sync""" user = UserFactory.create() sync_contact_with_hubspot(user.id) body = make_contact_sync_message(user.id) body[0]["changeOccurredTimestamp"] = ANY mock_hubspot_request.assert_called_once_with("CONTACT", HUBSPOT_SYNC_URL, "PUT", body=body)
def test_project_update_view_should_not_update_managers_if_user_is_manager( self): assert self.project.managers.count() == 0 user_manager = UserFactory(user_type=CustomUser.UserType.MANAGER.name) self.client.force_login(user=user_manager) self.data["managers"] = [self.user.pk, user_manager.pk] response = self.client.post(self.url, self.data) self.assertEqual(response.status_code, 404) self.project.refresh_from_db() self.assertEqual(self.project.managers.count(), 0)
def setUp(self): self.user = UserFactory(password='******') self.staff = UserFactory( password='******', is_staff=True, groups=[JobsBoardAdminGroupFactory()], ) self.job_category = JobCategoryFactory( name='Game Production', slug='game-production' ) self.job_type = JobTypeFactory( name='FrontEnd Developer', slug='frontend-developer' ) self.job = ApprovedJobFactory( description='Lorem ipsum dolor sit amet', category=self.job_category, city='Memphis', region='TN', country='USA', email='*****@*****.**', is_featured=True, telecommuting=True, ) self.job.job_types.add(self.job_type) self.job_draft = DraftJobFactory( description='Lorem ipsum dolor sit amet', category=self.job_category, city='Memphis', region='TN', country='USA', email='*****@*****.**', is_featured=True, creator=self.user, ) self.job_draft.job_types.add(self.job_type)
def setUpClass(cls): super().setUpClass() cls.user = UserFactory.create() cls.user.save() # needed to get names of HVCs, have to do again because factory # remembers other tests, even if flushed from DB for i in range(255): HVCFactory.create( campaign_id='E%03d' % (i + 1), financial_year=16, )
def test_admin_new_password(self): self._make_staff() self._login() UserFactory.create(email='*****@*****.**') response = self.alice_client.post( reverse('admin-new-password'), {'email': '*****@*****.**'}, ) self.assertEqual(response.status_code, 201) self.assertEquals(len(mail.outbox), 1) self.assertEquals( mail.outbox[0].subject, 'Export Wins Login Credentials', ) self.assertIn( 'This email contains your login credentials', mail.outbox[0].body, ) self.assertEqual( mail.outbox[0].to[0], '*****@*****.**', )
def get_data(self): self.email = UserFactory.build().email return {u'attachment_set-0-DELETE': '', u'attachment_set-0-attachment': '', u'attachment_set-0-id': '', u'attachment_set-0-letter': '', u'attachment_set-1-DELETE': '', u'attachment_set-1-attachment': '', u'attachment_set-1-id': '', u'attachment_set-1-letter': '', u'attachment_set-2-DELETE': '', u'attachment_set-2-attachment': '', u'attachment_set-2-id': '', u'attachment_set-2-letter': '', u'attachment_set-INITIAL_FORMS': '0', u'attachment_set-MAX_NUM_FORMS': '1000', u'attachment_set-MIN_NUM_FORMS': '0', u'attachment_set-TOTAL_FORMS': '3', u'client-autocomplete': '', u'email': self.email, u'giodo': 'on', u'name': 'Lorem ipsum subject example', u'text': 'Lorem ipsum example text'}
def setUp(self): self.object = UserFactory(is_staff=False)
def setUp(self): self.client = Client() self.alice_client = AliceClient() self.user = UserFactory.create() self.user.set_password('asdf') self.user.save() self.superuser = UserFactory.create(is_superuser=True, email="[email protected]") self.wins_schema = reverse("drf:win-schema") self.wins_list = reverse("drf:win-list") self.wins_detail = reverse("drf:win-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.customerresponses_schema = reverse("drf:customerresponse-schema") self.customerresponses_list = reverse("drf:customerresponse-list") self.customerresponses_detail = reverse("drf:customerresponse-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.breakdowns_schema = reverse("drf:breakdown-schema") self.breakdowns_list = reverse("drf:breakdown-list") self.breakdowns_detail = reverse("drf:breakdown-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.advisors_schema = reverse("drf:advisor-schema") self.advisors_list = reverse("drf:advisor-list") self.advisors_detail = reverse("drf:advisor-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.win = WinFactory.create() self.WINS_POST_SAMPLE = { "user": self.user.id, "cdms_reference": "cdms reference", "company_name": "company name", "country": "AF", "created": "2016-05-17T12:44:48.021705Z", "customer_email_address": "*****@*****.**", "customer_job_title": "customer job title", "customer_location": 3, "customer_name": "customer name", "date": "1979-06-01", "description": "asdlkjskdlfkjlsdjkl", "goods_vs_services": 1, "has_hvo_specialist_involvement": True, "hq_team": "other:1", "hvo_programme": "BSC-01", "is_e_exported": True, "is_line_manager_confirmed": True, "is_personally_confirmed": True, "is_prosperity_fund_related": True, "lead_officer_name": "lead officer name", "line_manager_name": "line manager name", "location": "Edinburgh, UK", "sector": 1, "team_type": "investment", "total_expected_export_value": 5, "total_expected_non_export_value": 5, "total_expected_odi_value": 5, "type": 1, "type_of_support_1": 1, "business_type": 1, "name_of_export": "name", "name_of_customer": "name", } self.CUSTOMER_RESPONSES_POST_SAMPLE = { "win": str(self.win.pk), "name": "bob", "improved_profile": "1", "gained_confidence": "1", "access_to_information": "1", "expected_portion_without_help": "1", "last_export": "1", "overcame_problem": "1", "developed_relationships": "1", "access_to_contacts": "1", "our_support": "1", "marketing_source": "1", "other_marketing_source": "" } self.BREAKDOWNS_POST_SAMPLE = { "win": str(self.win.pk), "type": Breakdown.TYPE_EXPORT, "year": "1999", "value": "1", } self.ADVISORS_POST_SAMPLE = { "win": str(self.win.pk), "name": "bob", "team_type": "other", "hq_team": "team:1", "location": "france" }
def setUp(self): self.user_list = UserFactory.create_batch(size=1, is_staff=False) self.staff_list = UserFactory.create_batch(size=1, is_staff=True) self.object_list = self.user_list + self.staff_list
def setUp(self): self.obj = UserFactory() self.user = UserFactory()