def test_apiview_get_multiple(rf, no_extra_users):
"""Tests retrieving multiple objects using the API."""
view = UserAPIView.as_view()
UserFactory.create(username='******')
request = create_api_request(rf)
response = view(request)
response_data = json.loads(response.content)
# Response should contain a 1-item list
assert response.status_code == 200
assert isinstance(response_data, dict)
assert 'count' in response_data
assert 'models' in response_data
assert len(response_data['models']) == User.objects.count()
# Let's add more users
UserFactory.create_batch(5)
response = view(request)
response_data = json.loads(response.content)
assert response.status_code == 200
assert isinstance(response_data, dict)
assert 'count' in response_data
assert 'models' in response_data
assert len(response_data['models']) == User.objects.count()
# Let's add even more users to test pagination
UserFactory.create_batch(5)
response = view(request)
response_data = json.loads(response.content)
# First page is full
assert response.status_code == 200
assert isinstance(response_data, dict)
assert 'count' in response_data
assert 'models' in response_data
assert len(response_data['models']) == 10
request = create_api_request(rf, url='/?p=2')
response = view(request)
response_data = json.loads(response.content)
# Second page constains a single user
assert response.status_code == 200
assert isinstance(response_data, dict)
assert 'count' in response_data
assert 'models' in response_data
assert len(response_data['models']) == User.objects.count() - 10
def generate() -> None:
"""
Generates some initial records in database
"""
from tests.factories import UserFactory, ActionFactory, MessageFactory, CostFactory
db.connect()
db.create_tables([db_models.User, db_models.Cost, db_models.Action, db_models.Photo, db_models.Message])
# will generate the whole database by chain of subfactories
UserFactory.create_batch(size=5)
ActionFactory.create_batch(size=5)
MessageFactory.create_batch(size=5)
CostFactory.create_batch(size=5)
click.secho("\nGeneration done!", fg='green')
db.close()
def test_update_editor_follows_signal(client, factory, reverse):
m1, m2 = factory.create_batch(2)
u1, u2, u3, u4 = UserFactory.create_batch(4)
if not reverse:
for user in [u1, u2, u3, u4]:
user.groups.add(m1.editors_group, m2.editors_group)
for user in [u3, u4]:
user.groups.remove(m1.editors_group)
for user in [u1, u2, u3, u4]:
user.groups.remove(m2.editors_group)
else:
g = Group.objects.filter(name=m1.editors_group).get()
g.user_set.add(u1, u2, u3, u4)
g.user_set.remove(u3, u4)
assert is_following(u1, m1)
assert is_following(u2, m1)
assert not is_following(u3, m1)
assert not is_following(u4, m1)
assert not is_following(u1, m2)
assert not is_following(u2, m2)
assert not is_following(u3, m2)
assert not is_following(u4, m2)
# Test clearing
if reverse:
u1.groups.clear()
else:
g = Group.objects.filter(name=m1.editors_group).get()
g.user_set.clear()
assert not is_following(u1, m1)
def test_get_receivers(factory, action):
u1, u2, u3, u4 = UserFactory.create_batch(4)
for user in [u1, u2]:
user.user_profile.receive_newsletter = True
user.user_profile.save()
if action == SendActionChoices.STAFF:
user.is_staff = True
user.save()
if factory == ChallengeFactory:
obj = factory(creator=u1)
obj2 = factory(creator=u2)
elif factory in [AlgorithmFactory, ReaderStudyFactory]:
obj = factory()
obj2 = factory()
obj.add_editor(u1)
obj2.add_editor(u2)
receivers = get_receivers(action)
assert len(receivers) == 2
for user in [u1, u2]:
assert user in receivers
for user in [u3, u4]:
assert user not in receivers
def test_get_users(db: Session, client: TestClient, http_basic_auth: HTTPBasicAuth):
existing_users = user_crud.get_multi(db)
users = UserFactory.create_batch(3)
response = client.get('/users', auth=http_basic_auth)
assert response.status_code == status.HTTP_200_OK
actual_users = UserListSchema(__root__=existing_users + users)
retrieved_users = UserListSchema.parse_raw(response.text)
assert actual_users == retrieved_users
def test_dispatch_event_with_backends(self):
users = UserFactory.create_batch(size=5)
self.assertEqual(0, Event.objects.filter(verb=CONFIRMED_EVENT).count())
stuff = StuffFactory()
stuff.confirm()
self.assertEqual(1, Event.objects.filter(verb=CONFIRMED_EVENT).count())
event = Event.objects.filter(verb=CONFIRMED_EVENT).first()
self.assertTrue(isinstance(event.handler(), ConfirmedHandler))
self.assertEqual(ConfirmedHandler.title, event.title())
self.assertTrue(event.notified)
self.assertEqual(len(users), Notification.objects.all().count())
def main(num_manufacturers, num_items_per_man, num_orders):
mans = ManufacturerFactory.create_batch(num_manufacturers)
print(f"Created {num_manufacturers} Manufacturers")
items = list(
chain.from_iterable([
ItemFactory.create_batch(num_items_per_man, manufacturer=man)
for man in mans
]))
print(f"Created {len(items)} Items")
users = UserFactory.create_batch(50)
for _ in range(0, num_orders):
num_items = random.randint(5, 20)
user = random.choice(users)
OrderFactory.create(user=user, items=random.sample(items, num_items))
print(f"Created {num_orders} Orders")
def handle(self, *args, **options):
call_command("reset_db", "--noinput")
call_command("migrate")
library = LibraryFactory()
UserFactory(username="******",
email="*****@*****.**",
password="******",
is_superuser=True)
users = UserFactory.create_batch(2, is_staff=False)
GroupFactory.create_batch(5)
for author in AuthorFactory.create_batch(10):
for book in BookFactory.create_batch(5,
author=author,
library=library):
BookLoanFactory(book=book, borrower=choice(users))
self.stdout.write("All Data reset")
def test_email_content(settings):
# Override the celery settings
settings.task_eager_propagates = (True,)
settings.task_always_eager = (True,)
email = EmailFactory(subject="Test email", body="Test content")
u1, u2 = UserFactory.create_batch(2)
for user in [u1, u2]:
user.user_profile.receive_newsletter = True
user.user_profile.save()
assert len(mail.outbox) == 0
send_bulk_email(action=SendActionChoices.MAILING_LIST, email_pk=email.pk)
assert len(mail.outbox) == 2
email.refresh_from_db()
assert email.sent
for m in mail.outbox:
assert (
m.subject
== f"[{Site.objects.get_current().domain.lower()}] Test email"
)
assert "Test content" in m.body
if m.to == [u1.email]:
assert reverse(
"profile-update", kwargs={"username": u1.username}
) in str(m.alternatives)
else:
assert reverse(
"profile-update", kwargs={"username": u2.username}
) in str(m.alternatives)
# check that email sending task is idempotent
mail.outbox.clear()
send_bulk_email(action=SendActionChoices.MAILING_LIST, email_pk=email.pk)
assert len(mail.outbox) == 0
def create_factories(self):
super().create_factories()
u1, u2 = UserFactory.create_batch(2, with_unix_account=True)
inconsistent = UserFactory.create(with_unix_account=True, email=None)
p_dummy = PropertyGroupFactory.create(name='group_without_grants')
pg_member = PropertyGroupFactory.create(
name='member', granted={'mail', 'ldap_login_enabled'})
UserWithMembershipFactory.create(membership__group=p_dummy,
with_unix_account=True)
for user in [u1, u2, inconsistent]:
MembershipFactory.create(group=pg_member, user=user)
MembershipFactory.create(
user=inconsistent,
group=PropertyGroupFactory.create(
name='some_weird_group',
granted={
'mail'
}, # weird, because grants mail, but not ldap_login_enabled
),
)
def test_post_authors_permissions_signal(client, reverse):
p1, p2 = PostFactory.create_batch(2)
u1, u2, u3, u4 = UserFactory.create_batch(4)
# Remove permissions from the default created user
p1.authors.clear()
p2.authors.clear()
if reverse:
for user in [u1, u2, u3, u4]:
user.blog_authors.add(p1, p2)
for user in [u3, u4]:
user.blog_authors.remove(p1, p2)
for user in [u1, u2]:
user.blog_authors.remove(p2)
else:
# Test that adding authors works
p1.authors.add(u1, u2, u3, u4)
# Test that removing authors works
p1.authors.remove(u3, u4)
assert get_users_with_set_perms(p1) == {
u1: {"change_post"},
u2: {"change_post"},
}
assert get_users_with_set_perms(p2) == {}
# Test clearing
if reverse:
u1.blog_authors.clear()
u2.blog_authors.clear()
else:
p1.authors.clear()
assert get_users_with_set_perms(p1) == {}
assert get_users_with_set_perms(p2) == {}
def test_get_users(db: Session):
actual_users = UserFactory.create_batch(3)
retrieved_users = user_crud.get_multi(db)
assert actual_users == retrieved_users
def create_factories(self):
super().create_factories()
self.group = PropertyGroupFactory.create()
self.user, self.processor = UserFactory.create_batch(2)
def make_fake_users(count=1, is_staff=False):
if count == 1:
return UserFactory(is_staff=is_staff)
else:
return UserFactory.create_batch(count, is_staff=is_staff)
def create_factories(self):
super().create_factories()
UserFactory.create_batch(5)
def test_get_export_users(self):
UserFactory.create_batch(size=20)
with self.login(self.user):
self.get("backoffice:user-export")
self.response_200()
def user_data(session):
return UserFactory.create_batch(5)
