def setUp(self):
User = get_user_model()
self.student = mommy.prepare(User, is_active=True)
self.student.set_password('123')
self.student.save()
self.leader = mommy.prepare(User, is_active=True)
self.leader.set_password('123')
self.leader.save()
self.superuser = mommy.prepare(
User, is_active=True, is_superuser=True, is_staff=True
)
self.superuser.set_password('123')
self.superuser.save()
self.project1 = mommy.make(Project, leader=self.leader)
self.project2 = mommy.make(Project)
self.announcements_project1 = mommy.make(
Announcement, project=self.project1, fixed=False, _quantity=5
)
self.announcements_project2 = mommy.make(
Announcement, project=self.project2, fixed=False, _quantity=10
)
self.enrollment = mommy.make(
Enrollment, project=self.project1, user=self.student,
blocked=True
)
self.client = Client()
def test_financial_aid_in_range_0_to_100(self):
trips_year = self.init_trips_year()
with self.assertRaises(ValidationError):
mommy.make(IncomingStudent, trips_year=trips_year, financial_aid=-1).full_clean()
with self.assertRaises(ValidationError):
mommy.prepare(IncomingStudent, trips_year=trips_year, financial_aid=101).full_clean()
mommy.prepare(IncomingStudent, trips_year=trips_year, financial_aid=100).full_clean()
def test_has_module_perms(self):
"""Staff members have all Django admin perms"""
user = prepare(User, is_staff=False)
self.assertFalse(user.has_module_perms("foo"), user)
user = prepare(User, is_staff=True)
self.assertTrue(user.has_module_perms("foo"), user)
def test(self):
class Car(models.Model):
name = models.CharField(max_length=255)
class CarIndex(Index):
class Meta:
fields = ['name']
model = Car
CarIndex.objects.put_mapping()
# I don't understand why this is the *only* test that will randomly
# blow up, unless you give ES a little time to do its thing
time.sleep(.1)
with suspended_updates():
car = prepare(Car, pk=1)
car2 = prepare(Car, pk=2)
car3 = prepare(Car, pk=3)
CarIndex.objects.update([car])
CarIndex.objects.update(car2)
CarIndex.objects.update(car3)
# bulk saving shouldn't happen yet
self.assertEqual([], CarIndex.objects.query("match", name=car.name).execute().hits)
# suspended_updates should handle deletes too
CarIndex.objects.delete(car3)
# now saving to ES should have happen
self.assertEqual(1, len(CarIndex.objects.query("match", name=car.name).execute().hits))
self.assertEqual(1, len(CarIndex.objects.query("match", name=car2.name).execute().hits))
# the third car was deleted
self.assertEqual(0, len(CarIndex.objects.query("match", name=car3.name).execute().hits))
def __create_distinct_comments(self, label):
assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
group = mommy.make('core.AssignmentGroup', parentnode=assignment)
feedbackset = mommy.make('devilry_group.FeedbackSet', group=group)
examiner = mommy.make('core.Examiner',
assignmentgroup=group,
relatedexaminer__user=mommy.make(settings.AUTH_USER_MODEL))
count = 100
comments = []
for x in range(count):
comments.append(mommy.prepare(GroupComment, user=examiner.relatedexaminer.user, feedback_set=feedbackset,
user_role=GroupComment.USER_ROLE_ADMIN))
comments.append(mommy.prepare(GroupComment, user=examiner.relatedexaminer.user, feedback_set=feedbackset,
user_role=GroupComment.USER_ROLE_STUDENT))
comments.append(mommy.prepare(GroupComment, user=examiner.relatedexaminer.user, feedback_set=feedbackset,
user_role=GroupComment.USER_ROLE_EXAMINER))
with TimeExecution('{} ({})'.format(label, count)):
for c in comments:
c.save()
# for c in comments:
# c.delete()
#
return group
def test_wipes_old_email(self):
"""Test that old emails are wiped"""
latest_email_open = mommy.prepare(EmailOpen)
latest_email_open.user_agent = ''
latest_email_open.save()
old_email_open = mommy.prepare(EmailOpen)
old_email_open.user_agent = ''
old_email_open.opened_at = self.month_ago
old_email_open.save()
# As the database will always update with the last modified at time we
# need to do an `UPDATE` operation in the database to change the time
# the open was created.
EmailOpen.objects.filter(
pk=old_email_open.pk).update(opened_at=self.month_ago)
all_email_opens_pre = EmailOpen.objects.all()
self.assertIn(latest_email_open, all_email_opens_pre)
self.assertIn(old_email_open, all_email_opens_pre)
tasks.wipe_old_email_opens()
all_email_opens_post = EmailOpen.objects.all()
self.assertIn(latest_email_open, all_email_opens_post)
self.assertNotIn(old_email_open, all_email_opens_post)
def test_str(self):
user = prepare(User, first_name="foo", last_name="bar")
self.assertEqual(str(user), "bar, foo")
# the str method should fall back on the email address if a part of
# their name is blank
user = prepare(User, first_name="", last_name="bar")
self.assertEqual(str(user), user.email)
def test_can_cloak_as(self):
"""Only staffers can cloak"""
user = prepare(User, is_staff=False)
self.assertFalse(user.has_module_perms("foo"), user)
user = prepare(User, is_staff=True)
self.assertTrue(user.has_module_perms("foo"), user)
def test_allow_create_fkey_related_model(self):
try:
person = mommy.make(Person, dog_set=[mommy.prepare(Dog), mommy.prepare(Dog)])
except TypeError:
self.fail('type error raised')
self.assertEqual(person.dog_set.count(), 2)
def test_prepare_should_create_objects_respecting_quantity_parameter(self):
people = mommy.prepare(Person, _quantity=5)
self.assertEqual(len(people), 5)
self.assertTrue(all(not p.id for p in people))
people = mommy.prepare(Person, _quantity=5, name="George Washington")
self.assertTrue(all(p.name == "George Washington" for p in people))
def test_checks_if_token_has_expired(self):
# expired token
yesterday = datetime.now() - timedelta(days=1)
sso_user_token = mommy.prepare(SSOUserToken, expiration_datetime=yesterday)
self.assertTrue(sso_user_token.has_expired)
# valid token
tomorrow = datetime.now() + timedelta(days=1)
sso_user_token = mommy.prepare(SSOUserToken, expiration_datetime=tomorrow)
self.assertFalse(sso_user_token.has_expired)
def test_clean_grading_points_is_none(self):
testuser = mommy.prepare(settings.AUTH_USER_MODEL)
testfeedbackset = mommy.prepare('devilry_group.FeedbackSet',
grading_published_datetime=timezone.now(),
grading_published_by=testuser,
grading_points=None)
with self.assertRaisesMessage(ValidationError,
'A FeedbackSet can not be published without providing "points".'):
testfeedbackset.clean()
def test_password_field_only_when_user_being_created(self):
"""
The password field should only be on the form if the user is being
created (not edited)
"""
form = UserForm(user=prepare(User))
self.assertIn("password", form.fields)
form = UserForm(instance=make(User), user=prepare(User))
self.assertNotIn("password", form.fields)
def setUp(self):
User = get_user_model()
self.student = mommy.prepare(User, is_active=True)
self.student.set_password('123')
self.student.save()
self.leader = mommy.prepare(User, is_active=True)
self.leader.set_password('123')
self.leader.save()
self.project = mommy.make(
Project, leader=self.leader, open_enrollment=True
)
def test_category_list_content(mocker):
"""Test the dictionary with the months and years."""
category_mock = mocker.patch('djangopress.blog.models.Category.objects')
uncategorized = mommy.prepare(Category, name='Uncategorized')
uncategorized.pk = 1
categories = mommy.prepare(Category, _quantity=3)
categories.insert(0, uncategorized)
category_mock.all.return_value = categories
dictionary = {}
dictionary['categories'] = categories
assert category_list() == dictionary
def test_bus_assignment_is_either_one_way_or_round_trip(self):
msg = "Cannot have round-trip AND one-way bus assignments"
with self.assertRaisesRegexp(ValidationError, msg):
mommy.prepare(
IncomingStudent, bus_assignment_round_trip=mommy.make(Stop), bus_assignment_to_hanover=mommy.make(Stop)
).full_clean()
with self.assertRaisesRegexp(ValidationError, msg):
mommy.prepare(
IncomingStudent,
bus_assignment_round_trip=mommy.make(Stop),
bus_assignment_from_hanover=mommy.make(Stop),
).full_clean()
def test_tag(self):
# dog = Recipe(Dog)
# tag_recipe = Recipe(
# Tag,
# content_object=foreign_key(dog))
# tag = tag_recipe.prepare()
dog = mommy.prepare(Dog)
tag = mommy.prepare(Tag)
tag.content_object = dog
self.assertIsNotNone(tag.content_object)
print "Mommy - test_tag: Dog Count", Dog.objects.all()
print "Mommy - test_tag: Person Count", Person.objects.all()
def test_default_pagination_value(rf, mocker):
"""Test the default value when a bad pagination option is given."""
mocker.patch('djangopress.blog.views.Option.objects.get_or_create',
new=option_get_or_create_stub('a')
)
category_mock = mocker.patch('djangopress.blog.models.Category.objects')
category = mommy.prepare(Category, name='Uncategorized')
category.pk = 1
category_mock.get_or_create.return_value = category, None
posts_mock = mocker.patch('djangopress.blog.models.Post.objects.all')
posts_mock.return_value = mommy.prepare(Post, _quantity=6)
request = rf.get(reverse('djangopress:home'))
response = PostList.as_view()(request)
assert response.context_data['paginator'].per_page == 5
def test_post_list_custom_pagination_pag(rf, mocker):
"""Test a custom pagination value."""
mocker.patch('djangopress.blog.views.Option.objects.get_or_create',
new=option_get_or_create_stub('3')
)
category_mock = mocker.patch('djangopress.blog.models.Category.objects')
category = mommy.prepare(Category, name='Uncategorized')
category.pk = 1
category_mock.get_or_create.return_value = category, None
posts_mock = mocker.patch('djangopress.blog.models.Post.objects.all')
posts_mock.return_value = mommy.prepare(Post, _quantity=4)
request = rf.get(reverse('djangopress:home'))
response = PostList.as_view()(request)
assert response.context_data['is_paginated']
def test_only_single_editable_group_for_each_period_id_none(self):
period1 = mommy.make('core.Period')
period2 = mommy.make('core.Period')
permissiongroup = mommy.make('devilry_account.PermissionGroup',
grouptype=PermissionGroup.GROUPTYPE_PERIODADMIN,
is_custom_manageable=True)
mommy.make('devilry_account.PeriodPermissionGroup',
permissiongroup=permissiongroup,
period=period1)
with self.assertRaisesMessage(ValidationError, 'Only a single editable permission '
'group is allowed for a semester.'):
mommy.prepare('devilry_account.PeriodPermissionGroup',
permissiongroup=permissiongroup,
period=period2).clean()
def test_only_single_editable_group_for_each_subject_id_none(self):
subject1 = mommy.make('core.Subject')
subject2 = mommy.make('core.Subject')
permissiongroup = mommy.make('devilry_account.PermissionGroup',
grouptype=PermissionGroup.GROUPTYPE_SUBJECTADMIN,
is_custom_manageable=True)
mommy.make('devilry_account.SubjectPermissionGroup',
permissiongroup=permissiongroup,
subject=subject1)
with self.assertRaisesMessage(ValidationError, 'Only a single editable permission '
'group is allowed for a course.'):
mommy.prepare('devilry_account.SubjectPermissionGroup',
permissiongroup=permissiongroup,
subject=subject2).clean()
def setUp(self):
self._user_password = '******'
self.user = mommy.prepare('users.User', email='*****@*****.**')
self.user.set_password(self._user_password)
self.user.save()
self.staff_user = mommy.prepare('users.User', email='*****@*****.**', is_staff=True)
self.staff_user.set_password(self._user_password)
self.staff_user.save()
self.superuser = mommy.prepare('users.User', email='*****@*****.**', is_staff=True,
is_superuser=True)
self.superuser.set_password(self._user_password)
self.superuser.save()
def test_extra_choices_for_repeating_reservations_become_choices(self):
res = prepare(Reservation, repeat_on=0)
res.save(starting_on=now(), ending_on=now() + timedelta(hours=1))
r = make(Request, reservation=res)
form = RequestDeleteForm(request=r)
self.assertNotIn("This and all after it", str(form["choice"]))
self.assertNotIn("The entire series", str(form["choice"]))
# now make the reservation repeat, and now we should see the extra choices
res = prepare(Reservation, repeat_on=DayOfWeek.MONDAY | DayOfWeek.TUESDAY)
res.save(starting_on=now(), ending_on=now() + timedelta(hours=1))
r = make(Request, reservation=res)
form = RequestDeleteForm(request=r)
self.assertIn("This and all after it", str(form["choice"]))
self.assertIn("The entire series", str(form["choice"]))
def mock_posts(mocker):
"""Mock the Post's objects."""
posts_mock = mocker.patch(
'arpegio.blog.templatetags.arpegio_blog_tags.Post.objects.public')
posts = mommy.prepare(Post, slug='some-slug', _quantity=10)
posts_mock.return_value = posts
return posts
def test_mocked_api_create_user(self):
attrs = dict((k, v) for (k, v) in mommy.prepare(User).__dict__.items() if k[0] != '_')
user = self.api.create_user(**attrs)
assert isinstance(user, User)
for k, v in attrs.items():
assert getattr(user, k) == v
def test_prepare_should_not_create_one_object(self):
dog = mommy.prepare(Dog)
self.assertIsInstance(dog, Dog)
self.assertIsInstance(dog.owner, Person)
self.assertEqual(Person.objects.all().count(), 1)
self.assertEqual(Dog.objects.all().count(), 0)
def test_default_behaviour_for_and_fk(self):
dog = mommy.prepare(models.Dog)
self.assertIsNone(dog.pk)
self.assertIsNone(dog.owner.pk)
with self.assertRaises(ValueError):
dog.friends_with
def test_create_fk_instances(self):
dog = mommy.prepare(models.Dog, _save_related=True)
self.assertIsNone(dog.pk)
self.assertTrue(dog.owner.pk)
with self.assertRaises(ValueError):
dog.friends_with
def test_prepare(self):
car = prepare(self.Car, pk=5)
prepared = self.CarIndex.objects.prepare(car)
self.assertEqual({
"name": car.name,
"color": "blue",
}, prepared)
def test_prepare_fk(self):
dog = mommy.prepare(Dog)
self.assertIsInstance(dog, Dog)
self.assertIsInstance(dog.owner, Person)
self.assertEqual(Person.objects.all().count(), 0)
self.assertEqual(Dog.objects.all().count(), 0)
def test_https_site(self):
site = mommy.prepare(Site, is_default_site=True, port=443)
with patch('v1.email.Site.objects.get', return_value=site):
request = create_request_for_email()
self.assertRequestMatches(request, site.hostname, site.port, True)
def setUp(self):
self.client = Client()
self.url = reverse('accounts:update_user')
self.user = mommy.prepare(settings.AUTH_USER_MODEL)
self.user.set_password('123')
self.user.save()
def test_create_model_with_contenttype_field(self):
dummy = mommy.prepare(models.DummyGenericForeignKeyModel)
self.assertIsInstance(dummy, models.DummyGenericForeignKeyModel)
def test_ForeignKey_model_field_population_should_work_with_prepare(self):
dog = mommy.prepare(models.Dog, breed='X1', owner__name='Bob')
assert 'X1' == dog.breed
assert 'Bob' == dog.owner.name
def test_create_one_to_one(self):
lonely_person = mommy.prepare(models.LonelyPerson, _save_related=True)
self.assertIsNone(lonely_person.pk)
self.assertTrue(lonely_person.only_friend.pk)
def setUp(self):
user = prepare(User, is_active=True)
user.set_password("foo")
user.save()
self.client.login(email=user.email, password="******")
self.user = user
def make_user(self, password, is_superuser=False):
user = mommy.prepare(User, is_superuser=is_superuser)
user.set_password(password)
user.save()
return user
def prepare_answer(self, **kwargs):
kwargs.setdefault('answer', 'Mock answer')
kwargs.setdefault('slug', 'mock-answer')
return mommy.prepare(Answer, **kwargs)
def test_user(self):
# ----- Create user -----
email = utils.random_email()
profile = {
'age': 15,
}
password = '******'
user = mommy.prepare(
models.KagisoUser,
id=None,
email=email,
first_name='George',
last_name='Smith',
is_staff=True,
is_superuser=True,
profile=profile,
)
user.set_password(password)
user.save()
result = models.KagisoUser.objects.get(id=user.id)
assert result.email == user.email
assert result.first_name == user.first_name
assert result.last_name == user.last_name
assert result.is_staff
assert result.is_superuser
assert not result.confirmation_token
assert result.profile == profile
# ----- Confirm user -----
assert not user.email_confirmed
user.confirm_email(user.confirmation_token)
assert user.email_confirmed
# ----- Can the user sign in? -----
auth_backend = KagisoBackend()
signed_in_user = auth_backend.authenticate(user.email, password)
assert signed_in_user == user
# ----- Update user -----
new_email = utils.random_email()
new_first_name = 'Fred'
new_last_name = 'Jones'
new_profile = {
'age': 50,
}
user.email = new_email
user.first_name = new_first_name
user.last_name = new_last_name
user.is_staff = False
user.is_superuser = False
user.profile = new_profile
user.save()
updated_result = models.KagisoUser.objects.get(id=user.id)
assert updated_result.email == new_email
assert updated_result.first_name == new_first_name
assert updated_result.last_name == new_last_name
assert not updated_result.is_staff
assert not updated_result.is_superuser
assert updated_result.profile == new_profile
# ----- Sign out the user -----
signed_out = user.record_sign_out()
assert signed_out
# ----- Delete user -----
updated_result.delete()
def test_update_speaker_name_on_creation_no_user(self):
speaker = mommy.prepare(Speaker, name='wut', user=None)
Speaker.update_speaker_name_on_creation(Speaker, speaker, True)
# Name is set from user on creation
self.assertEqual(speaker.name, 'wut')
def test_all_packages_dispatched_no_package(self):
subsidiary_box = mommy.prepare("SubsidiaryBox", )
self.assertEquals(subsidiary_box.packages_count(), 0)
self.assertEquals(subsidiary_box.dispatched_packages_count(), 0)
self.assertTrue(subsidiary_box.all_packages_dispatched())
def test_raise_on_ambiguous_model_string(self):
with self.assertRaises(AmbiguousModelName):
obj = mommy.prepare('Ambiguous')
def make_stub(model, id):
fields_dict = get_fields_dict(model)
new = mommy.prepare(model, **fields_dict)
save_with_id(new, id)
return new
def prepare_instance(self):
# prepare an uncomitted instance
return mommy.prepare(self.get_model(), **self.get_create_params())
def handle(self, *args, **options):
Student.objects.all().delete()
University.objects.all().delete()
Course.objects.all().delete()
start = time.time()
# database part
# make some Universities
university_names = ('MIT', 'MGU', 'CalTech', 'KPI', 'DPI', 'PSTU')
universities = []
for name in university_names:
uni = mommy.make(University, name=name)
universities.append(uni)
# make some courses
template_options = ['CS%s0%s', 'MATH%s0%s', 'CHEM%s0%s', 'PHYS%s0%s']
courses = []
for num in range(1, 4):
for course_num in range(1, 4):
for template in template_options:
name = template % (course_num, num)
course = mommy.make(Course, name=name)
courses.append(course)
students = []
for _ in xrange(options.get('count')[0]):
stud = mommy.prepare(Student,
university=random.choice(universities),
first_name=names.get_first_name(),
last_name=names.get_last_name(),
age=random.randint(17, 25))
students.append(stud)
Student.objects.bulk_create(students)
ThroughModel = Student.courses.through
stud_courses = []
for student_id in Student.objects.values_list('pk', flat=True):
courses_already_linked = []
for _ in range(random.randint(1, 10)):
index = random.randint(0, len(courses) - 1)
if index not in courses_already_linked:
courses_already_linked.append(index)
else:
continue
stud_courses.append(
ThroughModel(student_id=student_id,
course_id=courses[index].pk))
ThroughModel.objects.bulk_create(stud_courses)
# recreate index
indices_client = IndicesClient(client=settings.ES_CLIENT)
if indices_client.exists('django'):
indices_client.delete(index='django')
indices_client.create(index='django')
indices_client.put_mapping(doc_type='student',
body=Student._meta.es_mapping,
index='django')
# update part
put_all_to_index(Student)
finish = time.time() - start
print '%s items %s seconds' % (options.get('count')[0], finish)
def test_model_string(self):
obj = mommy.prepare('Person')
assert isinstance(obj, models.Person)
def test_keeps_prepare_autovalues(self):
dummy = mommy.prepare(models.DummyEmptyModel, id=543)
assert dummy.id == 543
dummy.save()
saved_dummy = models.DummyEmptyModel.objects.get()
assert saved_dummy.id == 543
def test_model_class(self):
obj = mommy.prepare(Person)
self.assertIsInstance(obj, Person)
def test_raise_on_ambiguous_model_string(self):
with pytest.raises(AmbiguousModelName):
mommy.prepare('Ambiguous')
def test_ForeignKey_model_field_population_should_work_with_prepare(self):
dog = mommy.prepare(Dog, breed='X1', owner__name='Bob')
self.assertEqual('X1', dog.breed)
self.assertEqual('Bob', dog.owner.name)
def setUp(self):
self.client = Client()
self.url = reverse('core:update_gestor_password')
self.user = mommy.prepare(settings.AUTH_USER_MODEL)
self.user.set_password('123')
self.user.save()
def test_unicode_regression(self):
obj = mommy.prepare(u'generic.Person')
self.assertIsInstance(obj, Person)
def setUp(self):
self.job_listing = mommy.prepare(JobListingPage, description='foo')
self.job_listing.full_clean = Mock(return_value=None)
self.root.add_child(instance=self.job_listing)
def test_keeps_prepare_autovalues(self):
dummy = mommy.prepare(models.DummyEmptyModel, id=543)
self.assertEqual(dummy.id, 543)
dummy.save()
saved_dummy = models.DummyEmptyModel.objects.get()
self.assertEqual(saved_dummy.id, 543)
def setUp(self):
self.client = Client()
self.login_url = reverse('login')
self.user = mommy.prepare(settings.AUTH_USER_MODEL)
self.user.set_password('123')
self.user.save()
def setUp(self):
self.profile = mommy.prepare(Profile)
def test_model_class(self):
obj = mommy.prepare(models.Person)
assert isinstance(obj, models.Person)
def test_aws_delete_role_calls_service(aws):
user = mommy.prepare('api.User')
user.delete()
aws.delete_role.assert_called_with(user.iam_role_name)
def test_model_string(self):
obj = mommy.prepare('Person')
self.assertIsInstance(obj, Person)
def test_app_model_string(self):
obj = mommy.prepare('generic.Person')
self.assertIsInstance(obj, models.Person)
