class InvitationFactory(DjangoModelFactory):
class Meta:
model = 'invitations.Invitation'
email = Sequence(lambda n: str(n) + faker.email())
invited_by = SubFactory('karrot.users.factories.UserFactory')
group = SubFactory('karrot.groups.factories.GroupFactory')
def setUpBeforeMigration(self, apps):
User = apps.get_model('users', 'User')
Group = apps.get_model('groups', 'Group')
Place = apps.get_model('places', 'Place')
PickupDateSeries = apps.get_model('places', 'PickupDateSeries')
PickupDate = apps.get_model('places', 'PickupDate')
Feedback = apps.get_model('places', 'Feedback')
self.email = faker.email()
self.now = datetime.datetime.now(tz=pytz.utc)
self.date = faker.date_time_between(start_date='now',
end_date='+24h',
tzinfo=pytz.utc)
self.group_name = 'Group ' + faker.name()
self.place_name = 'Place ' + faker.name()
user = User.objects.create(email=self.email, display_name='Peter')
group = Group.objects.create(name=self.group_name)
place = Place.objects.create(name=self.place_name, group=group)
pickup_date_series = PickupDateSeries.objects.create(
place=place, start_date=self.now)
pickup_date = PickupDate.objects.create(series=pickup_date_series,
place=place,
date=self.date)
pickup_date.collectors.add(user)
Feedback.objects.create(given_by=user, about=pickup_date)
def setUpBeforeMigration(self, apps):
logging.disable(logging.CRITICAL)
self.email = faker.email()
User = apps.get_model('users', 'User')
History = apps.get_model('history', 'History')
Group = apps.get_model('groups', 'Group')
GroupMembership = apps.get_model('groups', 'GroupMembership')
self.user = User.objects.create(email=self.email, display_name='Peter')
self.group = Group.objects.create(
name=faker.name(),
description=faker.sentence(nb_words=40),
public_description=faker.sentence(nb_words=20),
)
membership = GroupMembership.objects.create(group=self.group,
user=self.user)
self.membership_id = membership.id
self.history = History.objects.create(
typus=HistoryTypus.GROUP_CREATE,
group=self.group,
payload={},
)
self.history.users.add(self.user)
self.history.save()
self.history.date = timezone.now() - relativedelta(days=100)
self.history.save()
self.user.created_at = timezone.now() - relativedelta(days=200)
self.user.save()
def setUpBeforeMigration(self, apps):
User = apps.get_model('users', 'User')
Group = apps.get_model('groups', 'Group')
Place = apps.get_model('places', 'Place')
Conversation = apps.get_model('conversations', 'Conversation')
PickupDate = apps.get_model('pickups', 'PickupDate')
Application = apps.get_model('applications', 'Application')
ContentType = apps.get_model('contenttypes', 'ContentType')
self.group = Group.objects.create(name='hello')
target_type = ContentType.objects.get(app_label='groups',
model='group')
self.group_conversation = Conversation.objects.create(
target_type=target_type, target_id=self.group.id)
self.none_conversation = Conversation.objects.create()
self.private_conversation = Conversation.objects.create(
is_private=True)
place = Place.objects.create(group=self.group)
pickup = PickupDate.objects.create(place=place,
date=to_range(timezone.now()))
target_type = ContentType.objects.get(app_label='pickups',
model='pickupdate')
self.pickup_conversation = Conversation.objects.create(
target_type=target_type, target_id=pickup.id)
user = User.objects.create(email=faker.email())
application = Application.objects.create(user=user, group=self.group)
target_type = ContentType.objects.get(app_label='applications',
model='application')
self.application_conversation = Conversation.objects.create(
target_type=target_type, target_id=application.id)
def test_superusers_have_all_perms(self):
email = faker.email()
superuser = get_user_model().objects.create_superuser(email, 'foo')
self.assertTrue(superuser.has_perm('eating horses'))
self.assertTrue(
superuser.has_perm('eating this specific horse',
'I am a kind and gentle horse'))
self.assertTrue(superuser.has_module_perms('lunar'))
def setUpBeforeMigration(self, apps):
User = apps.get_model('users', 'User')
self.user_not_verified = User.objects.create(
email=faker.email(),
activation_key='123',
key_expires_at=timezone.now() + timedelta(minutes=1),
mail_verified=False)
self.user_verified = User.objects.create(email=faker.email(),
activation_key='',
key_expires_at=None,
mail_verified=True)
self.user_code_expired = User.objects.create(
email=faker.email(),
activation_key='123',
key_expires_at=timezone.now() - timedelta(minutes=1),
mail_verified=False)
def setUp(self):
self.verified_user = VerifiedUserFactory()
self.another_user = VerifiedUserFactory()
self.old_email = self.verified_user.email
self.new_email = faker.email()
self.password = self.verified_user.display_name
self.url = '/api/auth/email/'
self.url_patch = '/api/auth/user/'
mail.outbox = []
def test_normal_users_have_no_perms(self):
email = faker.email()
user = get_user_model().objects.create_user(email,
'foo',
display_name='I am normal')
self.assertFalse(user.has_perm('eating horses'))
self.assertFalse(
user.has_perm('eating this specific horse',
'I am a kind and gentle horse'))
self.assertFalse(user.has_module_perms('lunar'))
def test_changing_sensitive_fields_is_forbidden(self):
self.client.force_login(user=self.verified_user)
response = self.client.get(self.url_patch)
original = response.data
response = self.client.patch(self.url_patch, {'unverified_email': faker.email()})
self.assertEqual(response.data['unverified_email'], original['unverified_email'])
response = self.client.patch(self.url_patch, {'mail_verified': False})
self.assertEqual(response.data['mail_verified'], True)
def setUp(self):
self.user = UserFactory()
self.url = '/api/auth/user/'
self.user_data = {
'email': faker.email(),
'password': faker.name(),
'display_name': faker.name(),
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude()
}
mail.outbox = []
def make_user():
response = c.post(
'/api/auth/user/', {
'email': str(timezone.now().microsecond) + faker.email(),
'password': default_password,
'display_name': faker.name(),
'description': 'I am a fake user',
'mobile_number': faker.phone_number()
})
if response.status_code != 201:
raise Exception('could not make user', response.data)
print('created user:'******'email'])
return response.data
def setUpBeforeMigration(self, apps):
User = apps.get_model('users', 'User')
Conversation = apps.get_model('conversations', 'Conversation')
ConversationParticipant = apps.get_model('conversations',
'ConversationParticipant')
user = User.objects.create(email=faker.email(),
display_name=faker.name())
conversation = Conversation.objects.create()
self.non_muted_id = ConversationParticipant.objects.create(
user=user, conversation=conversation).id
conversation = Conversation.objects.create()
self.muted_id = ConversationParticipant.objects.create(
user=user, conversation=conversation, email_notifications=False).id
def setUp(self):
self.user = UserFactory()
self.user.photo = 'photo.jpg'
self.user.save()
self.user2 = UserFactory()
self.url = '/api/users/'
self.user_data = {
'email': faker.email(),
'password': faker.name(),
'display_name': faker.name(),
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude()
}
self.group = GroupFactory(members=[self.user, self.user2])
self.another_common_group = GroupFactory(members=[self.user, self.user2])
self.user_in_another_group = UserFactory()
self.another_group = GroupFactory(members=[self.user_in_another_group])
mail.outbox = []
class UserFactory(DjangoModelFactory):
class Meta:
model = get_user_model()
strategy = CREATE_STRATEGY
is_active = True
is_staff = False
display_name = LazyAttribute(lambda _: faker.name())
email = Sequence(lambda n: str(n) + faker.email())
description = LazyAttribute(lambda _: faker.text())
# Use display_name as password, as it is readable
password = PostGeneration(
lambda obj, *args, **kwargs: obj.set_password(obj.display_name))
@classmethod
def _create(cls, model_class, *args, **kwargs):
manager = cls._get_manager(model_class)
user = manager.create_user(*args, **kwargs)
return user
def setUpBeforeMigration(self, apps):
self.Reaction = Reaction = apps.get_model(
'conversations', 'ConversationMessageReaction')
User = apps.get_model('users', 'User')
Message = apps.get_model('conversations', 'ConversationMessage')
Conversation = apps.get_model('conversations', 'Conversation')
user = User.objects.create(email=faker.email())
conversation = Conversation.objects.create()
message = Message.objects.create(conversation=conversation,
author=user)
self.reaction = Reaction.objects.create(message=message,
user=user,
name='laughing')
self.alias_reaction = Reaction.objects.create(message=message,
user=user,
name='boat')
self.duplicate_alias_reaction = Reaction.objects.create(
message=message, user=user, name='satisfied')
self.unknown_reaction = Reaction.objects.create(message=message,
user=user,
name='flag_de')
def setUpBeforeMigration(self, apps):
logging.disable(logging.CRITICAL)
self.email = faker.email()
User = apps.get_model('users', 'User')
User.objects.create(email=self.email, display_name='Peter')
def test_create_superuser(self):
email = faker.email()
get_user_model().objects.create_superuser(email, 'letmein')
self.assertEqual(get_user_model().objects.filter(email=email).count(),
1)
