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)
