def test_course_change_updates_cache(self):
semester = mommy.make(Semester)
course1 = mommy.make(Course, semester=semester)
course2 = mommy.make(Course, semester=semester)
evaluation = mommy.make(Evaluation, course=course1)
evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form = EvaluationForm(form_data, instance=evaluation, semester=semester)
self.assertTrue(form.is_valid())
with patch('evap.results.views._delete_course_template_cache_impl') as delete_call, patch('evap.results.views.warm_up_template_cache') as warmup_call:
# save without changes
form.save()
self.assertEqual(Evaluation.objects.get(pk=evaluation.pk).course, course1)
self.assertEqual(delete_call.call_count, 0)
self.assertEqual(warmup_call.call_count, 0)
# change course and save
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form_data["course"] = course2.pk
form = EvaluationForm(form_data, instance=evaluation, semester=semester)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(Evaluation.objects.get(pk=evaluation.pk).course, course2)
self.assertEqual(delete_call.call_count, 2)
self.assertEqual(warmup_call.call_count, 2)
def test_course_change_updates_cache(self):
semester = baker.make(Semester)
course1 = baker.make(Course, semester=semester)
course2 = baker.make(Course, semester=semester)
evaluation = baker.make(Evaluation, course=course1)
evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form = EvaluationForm(form_data, instance=evaluation, semester=semester)
self.assertTrue(form.is_valid())
with patch('evap.results.views._delete_course_template_cache_impl') as delete_call, patch('evap.results.views.warm_up_template_cache') as warmup_call:
# save without changes
form.save()
self.assertEqual(Evaluation.objects.get(pk=evaluation.pk).course, course1)
self.assertEqual(delete_call.call_count, 0)
self.assertEqual(warmup_call.call_count, 0)
# change course and save
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form_data["course"] = course2.pk
form = EvaluationForm(form_data, instance=evaluation, semester=semester)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(Evaluation.objects.get(pk=evaluation.pk).course, course2)
self.assertEqual(delete_call.call_count, 2)
self.assertEqual(warmup_call.call_count, 2)
def test_locked_questionnaire(self):
"""
Asserts that locked (general) questionnaires can be changed by staff.
"""
questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.TOP, is_locked=False, visibility=Questionnaire.Visibility.EDITORS)
locked_questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.TOP, is_locked=True, visibility=Questionnaire.Visibility.EDITORS)
semester = baker.make(Semester)
evaluation = baker.make(Evaluation, course=baker.make(Course, semester=semester))
evaluation.general_contribution.questionnaires.add(questionnaire)
form_data = get_form_data_from_instance(EvaluationForm, evaluation, semester=semester)
form_data["general_questionnaires"] = [questionnaire.pk, locked_questionnaire.pk] # add locked questionnaire
form = EvaluationForm(form_data, instance=evaluation, semester=semester)
# Assert form is valid and locked questionnaire is added
form.save()
self.assertEqual({questionnaire, locked_questionnaire}, set(evaluation.general_contribution.questionnaires.all()))
form_data = get_form_data_from_instance(EvaluationForm, evaluation, semester=semester)
form_data["general_questionnaires"] = [questionnaire.pk] # remove locked questionnaire
form = EvaluationForm(form_data, instance=evaluation, semester=semester)
# Assert form is valid and locked questionnaire is removed
form.save()
self.assertEqual({questionnaire}, set(evaluation.general_contribution.questionnaires.all()))
def test_uniqueness_constraint_error_shown(self):
"""
Tests whether errors being caused by a uniqueness constraint are shown in the form
"""
course = mommy.make(Course)
evaluation1 = mommy.make(Evaluation,
course=course,
name_de="Evaluierung 1",
name_en="Evaluation 1")
evaluation2 = mommy.make(Evaluation,
course=course,
name_de="Evaluierung 2",
name_en="Evaluation 2")
form_data = get_form_data_from_instance(EvaluationForm, evaluation2)
form_data["name_de"] = evaluation1.name_de
form = EvaluationForm(form_data,
instance=evaluation2,
semester=evaluation2.course.semester)
self.assertFalse(form.is_valid())
self.assertIn('name_de', form.errors)
self.assertEqual(
form.errors['name_de'],
['Evaluation with this Course and Name (german) already exists.'])
def test_evaluation_form_same_name(self):
"""
Test whether giving an evaluation the same name as another evaluation
in the same course in the evaluation edit form is invalid.
"""
course = mommy.make(Course, degrees=[mommy.make(Degree)])
evaluation1 = mommy.make(Evaluation,
course=course,
name_de="Evaluierung 1",
name_en="Evaluation 1")
evaluation2 = mommy.make(Evaluation,
course=course,
name_de="Evaluierung 2",
name_en="Evaluation 2")
evaluation1.general_contribution.questionnaires.set(
[mommy.make(Questionnaire)])
evaluation2.general_contribution.questionnaires.set(
[mommy.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation1)
form_data[
"vote_start_datetime"] = "2098-01-01" # needed to fix the form
form_data["vote_end_date"] = "2099-01-01" # needed to fix the form
form = EvaluationForm(form_data,
instance=evaluation1,
semester=evaluation1.course.semester)
self.assertTrue(form.is_valid())
form_data['name_de'] = evaluation2.name_de
form = EvaluationForm(form_data,
instance=evaluation1,
semester=evaluation1.course.semester)
self.assertFalse(form.is_valid())
def test_settings_form(self):
"""
Tests whether the settings form can be submitted without errors
"""
user = baker.make(UserProfile,
email="*****@*****.**")
delegate = baker.make(UserProfile,
email="*****@*****.**")
self.assertFalse(
user.delegates.filter(
email="*****@*****.**").exists())
form_data = get_form_data_from_instance(DelegatesForm, user)
form_data["delegates"] = [delegate.pk] # add delegate
form = DelegatesForm(form_data, instance=user)
self.assertTrue(form.is_valid())
form.save()
user = UserProfile.objects.get(
email="*****@*****.**")
self.assertTrue(
user.delegates.filter(
email="*****@*****.**").exists())
def test_results_cache_refreshed(self):
contributor = baker.make(UserProfile, first_name="Peter")
evaluation = baker.make(Evaluation, state="published")
baker.make(Contribution,
contributor=contributor,
evaluation=evaluation)
cache_results(evaluation)
results_before = get_results(evaluation)
form_data = get_form_data_from_instance(UserForm, contributor)
form_data["first_name"] = "Patrick"
form = UserForm(form_data, instance=contributor)
form.save()
results_after = get_results(evaluation)
self.assertCountEqual(
(result.contributor.first_name
for result in results_before.contribution_results
if result.contributor),
("Peter", ),
)
self.assertCountEqual(
(result.contributor.first_name
for result in results_after.contribution_results
if result.contributor),
("Patrick", ),
)
def helper_test_course_form_same_name(self, CourseFormClass):
courses = Course.objects.all()
form_data = get_form_data_from_instance(CourseForm, courses[0])
form = CourseFormClass(form_data, instance=courses[0])
self.assertTrue(form.is_valid())
form_data['course-name_de'] = courses[1].name_de
form = CourseFormClass(form_data, instance=courses[0])
self.assertFalse(form.is_valid())
def helper_date_validation(self, CourseFormClass, start_date, end_date, expected_result):
course = Course.objects.get()
form_data = get_form_data_from_instance(CourseFormClass, course)
form_data["vote_start_datetime"] = start_date
form_data["vote_end_date"] = end_date
form = CourseFormClass(form_data, instance=course)
self.assertEqual(form.is_valid(), expected_result)
def test_save_makes_a_copy(self):
form_data = get_form_data_from_instance(EvaluationCopyForm, self.evaluation)
form_data['name_de'] = "Eine Kopie"
form_data['name_en'] = "A Copy"
form = EvaluationCopyForm(form_data, self.evaluation)
self.assertTrue(form.is_valid())
copied_evaluation = form.save()
self.assertNotEqual(copied_evaluation, self.evaluation)
self.assertEqual(Evaluation.objects.count(), 2)
def helper_date_validation(self, CourseFormClass, start_date, end_date, expected_result):
course = Course.objects.get()
form_data = get_form_data_from_instance(CourseFormClass, course)
form_data["vote_start_datetime"] = start_date
form_data["vote_end_date"] = end_date
form = CourseFormClass(form_data, instance=course)
self.assertEqual(form.is_valid(), expected_result)
def test_copy_contribution(self):
# To simulate the life-cycle of the form, first give the form an unsaved evaluation.
new_evaluation = baker.prepare(Evaluation, _save_related=True)
form_data = get_form_data_from_instance(ContributionCopyForm, self.contribution, evaluation=new_evaluation)
# Just before saving the form, save the evaluation instance.
new_evaluation.save()
form = ContributionCopyForm(form_data, instance=self.contribution, evaluation=new_evaluation)
self.assertTrue(form.is_valid())
copied_contribution = form.save()
self.assertEqual(copied_contribution.evaluation, new_evaluation)
def helper_date_validation(self, EvaluationFormClass, start_date, end_date,
expected_result):
evaluation = Evaluation.objects.get()
form_data = get_form_data_from_instance(EvaluationFormClass,
evaluation)
form_data["vote_start_datetime"] = start_date
form_data["vote_end_date"] = end_date
form = EvaluationFormClass(form_data, instance=evaluation)
self.assertEqual(form.is_valid(), expected_result)
def test_user_cannot_be_removed_from_evaluation_already_voted_for(self):
student = mommy.make(UserProfile)
mommy.make(Evaluation, participants=[student], voters=[student])
form_data = get_form_data_from_instance(UserForm, student)
form_data["evaluations_participating_in"] = []
form = UserForm(form_data, instance=student)
self.assertFalse(form.is_valid())
self.assertIn('evaluations_participating_in', form.errors)
self.assertIn("Evaluations for which the user already voted can't be removed", form.errors['evaluations_participating_in'][0])
def test_user_cannot_be_removed_from_evaluation_already_voted_for(self):
student = baker.make(UserProfile)
baker.make(Evaluation, participants=[student], voters=[student], course__semester__is_active=True)
form_data = get_form_data_from_instance(UserForm, student)
form_data["evaluations_participating_in"] = []
form = UserForm(form_data, instance=student)
self.assertFalse(form.is_valid())
self.assertIn('evaluations_participating_in', form.errors)
self.assertIn("Evaluations for which the user already voted can't be removed", form.errors['evaluations_participating_in'][0])
def test_user_cannot_be_removed_from_course_already_voted_for(self):
student = mommy.make(UserProfile)
mommy.make(Course, participants=[student], voters=[student])
form_data = get_form_data_from_instance(UserForm, student)
form_data["courses_participating_in"] = []
form = UserForm(form_data, instance=student)
self.assertFalse(form.is_valid())
self.assertIn('courses_participating_in', form.errors)
self.assertIn("Courses for which the user already voted can't be removed", form.errors['courses_participating_in'][0])
def helper_test_course_form_same_name(self, CourseFormClass):
courses = Course.objects.all()
form_data = get_form_data_from_instance(CourseForm, courses[0])
form_data["vote_start_date"] = "02/1/2098" # needed to fix the form
form_data["vote_end_date"] = "02/1/2099" # needed to fix the form
form = CourseFormClass(form_data, instance=courses[0])
self.assertTrue(form.is_valid())
form_data['name_de'] = courses[1].name_de
form = CourseFormClass(form_data, instance=courses[0])
self.assertFalse(form.is_valid())
def test_voter_cannot_be_removed_from_evaluation(self):
student = mommy.make(UserProfile)
evaluation = mommy.make(Evaluation, course=mommy.make(Course, degrees=[mommy.make(Degree)]), participants=[student], voters=[student])
evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form_data["participants"] = []
form = EvaluationForm(form_data, instance=evaluation, semester=evaluation.course.semester)
self.assertFalse(form.is_valid())
self.assertIn('participants', form.errors)
self.assertIn("Participants who already voted for the evaluation can't be removed", form.errors['participants'][0])
def helper_date_validation(self, EvaluationFormClass, start_date, end_date, expected_result):
evaluation = Evaluation.objects.get()
form_data = get_form_data_from_instance(EvaluationFormClass, evaluation)
form_data["vote_start_datetime"] = start_date
form_data["vote_end_date"] = end_date
if EvaluationFormClass == EvaluationForm:
form = EvaluationForm(form_data, instance=evaluation, semester=evaluation.course.semester)
else:
form = EvaluationFormClass(form_data, instance=evaluation)
self.assertEqual(form.is_valid(), expected_result)
def helper_test_course_form_same_name(self, CourseFormClass):
courses = Course.objects.all()
form_data = get_form_data_from_instance(CourseForm, courses[0])
form_data["vote_start_datetime"] = "2098-01-01" # needed to fix the form
form_data["vote_end_date"] = "2099-01-01" # needed to fix the form
form = CourseFormClass(form_data, instance=courses[0])
self.assertTrue(form.is_valid())
form_data['name_de'] = courses[1].name_de
form = CourseFormClass(form_data, instance=courses[0])
self.assertFalse(form.is_valid())
def test_voter_cannot_be_removed_from_evaluation(self):
student = baker.make(UserProfile)
evaluation = baker.make(Evaluation, course=baker.make(Course, degrees=[baker.make(Degree)]), participants=[student], voters=[student])
evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form_data["participants"] = []
form = EvaluationForm(form_data, instance=evaluation, semester=evaluation.course.semester)
self.assertFalse(form.is_valid())
self.assertIn('participants', form.errors)
self.assertIn("Participants who already voted for the evaluation can't be removed", form.errors['participants'][0])
def test_voter_cannot_be_removed_from_course(self):
student = mommy.make(UserProfile)
course = mommy.make(Course, degrees=[mommy.make(Degree)], participants=[student], voters=[student])
course.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
form_data = get_form_data_from_instance(CourseForm, course)
form_data["participants"] = []
form = CourseForm(form_data, instance=course)
self.assertFalse(form.is_valid())
self.assertIn('participants', form.errors)
self.assertIn("Participants who already voted for the course can't be removed", form.errors['participants'][0])
def test_uniqueness_constraint_error_shown(self):
"""
Tests whether errors being caused by a uniqueness constraint are shown in the form
"""
courses = baker.make(Course, semester=baker.make(Semester), responsibles=[baker.make(UserProfile)], degrees=[baker.make(Degree)], _quantity=2)
form_data = get_form_data_from_instance(CourseForm, courses[1])
form_data["name_de"] = courses[0].name_de
form = CourseForm(form_data, instance=courses[1])
self.assertFalse(form.is_valid())
self.assertIn('name_de', form.errors)
self.assertEqual(form.errors['name_de'], ['Course with this Semester and Name (german) already exists.'])
def test_course_form_same_name(self):
"""
Test whether giving a course the same name as another course
in the same semester in the course edit form is invalid.
"""
courses = baker.make(Course, semester=baker.make(Semester), responsibles=[baker.make(UserProfile)], degrees=[baker.make(Degree)], _quantity=2)
form_data = get_form_data_from_instance(CourseForm, courses[0])
form = CourseForm(form_data, instance=courses[0])
self.assertTrue(form.is_valid())
form_data['name_de'] = courses[1].name_de
form = CourseForm(form_data, instance=courses[0])
self.assertFalse(form.is_valid())
def test_course_form_same_name(self):
"""
Test whether giving a course the same name as another course
in the same semester in the course edit form is invalid.
"""
courses = mommy.make(Course, semester=mommy.make(Semester), responsibles=[mommy.make(UserProfile)], degrees=[mommy.make(Degree)], _quantity=2)
form_data = get_form_data_from_instance(CourseForm, courses[0])
form = CourseForm(form_data, instance=courses[0])
self.assertTrue(form.is_valid())
form_data['name_de'] = courses[1].name_de
form = CourseForm(form_data, instance=courses[0])
self.assertFalse(form.is_valid())
def test_uniqueness_constraint_error_shown(self):
"""
Tests whether errors being caused by a uniqueness constraint are shown in the form
"""
courses = mommy.make(Course, semester=mommy.make(Semester), responsibles=[mommy.make(UserProfile)], degrees=[mommy.make(Degree)], _quantity=2)
form_data = get_form_data_from_instance(CourseForm, courses[1])
form_data["name_de"] = courses[0].name_de
form = CourseForm(form_data, instance=courses[1])
self.assertFalse(form.is_valid())
self.assertIn('name_de', form.errors)
self.assertEqual(form.errors['name_de'], ['Course with this Semester and Name (german) already exists.'])
def test_uniqueness_constraint_error_shown(self):
"""
Tests whether errors being caused by a uniqueness constraint are shown in the form
"""
semester = mommy.make(Semester)
course1 = mommy.make(Course, semester=semester)
course2 = mommy.make(Course, semester=semester)
form_data = get_form_data_from_instance(CourseForm, course2)
form_data["name_de"] = course1.name_de
form = CourseForm(form_data, instance=course2)
self.assertFalse(form.is_valid())
self.assertIn('name_de', form.errors)
self.assertEqual(form.errors['name_de'], ['Course with this Semester and Name (german) already exists.'])
def test_uniqueness_constraint_error_shown(self):
"""
Tests whether errors being caused by a uniqueness constraint are shown in the form
"""
course = mommy.make(Course)
evaluation1 = mommy.make(Evaluation, course=course, name_de="Evaluierung 1", name_en="Evaluation 1")
evaluation2 = mommy.make(Evaluation, course=course, name_de="Evaluierung 2", name_en="Evaluation 2")
form_data = get_form_data_from_instance(EvaluationForm, evaluation2)
form_data["name_de"] = evaluation1.name_de
form = EvaluationForm(form_data, instance=evaluation2, semester=evaluation2.course.semester)
self.assertFalse(form.is_valid())
self.assertIn('name_de', form.errors)
self.assertEqual(form.errors['name_de'], ['Evaluation with this Course and Name (german) already exists.'])
def test_uniqueness_constraint_error_shown(self):
"""
Tests whether errors being caused by a uniqueness constraint are shown in the form
"""
semester = mommy.make(Semester)
course1 = mommy.make(Course, semester=semester)
course2 = mommy.make(Course, semester=semester)
form_data = get_form_data_from_instance(CourseForm, course2)
form_data["name_de"] = course1.name_de
form = CourseForm(form_data, instance=course2)
self.assertFalse(form.is_valid())
self.assertIn('name_de', form.errors)
self.assertEqual(form.errors['name_de'], ['Course with this Semester and Name (german) already exists.'])
def test_settings_form(self):
"""
Tests whether the settings form can be submitted without errors
"""
user = mommy.make(UserProfile, username="******")
delegate = mommy.make(UserProfile, username="******")
self.assertFalse(user.delegates.filter(username="******").exists())
form_data = get_form_data_from_instance(DelegatesForm, user)
form_data["delegates"] = [delegate.pk] # add delegate
form = DelegatesForm(form_data, instance=user)
self.assertTrue(form.is_valid())
form.save()
user = UserProfile.objects.get(username="******")
self.assertTrue(user.delegates.filter(username="******").exists())
def test_edit_participants(self):
student = baker.make(UserProfile)
evaluation = baker.make(Evaluation,
course__degrees=[baker.make(Degree)],
participants=[student])
evaluation.general_contribution.questionnaires.set(
[baker.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation)
form = EvaluationForm(form_data, instance=evaluation)
self.assertEqual(len(form["participants"].initial), 1)
form_data["participants"].remove(student.pk)
EvaluationForm(form_data, instance=evaluation).save()
self.assertEqual(evaluation.num_participants, 0)
form_data["participants"].append(student.pk)
EvaluationForm(form_data, instance=evaluation).save()
del evaluation.num_participants # discard cached property
self.assertEqual(evaluation.num_participants, 1)
def test_evaluation_form_same_name(self):
"""
Test whether giving an evaluation the same name as another evaluation
in the same course in the evaluation edit form is invalid.
"""
course = mommy.make(Course, degrees=[mommy.make(Degree)])
evaluation1 = mommy.make(Evaluation, course=course, name_de="Evaluierung 1", name_en="Evaluation 1")
evaluation2 = mommy.make(Evaluation, course=course, name_de="Evaluierung 2", name_en="Evaluation 2")
evaluation1.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
evaluation2.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
form_data = get_form_data_from_instance(EvaluationForm, evaluation1)
form_data["vote_start_datetime"] = "2098-01-01" # needed to fix the form
form_data["vote_end_date"] = "2099-01-01" # needed to fix the form
form = EvaluationForm(form_data, instance=evaluation1, semester=evaluation1.course.semester)
self.assertTrue(form.is_valid())
form_data['name_de'] = evaluation2.name_de
form = EvaluationForm(form_data, instance=evaluation1, semester=evaluation1.course.semester)
self.assertFalse(form.is_valid())
