def test_user_count(settings): """A basic test to execute the get_users_count Celery task.""" UserFactory.create_batch(3) settings.CELERY_TASK_ALWAYS_EAGER = True task_result = get_users_count.delay() assert isinstance(task_result, EagerResult) assert task_result.result == 3
def test_user_with_manage_perm_can_see_invisible_event(self): user = UserFactory() user.full_clean() permission = Permission.objects.get(codename='manage_events') user.user_permissions.add(permission) event = factories.EventFactory(visible=False) self.assertTrue(event._user_can_see_or_404(user))
def setUp(self): self.commented_user = UserFactory() self.comment = CommentUserFactory(content_object=self.commented_user) self.endpoint = reverse('users:user-activities', kwargs={'pk': self.commented_user.pk}) self.reading_user = UserFactory() self.client.force_authenticate(user=self.reading_user) self.response = self.client.get(self.endpoint)
def setUp(self): self.login_path = reverse('rest_login') # Create user and verify him self.verified_user = UserFactory(password='******') VerifiedUserFactory(user=self.verified_user) # Create unverified user self.unverified_user = UserFactory(password='******') VerifiedUserFactory(user=self.unverified_user, verified=False)
def test_chat_model_recipients(api_client, user): other_user = UserFactory() chat = ChatFactory(creator=user) chat.moderators.add(user) chat.users.add(user) chat.users.add(other_user) message = MessageFactory(chat=chat, creator=other_user) message.viewed_by.add(other_user) recipients = chat.get_recipients(sender=user) assert len(recipients) == 1 assert recipients[0] == other_user.name other_user.is_deleted = True other_user.save(update_fields=("is_deleted", )) recipients = chat.get_recipients(sender=user) assert len(recipients) == 1 assert recipients[0] == other_user.name other_user.is_active = False other_user.save(update_fields=("is_active", )) recipients = chat.get_recipients(sender=user) assert len(recipients) == 1 assert recipients[0] == other_user.name
def test_clean_username(self): # A user with proto_user params does not exist yet. proto_user = UserFactory.build() form = UserCreationForm( { "username": proto_user.username, "password1": proto_user._password, "password2": proto_user._password, } ) assert form.is_valid() assert form.clean_username() == proto_user.username # Creating a user. form.save() # The user with proto_user params already exists, # hence cannot be created. form = UserCreationForm( { "username": proto_user.username, "password1": proto_user._password, "password2": proto_user._password, } ) assert not form.is_valid() assert len(form.errors) == 1 assert "username" in form.errors
def test_authenticated(self, user: User, rf: RequestFactory): request = rf.get("/fake-url/") request.user = UserFactory() response = user_detail_view(request, username=user.username) assert response.status_code == 200
def test_get_event_for_moderation_returns_event_if_it_exists_and_user_has_perms(self): event = factories.EventFactory() user_w_perms = UserFactory() permission = Permission.objects.get(codename='manage_events') user_w_perms.user_permissions.add(permission) ret = Event.get_event_for_moderation_or_404(event.id, user_w_perms) self.assertEqual(event, ret)
def setUpTestData(cls): cls.user = UserFactory() # This should have its own factory, but this will do. cls.table = Table.objects.create( table_name='movies', fields={ 'title': { 'field_type': 'str', 'is_unique': True }, 'release_date': 'datetime', 'imdb_ranking': 'float', 'director': { 'field_type': 'int', 'foreign_key': 'directors.id' } } ) cls.valid_data = { 'table_name': 'another_table', 'fields': { 'field_one': {'field_type': 'str', 'primary_key': True}, 'field_two': 'int' } } cls.table_url = reverse('api:tables:table-detail', args=[cls.table.table_name]) cls.table_list_url = reverse('api:tables:table-list')
def test_get_user_progress_percent(): chapter = ChapterFactory() sub_chapters = SubChapterFactory.create_batch(chapter=chapter, size=5) user = UserFactory() StudentProgressFactory(user=user, sub_chapter=sub_chapters[0]) StudentProgressFactory(user=user, sub_chapter=sub_chapters[1]) assert get_user_progress_percent(chapter, user) == 40.0
def test_can_perform_group_modifications(self, position_state, expected_result): user = UserFactory() membership = UserTeamMembershipFactory(user=user, position_state=position_state) assert can_perform_group_modifications(membership, user) is expected_result
def test_make_user_admin_of_team__transition_not_allowed(): # Arrange membership = UserTeamMembershipFactory() user = UserFactory() # Act / Assert with pytest.raises(TransitionNotAllowed): make_user_admin_of_team(user, team=membership.team)
def setUp(self): self.login_path = reverse('rest_login') self.password_change_path = reverse('rest_password_change') self.verified_user = UserFactory(password='******') VerifiedUserFactory(user=self.verified_user) self.client.login(self.login_path, email=self.verified_user.email, password='******')
def test_invitee_is_already_user(self): existing_user_email = '*****@*****.**' existing_user = UserFactory(email=existing_user_email) UserTenantRelationshipFactory(user=existing_user) self.client.force_authenticate(user=self.user) post_data = {"email": existing_user_email} response = self.client.post(self.invite_path, data=post_data) assert response.status_code == status.HTTP_201_CREATED
def setUp(self): SUPER_ROLE, _ = Role.objects.get_or_create(name='SUPER_USER') self.client = APIClient() self.super_user = UserFactory(email='*****@*****.**', role=SUPER_ROLE) self.village = VillageFactory() self.parcel = ParcelFactory() self.destination = DestinationFactory() self.oven_type = OvenTypeFactory() self.tree_specie = TreeSpecieFactory()
def test_checks_unique_item_type_per_user(self, item_type, model): user = UserFactory() # cash accounts for the same user are created normally CashAccountFactory(user=user) CashAccountFactory(user=user) with self.assertRaises(IntegrityError): model.objects.create(user=user, name=f'{item_type} 1')
def test_existing_user(self): existing_user = UserFactory() existing_user_invite = InviteFactory(email=existing_user.email) existing_user_retrieve_path = reverse( 'rest_invite_retrieve', kwargs={'tenant_name': existing_user_invite.tenant.name, 'pk': existing_user_invite.pk} ) response = self.client.get(existing_user_retrieve_path) assert response.data['detail'] == f'Your account is now successfully connected to {existing_user_invite.tenant.name}.'
def setUp(self): state1 = SystemState(year="2010/11") state1.save() state2 = SystemState(year="2018/19") state2.save() students = [StudentFactory(), StudentFactory()] proposals = [ ProposalFactory(name="Pranie"), ProposalFactory(name="Zmywanie") ] SingleVote.objects.bulk_create([ SingleVote(state=state1, student=students[0], proposal=proposals[0], value=2), SingleVote(state=state1, student=students[1], proposal=proposals[0], value=0), SingleVote(state=state1, student=students[0], proposal=proposals[1], value=3), SingleVote(state=state1, student=students[1], proposal=proposals[1], value=1), SingleVote(state=state2, student=students[0], proposal=proposals[0], value=0), SingleVote(state=state2, student=students[1], proposal=proposals[0], value=0, correction=1), SingleVote(state=state2, student=students[0], proposal=proposals[1], value=3), SingleVote(state=state2, student=students[1], proposal=proposals[1], value=1, correction=2), ]) self.state1 = state1 self.state2 = state2 self.students = students self.employee = EmployeeFactory() self.semester = SemesterFactory() self.course_instance = CourseInstanceFactory(offer=proposals[1], semester=self.semester) self.staff_member = UserFactory(is_staff=True)
def setUp(self): self.anonym_client = self.get_anonymous_client() self.url = "/api/token/" self.example_password = "******" self.user = UserFactory(password=self.example_password) self.example_data = { "username": self.user.username, "password": self.example_password, }
def test_get_followers_when_type_other_than_exam_or_test(self): users = UserFactory.create_batch(random.randint(10, 20)) event = factories.EventFactory( type=random.choice([Event.TYPE_GENERIC, Event.TYPE_CLASS, Event.TYPE_OTHER]), interested=users ) followers = event.get_followers() users_emails = [user.email for user in users] self.assertEqual(len(users_emails), len(followers)) for email in users_emails: self.assertTrue(email in followers)
def test_state_transition__link_acount__happy_path(PatchedTwilio): # Arrange phone_number = PhoneNumberFactory(user=None) user = UserFactory() PatchedTwilio() # Act assert phone_number.account_link_state == PhoneNumber.AccountLinkState.INITIAL_STATE phone_number.link_account(user) # Assert assert phone_number.account_link_state == PhoneNumber.AccountLinkState.ATTEMPT_PHONE_LINK
def test_get_for_user(self): users = UserFactory.create_batch(8) users += self.users events = factories.EventFactory.create_batch(random.randint(50, 100), author=random.choice(users)) events.append(self.event) user = random.choice(users) events_for_user = Event.get_for_user(user) filtered_events = [x for x in events if x.author == user] self.assertEqual(len(filtered_events), len(events_for_user)) filtered_pk = [x.pk for x in filtered_events] for i in range(0, len(events_for_user)): self.assertTrue(events_for_user[i].pk in filtered_pk)
def setUp(self): # we ca't use patch decorador # because it wouldn't patch inside of setUp method. patcher = patch( 'apps.api.rest.v1.api_wrapper.sz_api.sz_api.requests', new=RequestsClient()) patcher.start() self.addCleanup(patcher.stop) employee = UserFactory(is_staff=True) token = Token.objects.create(user=employee) self.wrapper = ZapisyApi( "Token " + token.key, "http://testserver/api/v1/")
def test_make_user_admin_of_team__happy_path(): # Arrange team = TeamFactory() user = UserFactory() # Act make_user_admin_of_team(user, team) # Assert membership = UserTeamMembership.objects.first() assert membership.team == team assert membership.user == user assert membership.position_state == UserTeamMembership.PositionState.ADMIN
def test_create_dialog(self): friend = UserFactory() response = self.client.post( reverse('dialogs-list'), data={ 'user_id': friend.pk, }, format='json', ) assert response.status_code == 201 dialog_id = response.data['id'] dialog = Dialog.objects.get(pk=dialog_id) assert self.user.pk in dialog.users assert friend.pk in dialog.users
def test_user_joins_team__happy_path(self, client, login_user): # Arrange team = TeamFactory() user = UserFactory() login_user(user) # Act resp = client.post(f"/teams/join/", {"join_code": team.join_code}) # check that user is on team assert resp.status_code == 302 conditions = {"team": team, "user": user} membership = UserTeamMembership.objects.filter(**conditions).all() assert len(membership) == 1
def setUpTestData(cls): cls.user = UserFactory() # This should have its own factory, but this will do. cls.table = Table.objects.create( table_name='movies', fields={ 'title': { 'field_type': 'str', 'is_unique': True }, 'release_date': 'datetime', 'imdb_ranking': 'float', 'director': { 'field_type': 'int', 'foreign_key': 'directors.id' } } ) cls.entry_1 = Entry.objects.create( table=cls.table, data={ 'title': 'Title One', 'release_date': '2019-02-02', 'director': 2, 'imdb_ranking': 6.5 } ) cls.entry_2 = Entry.objects.create( table=cls.table, data={ 'title': 'Title Two', 'release_date': '2019-03-02', 'director': 3, 'imdb_ranking': 9.0 } ) cls.valid_data = { 'title': 'The Title', 'director': 1, 'imdb_ranking': 7.3, 'release_date': '1990-08-27', } cls.entry_list_url = reverse('api:tables:entry-list', args=[cls.table.table_name]) cls.entry_query_url = reverse('api:tables:entry-query', args=[cls.table.table_name])
def test_user_joins_team_with_old_join_code__rejected( self, client, login_user): # Arrange team = TeamFactory() old_join_code = team.join_code team.generate_new_join_code() user = UserFactory() login_user(user) # Act resp = client.post(f"/teams/join/", {"join_code": old_join_code}) # Assert user should not be on team assert resp.status_code == 200 conditions = {"team": team, "user": user} membership = UserTeamMembership.objects.filter(**conditions).all() assert len(membership) == 0
def create_test_user(user=None, role_assignment_data=None): if not user: user = UserFactory() if role_assignment_data: rps = role_assignment_data.pop("revenue_programs", None) org = role_assignment_data.pop("organization", None) ra = RoleAssignmentFactory(user=user, **role_assignment_data) do_save = False if rps: ra.revenue_programs.set(rps) do_save = True if org: do_save = True ra.organization = org if do_save: ra.save() else: RoleAssignmentFactory(user=user) return user
def generate_random_news(category, new=randint(1, 6), old=randint(1, 6)): ns = [] author_user = UserFactory() for i in range(new): n = News(title="news", body="news body", date=datetime.now() - timedelta(days=randint(0, 6)), author_id=author_user.pk) n.category = category n.save() ns.append(n) for i in range(old): n = News(title="old news", body="news body", date=datetime.now() - timedelta(days=randint(8, 20)), author_id=author_user.pk) n.category = category n.save() ns.append(n) return (new, old, ns)