Repository: e-valuation/EvaP

Issue:
Migrate from Model Mommy to Model Bakery
Model Mommy is no longer maintained and was replaced by Model Bakery. We should [migrate to Model Bakery](https://model-bakery.readthedocs.io/en/latest/migrating_from_mommy.html).


Discussion:

Resolving patch:
diff --git a/evap/settings.py b/evap/settings.py
--- a/evap/settings.py
+++ b/evap/settings.py
@@ -419,8 +419,8 @@
         },
     }
     # give random char field values a reasonable length
-    from model_mommy import random_gen
-    MOMMY_CUSTOM_FIELDS_GEN = {'django.db.models.CharField': lambda: random_gen.gen_string(20)}
+    from model_bakery import random_gen
+    BAKER_CUSTOM_FIELDS_GEN = {'django.db.models.CharField': lambda: random_gen.gen_string(20)}
 
 
 # Django debug toolbar settings


Test patch:
diff --git a/evap/contributor/tests/test_forms.py b/evap/contributor/tests/test_forms.py
--- a/evap/contributor/tests/test_forms.py
+++ b/evap/contributor/tests/test_forms.py
@@ -4,7 +4,7 @@
 from evap.evaluation.models import Contribution, Evaluation, Questionnaire, UserProfile
 from evap.evaluation.tests.tools import WebTest, get_form_data_from_instance
 from evap.staff.forms import ContributionFormSet
-from model_mommy import mommy
+from model_bakery import baker
 
 
 class UserFormTests(TestCase):
@@ -13,8 +13,8 @@ def test_settings_form(self):
         """
             Tests whether the settings form can be submitted without errors
         """
-        user = mommy.make(UserProfile, username="testuser")
-        delegate = mommy.make(UserProfile, username="delegate")
+        user = baker.make(UserProfile, username="testuser")
+        delegate = baker.make(UserProfile, username="delegate")
 
         self.assertFalse(user.delegates.filter(username="delegate").exists())
 
@@ -37,14 +37,14 @@ def test_managers_only(self):
             contribution of the Evaluation.
             Regression test for #593.
         """
-        evaluation = mommy.make(Evaluation)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.EDITORS)
-        questionnaire_managers_only = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.MANAGERS)
+        evaluation = baker.make(Evaluation)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.EDITORS)
+        questionnaire_managers_only = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.MANAGERS)
         # one hidden questionnaire that should never be shown
-        mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.HIDDEN)
+        baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.HIDDEN)
 
         # just the normal questionnaire should be shown.
-        contribution1 = mommy.make(Contribution, evaluation=evaluation, contributor=mommy.make(UserProfile), questionnaires=[])
+        contribution1 = baker.make(Contribution, evaluation=evaluation, contributor=baker.make(UserProfile), questionnaires=[])
 
         InlineContributionFormset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=EditorContributionForm, extra=1)
         formset = InlineContributionFormset(instance=evaluation, form_kwargs={'evaluation': evaluation})
@@ -74,12 +74,12 @@ def test_form_ordering(self):
             when the user submits the form with errors.
             Regression test for #456.
         """
-        evaluation = mommy.make(Evaluation, pk=1, state="prepared")
-        user1 = mommy.make(UserProfile)
-        user2 = mommy.make(UserProfile)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        contribution1 = mommy.make(Contribution, evaluation=evaluation, contributor=user1, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, questionnaires=[questionnaire], order=1)
-        contribution2 = mommy.make(Contribution, evaluation=evaluation, contributor=user2, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, questionnaires=[questionnaire], order=2)
+        evaluation = baker.make(Evaluation, pk=1, state="prepared")
+        user1 = baker.make(UserProfile)
+        user2 = baker.make(UserProfile)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        contribution1 = baker.make(Contribution, evaluation=evaluation, contributor=user1, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, questionnaires=[questionnaire], order=1)
+        contribution2 = baker.make(Contribution, evaluation=evaluation, contributor=user2, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, questionnaires=[questionnaire], order=2)
 
         # almost everything is missing in this set of data,
         # so we're guaranteed to have some errors
diff --git a/evap/contributor/tests/test_views.py b/evap/contributor/tests/test_views.py
--- a/evap/contributor/tests/test_views.py
+++ b/evap/contributor/tests/test_views.py
@@ -1,7 +1,7 @@
 from django.core import mail
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Evaluation, UserProfile, Contribution
 from evap.evaluation.tests.tools import WebTestWith200Check, create_evaluation_with_responsible_and_editor
@@ -14,11 +14,11 @@ class TestContributorDirectDelegationView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.evaluation = mommy.make(Evaluation, state='prepared')
+        cls.evaluation = baker.make(Evaluation, state='prepared')
 
-        cls.editor = mommy.make(UserProfile)
-        cls.non_editor = mommy.make(UserProfile, email="a@b.c")
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=cls.editor, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        cls.editor = baker.make(UserProfile)
+        cls.non_editor = baker.make(UserProfile, email="a@b.c")
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=cls.editor, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
     def test_direct_delegation_request(self):
         data = {"delegate_to": self.non_editor.id}
@@ -35,7 +35,7 @@ def test_direct_delegation_request(self):
         self.assertEqual(len(mail.outbox), 1)
 
     def test_direct_delegation_request_with_existing_contribution(self):
-        contribution = mommy.make(Contribution, evaluation=self.evaluation, contributor=self.non_editor, can_edit=False)
+        contribution = baker.make(Contribution, evaluation=self.evaluation, contributor=self.non_editor, can_edit=False)
         old_contribution_count = Contribution.objects.count()
 
         data = {"delegate_to": self.non_editor.id}
@@ -71,7 +71,7 @@ def setUpTestData(cls):
         create_evaluation_with_responsible_and_editor()
 
     def test_save_settings(self):
-        user = mommy.make(UserProfile)
+        user = baker.make(UserProfile)
         page = self.app.get(self.url, user="responsible", status=200)
         form = page.forms["settings-form"]
         form["delegates"] = [user.pk]
diff --git a/evap/evaluation/tests/test_auth.py b/evap/evaluation/tests/test_auth.py
--- a/evap/evaluation/tests/test_auth.py
+++ b/evap/evaluation/tests/test_auth.py
@@ -2,7 +2,7 @@
 from django.core import mail
 from django.test import override_settings
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Contribution, Evaluation, UserProfile
 from evap.evaluation.tests.tools import WebTest
@@ -13,13 +13,13 @@ class LoginTests(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.external_user = mommy.make(UserProfile, email="extern@extern.com")
+        cls.external_user = baker.make(UserProfile, email="extern@extern.com")
         cls.external_user.ensure_valid_login_key()
-        cls.inactive_external_user = mommy.make(UserProfile, email="inactive@extern.com", is_active=False)
+        cls.inactive_external_user = baker.make(UserProfile, email="inactive@extern.com", is_active=False)
         cls.inactive_external_user.ensure_valid_login_key()
-        evaluation = mommy.make(Evaluation, state='published')
-        mommy.make(Contribution, evaluation=evaluation, contributor=cls.external_user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(Contribution, evaluation=evaluation, contributor=cls.inactive_external_user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        evaluation = baker.make(Evaluation, state='published')
+        baker.make(Contribution, evaluation=evaluation, contributor=cls.external_user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(Contribution, evaluation=evaluation, contributor=cls.inactive_external_user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
     @override_settings(PAGE_URL='https://example.com')
     def test_login_url_generation(self):
diff --git a/evap/evaluation/tests/test_commands.py b/evap/evaluation/tests/test_commands.py
--- a/evap/evaluation/tests/test_commands.py
+++ b/evap/evaluation/tests/test_commands.py
@@ -12,7 +12,7 @@
 from django.test import TestCase
 from django.test.utils import override_settings
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import (CHOICES, Contribution, Course, Evaluation, EmailTemplate, NO_ANSWER,
     Question, Questionnaire, RatingAnswerCounter, Semester, UserProfile)
@@ -21,8 +21,8 @@
 class TestAnonymizeCommand(TestCase):
     @classmethod
     def setUpTestData(cls):
-        mommy.make(EmailTemplate, name="name", subject="Subject", body="Body.")
-        mommy.make(UserProfile,
+        baker.make(EmailTemplate, name="name", subject="Subject", body="Body.")
+        baker.make(UserProfile,
           username="secret.username",
           email="secret.email@hpi.de",
           title="Prof.",
@@ -30,45 +30,45 @@ def setUpTestData(cls):
           last_name="User",
           login_key=1234567890,
           login_key_valid_until=date.today())
-        semester1 = mommy.make(Semester, name_de="S1", name_en="S1")
-        mommy.make(Semester, name_de="S2", name_en="S2")
-        cls.course = mommy.make(
+        semester1 = baker.make(Semester, name_de="S1", name_en="S1")
+        baker.make(Semester, name_de="S2", name_en="S2")
+        cls.course = baker.make(
             Course,
             semester=semester1,
             name_de="Eine private Veranstaltung",
             name_en="A private course",
             is_private=True,
         )
-        course2 = mommy.make(
+        course2 = baker.make(
             Course,
             semester=semester1,
             name_de="Veranstaltungsexperimente",
             name_en="Course experiments",
         )
-        cls.evaluation = mommy.make(
+        cls.evaluation = baker.make(
             Evaluation,
             course=cls.course,
             name_de="Wie man Software testet",
             name_en="Testing your software",
         )
-        mommy.make(
+        baker.make(
             Evaluation,
             course=course2,
             name_de="Die Entstehung von Unicode 😄",
             name_en="History of Unicode 😄",
         )
 
-        cls.contributor_questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        cls.general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
+        cls.contributor_questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        cls.general_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
 
-        cls.contributor_questions = mommy.make(Question, _quantity=10,
+        cls.contributor_questions = baker.make(Question, _quantity=10,
                 questionnaire=cls.contributor_questionnaire, type=cycle(iter(CHOICES.keys())))
-        cls.general_questions = mommy.make(Question, _quantity=10,
+        cls.general_questions = baker.make(Question, _quantity=10,
                 questionnaire=cls.contributor_questionnaire, type=cycle(iter(CHOICES.keys())))
 
-        cls.contributor = mommy.make(UserProfile)
+        cls.contributor = baker.make(UserProfile)
 
-        cls.contribution = mommy.make(Contribution, contributor=cls.contributor, evaluation=cls.evaluation,
+        cls.contribution = baker.make(Contribution, contributor=cls.contributor, evaluation=cls.evaluation,
             questionnaires=[cls.contributor_questionnaire, cls.contributor_questionnaire])
 
         cls.general_contribution = cls.evaluation.general_contribution
@@ -85,7 +85,7 @@ def test_no_empty_rating_answer_counters_left(self):
         for question in chain(self.contributor_questions, self.general_questions):
             choices = [choice for choice in CHOICES[question.type].values if choice != NO_ANSWER]
             for answer in choices:
-                mommy.make(RatingAnswerCounter, question=question, contribution=self.contribution, count=1, answer=answer)
+                baker.make(RatingAnswerCounter, question=question, contribution=self.contribution, count=1, answer=answer)
 
         old_count = RatingAnswerCounter.objects.count()
 
@@ -109,7 +109,7 @@ def test_answer_count_unchanged(self):
             choices = [choice for choice in CHOICES[question.type].values if choice != NO_ANSWER]
             for answer in choices:
                 count = random.randint(10, 100)
-                mommy.make(RatingAnswerCounter, question=question, contribution=self.contribution, count=count, answer=answer)
+                baker.make(RatingAnswerCounter, question=question, contribution=self.contribution, count=count, answer=answer)
                 answers_per_question[question] += count
 
         management.call_command('anonymize', stdout=StringIO())
@@ -120,7 +120,7 @@ def test_answer_count_unchanged(self):
 
     def test_single_result_anonymization(self):
         questionnaire = Questionnaire.single_result_questionnaire()
-        single_result = mommy.make(Evaluation, is_single_result=True, course=self.course)
+        single_result = baker.make(Evaluation, is_single_result=True, course=self.course)
         single_result.general_contribution.questionnaires.set([questionnaire])
         question = Question.objects.get(questionnaire=questionnaire)
 
@@ -129,7 +129,7 @@ def test_single_result_anonymization(self):
         random.seed(0)
         for answer in choices:
             count = random.randint(50, 100)
-            mommy.make(RatingAnswerCounter, question=question, contribution=single_result.general_contribution, count=count, answer=answer)
+            baker.make(RatingAnswerCounter, question=question, contribution=single_result.general_contribution, count=count, answer=answer)
             answer_count_before += count
 
         management.call_command('anonymize', stdout=StringIO())
@@ -177,7 +177,7 @@ def test_executes_key_commands(self, mock_call_command, mock_input):
 
 class TestRefreshResultsCacheCommand(TestCase):
     def test_calls_collect_results(self):
-        mommy.make(Evaluation)
+        baker.make(Evaluation)
 
         with patch('evap.evaluation.management.commands.refresh_results_cache.collect_results') as mock:
             management.call_command('refresh_results_cache', stdout=StringIO())
@@ -205,8 +205,8 @@ def test_dumpdata_called(self):
 @override_settings(REMIND_X_DAYS_AHEAD_OF_END_DATE=[0, 2])
 class TestSendRemindersCommand(TestCase):
     def test_remind_user_about_one_evaluation(self):
-        user_to_remind = mommy.make(UserProfile)
-        evaluation = mommy.make(
+        user_to_remind = baker.make(UserProfile)
+        evaluation = baker.make(
             Evaluation,
             state='in_evaluation',
             vote_start_datetime=datetime.now() - timedelta(days=1),
@@ -220,14 +220,14 @@ def test_remind_user_about_one_evaluation(self):
         mock.assert_called_once_with(user_to_remind, first_due_in_days=2, due_evaluations=[(evaluation, 2)])
 
     def test_remind_user_once_about_two_evaluations(self):
-        user_to_remind = mommy.make(UserProfile)
-        evaluation1 = mommy.make(
+        user_to_remind = baker.make(UserProfile)
+        evaluation1 = baker.make(
             Evaluation,
             state='in_evaluation',
             vote_start_datetime=datetime.now() - timedelta(days=1),
             vote_end_date=date.today() + timedelta(days=0),
             participants=[user_to_remind])
-        evaluation2 = mommy.make(
+        evaluation2 = baker.make(
             Evaluation,
             state='in_evaluation',
             vote_start_datetime=datetime.now() - timedelta(days=1),
@@ -241,8 +241,8 @@ def test_remind_user_once_about_two_evaluations(self):
         mock.assert_called_once_with(user_to_remind, first_due_in_days=0, due_evaluations=[(evaluation1, 0), (evaluation2, 2)])
 
     def test_dont_remind_already_voted(self):
-        user_no_remind = mommy.make(UserProfile)
-        mommy.make(
+        user_no_remind = baker.make(UserProfile)
+        baker.make(
             Evaluation,
             state='in_evaluation',
             vote_start_datetime=datetime.now() - timedelta(days=1),
diff --git a/evap/evaluation/tests/test_forms.py b/evap/evaluation/tests/test_forms.py
--- a/evap/evaluation/tests/test_forms.py
+++ b/evap/evaluation/tests/test_forms.py
@@ -1,6 +1,6 @@
 from django.test import TestCase
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import UserProfile
 from evap.evaluation.forms import NewKeyForm
@@ -9,7 +9,7 @@
 class TestNewKeyForm(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.inactive_external_user = mommy.make(UserProfile, email="inactive@extern.com", is_active=False)
+        cls.inactive_external_user = baker.make(UserProfile, email="inactive@extern.com", is_active=False)
 
     def test_inactive_external_users_can_not_request_login_key(self):
         data = {
diff --git a/evap/evaluation/tests/test_misc.py b/evap/evaluation/tests/test_misc.py
--- a/evap/evaluation/tests/test_misc.py
+++ b/evap/evaluation/tests/test_misc.py
@@ -7,7 +7,7 @@
 from django.test import TestCase
 from django.test.utils import override_settings
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Semester, UserProfile, CourseType
 from evap.evaluation.tests.tools import WebTest
@@ -20,10 +20,10 @@ class SampleXlsTests(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester)
-        mommy.make(UserProfile, username="user", groups=[Group.objects.get(name="Manager")])
-        mommy.make(CourseType, name_de="Vorlesung", name_en="Vorlesung")
-        mommy.make(CourseType, name_de="Seminar", name_en="Seminar")
+        cls.semester = baker.make(Semester)
+        baker.make(UserProfile, username="user", groups=[Group.objects.get(name="Manager")])
+        baker.make(CourseType, name_de="Vorlesung", name_en="Vorlesung")
+        baker.make(CourseType, name_de="Seminar", name_en="Seminar")
 
     def test_sample_xls(self):
         page = self.app.get(reverse("staff:semester_import", args=[self.semester.pk]), user='user')
diff --git a/evap/evaluation/tests/test_models.py b/evap/evaluation/tests/test_models.py
--- a/evap/evaluation/tests/test_models.py
+++ b/evap/evaluation/tests/test_models.py
@@ -7,7 +7,7 @@
 from django.core import mail
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import (Contribution, Course, CourseType, EmailTemplate, Evaluation, NotArchiveable,
                                     Question, Questionnaire, RatingAnswerCounter, Semester, TextAnswer, UserProfile)
@@ -19,7 +19,7 @@
 @override_settings(EVALUATION_END_OFFSET_HOURS=0)
 class TestEvaluations(WebTest):
     def test_approved_to_in_evaluation(self):
-        evaluation = mommy.make(Evaluation, state='approved', vote_start_datetime=datetime.now())
+        evaluation = baker.make(Evaluation, state='approved', vote_start_datetime=datetime.now())
 
         with patch('evap.evaluation.models.EmailTemplate.send_to_users_in_evaluations') as mock:
             Evaluation.update_evaluations()
@@ -32,7 +32,7 @@ def test_approved_to_in_evaluation(self):
         self.assertEqual(evaluation.state, 'in_evaluation')
 
     def test_in_evaluation_to_evaluated(self):
-        evaluation = mommy.make(Evaluation, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
+        evaluation = baker.make(Evaluation, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
                             vote_end_date=date.today() - timedelta(days=1))
 
         with patch('evap.evaluation.models.Evaluation.is_fully_reviewed') as mock:
@@ -44,7 +44,7 @@ def test_in_evaluation_to_evaluated(self):
 
     def test_in_evaluation_to_reviewed(self):
         # Evaluation is "fully reviewed" as no open text answers are present by default.
-        evaluation = mommy.make(Evaluation, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
+        evaluation = baker.make(Evaluation, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
                             vote_end_date=date.today() - timedelta(days=1))
 
         Evaluation.update_evaluations()
@@ -54,8 +54,8 @@ def test_in_evaluation_to_reviewed(self):
 
     def test_in_evaluation_to_published(self):
         # Evaluation is "fully reviewed" and not graded, thus gets published immediately.
-        course = mommy.make(Course, is_graded=False)
-        evaluation = mommy.make(Evaluation, course=course, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
+        course = baker.make(Course, is_graded=False)
+        evaluation = baker.make(Evaluation, course=course, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
                             vote_end_date=date.today() - timedelta(days=1))
 
         with patch('evap.evaluation.tools.send_publish_notifications') as mock:
@@ -68,7 +68,7 @@ def test_in_evaluation_to_published(self):
 
     @override_settings(EVALUATION_END_WARNING_PERIOD=24)
     def test_evaluation_ends_soon(self):
-        evaluation = mommy.make(Evaluation, vote_start_datetime=datetime.now() - timedelta(days=2),
+        evaluation = baker.make(Evaluation, vote_start_datetime=datetime.now() - timedelta(days=2),
                             vote_end_date=date.today() + timedelta(hours=24))
 
         self.assertFalse(evaluation.evaluation_ends_soon())
@@ -81,7 +81,7 @@ def test_evaluation_ends_soon(self):
 
     @override_settings(EVALUATION_END_WARNING_PERIOD=24, EVALUATION_END_OFFSET_HOURS=24)
     def test_evaluation_ends_soon_with_offset(self):
-        evaluation = mommy.make(Evaluation, vote_start_datetime=datetime.now() - timedelta(days=2),
+        evaluation = baker.make(Evaluation, vote_start_datetime=datetime.now() - timedelta(days=2),
                             vote_end_date=date.today())
 
         self.assertFalse(evaluation.evaluation_ends_soon())
@@ -94,12 +94,12 @@ def test_evaluation_ends_soon_with_offset(self):
 
     def test_evaluation_ended(self):
         # Evaluation is out of evaluation period.
-        course_1 = mommy.make(Course, is_graded=False)
-        course_2 = mommy.make(Course, is_graded=False)
-        mommy.make(Evaluation, course=course_1, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
+        course_1 = baker.make(Course, is_graded=False)
+        course_2 = baker.make(Course, is_graded=False)
+        baker.make(Evaluation, course=course_1, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
                    vote_end_date=date.today() - timedelta(days=1))
         # This evaluation is not.
-        mommy.make(Evaluation, course=course_2, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
+        baker.make(Evaluation, course=course_2, state='in_evaluation', vote_start_datetime=datetime.now() - timedelta(days=2),
                    vote_end_date=date.today())
 
         with patch('evap.evaluation.models.Evaluation.evaluation_end') as mock:
@@ -109,8 +109,8 @@ def test_evaluation_ended(self):
 
     def test_approved_to_in_evaluation_sends_emails(self):
         """ Regression test for #945 """
-        participant = mommy.make(UserProfile, email='foo@example.com')
-        evaluation = mommy.make(Evaluation, state='approved', vote_start_datetime=datetime.now(), participants=[participant])
+        participant = baker.make(UserProfile, email='foo@example.com')
+        evaluation = baker.make(Evaluation, state='approved', vote_start_datetime=datetime.now(), participants=[participant])
 
         Evaluation.update_evaluations()
 
@@ -120,27 +120,27 @@ def test_approved_to_in_evaluation_sends_emails(self):
 
     def test_has_enough_questionnaires(self):
         # manually circumvent Evaluation's save() method to have a Evaluation without a general contribution
-        # the semester must be specified because of https://github.com/vandersonmota/model_mommy/issues/258
-        course = mommy.make(Course, semester=mommy.make(Semester), type=mommy.make(CourseType))
-        Evaluation.objects.bulk_create([mommy.prepare(Evaluation, course=course)])
+        # the semester must be specified because of https://github.com/vandersonmota/model_bakery/issues/258
+        course = baker.make(Course, semester=baker.make(Semester), type=baker.make(CourseType))
+        Evaluation.objects.bulk_create([baker.prepare(Evaluation, course=course)])
         evaluation = Evaluation.objects.get()
         self.assertEqual(evaluation.contributions.count(), 0)
         self.assertFalse(evaluation.general_contribution_has_questionnaires)
         self.assertFalse(evaluation.all_contributions_have_questionnaires)
 
-        editor_contribution = mommy.make(
-                Contribution, evaluation=evaluation, contributor=mommy.make(UserProfile),
+        editor_contribution = baker.make(
+                Contribution, evaluation=evaluation, contributor=baker.make(UserProfile),
                 can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
         evaluation = Evaluation.objects.get()
         self.assertFalse(evaluation.general_contribution_has_questionnaires)
         self.assertFalse(evaluation.all_contributions_have_questionnaires)
 
-        general_contribution = mommy.make(Contribution, evaluation=evaluation, contributor=None)
+        general_contribution = baker.make(Contribution, evaluation=evaluation, contributor=None)
         evaluation = Evaluation.objects.get()
         self.assertFalse(evaluation.general_contribution_has_questionnaires)
         self.assertFalse(evaluation.all_contributions_have_questionnaires)
 
-        questionnaire = mommy.make(Questionnaire)
+        questionnaire = baker.make(Questionnaire)
         general_contribution.questionnaires.add(questionnaire)
         self.assertTrue(evaluation.general_contribution_has_questionnaires)
         self.assertFalse(evaluation.all_contributions_have_questionnaires)
@@ -150,19 +150,19 @@ def test_has_enough_questionnaires(self):
         self.assertTrue(evaluation.all_contributions_have_questionnaires)
 
     def test_deleting_last_modified_user_does_not_delete_evaluation(self):
-        user = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, last_modified_user=user)
+        user = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, last_modified_user=user)
         user.delete()
         self.assertTrue(Evaluation.objects.filter(pk=evaluation.pk).exists())
 
     def test_single_result_can_be_deleted_only_in_reviewed(self):
-        responsible = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, is_single_result=True)
-        contribution = mommy.make(Contribution,
+        responsible = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, is_single_result=True)
+        contribution = baker.make(Contribution,
             evaluation=evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS,
             questionnaires=[Questionnaire.single_result_questionnaire()]
         )
-        mommy.make(RatingAnswerCounter, answer=1, count=1, question=Questionnaire.single_result_questionnaire().questions.first(), contribution=contribution)
+        baker.make(RatingAnswerCounter, answer=1, count=1, question=Questionnaire.single_result_questionnaire().questions.first(), contribution=contribution)
         evaluation.single_result_created()
         evaluation.publish()
         evaluation.save()
@@ -179,24 +179,24 @@ def test_single_result_can_be_deleted_only_in_reviewed(self):
 
     def test_single_result_can_be_published(self):
         """ Regression test for #1238 """
-        responsible = mommy.make(UserProfile)
-        single_result = mommy.make(Evaluation, is_single_result=True, _participant_count=5, _voter_count=5)
-        contribution = mommy.make(Contribution,
+        responsible = baker.make(UserProfile)
+        single_result = baker.make(Evaluation, is_single_result=True, _participant_count=5, _voter_count=5)
+        contribution = baker.make(Contribution,
             evaluation=single_result, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS,
             questionnaires=[Questionnaire.single_result_questionnaire()]
         )
-        mommy.make(RatingAnswerCounter, answer=1, count=1, question=Questionnaire.single_result_questionnaire().questions.first(), contribution=contribution)
+        baker.make(RatingAnswerCounter, answer=1, count=1, question=Questionnaire.single_result_questionnaire().questions.first(), contribution=contribution)
 
         single_result.single_result_created()
         single_result.publish()  # used to crash
 
     def test_adding_second_voter_sets_can_publish_text_results_to_true(self):
-        student1 = mommy.make(UserProfile)
-        student2 = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, participants=[student1, student2], voters=[student1], state="in_evaluation")
+        student1 = baker.make(UserProfile)
+        student2 = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, participants=[student1, student2], voters=[student1], state="in_evaluation")
         evaluation.save()
-        top_general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        mommy.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
+        top_general_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        baker.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
         evaluation.general_contribution.questionnaires.set([top_general_questionnaire])
 
         self.assertFalse(evaluation.can_publish_text_results)
@@ -207,40 +207,40 @@ def test_adding_second_voter_sets_can_publish_text_results_to_true(self):
         self.assertTrue(evaluation.can_publish_text_results)
 
     def test_textanswers_get_deleted_if_they_cannot_be_published(self):
-        student = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state='reviewed', participants=[student], voters=[student], can_publish_text_results=False)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        question = mommy.make(Question, type=Question.TEXT, questionnaire=questionnaire)
+        student = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state='reviewed', participants=[student], voters=[student], can_publish_text_results=False)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        question = baker.make(Question, type=Question.TEXT, questionnaire=questionnaire)
         evaluation.general_contribution.questionnaires.set([questionnaire])
-        mommy.make(TextAnswer, question=question, contribution=evaluation.general_contribution)
+        baker.make(TextAnswer, question=question, contribution=evaluation.general_contribution)
 
         self.assertEqual(evaluation.textanswer_set.count(), 1)
         evaluation.publish()
         self.assertEqual(evaluation.textanswer_set.count(), 0)
 
     def test_textanswers_do_not_get_deleted_if_they_can_be_published(self):
-        student = mommy.make(UserProfile)
-        student2 = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state='reviewed', participants=[student, student2], voters=[student, student2], can_publish_text_results=True)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        question = mommy.make(Question, type=Question.TEXT, questionnaire=questionnaire)
+        student = baker.make(UserProfile)
+        student2 = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state='reviewed', participants=[student, student2], voters=[student, student2], can_publish_text_results=True)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        question = baker.make(Question, type=Question.TEXT, questionnaire=questionnaire)
         evaluation.general_contribution.questionnaires.set([questionnaire])
-        mommy.make(TextAnswer, question=question, contribution=evaluation.general_contribution)
+        baker.make(TextAnswer, question=question, contribution=evaluation.general_contribution)
 
         self.assertEqual(evaluation.textanswer_set.count(), 1)
         evaluation.publish()
         self.assertEqual(evaluation.textanswer_set.count(), 1)
 
     def test_hidden_textanswers_get_deleted_on_publish(self):
-        student = mommy.make(UserProfile)
-        student2 = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state='reviewed', participants=[student, student2], voters=[student, student2], can_publish_text_results=True)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        question = mommy.make(Question, type=Question.TEXT, questionnaire=questionnaire)
+        student = baker.make(UserProfile)
+        student2 = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state='reviewed', participants=[student, student2], voters=[student, student2], can_publish_text_results=True)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        question = baker.make(Question, type=Question.TEXT, questionnaire=questionnaire)
         evaluation.general_contribution.questionnaires.set([questionnaire])
-        mommy.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="hidden", state=TextAnswer.HIDDEN)
-        mommy.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="published", state=TextAnswer.PUBLISHED)
-        mommy.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="private", state=TextAnswer.PRIVATE)
+        baker.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="hidden", state=TextAnswer.HIDDEN)
+        baker.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="published", state=TextAnswer.PUBLISHED)
+        baker.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="private", state=TextAnswer.PRIVATE)
 
         self.assertEqual(evaluation.textanswer_set.count(), 3)
         evaluation.publish()
@@ -248,13 +248,13 @@ def test_hidden_textanswers_get_deleted_on_publish(self):
         self.assertFalse(TextAnswer.objects.filter(answer="hidden").exists())
 
     def test_original_textanswers_get_deleted_on_publish(self):
-        student = mommy.make(UserProfile)
-        student2 = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state='reviewed', participants=[student, student2], voters=[student, student2], can_publish_text_results=True)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        question = mommy.make(Question, type=Question.TEXT, questionnaire=questionnaire)
+        student = baker.make(UserProfile)
+        student2 = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state='reviewed', participants=[student, student2], voters=[student, student2], can_publish_text_results=True)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        question = baker.make(Question, type=Question.TEXT, questionnaire=questionnaire)
         evaluation.general_contribution.questionnaires.set([questionnaire])
-        mommy.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="published answer", original_answer="original answer", state=TextAnswer.PUBLISHED)
+        baker.make(TextAnswer, question=question, contribution=evaluation.general_contribution, answer="published answer", original_answer="original answer", state=TextAnswer.PUBLISHED)
 
         self.assertEqual(evaluation.textanswer_set.count(), 1)
         self.assertFalse(TextAnswer.objects.get().original_answer is None)
@@ -263,8 +263,8 @@ def test_original_textanswers_get_deleted_on_publish(self):
         self.assertTrue(TextAnswer.objects.get().original_answer is None)
 
     def test_publishing_and_unpublishing_effect_on_template_cache(self):
-        student = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state='reviewed', participants=[student], voters=[student], can_publish_text_results=True)
+        student = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state='reviewed', participants=[student], voters=[student], can_publish_text_results=True)
 
         self.assertIsNone(caches['results'].get(get_evaluation_result_template_fragment_cache_key(evaluation.id, "en", True)))
         self.assertIsNone(caches['results'].get(get_evaluation_result_template_fragment_cache_key(evaluation.id, "en", False)))
@@ -290,8 +290,8 @@ def test_publishing_and_unpublishing_effect_on_template_cache(self):
 
 class TestCourse(TestCase):
     def test_can_be_deleted_by_manager(self):
-        course = mommy.make(Course)
-        evaluation = mommy.make(Evaluation, course=course)
+        course = baker.make(Course)
+        evaluation = baker.make(Evaluation, course=course)
         self.assertFalse(course.can_be_deleted_by_manager)
 
         evaluation.delete()
@@ -299,31 +299,31 @@ def test_can_be_deleted_by_manager(self):
 
     def test_responsibles_names(self):
         # last names required for sorting
-        user1 = mommy.make(UserProfile, last_name="Doe")
-        user2 = mommy.make(UserProfile, last_name="Meyer")
-        course = mommy.make(Course, responsibles=[user1, user2])
+        user1 = baker.make(UserProfile, last_name="Doe")
+        user2 = baker.make(UserProfile, last_name="Meyer")
+        course = baker.make(Course, responsibles=[user1, user2])
         self.assertEqual(course.responsibles_names, ("{}, {}").format(user1.full_name, user2.full_name))
 
 
 class TestUserProfile(TestCase):
     def test_is_student(self):
-        some_user = mommy.make(UserProfile)
+        some_user = baker.make(UserProfile)
         self.assertFalse(some_user.is_student)
 
-        student = mommy.make(UserProfile, evaluations_participating_in=[mommy.make(Evaluation)])
+        student = baker.make(UserProfile, evaluations_participating_in=[baker.make(Evaluation)])
         self.assertTrue(student.is_student)
 
-        contributor = mommy.make(UserProfile, contributions=[mommy.make(Contribution)])
+        contributor = baker.make(UserProfile, contributions=[baker.make(Contribution)])
         self.assertFalse(contributor.is_student)
 
-        semester_contributed_to = mommy.make(Semester, created_at=date.today())
-        semester_participated_in = mommy.make(Semester, created_at=date.today())
-        course_contributed_to = mommy.make(Course, semester=semester_contributed_to)
-        course_participated_in = mommy.make(Course, semester=semester_participated_in)
-        evaluation_contributed_to = mommy.make(Evaluation, course=course_contributed_to)
-        evaluation_participated_in = mommy.make(Evaluation, course=course_participated_in)
-        contribution = mommy.make(Contribution, evaluation=evaluation_contributed_to)
-        user = mommy.make(UserProfile, contributions=[contribution], evaluations_participating_in=[evaluation_participated_in])
+        semester_contributed_to = baker.make(Semester, created_at=date.today())
+        semester_participated_in = baker.make(Semester, created_at=date.today())
+        course_contributed_to = baker.make(Course, semester=semester_contributed_to)
+        course_participated_in = baker.make(Course, semester=semester_participated_in)
+        evaluation_contributed_to = baker.make(Evaluation, course=course_contributed_to)
+        evaluation_participated_in = baker.make(Evaluation, course=course_participated_in)
+        contribution = baker.make(Contribution, evaluation=evaluation_contributed_to)
+        user = baker.make(UserProfile, contributions=[contribution], evaluations_participating_in=[evaluation_participated_in])
 
         self.assertTrue(user.is_student)
 
@@ -338,73 +338,73 @@ def test_is_student(self):
         self.assertFalse(user.is_student)
 
     def test_can_be_deleted_by_manager(self):
-        user = mommy.make(UserProfile)
-        mommy.make(Evaluation, participants=[user], state="new")
+        user = baker.make(UserProfile)
+        baker.make(Evaluation, participants=[user], state="new")
         self.assertFalse(user.can_be_deleted_by_manager)
 
-        user2 = mommy.make(UserProfile)
-        mommy.make(Evaluation, participants=[user2], state="in_evaluation")
+        user2 = baker.make(UserProfile)
+        baker.make(Evaluation, participants=[user2], state="in_evaluation")
         self.assertFalse(user2.can_be_deleted_by_manager)
 
-        contributor = mommy.make(UserProfile)
-        mommy.make(Contribution, contributor=contributor)
+        contributor = baker.make(UserProfile)
+        baker.make(Contribution, contributor=contributor)
         self.assertFalse(contributor.can_be_deleted_by_manager)
 
-        proxy_user = mommy.make(UserProfile, is_proxy_user=True)
+        proxy_user = baker.make(UserProfile, is_proxy_user=True)
         self.assertFalse(proxy_user.can_be_deleted_by_manager)
 
     def test_inactive_users_hidden(self):
-        active_user = mommy.make(UserProfile)
-        mommy.make(UserProfile, is_active=False)
+        active_user = baker.make(UserProfile)
+        baker.make(UserProfile, is_active=False)
 
         self.assertEqual(list(UserProfile.objects.exclude(is_active=False)), [active_user])
 
     def test_inactive_users_shown(self):
-        active_user = mommy.make(UserProfile)
-        inactive_user = mommy.make(UserProfile, is_active=False)
+        active_user = baker.make(UserProfile)
+        inactive_user = baker.make(UserProfile, is_active=False)
 
         user_list = list(UserProfile.objects.all())
         self.assertIn(active_user, user_list)
         self.assertIn(inactive_user, user_list)
 
     def test_can_be_marked_inactive_by_manager(self):
-        user = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state="new")
+        user = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state="new")
         self.assertTrue(user.can_be_marked_inactive_by_manager)
         evaluation.participants.set([user])
         evaluation.save()
         self.assertFalse(user.can_be_marked_inactive_by_manager)
 
-        contributor = mommy.make(UserProfile)
-        mommy.make(Contribution, contributor=contributor)
+        contributor = baker.make(UserProfile)
+        baker.make(Contribution, contributor=contributor)
         self.assertFalse(contributor.can_be_marked_inactive_by_manager)
 
-        reviewer = mommy.make(UserProfile, groups=[Group.objects.get(name="Reviewer")])
+        reviewer = baker.make(UserProfile, groups=[Group.objects.get(name="Reviewer")])
         self.assertFalse(reviewer.can_be_marked_inactive_by_manager)
 
-        grade_publisher = mommy.make(UserProfile, groups=[Group.objects.get(name="Grade publisher")])
+        grade_publisher = baker.make(UserProfile, groups=[Group.objects.get(name="Grade publisher")])
         self.assertFalse(grade_publisher.can_be_marked_inactive_by_manager)
 
-        super_user = mommy.make(UserProfile, is_superuser=True)
+        super_user = baker.make(UserProfile, is_superuser=True)
         self.assertFalse(super_user.can_be_marked_inactive_by_manager)
 
-        proxy_user = mommy.make(UserProfile, is_proxy_user=True)
+        proxy_user = baker.make(UserProfile, is_proxy_user=True)
         self.assertFalse(proxy_user.can_be_marked_inactive_by_manager)
 
     @override_settings(INSTITUTION_EMAIL_REPLACEMENTS=[("example.com","institution.com")])
     def test_email_domain_replacement(self):
-        user = mommy.make(UserProfile, email="test@example.com")
+        user = baker.make(UserProfile, email="test@example.com")
         self.assertEqual(user.email, "test@institution.com")
 
 
 class ParticipationArchivingTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester)
-        cls.evaluation = mommy.make(Evaluation, state="published", course=mommy.make(Course, semester=cls.semester))
-        cls.evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
+        cls.semester = baker.make(Semester)
+        cls.evaluation = baker.make(Evaluation, state="published", course=baker.make(Course, semester=cls.semester))
+        cls.evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
-        users = mommy.make(UserProfile, _quantity=3)
+        users = baker.make(UserProfile, _quantity=3)
         cls.evaluation.participants.set(users)
         cls.evaluation.voters.set(users[:2])
 
@@ -468,14 +468,14 @@ def test_archiving_participations_twice_raises_exception(self):
             self.semester.courses.first().evaluations.first()._archive_participations()
 
     def test_evaluation_participations_are_not_archived_if_participant_count_is_set(self):
-        evaluation = mommy.make(Evaluation, state="published", _participant_count=1, _voter_count=1)
+        evaluation = baker.make(Evaluation, state="published", _participant_count=1, _voter_count=1)
         self.assertFalse(evaluation.participations_are_archived)
         self.assertTrue(evaluation.participations_can_be_archived)
 
     def test_archiving_participations_doesnt_change_single_results_participant_count(self):
-        responsible = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, state="published", is_single_result=True, _participant_count=5, _voter_count=5)
-        contribution = mommy.make(Contribution, evaluation=evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        responsible = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, state="published", is_single_result=True, _participant_count=5, _voter_count=5)
+        contribution = baker.make(Contribution, evaluation=evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
         contribution.questionnaires.add(Questionnaire.single_result_questionnaire())
 
         evaluation.course.semester.archive_participations()
@@ -487,14 +487,14 @@ def test_archiving_participations_doesnt_change_single_results_participant_count
 class TestLoginUrlEmail(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.other_user = mommy.make(UserProfile, email="other@extern.com")
-        cls.user = mommy.make(UserProfile, email="extern@extern.com")
+        cls.other_user = baker.make(UserProfile, email="other@extern.com")
+        cls.user = baker.make(UserProfile, email="extern@extern.com")
         cls.user.ensure_valid_login_key()
 
-        cls.evaluation = mommy.make(Evaluation)
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=cls.user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        cls.evaluation = baker.make(Evaluation)
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=cls.user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
-        cls.template = mommy.make(EmailTemplate, body="{{ login_url }}")
+        cls.template = baker.make(EmailTemplate, body="{{ login_url }}")
 
         EmailTemplate.objects.filter(name="Login Key Created").update(body="{{ user.login_url }}")
 
@@ -537,23 +537,23 @@ def test_missing_email_address(self):
         Tests that __send_to_user behaves when the user has no email address.
         Regression test to https://github.com/fsr-de/EvaP/issues/825
         """
-        user = mommy.make(UserProfile, email=None)
+        user = baker.make(UserProfile, email=None)
         template = EmailTemplate.objects.get(name=EmailTemplate.STUDENT_REMINDER)
         EmailTemplate.send_to_user(user, template, {}, {}, False, None)
 
 
 class TestEmailRecipientList(TestCase):
     def test_recipient_list(self):
-        evaluation = mommy.make(Evaluation)
-        responsible = mommy.make(UserProfile)
-        editor = mommy.make(UserProfile)
-        contributor = mommy.make(UserProfile)
+        evaluation = baker.make(Evaluation)
+        responsible = baker.make(UserProfile)
+        editor = baker.make(UserProfile)
+        contributor = baker.make(UserProfile)
         evaluation.course.responsibles.set([responsible])
-        mommy.make(Contribution, evaluation=evaluation, contributor=editor, can_edit=True)
-        mommy.make(Contribution, evaluation=evaluation, contributor=contributor)
+        baker.make(Contribution, evaluation=evaluation, contributor=editor, can_edit=True)
+        baker.make(Contribution, evaluation=evaluation, contributor=contributor)
 
-        participant1 = mommy.make(UserProfile, evaluations_participating_in=[evaluation])
-        participant2 = mommy.make(UserProfile, evaluations_participating_in=[evaluation])
+        participant1 = baker.make(UserProfile, evaluations_participating_in=[evaluation])
+        participant2 = baker.make(UserProfile, evaluations_participating_in=[evaluation])
         evaluation.voters.set([participant1])
 
         recipient_list = EmailTemplate.recipient_list_for_evaluation(evaluation, [], filter_users_in_cc=False)
@@ -575,13 +575,13 @@ def test_recipient_list(self):
         self.assertCountEqual(recipient_list, [participant2])
 
     def test_recipient_list_filtering(self):
-        evaluation = mommy.make(Evaluation)
+        evaluation = baker.make(Evaluation)
 
-        contributor1 = mommy.make(UserProfile)
-        contributor2 = mommy.make(UserProfile, delegates=[contributor1])
+        contributor1 = baker.make(UserProfile)
+        contributor2 = baker.make(UserProfile, delegates=[contributor1])
 
-        mommy.make(Contribution, evaluation=evaluation, contributor=contributor1)
-        mommy.make(Contribution, evaluation=evaluation, contributor=contributor2)
+        baker.make(Contribution, evaluation=evaluation, contributor=contributor1)
+        baker.make(Contribution, evaluation=evaluation, contributor=contributor2)
 
         # no-one should get filtered.
         recipient_list = EmailTemplate.recipient_list_for_evaluation(evaluation, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=False)
@@ -591,8 +591,8 @@ def test_recipient_list_filtering(self):
         recipient_list = EmailTemplate.recipient_list_for_evaluation(evaluation, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=True)
         self.assertCountEqual(recipient_list, [contributor2])
 
-        contributor3 = mommy.make(UserProfile, delegates=[contributor2])
-        mommy.make(Contribution, evaluation=evaluation, contributor=contributor3)
+        contributor3 = baker.make(UserProfile, delegates=[contributor2])
+        baker.make(Contribution, evaluation=evaluation, contributor=contributor3)
 
         # again, no-one should get filtered.
         recipient_list = EmailTemplate.recipient_list_for_evaluation(evaluation, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=False)
diff --git a/evap/evaluation/tests/test_tools.py b/evap/evaluation/tests/test_tools.py
--- a/evap/evaluation/tests/test_tools.py
+++ b/evap/evaluation/tests/test_tools.py
@@ -6,7 +6,7 @@
 from django.test.testcases import TestCase
 from django.utils import translation
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.tests.tools import WebTest
 from evap.evaluation.models import UserProfile
@@ -17,7 +17,7 @@ def test_signal_sets_language_if_none(self):
         """
         Check that a user gets the default language set if they have none
         """
-        user = mommy.make(UserProfile, language=None, email="user@institution.example.com")
+        user = baker.make(UserProfile, language=None, email="user@institution.example.com")
         user.ensure_valid_login_key()
 
         self.app.get("/", user=user)
@@ -30,7 +30,7 @@ def test_signal_doesnt_set_language(self):
         Activate 'en' as langauge and check, that user does not get this langauge as he has one.
         """
         translation.activate('en')
-        user = mommy.make(UserProfile, language='de', email="user@institution.example.com")
+        user = baker.make(UserProfile, language='de', email="user@institution.example.com")
         user.ensure_valid_login_key()
 
         self.app.get(reverse("evaluation:login_key_authentication", args=[user.login_key]))
diff --git a/evap/evaluation/tests/test_views.py b/evap/evaluation/tests/test_views.py
--- a/evap/evaluation/tests/test_views.py
+++ b/evap/evaluation/tests/test_views.py
@@ -2,7 +2,7 @@
 from django.contrib.auth.hashers import make_password
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import UserProfile
 from evap.evaluation.tests.tools import WebTestWith200Check
@@ -13,7 +13,7 @@ class TestIndexView(WebTest):
 
     def test_passworduser_login(self):
         """ Tests whether a user can login with an incorrect and a correct password. """
-        mommy.make(UserProfile, username='password.user', password=make_password('evap'))
+        baker.make(UserProfile, username='password.user', password=make_password('evap'))
         response = self.app.get(self.url)
         password_form = response.forms[0]
         password_form['username'] = 'password.user'
@@ -26,7 +26,7 @@ def test_send_new_login_key(self):
         """ Tests whether requesting a new login key is only possible for existing users,
             shows the expected success message and sends only one email to the requesting
             user without people in cc even if the user has delegates and cc users. """
-        mommy.make(UserProfile, email='asdf@example.com')
+        baker.make(UserProfile, email='asdf@example.com')
         response = self.app.get(self.url)
         email_form = response.forms[1]
         email_form['email'] = "doesnotexist@example.com"
@@ -53,7 +53,7 @@ class TestContactEmail(WebTest):
     csrf_checks = False
 
     def test_sends_mail(self):
-        user = mommy.make(UserProfile)
+        user = baker.make(UserProfile)
         self.app.post('/contact', params={'message': 'feedback message', 'title': 'some title', 'sender_email': 'unique@mail.de'}, user=user.username)
         self.assertEqual(len(mail.outbox), 1)
 
@@ -63,7 +63,7 @@ class TestChangeLanguageView(WebTest):
     csrf_checks = False
 
     def test_changes_language(self):
-        user = mommy.make(UserProfile, username='tester', language='de')
+        user = baker.make(UserProfile, username='tester', language='de')
 
         self.app.post(self.url, params={'language': 'en'}, user='tester')
 
diff --git a/evap/evaluation/tests/tools.py b/evap/evaluation/tests/tools.py
--- a/evap/evaluation/tests/tools.py
+++ b/evap/evaluation/tests/tools.py
@@ -4,7 +4,7 @@
 from django.utils import timezone
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Contribution, Course, Degree, Evaluation, Questionnaire, UserProfile
 from evap.student.tools import question_id
@@ -62,14 +62,14 @@ def get_form_data_from_instance(FormClass, instance):
 
 
 def create_evaluation_with_responsible_and_editor(evaluation_id=None):
-    responsible = mommy.make(UserProfile, username='responsible')
-    editor = mommy.make(UserProfile, username='editor')
+    responsible = baker.make(UserProfile, username='responsible')
+    editor = baker.make(UserProfile, username='editor')
 
     in_one_hour = (timezone.now() + timedelta(hours=1)).replace(second=0, microsecond=0)
     tomorrow = (timezone.now() + timedelta(days=1)).date
     evaluation_params = dict(
         state='prepared',
-        course=mommy.make(Course, degrees=[mommy.make(Degree)], responsibles=[responsible]),
+        course=baker.make(Course, degrees=[baker.make(Degree)], responsibles=[responsible]),
         vote_start_datetime=in_one_hour,
         vote_end_date=tomorrow
     )
@@ -77,8 +77,8 @@ def create_evaluation_with_responsible_and_editor(evaluation_id=None):
     if evaluation_id:
         evaluation_params['id'] = evaluation_id
 
-    evaluation = mommy.make(Evaluation, **evaluation_params)
-    mommy.make(Contribution, evaluation=evaluation, contributor=editor, can_edit=True, questionnaires=[mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)])
-    evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire, type=Questionnaire.TOP)])
+    evaluation = baker.make(Evaluation, **evaluation_params)
+    baker.make(Contribution, evaluation=evaluation, contributor=editor, can_edit=True, questionnaires=[baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)])
+    evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire, type=Questionnaire.TOP)])
 
     return evaluation
diff --git a/evap/grades/tests.py b/evap/grades/tests.py
--- a/evap/grades/tests.py
+++ b/evap/grades/tests.py
@@ -4,7 +4,7 @@
 from django.contrib.auth.models import Group
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Contribution, Course, Evaluation, Questionnaire, Semester, UserProfile
 
@@ -14,15 +14,15 @@ class GradeUploadTest(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
-        cls.student = mommy.make(UserProfile, username="student", email="student@institution.example.com")
-        cls.student2 = mommy.make(UserProfile, username="student2", email="student2@institution.example.com")
-        cls.student3 = mommy.make(UserProfile, username="student3", email="student3@institution.example.com")
-        editor = mommy.make(UserProfile, username="editor", email="editor@institution.example.com")
-
-        cls.semester = mommy.make(Semester, grade_documents_are_deleted=False)
-        cls.course = mommy.make(Course, semester=cls.semester)
-        cls.evaluation = mommy.make(
+        baker.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
+        cls.student = baker.make(UserProfile, username="student", email="student@institution.example.com")
+        cls.student2 = baker.make(UserProfile, username="student2", email="student2@institution.example.com")
+        cls.student3 = baker.make(UserProfile, username="student3", email="student3@institution.example.com")
+        editor = baker.make(UserProfile, username="editor", email="editor@institution.example.com")
+
+        cls.semester = baker.make(Semester, grade_documents_are_deleted=False)
+        cls.course = baker.make(Course, semester=cls.semester)
+        cls.evaluation = baker.make(
             Evaluation,
             course=cls.course,
             vote_start_datetime=datetime.now() - timedelta(days=10),
@@ -31,11 +31,11 @@ def setUpTestData(cls):
             voters=[cls.student, cls.student2],
         )
 
-        contribution = mommy.make(Contribution, evaluation=cls.evaluation, contributor=editor, can_edit=True,
+        contribution = baker.make(Contribution, evaluation=cls.evaluation, contributor=editor, can_edit=True,
                                   textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        contribution.questionnaires.set([mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)])
+        contribution.questionnaires.set([baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)])
 
-        cls.evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
+        cls.evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
     def setUp(self):
         self.evaluation = Evaluation.objects.get(pk=self.evaluation.pk)
@@ -126,7 +126,7 @@ def test_upload_final_grades(self):
         self.helper_check_final_grade_upload(course, 0)
 
     def test_toggle_no_grades(self):
-        evaluation = mommy.make(
+        evaluation = baker.make(
             Evaluation,
             name_en="Toggle",
             vote_start_datetime=datetime.now(),
@@ -137,9 +137,9 @@ def test_toggle_no_grades(self):
         contribution = Contribution(evaluation=evaluation, contributor=UserProfile.objects.get(username="editor"),
                                     can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
         contribution.save()
-        contribution.questionnaires.set([mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)])
+        contribution.questionnaires.set([baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)])
 
-        evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
+        evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
         self.assertFalse(evaluation.course.gets_no_grade_documents)
 
@@ -173,9 +173,9 @@ class GradeDocumentIndexTest(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
-        cls.semester = mommy.make(Semester, grade_documents_are_deleted=False)
-        cls.archived_semester = mommy.make(Semester, grade_documents_are_deleted=True)
+        baker.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
+        cls.semester = baker.make(Semester, grade_documents_are_deleted=False)
+        cls.archived_semester = baker.make(Semester, grade_documents_are_deleted=True)
 
     def test_visible_semesters(self):
         page = self.app.get(self.url, user="grade_publisher", status=200)
@@ -188,17 +188,17 @@ class GradeSemesterViewTest(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
+        baker.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
 
     def test_does_not_crash(self):
-        semester = mommy.make(Semester, pk=1, grade_documents_are_deleted=False)
-        course = mommy.make(Course, semester=semester)
-        mommy.make(Evaluation, course=course, state="prepared")
+        semester = baker.make(Semester, pk=1, grade_documents_are_deleted=False)
+        course = baker.make(Course, semester=semester)
+        baker.make(Evaluation, course=course, state="prepared")
         page = self.app.get(self.url, user="grade_publisher", status=200)
         self.assertIn(course.name, page)
 
     def test_403_on_deleted(self):
-        mommy.make(Semester, pk=1, grade_documents_are_deleted=True)
+        baker.make(Semester, pk=1, grade_documents_are_deleted=True)
         self.app.get('/grades/semester/1', user="grade_publisher", status=403)
 
 
@@ -207,14 +207,14 @@ class GradeCourseViewTest(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
+        baker.make(UserProfile, username="grade_publisher", groups=[Group.objects.get(name="Grade publisher")])
 
     def test_does_not_crash(self):
-        semester = mommy.make(Semester, pk=1, grade_documents_are_deleted=False)
-        mommy.make(Evaluation, course=mommy.make(Course, pk=1, semester=semester), state="prepared")
+        semester = baker.make(Semester, pk=1, grade_documents_are_deleted=False)
+        baker.make(Evaluation, course=baker.make(Course, pk=1, semester=semester), state="prepared")
         self.app.get('/grades/semester/1/course/1', user="grade_publisher", status=200)
 
     def test_403_on_archived_semester(self):
-        archived_semester = mommy.make(Semester, pk=1, grade_documents_are_deleted=True)
-        mommy.make(Evaluation, course=mommy.make(Course, pk=1, semester=archived_semester), state="prepared")
+        archived_semester = baker.make(Semester, pk=1, grade_documents_are_deleted=True)
+        baker.make(Evaluation, course=baker.make(Course, pk=1, semester=archived_semester), state="prepared")
         self.app.get('/grades/semester/1/course/1', user="grade_publisher", status=403)
diff --git a/evap/results/tests/test_exporters.py b/evap/results/tests/test_exporters.py
--- a/evap/results/tests/test_exporters.py
+++ b/evap/results/tests/test_exporters.py
@@ -1,6 +1,6 @@
 import xlrd
 from io import BytesIO
-from model_mommy import mommy
+from model_bakery import baker
 from django.test import TestCase
 from django.utils import translation
 
@@ -26,31 +26,31 @@ def test_grade_color_calculation(self):
         self.assertEqual(exporter.normalize_number(2.8), 2.8)
 
     def test_questionnaire_ordering(self):
-        degree = mommy.make(Degree)
-        evaluation = mommy.make(
+        degree = baker.make(Degree)
+        evaluation = baker.make(
             Evaluation,
-            course=mommy.make(Course, degrees=[degree]),
+            course=baker.make(Course, degrees=[degree]),
             state='published',
             _participant_count=2,
             _voter_count=2
         )
 
-        questionnaire_1 = mommy.make(Questionnaire, order=1, type=Questionnaire.TOP)
-        questionnaire_2 = mommy.make(Questionnaire, order=4, type=Questionnaire.TOP)
-        questionnaire_3 = mommy.make(Questionnaire, order=1, type=Questionnaire.BOTTOM)
-        questionnaire_4 = mommy.make(Questionnaire, order=4, type=Questionnaire.BOTTOM)
+        questionnaire_1 = baker.make(Questionnaire, order=1, type=Questionnaire.TOP)
+        questionnaire_2 = baker.make(Questionnaire, order=4, type=Questionnaire.TOP)
+        questionnaire_3 = baker.make(Questionnaire, order=1, type=Questionnaire.BOTTOM)
+        questionnaire_4 = baker.make(Questionnaire, order=4, type=Questionnaire.BOTTOM)
 
-        question_1 = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire_1)
-        question_2 = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire_2)
-        question_3 = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire_3)
-        question_4 = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire_4)
+        question_1 = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire_1)
+        question_2 = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire_2)
+        question_3 = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire_3)
+        question_4 = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire_4)
 
         evaluation.general_contribution.questionnaires.set([questionnaire_1, questionnaire_2, questionnaire_3, questionnaire_4])
 
-        mommy.make(RatingAnswerCounter, question=question_1, contribution=evaluation.general_contribution, answer=3, count=100)
-        mommy.make(RatingAnswerCounter, question=question_2, contribution=evaluation.general_contribution, answer=3, count=100)
-        mommy.make(RatingAnswerCounter, question=question_3, contribution=evaluation.general_contribution, answer=3, count=100)
-        mommy.make(RatingAnswerCounter, question=question_4, contribution=evaluation.general_contribution, answer=3, count=100)
+        baker.make(RatingAnswerCounter, question=question_1, contribution=evaluation.general_contribution, answer=3, count=100)
+        baker.make(RatingAnswerCounter, question=question_2, contribution=evaluation.general_contribution, answer=3, count=100)
+        baker.make(RatingAnswerCounter, question=question_3, contribution=evaluation.general_contribution, answer=3, count=100)
+        baker.make(RatingAnswerCounter, question=question_4, contribution=evaluation.general_contribution, answer=3, count=100)
 
         binary_content = BytesIO()
         ExcelExporter(evaluation.course.semester).export(
@@ -75,25 +75,25 @@ def test_questionnaire_ordering(self):
         self.assertEqual(workbook.sheets()[0].row_values(14)[0], question_4.text)
 
     def test_heading_question_filtering(self):
-        degree = mommy.make(Degree)
-        evaluation = mommy.make(
+        degree = baker.make(Degree)
+        evaluation = baker.make(
             Evaluation,
-            course=mommy.make(Course, degrees=[degree]),
+            course=baker.make(Course, degrees=[degree]),
             state='published',
             _participant_count=2,
             _voter_count=2
         )
-        contributor = mommy.make(UserProfile)
-        evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
+        contributor = baker.make(UserProfile)
+        evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
-        questionnaire = mommy.make(Questionnaire)
-        mommy.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=0)
-        heading_question = mommy.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=1)
-        likert_question = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire, order=2)
-        mommy.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=3)
+        questionnaire = baker.make(Questionnaire)
+        baker.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=0)
+        heading_question = baker.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=1)
+        likert_question = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire, order=2)
+        baker.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=3)
 
-        contribution = mommy.make(Contribution, evaluation=evaluation, questionnaires=[questionnaire], contributor=contributor)
-        mommy.make(RatingAnswerCounter, question=likert_question, contribution=contribution, answer=3, count=100)
+        contribution = baker.make(Contribution, evaluation=evaluation, questionnaires=[questionnaire], contributor=contributor)
+        baker.make(RatingAnswerCounter, question=likert_question, contribution=contribution, answer=3, count=100)
 
         binary_content = BytesIO()
         ExcelExporter(evaluation.course.semester).export(
@@ -111,20 +111,20 @@ def test_heading_question_filtering(self):
         self.assertEqual(workbook.sheets()[0].row_values(7)[0], "")
 
     def test_view_excel_file_sorted(self):
-        semester = mommy.make(Semester)
-        course_type = mommy.make(CourseType)
-        degree = mommy.make(Degree)
-        mommy.make(
+        semester = baker.make(Semester)
+        course_type = baker.make(CourseType)
+        degree = baker.make(Degree)
+        baker.make(
             Evaluation,
             state='published',
-            course=mommy.make(Course, degrees=[degree], type=course_type, semester=semester, name_de="A", name_en="B"),
+            course=baker.make(Course, degrees=[degree], type=course_type, semester=semester, name_de="A", name_en="B"),
             name_de='Evaluation1',
             name_en='Evaluation1'
         )
-        mommy.make(
+        baker.make(
             Evaluation,
             state='published',
-            course=mommy.make(Course, degrees=[degree], type=course_type, semester=semester, name_de="B", name_en="A"),
+            course=baker.make(Course, degrees=[degree], type=course_type, semester=semester, name_de="B", name_en="A"),
             name_de='Evaluation2',
             name_en='Evaluation2'
         )
@@ -150,31 +150,31 @@ def test_view_excel_file_sorted(self):
         self.assertEqual(workbook.sheets()[0].row_values(0)[2], "B – Evaluation1")
 
     def test_course_type_ordering(self):
-        degree = mommy.make(Degree)
-        course_type_1 = mommy.make(CourseType, order=1)
-        course_type_2 = mommy.make(CourseType, order=2)
-        semester = mommy.make(Semester)
-        evaluation_1 = mommy.make(Evaluation,
-            course=mommy.make(Course, semester=semester, degrees=[degree], type=course_type_1),
+        degree = baker.make(Degree)
+        course_type_1 = baker.make(CourseType, order=1)
+        course_type_2 = baker.make(CourseType, order=2)
+        semester = baker.make(Semester)
+        evaluation_1 = baker.make(Evaluation,
+            course=baker.make(Course, semester=semester, degrees=[degree], type=course_type_1),
             state='published',
             _participant_count=2,
             _voter_count=2
         )
-        evaluation_2 = mommy.make(Evaluation,
-            course=mommy.make(Course, semester=semester, degrees=[degree], type=course_type_2),
+        evaluation_2 = baker.make(Evaluation,
+            course=baker.make(Course, semester=semester, degrees=[degree], type=course_type_2),
             state='published',
             _participant_count=2,
             _voter_count=2
         )
 
-        questionnaire = mommy.make(Questionnaire)
-        question = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire)
+        questionnaire = baker.make(Questionnaire)
+        question = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire)
 
         evaluation_1.general_contribution.questionnaires.set([questionnaire])
-        mommy.make(RatingAnswerCounter, question=question, contribution=evaluation_1.general_contribution, answer=3, count=2)
+        baker.make(RatingAnswerCounter, question=question, contribution=evaluation_1.general_contribution, answer=3, count=2)
 
         evaluation_2.general_contribution.questionnaires.set([questionnaire])
-        mommy.make(RatingAnswerCounter, question=question, contribution=evaluation_2.general_contribution, answer=3, count=2)
+        baker.make(RatingAnswerCounter, question=question, contribution=evaluation_2.general_contribution, answer=3, count=2)
 
         binary_content = BytesIO()
         ExcelExporter(semester).export(binary_content, [([degree.id], [course_type_1.id, course_type_2.id])], True, True)
diff --git a/evap/results/tests/test_tools.py b/evap/results/tests/test_tools.py
--- a/evap/results/tests/test_tools.py
+++ b/evap/results/tests/test_tools.py
@@ -3,7 +3,7 @@
 from django.core.cache import caches
 from django.test import override_settings
 from django.test.testcases import TestCase
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import (Contribution, Course, Evaluation, Question, Questionnaire, RatingAnswerCounter,
                                     TextAnswer, UserProfile)
@@ -16,7 +16,7 @@
 
 class TestCalculateResults(TestCase):
     def test_caches_published_evaluation(self):
-        evaluation = mommy.make(Evaluation, state='published')
+        evaluation = baker.make(Evaluation, state='published')
 
         self.assertIsNone(caches['results'].get(get_collect_results_cache_key(evaluation)))
 
@@ -25,7 +25,7 @@ def test_caches_published_evaluation(self):
         self.assertIsNotNone(caches['results'].get(get_collect_results_cache_key(evaluation)))
 
     def test_cache_unpublished_evaluation(self):
-        evaluation = mommy.make(Evaluation, state='published', _voter_count=0, _participant_count=0)
+        evaluation = baker.make(Evaluation, state='published', _voter_count=0, _participant_count=0)
         collect_results(evaluation)
         evaluation.unpublish()
         evaluation.save()
@@ -33,19 +33,19 @@ def test_cache_unpublished_evaluation(self):
         self.assertIsNone(caches['results'].get(get_collect_results_cache_key(evaluation)))
 
     def test_calculation_unipolar_results(self):
-        contributor1 = mommy.make(UserProfile)
-        student = mommy.make(UserProfile)
+        contributor1 = baker.make(UserProfile)
+        student = baker.make(UserProfile)
 
-        evaluation = mommy.make(Evaluation, state='published', participants=[student, contributor1], voters=[student, contributor1])
-        questionnaire = mommy.make(Questionnaire)
-        question = mommy.make(Question, questionnaire=questionnaire, type=Question.GRADE)
-        contribution1 = mommy.make(Contribution, contributor=contributor1, evaluation=evaluation, questionnaires=[questionnaire])
+        evaluation = baker.make(Evaluation, state='published', participants=[student, contributor1], voters=[student, contributor1])
+        questionnaire = baker.make(Questionnaire)
+        question = baker.make(Question, questionnaire=questionnaire, type=Question.GRADE)
+        contribution1 = baker.make(Contribution, contributor=contributor1, evaluation=evaluation, questionnaires=[questionnaire])
 
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=1, count=5)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=2, count=15)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=3, count=40)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=4, count=60)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=5, count=30)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=1, count=5)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=2, count=15)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=3, count=40)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=4, count=60)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=5, count=30)
 
         evaluation_results = collect_results(evaluation)
 
@@ -59,21 +59,21 @@ def test_calculation_unipolar_results(self):
         self.assertEqual(question_result.counts, (5, 15, 40, 60, 30))
 
     def test_calculation_bipolar_results(self):
-        contributor1 = mommy.make(UserProfile)
-        student = mommy.make(UserProfile)
-
-        evaluation = mommy.make(Evaluation, state='published', participants=[student, contributor1], voters=[student, contributor1])
-        questionnaire = mommy.make(Questionnaire)
-        question = mommy.make(Question, questionnaire=questionnaire, type=Question.EASY_DIFFICULT)
-        contribution1 = mommy.make(Contribution, contributor=contributor1, evaluation=evaluation, questionnaires=[questionnaire])
-
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=-3, count=5)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=-2, count=5)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=-1, count=15)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=0, count=30)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=1, count=25)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=2, count=15)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=3, count=10)
+        contributor1 = baker.make(UserProfile)
+        student = baker.make(UserProfile)
+
+        evaluation = baker.make(Evaluation, state='published', participants=[student, contributor1], voters=[student, contributor1])
+        questionnaire = baker.make(Questionnaire)
+        question = baker.make(Question, questionnaire=questionnaire, type=Question.EASY_DIFFICULT)
+        contribution1 = baker.make(Contribution, contributor=contributor1, evaluation=evaluation, questionnaires=[questionnaire])
+
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=-3, count=5)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=-2, count=5)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=-1, count=15)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=0, count=30)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=1, count=25)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=2, count=15)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution1, answer=3, count=10)
 
         evaluation_results = collect_results(evaluation)
 
@@ -97,14 +97,14 @@ def test_calculation_bipolar_results(self):
 
     def test_collect_results_after_user_merge(self):
         """ Asserts that merge_users leaves the results cache in a consistent state. Regression test for #907 """
-        contributor = mommy.make(UserProfile)
-        main_user = mommy.make(UserProfile)
-        student = mommy.make(UserProfile)
+        contributor = baker.make(UserProfile)
+        main_user = baker.make(UserProfile)
+        student = baker.make(UserProfile)
 
-        evaluation = mommy.make(Evaluation, state='published', participants=[student])
-        questionnaire = mommy.make(Questionnaire)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.GRADE)
-        mommy.make(Contribution, contributor=contributor, evaluation=evaluation, questionnaires=[questionnaire])
+        evaluation = baker.make(Evaluation, state='published', participants=[student])
+        questionnaire = baker.make(Questionnaire)
+        baker.make(Question, questionnaire=questionnaire, type=Question.GRADE)
+        baker.make(Contribution, contributor=contributor, evaluation=evaluation, questionnaires=[questionnaire])
 
         collect_results(evaluation)
 
@@ -119,33 +119,33 @@ def test_collect_results_after_user_merge(self):
 class TestCalculateAverageDistribution(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.student1 = mommy.make(UserProfile)
-        cls.student2 = mommy.make(UserProfile)
-
-        cls.evaluation = mommy.make(Evaluation, state='published', participants=[cls.student1, cls.student2], voters=[cls.student1, cls.student2])
-        cls.questionnaire = mommy.make(Questionnaire)
-        cls.question_grade = mommy.make(Question, questionnaire=cls.questionnaire, type=Question.GRADE)
-        cls.question_likert = mommy.make(Question, questionnaire=cls.questionnaire, type=Question.LIKERT)
-        cls.question_likert_2 = mommy.make(Question, questionnaire=cls.questionnaire, type=Question.LIKERT)
-        cls.question_bipolar = mommy.make(Question, questionnaire=cls.questionnaire, type=Question.FEW_MANY)
-        cls.question_bipolar_2 = mommy.make(Question, questionnaire=cls.questionnaire, type=Question.LITTLE_MUCH)
+        cls.student1 = baker.make(UserProfile)
+        cls.student2 = baker.make(UserProfile)
+
+        cls.evaluation = baker.make(Evaluation, state='published', participants=[cls.student1, cls.student2], voters=[cls.student1, cls.student2])
+        cls.questionnaire = baker.make(Questionnaire)
+        cls.question_grade = baker.make(Question, questionnaire=cls.questionnaire, type=Question.GRADE)
+        cls.question_likert = baker.make(Question, questionnaire=cls.questionnaire, type=Question.LIKERT)
+        cls.question_likert_2 = baker.make(Question, questionnaire=cls.questionnaire, type=Question.LIKERT)
+        cls.question_bipolar = baker.make(Question, questionnaire=cls.questionnaire, type=Question.FEW_MANY)
+        cls.question_bipolar_2 = baker.make(Question, questionnaire=cls.questionnaire, type=Question.LITTLE_MUCH)
         cls.general_contribution = cls.evaluation.general_contribution
         cls.general_contribution.questionnaires.set([cls.questionnaire])
-        cls.contribution1 = mommy.make(Contribution, contributor=mommy.make(UserProfile), evaluation=cls.evaluation, questionnaires=[cls.questionnaire])
-        cls.contribution2 = mommy.make(Contribution, contributor=mommy.make(UserProfile), evaluation=cls.evaluation, questionnaires=[cls.questionnaire])
+        cls.contribution1 = baker.make(Contribution, contributor=baker.make(UserProfile), evaluation=cls.evaluation, questionnaires=[cls.questionnaire])
+        cls.contribution2 = baker.make(Contribution, contributor=baker.make(UserProfile), evaluation=cls.evaluation, questionnaires=[cls.questionnaire])
 
     @override_settings(CONTRIBUTOR_GRADE_QUESTIONS_WEIGHT=4, CONTRIBUTOR_NON_GRADE_RATING_QUESTIONS_WEIGHT=6, CONTRIBUTIONS_WEIGHT=3, GENERAL_GRADE_QUESTIONS_WEIGHT=2, GENERAL_NON_GRADE_QUESTIONS_WEIGHT=5)
     def test_average_grade(self):
-        question_grade2 = mommy.make(Question, questionnaire=self.questionnaire, type=Question.GRADE)
+        question_grade2 = baker.make(Question, questionnaire=self.questionnaire, type=Question.GRADE)
 
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=2, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=4, count=2)
-        mommy.make(RatingAnswerCounter, question=question_grade2, contribution=self.contribution1, answer=1, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=3, count=4)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=5, count=5)
-        mommy.make(RatingAnswerCounter, question=self.question_likert_2, contribution=self.general_contribution, answer=3, count=3)
-        mommy.make(RatingAnswerCounter, question=self.question_bipolar, contribution=self.general_contribution, answer=3, count=2)
-        mommy.make(RatingAnswerCounter, question=self.question_bipolar_2, contribution=self.general_contribution, answer=-1, count=4)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=2, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=4, count=2)
+        baker.make(RatingAnswerCounter, question=question_grade2, contribution=self.contribution1, answer=1, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=3, count=4)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=5, count=5)
+        baker.make(RatingAnswerCounter, question=self.question_likert_2, contribution=self.general_contribution, answer=3, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_bipolar, contribution=self.general_contribution, answer=3, count=2)
+        baker.make(RatingAnswerCounter, question=self.question_bipolar_2, contribution=self.general_contribution, answer=-1, count=4)
 
         contributor_weights_sum = settings.CONTRIBUTOR_GRADE_QUESTIONS_WEIGHT + settings.CONTRIBUTOR_NON_GRADE_RATING_QUESTIONS_WEIGHT
         contributor1_average = ((settings.CONTRIBUTOR_GRADE_QUESTIONS_WEIGHT * ((2 * 1) + (1 * 1)) / (1 + 1)) + (settings.CONTRIBUTOR_NON_GRADE_RATING_QUESTIONS_WEIGHT * 3)) / contributor_weights_sum  # 2.4
@@ -165,14 +165,14 @@ def test_average_grade(self):
 
     @override_settings(CONTRIBUTOR_GRADE_QUESTIONS_WEIGHT=4, CONTRIBUTOR_NON_GRADE_RATING_QUESTIONS_WEIGHT=6, CONTRIBUTIONS_WEIGHT=3, GENERAL_GRADE_QUESTIONS_WEIGHT=2, GENERAL_NON_GRADE_QUESTIONS_WEIGHT=5)
     def test_distribution_without_general_grade_question(self):
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=1, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=3, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=4, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=2, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=3, count=3)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=5, count=3)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=5, count=5)
-        mommy.make(RatingAnswerCounter, question=self.question_likert_2, contribution=self.general_contribution, answer=3, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=1, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=3, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=4, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=2, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=3, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=5, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=5, count=5)
+        baker.make(RatingAnswerCounter, question=self.question_likert_2, contribution=self.general_contribution, answer=3, count=3)
 
         # contribution1: 0.4 * (0.5, 0, 0.5, 0, 0) + 0.6 * (0, 0, 0.5, 0, 0.5) = (0.2, 0, 0.5, 0, 0.3)
         # contribution2: (0, 0.5, 0, 0.5, 0)
@@ -191,15 +191,15 @@ def test_distribution_without_general_grade_question(self):
 
     @override_settings(CONTRIBUTOR_GRADE_QUESTIONS_WEIGHT=4, CONTRIBUTOR_NON_GRADE_RATING_QUESTIONS_WEIGHT=6, CONTRIBUTIONS_WEIGHT=3, GENERAL_GRADE_QUESTIONS_WEIGHT=2, GENERAL_NON_GRADE_QUESTIONS_WEIGHT=5)
     def test_distribution_with_general_grade_question(self):
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=1, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=3, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=4, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=2, count=1)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=3, count=3)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=5, count=3)
-        mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=5, count=5)
-        mommy.make(RatingAnswerCounter, question=self.question_likert_2, contribution=self.general_contribution, answer=3, count=3)
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.general_contribution, answer=2, count=10)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=1, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=3, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=4, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution2, answer=2, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=3, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.contribution1, answer=5, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=5, count=5)
+        baker.make(RatingAnswerCounter, question=self.question_likert_2, contribution=self.general_contribution, answer=3, count=3)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.general_contribution, answer=2, count=10)
 
         # contributions and general_non_grade are as above
         # general_grade: (0, 1, 0, 0, 0)
@@ -214,24 +214,24 @@ def test_distribution_with_general_grade_question(self):
         self.assertAlmostEqual(distribution[4], 0.38)
 
     def test_get_single_result_rating_result(self):
-        single_result_evaluation = mommy.make(Evaluation, state='published', is_single_result=True)
+        single_result_evaluation = baker.make(Evaluation, state='published', is_single_result=True)
         questionnaire = Questionnaire.objects.get(name_en=Questionnaire.SINGLE_RESULT_QUESTIONNAIRE_NAME)
-        contribution = mommy.make(Contribution, contributor=mommy.make(UserProfile), evaluation=single_result_evaluation, questionnaires=[questionnaire], can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(RatingAnswerCounter, question=questionnaire.questions.first(), contribution=contribution, answer=1, count=1)
-        mommy.make(RatingAnswerCounter, question=questionnaire.questions.first(), contribution=contribution, answer=4, count=1)
+        contribution = baker.make(Contribution, contributor=baker.make(UserProfile), evaluation=single_result_evaluation, questionnaires=[questionnaire], can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(RatingAnswerCounter, question=questionnaire.questions.first(), contribution=contribution, answer=1, count=1)
+        baker.make(RatingAnswerCounter, question=questionnaire.questions.first(), contribution=contribution, answer=4, count=1)
         distribution = calculate_average_distribution(single_result_evaluation)
         self.assertEqual(distribution, (0.5, 0, 0, 0.5, 0))
         rating_result = get_single_result_rating_result(single_result_evaluation)
         self.assertEqual(rating_result.counts, (1, 0, 0, 1, 0))
 
     def test_result_calculation_with_no_contributor_rating_question_does_not_fail(self):
-        evaluation = mommy.make(Evaluation, state='published', participants=[self.student1, self.student2], voters=[self.student1, self.student2])
-        questionnaire_text = mommy.make(Questionnaire)
-        mommy.make(Question, questionnaire=questionnaire_text, type=Question.TEXT)
-        mommy.make(Contribution, contributor=mommy.make(UserProfile), evaluation=evaluation, questionnaires=[questionnaire_text])
+        evaluation = baker.make(Evaluation, state='published', participants=[self.student1, self.student2], voters=[self.student1, self.student2])
+        questionnaire_text = baker.make(Questionnaire)
+        baker.make(Question, questionnaire=questionnaire_text, type=Question.TEXT)
+        baker.make(Contribution, contributor=baker.make(UserProfile), evaluation=evaluation, questionnaires=[questionnaire_text])
 
         evaluation.general_contribution.questionnaires.set([self.questionnaire])
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=evaluation.general_contribution, answer=1, count=1)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=evaluation.general_contribution, answer=1, count=1)
 
         distribution = calculate_average_distribution(evaluation)
         self.assertEqual(distribution[0], 1)
@@ -240,7 +240,7 @@ def test_unipolarized_unipolar(self):
         counts = (5, 3, 1, 1, 0)
 
         answer_counters = [
-            mommy.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=answer, count=count)
+            baker.make(RatingAnswerCounter, question=self.question_likert, contribution=self.general_contribution, answer=answer, count=count)
             for answer, count in enumerate(counts, start=1)
         ]
 
@@ -256,7 +256,7 @@ def test_unipolarized_bipolar(self):
         counts = (0, 1, 4, 8, 2, 2, 3)
 
         answer_counters = [
-            mommy.make(RatingAnswerCounter, question=self.question_bipolar, contribution=self.general_contribution, answer=answer, count=count)
+            baker.make(RatingAnswerCounter, question=self.question_bipolar, contribution=self.general_contribution, answer=answer, count=count)
             for answer, count in enumerate(counts, start=-3)
         ]
 
@@ -270,10 +270,10 @@ def test_unipolarized_bipolar(self):
 
     def test_unipolarized_yesno(self):
         counts = (57, 43)
-        question_yesno = mommy.make(Question, questionnaire=self.questionnaire, type=Question.POSITIVE_YES_NO)
+        question_yesno = baker.make(Question, questionnaire=self.questionnaire, type=Question.POSITIVE_YES_NO)
         answer_counters = [
-            mommy.make(RatingAnswerCounter, question=question_yesno, contribution=self.general_contribution, answer=1, count=counts[0]),
-            mommy.make(RatingAnswerCounter, question=question_yesno, contribution=self.general_contribution, answer=5, count=counts[1])
+            baker.make(RatingAnswerCounter, question=question_yesno, contribution=self.general_contribution, answer=1, count=counts[0]),
+            baker.make(RatingAnswerCounter, question=question_yesno, contribution=self.general_contribution, answer=5, count=counts[1])
         ]
 
         result = RatingResult(question_yesno, answer_counters)
@@ -285,10 +285,10 @@ def test_unipolarized_yesno(self):
         self.assertAlmostEqual(distribution[4], 0.43)
 
     def test_calculate_average_course_distribution(self):
-        mommy.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=1, count=2)
+        baker.make(RatingAnswerCounter, question=self.question_grade, contribution=self.contribution1, answer=1, count=2)
 
         course = self.evaluation.course
-        single_result = mommy.make(
+        single_result = baker.make(
             Evaluation,
             name_de="Single Result",
             name_en="Single Result",
@@ -302,9 +302,9 @@ def test_calculate_average_course_distribution(self):
         single_result_questionnaire = Questionnaire.single_result_questionnaire()
         single_result_question = single_result_questionnaire.questions.first()
 
-        contribution = mommy.make(Contribution, evaluation=single_result, contributor=None, questionnaires=[single_result_questionnaire])
-        mommy.make(RatingAnswerCounter, question=single_result_question, contribution=contribution, answer=2, count=1)
-        mommy.make(RatingAnswerCounter, question=single_result_question, contribution=contribution, answer=3, count=1)
+        contribution = baker.make(Contribution, evaluation=single_result, contributor=None, questionnaires=[single_result_questionnaire])
+        baker.make(RatingAnswerCounter, question=single_result_question, contribution=contribution, answer=2, count=1)
+        baker.make(RatingAnswerCounter, question=single_result_question, contribution=contribution, answer=3, count=1)
 
         distribution = calculate_average_course_distribution(course)
         self.assertEqual(distribution[0], 0.25)
@@ -317,33 +317,33 @@ def test_calculate_average_course_distribution(self):
 class TestTextAnswerVisibilityInfo(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.delegate1 = mommy.make(UserProfile, username="delegate1")
-        cls.delegate2 = mommy.make(UserProfile, username="delegate2")
-        cls.contributor_own = mommy.make(UserProfile, username="contributor_own", delegates=[cls.delegate1])
-        cls.contributor_general = mommy.make(UserProfile, username="contributor_general", delegates=[cls.delegate2])
-        cls.responsible1 = mommy.make(UserProfile, username="responsible1", delegates=[cls.delegate1, cls.contributor_general])
-        cls.responsible2 = mommy.make(UserProfile, username="responsible2")
-        cls.responsible_without_contribution = mommy.make(UserProfile, username="responsible_without_contribution")
-        cls.other_user = mommy.make(UserProfile, username="other_user")
-
-        cls.evaluation = mommy.make(Evaluation, course=mommy.make(Course, responsibles=[cls.responsible1, cls.responsible2, cls.responsible_without_contribution]), state='published', can_publish_text_results=True)
-        cls.questionnaire = mommy.make(Questionnaire)
-        cls.question = mommy.make(Question, questionnaire=cls.questionnaire, type=Question.TEXT)
+        cls.delegate1 = baker.make(UserProfile, username="delegate1")
+        cls.delegate2 = baker.make(UserProfile, username="delegate2")
+        cls.contributor_own = baker.make(UserProfile, username="contributor_own", delegates=[cls.delegate1])
+        cls.contributor_general = baker.make(UserProfile, username="contributor_general", delegates=[cls.delegate2])
+        cls.responsible1 = baker.make(UserProfile, username="responsible1", delegates=[cls.delegate1, cls.contributor_general])
+        cls.responsible2 = baker.make(UserProfile, username="responsible2")
+        cls.responsible_without_contribution = baker.make(UserProfile, username="responsible_without_contribution")
+        cls.other_user = baker.make(UserProfile, username="other_user")
+
+        cls.evaluation = baker.make(Evaluation, course=baker.make(Course, responsibles=[cls.responsible1, cls.responsible2, cls.responsible_without_contribution]), state='published', can_publish_text_results=True)
+        cls.questionnaire = baker.make(Questionnaire)
+        cls.question = baker.make(Question, questionnaire=cls.questionnaire, type=Question.TEXT)
         cls.general_contribution = cls.evaluation.general_contribution
         cls.general_contribution.questionnaires.set([cls.questionnaire])
-        cls.responsible1_contribution = mommy.make(Contribution, contributor=cls.responsible1, evaluation=cls.evaluation,
+        cls.responsible1_contribution = baker.make(Contribution, contributor=cls.responsible1, evaluation=cls.evaluation,
             questionnaires=[cls.questionnaire], can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        cls.responsible2_contribution = mommy.make(Contribution, contributor=cls.responsible2, evaluation=cls.evaluation,
+        cls.responsible2_contribution = baker.make(Contribution, contributor=cls.responsible2, evaluation=cls.evaluation,
             questionnaires=[cls.questionnaire], can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        cls.contributor_own_contribution = mommy.make(Contribution, contributor=cls.contributor_own, evaluation=cls.evaluation,
+        cls.contributor_own_contribution = baker.make(Contribution, contributor=cls.contributor_own, evaluation=cls.evaluation,
             questionnaires=[cls.questionnaire], textanswer_visibility=Contribution.OWN_TEXTANSWERS)
-        cls.contributor_general_contribution = mommy.make(Contribution, contributor=cls.contributor_general, evaluation=cls.evaluation,
+        cls.contributor_general_contribution = baker.make(Contribution, contributor=cls.contributor_general, evaluation=cls.evaluation,
             questionnaires=[cls.questionnaire], textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        cls.general_contribution_textanswer = mommy.make(TextAnswer, question=cls.question, contribution=cls.general_contribution, state=TextAnswer.PUBLISHED)
-        cls.responsible1_textanswer = mommy.make(TextAnswer, question=cls.question, contribution=cls.responsible1_contribution, state=TextAnswer.PUBLISHED)
-        cls.responsible2_textanswer = mommy.make(TextAnswer, question=cls.question, contribution=cls.responsible2_contribution, state=TextAnswer.PUBLISHED)
-        cls.contributor_own_textanswer = mommy.make(TextAnswer, question=cls.question, contribution=cls.contributor_own_contribution, state=TextAnswer.PUBLISHED)
-        cls.contributor_general_textanswer = mommy.make(TextAnswer, question=cls.question, contribution=cls.contributor_general_contribution, state=TextAnswer.PUBLISHED)
+        cls.general_contribution_textanswer = baker.make(TextAnswer, question=cls.question, contribution=cls.general_contribution, state=TextAnswer.PUBLISHED)
+        cls.responsible1_textanswer = baker.make(TextAnswer, question=cls.question, contribution=cls.responsible1_contribution, state=TextAnswer.PUBLISHED)
+        cls.responsible2_textanswer = baker.make(TextAnswer, question=cls.question, contribution=cls.responsible2_contribution, state=TextAnswer.PUBLISHED)
+        cls.contributor_own_textanswer = baker.make(TextAnswer, question=cls.question, contribution=cls.contributor_own_contribution, state=TextAnswer.PUBLISHED)
+        cls.contributor_general_textanswer = baker.make(TextAnswer, question=cls.question, contribution=cls.contributor_general_contribution, state=TextAnswer.PUBLISHED)
 
     def test_text_answer_visible_to_non_contributing_responsible(self):
         self.assertIn(self.responsible_without_contribution, textanswers_visible_to(self.general_contribution_textanswer.contribution)[0])
diff --git a/evap/results/tests/test_views.py b/evap/results/tests/test_views.py
--- a/evap/results/tests/test_views.py
+++ b/evap/results/tests/test_views.py
@@ -10,7 +10,7 @@
 from django.test.utils import CaptureQueriesContext
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import (Contribution, Course, Degree, Evaluation, Question, Questionnaire, RatingAnswerCounter,
                                     Semester, UserProfile)
@@ -25,22 +25,22 @@ class TestResultsView(WebTest):
 
     @patch('evap.evaluation.models.Evaluation.can_be_seen_by', new=(lambda self, user: True))
     def test_multiple_evaluations_per_course(self):
-        mommy.make(UserProfile, username='student', email="student@institution.example.com")
+        baker.make(UserProfile, username='student', email="student@institution.example.com")
 
         # course with no evaluations does not show up
-        course = mommy.make(Course)
+        course = baker.make(Course)
         page = self.app.get(self.url, user="student")
         self.assertNotContains(page, course.name)
         caches['results'].clear()
 
         # course with one evaluation is a single line with the evaluation's full_name
-        evaluation = mommy.make(Evaluation, course=course, name_en='unique_evaluation_name1', name_de="foo", state='published')
+        evaluation = baker.make(Evaluation, course=course, name_en='unique_evaluation_name1', name_de="foo", state='published')
         page = self.app.get(self.url, user="student")
         self.assertContains(page, evaluation.full_name)
         caches['results'].clear()
 
         # course with two evaluations is three lines without using the full names
-        evaluation2 = mommy.make(Evaluation, course=course, name_en='unique_evaluation_name2', name_de="bar", state='published')
+        evaluation2 = baker.make(Evaluation, course=course, name_en='unique_evaluation_name2', name_de="bar", state='published')
         page = self.app.get(self.url, user="student")
         self.assertContains(page, course.name)
         self.assertContains(page, evaluation.name_en)
@@ -61,15 +61,15 @@ def test_num_queries_is_constant(self):
             ensures that the number of queries in the user list is constant
             and not linear to the number of courses/evaluations
         """
-        mommy.make(UserProfile, username='student', email="student@institution.example.com")
+        baker.make(UserProfile, username='student', email="student@institution.example.com")
 
         # warm up some caches
         self.app.get(self.url, user="student")
 
         def make_course_with_evaluations(unique_suffix):
-            course = mommy.make(Course)
-            mommy.make(Evaluation, course=course, name_en='foo' + unique_suffix, name_de='foo' + unique_suffix, state='published', _voter_count=0)
-            mommy.make(Evaluation, course=course, name_en='bar' + unique_suffix, name_de='bar' + unique_suffix, state='published', _voter_count=0)
+            course = baker.make(Course)
+            baker.make(Evaluation, course=course, name_en='foo' + unique_suffix, name_de='foo' + unique_suffix, state='published', _voter_count=0)
+            baker.make(Evaluation, course=course, name_en='bar' + unique_suffix, name_de='bar' + unique_suffix, state='published', _voter_count=0)
 
         # first measure the number of queries with two courses
         make_course_with_evaluations('frob')
@@ -97,8 +97,8 @@ def make_course_with_evaluations(unique_suffix):
 class TestGetEvaluationsWithPrefetchedData(TestCase):
     def test_returns_correct_participant_count(self):
         """ Regression test for #1248 """
-        participants = mommy.make(UserProfile, _quantity=2)
-        evaluation = mommy.make(Evaluation,
+        participants = baker.make(UserProfile, _quantity=2)
+        evaluation = baker.make(Evaluation,
             state='published', _participant_count=2, _voter_count=2,
             participants=participants, voters=participants
         )
@@ -116,22 +116,22 @@ def test_returns_correct_participant_count(self):
 class TestResultsViewContributionWarning(WebTest):
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester, id=3)
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        contributor = mommy.make(UserProfile)
+        cls.semester = baker.make(Semester, id=3)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        contributor = baker.make(UserProfile)
 
         # Set up an evaluation with one question but no answers
-        student1 = mommy.make(UserProfile)
-        student2 = mommy.make(UserProfile)
-        cls.evaluation = mommy.make(Evaluation, id=21, state='published', course=mommy.make(Course, semester=cls.semester), participants=[student1, student2], voters=[student1, student2])
-        questionnaire = mommy.make(Questionnaire)
+        student1 = baker.make(UserProfile)
+        student2 = baker.make(UserProfile)
+        cls.evaluation = baker.make(Evaluation, id=21, state='published', course=baker.make(Course, semester=cls.semester), participants=[student1, student2], voters=[student1, student2])
+        questionnaire = baker.make(Questionnaire)
         cls.evaluation.general_contribution.questionnaires.set([questionnaire])
-        cls.contribution = mommy.make(Contribution, evaluation=cls.evaluation, questionnaires=[questionnaire], contributor=contributor)
-        cls.likert_question = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire, order=2)
+        cls.contribution = baker.make(Contribution, evaluation=cls.evaluation, questionnaires=[questionnaire], contributor=contributor)
+        cls.likert_question = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire, order=2)
         cls.url = '/results/semester/%s/evaluation/%s' % (cls.semester.id, cls.evaluation.id)
 
     def test_many_answers_evaluation_no_warning(self):
-        mommy.make(RatingAnswerCounter, question=self.likert_question, contribution=self.contribution, answer=3, count=10)
+        baker.make(RatingAnswerCounter, question=self.likert_question, contribution=self.contribution, answer=3, count=10)
         page = self.app.get(self.url, user='manager', status=200)
         self.assertNotIn("Only a few participants answered these questions.", page)
 
@@ -140,7 +140,7 @@ def test_zero_answers_evaluation_no_warning(self):
         self.assertNotIn("Only a few participants answered these questions.", page)
 
     def test_few_answers_evaluation_show_warning(self):
-        mommy.make(RatingAnswerCounter, question=self.likert_question, contribution=self.contribution, answer=3, count=3)
+        baker.make(RatingAnswerCounter, question=self.likert_question, contribution=self.contribution, answer=3, count=3)
         page = self.app.get(self.url, user='manager', status=200)
         self.assertIn("Only a few participants answered these questions.", page)
 
@@ -151,37 +151,37 @@ class TestResultsSemesterEvaluationDetailView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester, id=2)
+        cls.semester = baker.make(Semester, id=2)
 
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
-        contributor = mommy.make(UserProfile, username='contributor')
-        responsible = mommy.make(UserProfile, username='responsible')
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
+        contributor = baker.make(UserProfile, username='contributor')
+        responsible = baker.make(UserProfile, username='responsible')
 
         # Normal evaluation with responsible and contributor.
-        cls.evaluation = mommy.make(Evaluation, id=21, state='published', course=mommy.make(Course, semester=cls.semester))
+        cls.evaluation = baker.make(Evaluation, id=21, state='published', course=baker.make(Course, semester=cls.semester))
 
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        cls.contribution = mommy.make(Contribution, evaluation=cls.evaluation, contributor=contributor, can_edit=True)
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        cls.contribution = baker.make(Contribution, evaluation=cls.evaluation, contributor=contributor, can_edit=True)
 
     def test_questionnaire_ordering(self):
-        top_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        contributor_questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        bottom_questionnaire = mommy.make(Questionnaire, type=Questionnaire.BOTTOM)
+        top_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        contributor_questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        bottom_questionnaire = baker.make(Questionnaire, type=Questionnaire.BOTTOM)
 
-        top_heading_question = mommy.make(Question, type=Question.HEADING, questionnaire=top_questionnaire, order=0)
-        top_likert_question = mommy.make(Question, type=Question.LIKERT, questionnaire=top_questionnaire, order=1)
+        top_heading_question = baker.make(Question, type=Question.HEADING, questionnaire=top_questionnaire, order=0)
+        top_likert_question = baker.make(Question, type=Question.LIKERT, questionnaire=top_questionnaire, order=1)
 
-        contributor_likert_question = mommy.make(Question, type=Question.LIKERT, questionnaire=contributor_questionnaire)
+        contributor_likert_question = baker.make(Question, type=Question.LIKERT, questionnaire=contributor_questionnaire)
 
-        bottom_heading_question = mommy.make(Question, type=Question.HEADING, questionnaire=bottom_questionnaire, order=0)
-        bottom_likert_question = mommy.make(Question, type=Question.LIKERT, questionnaire=bottom_questionnaire, order=1)
+        bottom_heading_question = baker.make(Question, type=Question.HEADING, questionnaire=bottom_questionnaire, order=0)
+        bottom_likert_question = baker.make(Question, type=Question.LIKERT, questionnaire=bottom_questionnaire, order=1)
 
         self.evaluation.general_contribution.questionnaires.set([top_questionnaire, bottom_questionnaire])
         self.contribution.questionnaires.set([contributor_questionnaire])
 
-        mommy.make(RatingAnswerCounter, question=top_likert_question, contribution=self.evaluation.general_contribution, answer=2, count=100)
-        mommy.make(RatingAnswerCounter, question=contributor_likert_question, contribution=self.contribution, answer=1, count=100)
-        mommy.make(RatingAnswerCounter, question=bottom_likert_question, contribution=self.evaluation.general_contribution, answer=3, count=100)
+        baker.make(RatingAnswerCounter, question=top_likert_question, contribution=self.evaluation.general_contribution, answer=2, count=100)
+        baker.make(RatingAnswerCounter, question=contributor_likert_question, contribution=self.contribution, answer=1, count=100)
+        baker.make(RatingAnswerCounter, question=bottom_likert_question, contribution=self.evaluation.general_contribution, answer=3, count=100)
 
         content = self.app.get(self.url, user='manager').body.decode()
 
@@ -194,16 +194,16 @@ def test_questionnaire_ordering(self):
         self.assertTrue(top_heading_index < top_likert_index < contributor_likert_index < bottom_heading_index < bottom_likert_index)
 
     def test_heading_question_filtering(self):
-        contributor = mommy.make(UserProfile)
-        questionnaire = mommy.make(Questionnaire)
+        contributor = baker.make(UserProfile)
+        questionnaire = baker.make(Questionnaire)
 
-        heading_question_0 = mommy.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=0)
-        heading_question_1 = mommy.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=1)
-        likert_question = mommy.make(Question, type=Question.LIKERT, questionnaire=questionnaire, order=2)
-        heading_question_2 = mommy.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=3)
+        heading_question_0 = baker.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=0)
+        heading_question_1 = baker.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=1)
+        likert_question = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire, order=2)
+        heading_question_2 = baker.make(Question, type=Question.HEADING, questionnaire=questionnaire, order=3)
 
-        contribution = mommy.make(Contribution, evaluation=self.evaluation, questionnaires=[questionnaire], contributor=contributor)
-        mommy.make(RatingAnswerCounter, question=likert_question, contribution=contribution, answer=3, count=100)
+        contribution = baker.make(Contribution, evaluation=self.evaluation, questionnaires=[questionnaire], contributor=contributor)
+        baker.make(RatingAnswerCounter, question=likert_question, contribution=contribution, answer=3, count=100)
 
         page = self.app.get(self.url, user='manager')
 
@@ -223,7 +223,7 @@ def test_default_view_is_public(self):
         self.assertEqual(page_without_get_parameter.body, page_with_random_get_parameter.body)
 
     def test_wrong_state(self):
-        evaluation = mommy.make(Evaluation, state='reviewed', course=mommy.make(Course, semester=self.semester))
+        evaluation = baker.make(Evaluation, state='reviewed', course=baker.make(Course, semester=self.semester))
         url = '/results/semester/%s/evaluation/%s' % (self.semester.id, evaluation.id)
         self.app.get(url, user='student', status=403)
 
@@ -231,20 +231,20 @@ def test_wrong_state(self):
 class TestResultsSemesterEvaluationDetailViewFewVoters(WebTest):
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester, id=2)
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
-        responsible = mommy.make(UserProfile, username='responsible')
-        cls.student1 = mommy.make(UserProfile, username='student')
-        cls.student2 = mommy.make(UserProfile)
-        students = mommy.make(UserProfile, _quantity=10)
+        cls.semester = baker.make(Semester, id=2)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
+        responsible = baker.make(UserProfile, username='responsible')
+        cls.student1 = baker.make(UserProfile, username='student')
+        cls.student2 = baker.make(UserProfile)
+        students = baker.make(UserProfile, _quantity=10)
         students.extend([cls.student1, cls.student2])
 
-        cls.evaluation = mommy.make(Evaluation, id=22, state='in_evaluation', course=mommy.make(Course, semester=cls.semester), participants=students)
-        questionnaire = mommy.make(Questionnaire)
-        cls.question_grade = mommy.make(Question, questionnaire=questionnaire, type=Question.GRADE)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.LIKERT)
+        cls.evaluation = baker.make(Evaluation, id=22, state='in_evaluation', course=baker.make(Course, semester=cls.semester), participants=students)
+        questionnaire = baker.make(Questionnaire)
+        cls.question_grade = baker.make(Question, questionnaire=questionnaire, type=Question.GRADE)
+        baker.make(Question, questionnaire=questionnaire, type=Question.LIKERT)
         cls.evaluation.general_contribution.questionnaires.set([questionnaire])
-        cls.responsible_contribution = mommy.make(Contribution, contributor=responsible, evaluation=cls.evaluation, questionnaires=[questionnaire])
+        cls.responsible_contribution = baker.make(Contribution, contributor=responsible, evaluation=cls.evaluation, questionnaires=[questionnaire])
 
     def setUp(self):
         self.evaluation = Evaluation.objects.get(pk=self.evaluation.pk)
@@ -300,22 +300,22 @@ def test_answer_visibility_two_voters(self):
 class TestResultsSemesterEvaluationDetailViewPrivateEvaluation(WebTest):
     @patch('evap.results.templatetags.results_templatetags.get_grade_color', new=lambda x: (0, 0, 0))
     def test_private_evaluation(self):
-        semester = mommy.make(Semester)
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
-        student = mommy.make(UserProfile, username="student", email="student@institution.example.com")
-        student_external = mommy.make(UserProfile, username="student_external")
-        contributor = mommy.make(UserProfile, username="contributor", email="contributor@institution.example.com")
-        responsible = mommy.make(UserProfile, username="responsible", email="responsible@institution.example.com")
-        responsible_contributor = mommy.make(UserProfile, username="responsible_contributor", email="responsible_contributor@institution.example.com")
-        test1 = mommy.make(UserProfile, username="test1")
-        test2 = mommy.make(UserProfile, username="test2")
-        mommy.make(UserProfile, username="random", email="random@institution.example.com")
-        degree = mommy.make(Degree)
-        course = mommy.make(Course, semester=semester, degrees=[degree], is_private=True, responsibles=[responsible, responsible_contributor])
-        private_evaluation = mommy.make(Evaluation, course=course, state='published', participants=[student, student_external, test1, test2], voters=[test1, test2])
-        private_evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
-        mommy.make(Contribution, evaluation=private_evaluation, contributor=responsible_contributor, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(Contribution, evaluation=private_evaluation, contributor=contributor, can_edit=True)
+        semester = baker.make(Semester)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
+        student = baker.make(UserProfile, username="student", email="student@institution.example.com")
+        student_external = baker.make(UserProfile, username="student_external")
+        contributor = baker.make(UserProfile, username="contributor", email="contributor@institution.example.com")
+        responsible = baker.make(UserProfile, username="responsible", email="responsible@institution.example.com")
+        responsible_contributor = baker.make(UserProfile, username="responsible_contributor", email="responsible_contributor@institution.example.com")
+        test1 = baker.make(UserProfile, username="test1")
+        test2 = baker.make(UserProfile, username="test2")
+        baker.make(UserProfile, username="random", email="random@institution.example.com")
+        degree = baker.make(Degree)
+        course = baker.make(Course, semester=semester, degrees=[degree], is_private=True, responsibles=[responsible, responsible_contributor])
+        private_evaluation = baker.make(Evaluation, course=course, state='published', participants=[student, student_external, test1, test2], voters=[test1, test2])
+        private_evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
+        baker.make(Contribution, evaluation=private_evaluation, contributor=responsible_contributor, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(Contribution, evaluation=private_evaluation, contributor=contributor, can_edit=True)
 
         url = '/results/'
         self.assertNotIn(private_evaluation.full_name, self.app.get(url, user='random'))
@@ -342,7 +342,7 @@ class TestResultsTextanswerVisibilityForManager(WebTest):
     @classmethod
     def setUpTestData(cls):
         manager_group = Group.objects.get(name="Manager")
-        mommy.make(UserProfile, username="manager", groups=[manager_group])
+        baker.make(UserProfile, username="manager", groups=[manager_group])
 
     def test_textanswer_visibility_for_manager_before_publish(self):
         evaluation = Evaluation.objects.get(id=1)
@@ -505,19 +505,19 @@ def test_textanswer_visibility_info_for_proxy_user(self):
 class TestResultsOtherContributorsListOnExportView(WebTest):
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester, id=2)
-        responsible = mommy.make(UserProfile, username='responsible')
-        cls.evaluation = mommy.make(Evaluation, id=21, state='published', course=mommy.make(Course, semester=cls.semester, responsibles=[responsible]))
+        cls.semester = baker.make(Semester, id=2)
+        responsible = baker.make(UserProfile, username='responsible')
+        cls.evaluation = baker.make(Evaluation, id=21, state='published', course=baker.make(Course, semester=cls.semester, responsibles=[responsible]))
 
-        questionnaire = mommy.make(Questionnaire)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.LIKERT)
+        questionnaire = baker.make(Questionnaire)
+        baker.make(Question, questionnaire=questionnaire, type=Question.LIKERT)
         cls.evaluation.general_contribution.questionnaires.set([questionnaire])
 
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=responsible, questionnaires=[questionnaire], can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        cls.other_contributor_1 = mommy.make(UserProfile, username='other contributor 1')
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=cls.other_contributor_1, questionnaires=[questionnaire], textanswer_visibility=Contribution.OWN_TEXTANSWERS)
-        cls.other_contributor_2 = mommy.make(UserProfile, username='other contributor 2')
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=cls.other_contributor_2, questionnaires=[questionnaire], textanswer_visibility=Contribution.OWN_TEXTANSWERS)
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=responsible, questionnaires=[questionnaire], can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        cls.other_contributor_1 = baker.make(UserProfile, username='other contributor 1')
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=cls.other_contributor_1, questionnaires=[questionnaire], textanswer_visibility=Contribution.OWN_TEXTANSWERS)
+        cls.other_contributor_2 = baker.make(UserProfile, username='other contributor 2')
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=cls.other_contributor_2, questionnaires=[questionnaire], textanswer_visibility=Contribution.OWN_TEXTANSWERS)
 
     def test_contributor_list(self):
         url = '/results/semester/{}/evaluation/{}?view=export'.format(self.semester.id, self.evaluation.id)
@@ -532,7 +532,7 @@ class TestResultsTextanswerVisibilityForExportView(WebTest):
     @classmethod
     def setUpTestData(cls):
         manager_group = Group.objects.get(name="Manager")
-        cls.manager = mommy.make(UserProfile, username="manager", groups=[manager_group])
+        cls.manager = baker.make(UserProfile, username="manager", groups=[manager_group])
 
     def test_textanswer_visibility_for_responsible(self):
         page = self.app.get("/results/semester/1/evaluation/1?view=export", user='responsible')
@@ -654,19 +654,19 @@ def test_textanswer_visibility_for_manager_contributor(self):
 class TestArchivedResults(WebTest):
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester)
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
-        mommy.make(UserProfile, username='reviewer', groups=[Group.objects.get(name='Reviewer')], email="reviewer@institution.example.com")
-        student = mommy.make(UserProfile, username="student", email="student@institution.example.com")
-        student_external = mommy.make(UserProfile, username="student_external")
-        contributor = mommy.make(UserProfile, username="contributor", email="contributor@institution.example.com")
-        responsible = mommy.make(UserProfile, username="responsible", email="responsible@institution.example.com")
-
-        course = mommy.make(Course, semester=cls.semester, degrees=[mommy.make(Degree)], responsibles=[responsible])
-        cls.evaluation = mommy.make(Evaluation, course=course, state='published', participants=[student, student_external], voters=[student, student_external])
-        cls.evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
-        cls.contribution = mommy.make(Contribution, evaluation=cls.evaluation, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, contributor=responsible)
-        cls.contribution = mommy.make(Contribution, evaluation=cls.evaluation, contributor=contributor)
+        cls.semester = baker.make(Semester)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')], email="manager@institution.example.com")
+        baker.make(UserProfile, username='reviewer', groups=[Group.objects.get(name='Reviewer')], email="reviewer@institution.example.com")
+        student = baker.make(UserProfile, username="student", email="student@institution.example.com")
+        student_external = baker.make(UserProfile, username="student_external")
+        contributor = baker.make(UserProfile, username="contributor", email="contributor@institution.example.com")
+        responsible = baker.make(UserProfile, username="responsible", email="responsible@institution.example.com")
+
+        course = baker.make(Course, semester=cls.semester, degrees=[baker.make(Degree)], responsibles=[responsible])
+        cls.evaluation = baker.make(Evaluation, course=course, state='published', participants=[student, student_external], voters=[student, student_external])
+        cls.evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
+        cls.contribution = baker.make(Contribution, evaluation=cls.evaluation, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, contributor=responsible)
+        cls.contribution = baker.make(Contribution, evaluation=cls.evaluation, contributor=contributor)
 
     @patch('evap.results.templatetags.results_templatetags.get_grade_color', new=lambda x: (0, 0, 0))
     def test_unarchived_results(self):
diff --git a/evap/rewards/tests/test_tools.py b/evap/rewards/tests/test_tools.py
--- a/evap/rewards/tests/test_tools.py
+++ b/evap/rewards/tests/test_tools.py
@@ -1,7 +1,7 @@
 from django.test import TestCase, override_settings
 from django.urls import reverse
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Course, Evaluation, NO_ANSWER, Question, Questionnaire, UserProfile
 from evap.evaluation.tests.tools import WebTest
@@ -19,11 +19,11 @@ class TestGrantRewardPoints(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.student = mommy.make(UserProfile, username='student', email='foo@institution.example.com')
-        cls.evaluation = mommy.make(Evaluation, state='in_evaluation', participants=[cls.student])
+        cls.student = baker.make(UserProfile, username='student', email='foo@institution.example.com')
+        cls.evaluation = baker.make(Evaluation, state='in_evaluation', participants=[cls.student])
 
-        questionnaire = mommy.make(Questionnaire)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.GRADE)
+        questionnaire = baker.make(Questionnaire)
+        baker.make(Question, questionnaire=questionnaire, type=Question.GRADE)
         cls.evaluation.general_contribution.questionnaires.set([questionnaire])
 
     def setUp(self):
@@ -45,20 +45,20 @@ def test_everything_works(self):
 
     def test_semester_activated_not_all_evaluations(self):
         SemesterActivation.objects.create(semester=self.evaluation.course.semester, is_active=True)
-        mommy.make(Evaluation, course=mommy.make(Course, semester=self.evaluation.course.semester), participants=[self.student])
+        baker.make(Evaluation, course=baker.make(Course, semester=self.evaluation.course.semester), participants=[self.student])
         self.form.submit()
         self.assertEqual(1, reward_points_of_user(self.student))
 
     def test_already_got_grant_objects_but_points_missing(self):
         SemesterActivation.objects.create(semester=self.evaluation.course.semester, is_active=True)
-        mommy.make(RewardPointGranting, user_profile=self.student, value=0, semester=self.evaluation.course.semester)
+        baker.make(RewardPointGranting, user_profile=self.student, value=0, semester=self.evaluation.course.semester)
         self.form.submit()
         self.assertEqual(3, reward_points_of_user(self.student))
         self.assertEqual(2, RewardPointGranting.objects.filter(user_profile=self.student, semester=self.evaluation.course.semester).count())
 
     def test_already_got_enough_points(self):
         SemesterActivation.objects.create(semester=self.evaluation.course.semester, is_active=True)
-        mommy.make(RewardPointGranting, user_profile=self.student, value=3, semester=self.evaluation.course.semester)
+        baker.make(RewardPointGranting, user_profile=self.student, value=3, semester=self.evaluation.course.semester)
         self.form.submit()
         self.assertEqual(3, reward_points_of_user(self.student))
         self.assertEqual(1, RewardPointGranting.objects.filter(user_profile=self.student, semester=self.evaluation.course.semester).count())
@@ -72,10 +72,10 @@ def test_already_got_enough_points(self):
 class TestGrantRewardPointsParticipationChange(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.evaluation = mommy.make(Evaluation)
-        already_evaluated = mommy.make(Evaluation, course=mommy.make(Course, semester=cls.evaluation.course.semester))
+        cls.evaluation = baker.make(Evaluation)
+        already_evaluated = baker.make(Evaluation, course=baker.make(Course, semester=cls.evaluation.course.semester))
         SemesterActivation.objects.create(semester=cls.evaluation.course.semester, is_active=True)
-        cls.student = mommy.make(UserProfile, username="student", email="foo@institution.example.com",
+        cls.student = baker.make(UserProfile, username="student", email="foo@institution.example.com",
             evaluations_participating_in=[cls.evaluation, already_evaluated], evaluations_voted_for=[already_evaluated])
 
     def test_participant_removed_from_evaluation(self):
diff --git a/evap/rewards/tests/test_views.py b/evap/rewards/tests/test_views.py
--- a/evap/rewards/tests/test_views.py
+++ b/evap/rewards/tests/test_views.py
@@ -4,7 +4,7 @@
 from django.urls import reverse
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import UserProfile, Evaluation, Semester
 from evap.evaluation.tests.tools import WebTestWith200Check
@@ -18,18 +18,18 @@ class TestEventDeleteView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_deletion_success(self):
-        event = mommy.make(RewardPointRedemptionEvent)
+        event = baker.make(RewardPointRedemptionEvent)
         response = self.app.post(self.url, params={'event_id': event.pk}, user='manager')
         self.assertEqual(response.status_code, 200)
         self.assertFalse(RewardPointRedemptionEvent.objects.filter(pk=event.pk).exists())
 
     def test_deletion_failure(self):
         """ try to delete event that can not be deleted, because people already redeemed points """
-        event = mommy.make(RewardPointRedemptionEvent)
-        mommy.make(RewardPointRedemption, value=1, event=event)
+        event = baker.make(RewardPointRedemptionEvent)
+        baker.make(RewardPointRedemption, value=1, event=event)
 
         response = self.app.post(self.url, params={'event_id': event.pk}, user='manager', expect_errors=True)
         self.assertEqual(response.status_code, 400)
@@ -42,11 +42,11 @@ class TestIndexView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.student = mommy.make(UserProfile, username='student', email='foo@institution.example.com')
-        mommy.make(Evaluation, participants=[cls.student])
-        mommy.make(RewardPointGranting, user_profile=cls.student, value=5)
-        mommy.make(RewardPointRedemptionEvent, pk=1, redeem_end_date=date.today() + timedelta(days=1))
-        mommy.make(RewardPointRedemptionEvent, pk=2, redeem_end_date=date.today() + timedelta(days=1))
+        cls.student = baker.make(UserProfile, username='student', email='foo@institution.example.com')
+        baker.make(Evaluation, participants=[cls.student])
+        baker.make(RewardPointGranting, user_profile=cls.student, value=5)
+        baker.make(RewardPointRedemptionEvent, pk=1, redeem_end_date=date.today() + timedelta(days=1))
+        baker.make(RewardPointRedemptionEvent, pk=2, redeem_end_date=date.today() + timedelta(days=1))
 
     def test_redeem_all_points(self):
         response = self.app.get(self.url, user='student')
@@ -84,9 +84,9 @@ class TestEventsView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        mommy.make(RewardPointRedemptionEvent, redeem_end_date=date.today() + timedelta(days=1))
-        mommy.make(RewardPointRedemptionEvent, redeem_end_date=date.today() + timedelta(days=1))
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(RewardPointRedemptionEvent, redeem_end_date=date.today() + timedelta(days=1))
+        baker.make(RewardPointRedemptionEvent, redeem_end_date=date.today() + timedelta(days=1))
 
 
 class TestEventCreateView(WebTest):
@@ -95,7 +95,7 @@ class TestEventCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_create_redemption_event(self):
         """ submits a newly created redemption event and checks that the event has been created """
@@ -118,8 +118,8 @@ class TestEventEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.event = mommy.make(RewardPointRedemptionEvent, pk=1, name='old name')
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.event = baker.make(RewardPointRedemptionEvent, pk=1, name='old name')
 
     def test_edit_redemption_event(self):
         """ submits a newly created redemption event and checks that the event has been created """
@@ -139,9 +139,9 @@ class TestExportView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        event = mommy.make(RewardPointRedemptionEvent, pk=1, redeem_end_date=date.today() + timedelta(days=1))
-        mommy.make(RewardPointRedemption, value=1, event=event)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        event = baker.make(RewardPointRedemptionEvent, pk=1, redeem_end_date=date.today() + timedelta(days=1))
+        baker.make(RewardPointRedemption, value=1, event=event)
 
 
 class TestSemesterActivationView(WebTest):
@@ -150,15 +150,15 @@ class TestSemesterActivationView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
 
     def test_activate(self):
-        mommy.make(SemesterActivation, semester=self.semester, is_active=False)
+        baker.make(SemesterActivation, semester=self.semester, is_active=False)
         self.app.post(self.url + 'on', user='manager')
         self.assertTrue(is_semester_activated(self.semester))
 
     def test_deactivate(self):
-        mommy.make(SemesterActivation, semester=self.semester, is_active=True)
+        baker.make(SemesterActivation, semester=self.semester, is_active=True)
         self.app.post(self.url + 'off', user='manager')
         self.assertFalse(is_semester_activated(self.semester))
diff --git a/evap/staff/tests/test_forms.py b/evap/staff/tests/test_forms.py
--- a/evap/staff/tests/test_forms.py
+++ b/evap/staff/tests/test_forms.py
@@ -1,7 +1,7 @@
 from unittest.mock import patch
 from django.forms.models import inlineformset_factory
 from django.test import TestCase
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import (Contribution, Course, Degree, EmailTemplate, Evaluation, Question,
                                     Questionnaire, Semester, UserProfile)
@@ -14,9 +14,9 @@
 
 class QuestionnaireFormTest(TestCase):
     def test_force_highest_order(self):
-        mommy.make(Questionnaire, order=45, type=Questionnaire.TOP)
+        baker.make(Questionnaire, order=45, type=Questionnaire.TOP)
 
-        question = mommy.make(Question)
+        question = baker.make(Question)
 
         data = {
             'description_de': 'English description',
@@ -37,10 +37,10 @@ def test_force_highest_order(self):
         self.assertEqual(questionnaire.order, 46)
 
     def test_automatic_order_correction_on_type_change(self):
-        mommy.make(Questionnaire, order=72, type=Questionnaire.BOTTOM)
+        baker.make(Questionnaire, order=72, type=Questionnaire.BOTTOM)
 
-        questionnaire = mommy.make(Questionnaire, order=7, type=Questionnaire.TOP)
-        question = mommy.make(Question)
+        questionnaire = baker.make(Questionnaire, order=7, type=Questionnaire.TOP)
+        question = baker.make(Question)
 
         data = {
             'description_de': questionnaire.description_de,
@@ -82,8 +82,8 @@ def test_user_form(self):
         """
             Tests the UserForm with one valid and one invalid input dataset.
         """
-        user = mommy.make(UserProfile)
-        another_user = mommy.make(UserProfile)
+        user = baker.make(UserProfile)
+        another_user = baker.make(UserProfile)
         data = {"username": "mklqoep50x2", "email": "a@b.ce"}
         form = UserForm(instance=user, data=data)
         self.assertTrue(form.is_valid())
@@ -98,7 +98,7 @@ def test_user_with_same_email(self):
             that already exist in the database
             Regression test for #590
         """
-        user = mommy.make(UserProfile, email="uiae@example.com")
+        user = baker.make(UserProfile, email="uiae@example.com")
 
         data = {"username": "uiae", "email": user.email}
         form = UserForm(data=data)
@@ -117,7 +117,7 @@ def test_user_with_same_username(self):
             Tests whether the user form correctly handles usernames
             that already exist in the database
         """
-        user = mommy.make(UserProfile)
+        user = baker.make(UserProfile)
 
         data = {"username": user.username}
         form = UserForm(data=data)
@@ -132,8 +132,8 @@ def test_user_with_same_username(self):
         self.assertTrue(form.is_valid())
 
     def test_user_cannot_be_removed_from_evaluation_already_voted_for(self):
-        student = mommy.make(UserProfile)
-        mommy.make(Evaluation, participants=[student], voters=[student])
+        student = baker.make(UserProfile)
+        baker.make(Evaluation, participants=[student], voters=[student])
 
         form_data = get_form_data_from_instance(UserForm, student)
         form_data["evaluations_participating_in"] = []
@@ -146,7 +146,7 @@ def test_user_cannot_be_removed_from_evaluation_already_voted_for(self):
 
 class SingleResultFormTests(TestCase):
     def test_single_result_form_saves_participant_and_voter_count(self):
-        course = mommy.make(Course)
+        course = baker.make(Course)
         evaluation = Evaluation(course=course, is_single_result=True)
         form_data = {
             "name_de": "qwertz",
@@ -163,7 +163,7 @@ def test_single_result_form_saves_participant_and_voter_count(self):
         form = SingleResultForm(form_data, instance=evaluation, semester=evaluation.course.semester)
         self.assertTrue(form.is_valid())
 
-        form.save(user=mommy.make(UserProfile))
+        form.save(user=baker.make(UserProfile))
 
         evaluation = Evaluation.objects.get()
         self.assertEqual(evaluation.num_participants, 10)
@@ -175,11 +175,11 @@ def test_contribution_form_set(self):
         """
             Tests the ContributionFormset with various input data sets.
         """
-        evaluation = mommy.make(Evaluation)
-        user1 = mommy.make(UserProfile)
-        user2 = mommy.make(UserProfile)
-        mommy.make(UserProfile)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        evaluation = baker.make(Evaluation)
+        user1 = baker.make(UserProfile)
+        user2 = baker.make(UserProfile)
+        baker.make(UserProfile)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
 
         ContributionFormset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=0)
 
@@ -216,11 +216,11 @@ def test_dont_validate_deleted_contributions(self):
             Tests whether contributions marked for deletion are validated.
             Regression test for #415 and #244
         """
-        evaluation = mommy.make(Evaluation)
-        user1 = mommy.make(UserProfile)
-        user2 = mommy.make(UserProfile)
-        mommy.make(UserProfile)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        evaluation = baker.make(Evaluation)
+        user1 = baker.make(UserProfile)
+        user2 = baker.make(UserProfile)
+        baker.make(UserProfile)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
 
         contribution_formset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=0)
 
@@ -267,9 +267,9 @@ def test_deleted_empty_contribution_does_not_crash(self):
             Similarly, when removing the contribution formset of an existing contributor, and entering some data in the extra formset, it should not crash.
             Regression test for #1057
         """
-        evaluation = mommy.make(Evaluation)
-        user1 = mommy.make(UserProfile)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        evaluation = baker.make(Evaluation)
+        user1 = baker.make(UserProfile)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
 
         contribution_formset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=0)
 
@@ -309,10 +309,10 @@ def test_take_deleted_contributions_into_account(self):
             when the same contributor got added again in the same formset.
             Regression test for #415
         """
-        evaluation = mommy.make(Evaluation)
-        user1 = mommy.make(UserProfile)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        contribution1 = mommy.make(Contribution, evaluation=evaluation, contributor=user1, can_edit=True,
+        evaluation = baker.make(Evaluation)
+        user1 = baker.make(UserProfile)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        contribution1 = baker.make(Contribution, evaluation=evaluation, contributor=user1, can_edit=True,
                                    textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, questionnaires=[questionnaire])
 
         contribution_formset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=0)
@@ -346,7 +346,7 @@ def test_there_can_be_no_contributions(self):
             Tests that there can also be no contribution
             Regression test for #1347
         """
-        evaluation = mommy.make(Evaluation)
+        evaluation = baker.make(Evaluation)
         contribution_formset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=0)
 
         data = to_querydict({
@@ -364,13 +364,13 @@ def test_hidden_and_managers_only(self):
             contribution of the Evaluation, and that manager only questionnaires are always shown.
             Regression test for #593.
         """
-        evaluation = mommy.make(Evaluation)
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.EDITORS)
-        questionnaire_hidden = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.HIDDEN)
-        questionnaire_managers_only = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.MANAGERS)
+        evaluation = baker.make(Evaluation)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.EDITORS)
+        questionnaire_hidden = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.HIDDEN)
+        questionnaire_managers_only = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR, visibility=Questionnaire.MANAGERS)
 
         # The normal and managers_only questionnaire should be shown.
-        contribution1 = mommy.make(Contribution, evaluation=evaluation, contributor=mommy.make(UserProfile), questionnaires=[])
+        contribution1 = baker.make(Contribution, evaluation=evaluation, contributor=baker.make(UserProfile), questionnaires=[])
 
         inline_contribution_formset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=1)
         formset = inline_contribution_formset(instance=evaluation, form_kwargs={'evaluation': evaluation})
@@ -390,8 +390,8 @@ def test_hidden_and_managers_only(self):
         self.assertEqual(expected, set(formset.forms[1].fields['questionnaires'].queryset.all()))
 
     def test_staff_can_select_proxy_user(self):
-        proxy_user = mommy.make(UserProfile, is_proxy_user=True)
-        course = mommy.make(Course, semester=mommy.make(Semester))
+        proxy_user = baker.make(UserProfile, is_proxy_user=True)
+        course = baker.make(Course, semester=baker.make(Semester))
         form = CourseForm(instance=course)
         self.assertIn(proxy_user, form.fields['responsibles'].queryset)
 
@@ -402,13 +402,13 @@ class ContributionFormset775RegressionTests(TestCase):
     """
     @classmethod
     def setUpTestData(cls):
-        cls.evaluation = mommy.make(Evaluation, name_en="some evaluation")
-        cls.user1 = mommy.make(UserProfile)
-        cls.user2 = mommy.make(UserProfile)
-        mommy.make(UserProfile)
-        cls.questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        cls.contribution1 = mommy.make(Contribution, contributor=cls.user1, evaluation=cls.evaluation, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        cls.contribution2 = mommy.make(Contribution, contributor=cls.user2, evaluation=cls.evaluation)
+        cls.evaluation = baker.make(Evaluation, name_en="some evaluation")
+        cls.user1 = baker.make(UserProfile)
+        cls.user2 = baker.make(UserProfile)
+        baker.make(UserProfile)
+        cls.questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        cls.contribution1 = baker.make(Contribution, contributor=cls.user1, evaluation=cls.evaluation, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        cls.contribution2 = baker.make(Contribution, contributor=cls.user2, evaluation=cls.evaluation)
 
         cls.contribution_formset = inlineformset_factory(Evaluation, Contribution, formset=ContributionFormSet, form=ContributionForm, extra=0)
 
@@ -489,7 +489,7 @@ def test_handle_multivaluedicts(self):
         self.data['contributions-0-contributor'] = self.user2.pk
         self.data['contributions-1-contributor'] = self.user1.pk
 
-        questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
         self.data.appendlist('contributions-0-questionnaires', questionnaire.pk)
         formset = self.contribution_formset(instance=self.evaluation, form_kwargs={'evaluation': self.evaluation}, data=self.data)
         formset.save()
@@ -502,7 +502,7 @@ 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)
+        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])
@@ -515,7 +515,7 @@ 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)
+        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
@@ -526,8 +526,8 @@ def test_uniqueness_constraint_error_shown(self):
         self.assertEqual(form.errors['name_de'], ['Course with this Semester and Name (german) already exists.'])
 
     def test_that_proxy_user_can_be_responsible(self):
-        course = mommy.make(Course, semester=mommy.make(Semester), degrees=[mommy.make(Degree)])
-        proxy = mommy.make(UserProfile, is_proxy_user=True, is_active=True)
+        course = baker.make(Course, semester=baker.make(Semester), degrees=[baker.make(Degree)])
+        proxy = baker.make(UserProfile, is_proxy_user=True, is_active=True)
         form = CourseForm(instance=course)
         self.assertIn(proxy, form.fields['responsibles'].queryset)
 
@@ -538,11 +538,11 @@ 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)])
+        course = baker.make(Course, degrees=[baker.make(Degree)])
+        evaluation1 = baker.make(Evaluation, course=course, name_de="Evaluierung 1", name_en="Evaluation 1")
+        evaluation2 = baker.make(Evaluation, course=course, name_de="Evaluierung 2", name_en="Evaluation 2")
+        evaluation1.general_contribution.questionnaires.set([baker.make(Questionnaire)])
+        evaluation2.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
         form_data = get_form_data_from_instance(EvaluationForm, evaluation1)
         form_data["vote_start_datetime"] = "2098-01-01"  # needed to fix the form
@@ -572,8 +572,8 @@ def test_contributor_evaluation_form_date_validation(self):
             Tests validity of various start/end date combinations in
             the two evaluation edit forms.
         """
-        evaluation = mommy.make(Evaluation)
-        evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
+        evaluation = baker.make(Evaluation)
+        evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
         # contributors: start date does not have to be in the future
         self.helper_date_validation(ContributorEvaluationForm, "1999-01-01", "2099-01-01", True)
@@ -600,9 +600,9 @@ 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")
+        course = baker.make(Course)
+        evaluation1 = baker.make(Evaluation, course=course, name_de="Evaluierung 1", name_en="Evaluation 1")
+        evaluation2 = baker.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
@@ -613,9 +613,9 @@ def test_uniqueness_constraint_error_shown(self):
         self.assertEqual(form.errors['name_de'], ['Evaluation with this Course and Name (german) already exists.'])
 
     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)])
+        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"] = []
@@ -626,11 +626,11 @@ def test_voter_cannot_be_removed_from_evaluation(self):
         self.assertIn("Participants who already voted for the evaluation can't be removed", form.errors['participants'][0])
 
     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)])
+        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)
diff --git a/evap/staff/tests/test_importers.py b/evap/staff/tests/test_importers.py
--- a/evap/staff/tests/test_importers.py
+++ b/evap/staff/tests/test_importers.py
@@ -3,7 +3,7 @@
 from datetime import date, datetime
 from django.test import TestCase, override_settings
 from django.conf import settings
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import Course, Degree, UserProfile, Semester, Evaluation, Contribution, CourseType
 from evap.staff.importers import UserImporter, EnrollmentImporter, ExcelImporter, PersonImporter
@@ -60,7 +60,7 @@ def test_created_users(self):
         self.assertTrue(UserProfile.objects.filter(email="bastius.quid@external.example.com").exists())
 
     def test_duplicate_warning(self):
-        mommy.make(UserProfile, first_name='Lucilia', last_name="Manilium", email="luma@institution.example.com")
+        baker.make(UserProfile, first_name='Lucilia', last_name="Manilium", email="luma@institution.example.com")
 
         __, __, warnings_test, __ = UserImporter.process(self.valid_excel_content, test_run=True)
         __, __, warnings_no_test, __ = UserImporter.process(self.valid_excel_content, test_run=False)
@@ -94,7 +94,7 @@ def test_invalid_file_error(self):
         self.assertEqual(UserProfile.objects.count(), original_user_count)
 
     def test_import_makes_inactive_user_active(self):
-        mommy.make(UserProfile, email="lucilia.manilium@institution.example.com", is_active=False)
+        baker.make(UserProfile, email="lucilia.manilium@institution.example.com", is_active=False)
 
         __, __, warnings_test, __ = UserImporter.process(self.valid_excel_content, test_run=True)
         self.assertIn("The following user is currently marked inactive and will be marked active upon importing: "
@@ -117,11 +117,11 @@ class TestEnrollmentImporter(TestCase):
 
     @classmethod
     def setUpTestData(cls):
-        cls.semester = mommy.make(Semester)
+        cls.semester = baker.make(Semester)
         cls.vote_start_datetime = datetime(2017, 1, 10)
         cls.vote_end_date = date(2017, 3, 10)
-        mommy.make(CourseType, name_de="Seminar")
-        mommy.make(CourseType, name_de="Vorlesung")
+        baker.make(CourseType, name_de="Seminar")
+        baker.make(CourseType, name_de="Vorlesung")
 
     def test_valid_file_import(self):
         with open(self.filename_valid, "rb") as excel_file:
@@ -224,15 +224,15 @@ def test_invalid_file_error(self):
 class TestPersonImporter(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.participant1 = mommy.make(UserProfile, email="participant1@example.com")
-        cls.evaluation1 = mommy.make(Evaluation, participants=[cls.participant1])
-        cls.contributor1 = mommy.make(UserProfile)
-        cls.contribution1 = mommy.make(Contribution, contributor=cls.contributor1, evaluation=cls.evaluation1)
-
-        cls.participant2 = mommy.make(UserProfile, email="participant2@example.com")
-        cls.evaluation2 = mommy.make(Evaluation, participants=[cls.participant2])
-        cls.contributor2 = mommy.make(UserProfile)
-        cls.contribution2 = mommy.make(Contribution, contributor=cls.contributor2, evaluation=cls.evaluation2)
+        cls.participant1 = baker.make(UserProfile, email="participant1@example.com")
+        cls.evaluation1 = baker.make(Evaluation, participants=[cls.participant1])
+        cls.contributor1 = baker.make(UserProfile)
+        cls.contribution1 = baker.make(Contribution, contributor=cls.contributor1, evaluation=cls.evaluation1)
+
+        cls.participant2 = baker.make(UserProfile, email="participant2@example.com")
+        cls.evaluation2 = baker.make(Evaluation, participants=[cls.participant2])
+        cls.contributor2 = baker.make(UserProfile)
+        cls.contribution2 = baker.make(Contribution, contributor=cls.contributor2, evaluation=cls.evaluation2)
 
     def test_import_existing_contributor(self):
         self.assertEqual(self.evaluation1.contributions.count(), 2)
diff --git a/evap/staff/tests/test_tools.py b/evap/staff/tests/test_tools.py
--- a/evap/staff/tests/test_tools.py
+++ b/evap/staff/tests/test_tools.py
@@ -3,7 +3,7 @@
 from django.core.cache import cache
 from django.core.cache.utils import make_template_fragment_key
 
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.tests.tools import WebTest
 from evap.evaluation.models import Contribution, Course, Evaluation, UserProfile
@@ -13,8 +13,8 @@
 
 class NavbarCacheTest(WebTest):
     def test_navbar_cache_deletion_for_users(self):
-        user1 = mommy.make(UserProfile, username='user1', email="user1@institution.example.com")
-        user2 = mommy.make(UserProfile, username='user2', email="user2@institution.example.com")
+        user1 = baker.make(UserProfile, username='user1', email="user1@institution.example.com")
+        user2 = baker.make(UserProfile, username='user2', email="user2@institution.example.com")
 
         # create navbar caches for anonymous user, user1 and user2
         self.app.get("/")
@@ -39,12 +39,12 @@ def test_navbar_cache_deletion_for_users(self):
 class MergeUsersTest(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.user1 = mommy.make(UserProfile, username="test1")
-        cls.user2 = mommy.make(UserProfile, username="test2")
-        cls.user3 = mommy.make(UserProfile, username="test3")
-        cls.group1 = mommy.make(Group, pk=4)
-        cls.group2 = mommy.make(Group, pk=5)
-        cls.main_user = mommy.make(UserProfile,
+        cls.user1 = baker.make(UserProfile, username="test1")
+        cls.user2 = baker.make(UserProfile, username="test2")
+        cls.user3 = baker.make(UserProfile, username="test3")
+        cls.group1 = baker.make(Group, pk=4)
+        cls.group2 = baker.make(Group, pk=5)
+        cls.main_user = baker.make(UserProfile,
             username="main_user",
             title="Dr.",
             first_name="Main",
@@ -56,7 +56,7 @@ def setUpTestData(cls):
             cc_users=[cls.user1],
             ccing_users=[]
         )
-        cls.other_user = mommy.make(UserProfile,
+        cls.other_user = baker.make(UserProfile,
             username="other_user",
             title="",
             first_name="Other",
@@ -69,23 +69,23 @@ def setUpTestData(cls):
             ccing_users=[cls.user1, cls.user2],
             is_superuser=True
         )
-        cls.course1 = mommy.make(Course, responsibles=[cls.main_user])
-        cls.course2 = mommy.make(Course, responsibles=[cls.main_user])
-        cls.course3 = mommy.make(Course, responsibles=[cls.other_user])
-        cls.evaluation1 = mommy.make(Evaluation, course=cls.course1, name_de="evaluation1", participants=[cls.main_user, cls.other_user])  # this should make the merge fail
-        cls.evaluation2 = mommy.make(Evaluation, course=cls.course2, name_de="evaluation2", participants=[cls.main_user], voters=[cls.main_user])
-        cls.evaluation3 = mommy.make(Evaluation, course=cls.course3, name_de="evaluation3", participants=[cls.other_user], voters=[cls.other_user])
-        cls.contribution1 = mommy.make(Contribution, contributor=cls.main_user, evaluation=cls.evaluation1)
-        cls.contribution2 = mommy.make(Contribution, contributor=cls.other_user, evaluation=cls.evaluation1)  # this should make the merge fail
-        cls.contribution3 = mommy.make(Contribution, contributor=cls.other_user, evaluation=cls.evaluation2)
-        cls.rewardpointgranting_main = mommy.make(RewardPointGranting, user_profile=cls.main_user)
-        cls.rewardpointgranting_other = mommy.make(RewardPointGranting, user_profile=cls.other_user)
-        cls.rewardpointredemption_main = mommy.make(RewardPointRedemption, user_profile=cls.main_user)
-        cls.rewardpointredemption_other = mommy.make(RewardPointRedemption, user_profile=cls.other_user)
+        cls.course1 = baker.make(Course, responsibles=[cls.main_user])
+        cls.course2 = baker.make(Course, responsibles=[cls.main_user])
+        cls.course3 = baker.make(Course, responsibles=[cls.other_user])
+        cls.evaluation1 = baker.make(Evaluation, course=cls.course1, name_de="evaluation1", participants=[cls.main_user, cls.other_user])  # this should make the merge fail
+        cls.evaluation2 = baker.make(Evaluation, course=cls.course2, name_de="evaluation2", participants=[cls.main_user], voters=[cls.main_user])
+        cls.evaluation3 = baker.make(Evaluation, course=cls.course3, name_de="evaluation3", participants=[cls.other_user], voters=[cls.other_user])
+        cls.contribution1 = baker.make(Contribution, contributor=cls.main_user, evaluation=cls.evaluation1)
+        cls.contribution2 = baker.make(Contribution, contributor=cls.other_user, evaluation=cls.evaluation1)  # this should make the merge fail
+        cls.contribution3 = baker.make(Contribution, contributor=cls.other_user, evaluation=cls.evaluation2)
+        cls.rewardpointgranting_main = baker.make(RewardPointGranting, user_profile=cls.main_user)
+        cls.rewardpointgranting_other = baker.make(RewardPointGranting, user_profile=cls.other_user)
+        cls.rewardpointredemption_main = baker.make(RewardPointRedemption, user_profile=cls.main_user)
+        cls.rewardpointredemption_other = baker.make(RewardPointRedemption, user_profile=cls.other_user)
 
     def test_merge_handles_all_attributes(self):
-        user1 = mommy.make(UserProfile)
-        user2 = mommy.make(UserProfile)
+        user1 = baker.make(UserProfile)
+        user2 = baker.make(UserProfile)
 
         all_attrs = list(field.name for field in UserProfile._meta.get_fields(include_hidden=True))
 
diff --git a/evap/staff/tests/test_views.py b/evap/staff/tests/test_views.py
--- a/evap/staff/tests/test_views.py
+++ b/evap/staff/tests/test_views.py
@@ -11,7 +11,7 @@
 from django.test.testcases import TestCase
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 import xlrd
 
 from evap.evaluation.models import (Contribution, Course, CourseType, Degree, EmailTemplate, Evaluation, FaqSection,
@@ -35,7 +35,7 @@ class TestDownloadSampleXlsView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_sample_file_correctness(self):
         page = self.app.get(self.url, user='manager')
@@ -59,7 +59,7 @@ class TestStaffIndexView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
 
 class TestStaffFAQView(WebTestWith200Check):
@@ -68,7 +68,7 @@ class TestStaffFAQView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
 
 class TestStaffFAQEditView(WebTestWith200Check):
@@ -77,9 +77,9 @@ class TestStaffFAQEditView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        section = mommy.make(FaqSection, pk=1)
-        mommy.make(FaqQuestion, section=section)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        section = baker.make(FaqSection, pk=1)
+        baker.make(FaqQuestion, section=section)
 
 
 class TestUserIndexView(WebTest):
@@ -87,7 +87,7 @@ class TestUserIndexView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_num_queries_is_constant(self):
         """
@@ -95,11 +95,11 @@ def test_num_queries_is_constant(self):
             and not linear to the number of users
         """
         num_users = 50
-        semester = mommy.make(Semester, participations_are_archived=True)
+        semester = baker.make(Semester, participations_are_archived=True)
 
         # this triggers more checks in UserProfile.can_be_deleted_by_manager
-        evaluation = mommy.make(Evaluation, state="published", course=mommy.make(Course, semester=semester), _participant_count=1, _voter_count=1)
-        mommy.make(UserProfile, _quantity=num_users, evaluations_participating_in=[evaluation])
+        evaluation = baker.make(Evaluation, state="published", course=baker.make(Course, semester=semester), _participant_count=1, _voter_count=1)
+        baker.make(UserProfile, _quantity=num_users, evaluations_participating_in=[evaluation])
 
         with self.assertNumQueries(FuzzyInt(0, num_users - 1)):
             self.app.get(self.url, user="manager")
@@ -110,7 +110,7 @@ class TestUserCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_user_is_created(self):
         page = self.app.get(self.url, user="manager", status=200)
@@ -135,8 +135,8 @@ class TestUserEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        mommy.make(UserProfile, pk=3)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, pk=3)
 
     def test_questionnaire_edit(self):
         page = self.app.get(self.url, user="manager", status=200)
@@ -146,10 +146,10 @@ def test_questionnaire_edit(self):
         self.assertTrue(UserProfile.objects.filter(username='lfo9e7bmxp1xi').exists())
 
     def test_reward_points_granting_message(self):
-        evaluation = mommy.make(Evaluation)
-        already_evaluated = mommy.make(Evaluation, course=mommy.make(Course, semester=evaluation.course.semester))
+        evaluation = baker.make(Evaluation)
+        already_evaluated = baker.make(Evaluation, course=baker.make(Course, semester=evaluation.course.semester))
         SemesterActivation.objects.create(semester=evaluation.course.semester, is_active=True)
-        student = mommy.make(UserProfile, email="foo@institution.example.com",
+        student = baker.make(UserProfile, email="foo@institution.example.com",
             evaluations_participating_in=[evaluation, already_evaluated], evaluations_voted_for=[already_evaluated])
 
         page = self.app.get(reverse('staff:user_edit', args=[student.pk]), user='manager', status=200)
@@ -170,8 +170,8 @@ class TestUserMergeSelectionView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        mommy.make(UserProfile)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile)
 
 
 class TestUserMergeView(WebTestWith200Check):
@@ -180,9 +180,9 @@ class TestUserMergeView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        mommy.make(UserProfile, pk=3)
-        mommy.make(UserProfile, pk=4)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, pk=3)
+        baker.make(UserProfile, pk=4)
 
 
 class TestUserBulkDeleteView(WebTest):
@@ -191,7 +191,7 @@ class TestUserBulkDeleteView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_testrun_deletes_no_users(self):
         page = self.app.get(self.url, user='manager')
@@ -199,7 +199,7 @@ def test_testrun_deletes_no_users(self):
 
         form['username_file'] = (self.filename,)
 
-        mommy.make(UserProfile, is_active=False)
+        baker.make(UserProfile, is_active=False)
         users_before = UserProfile.objects.count()
 
         reply = form.submit(name='operation', value='test')
@@ -210,14 +210,14 @@ def test_testrun_deletes_no_users(self):
         self.assertEqual(users_before, UserProfile.objects.count())
 
     def test_deletes_users(self):
-        mommy.make(UserProfile, username='testuser1')
-        mommy.make(UserProfile, username='testuser2')
-        contribution1 = mommy.make(Contribution)
-        semester = mommy.make(Semester, participations_are_archived=True)
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=semester), _participant_count=0, _voter_count=0)
-        contribution2 = mommy.make(Contribution, evaluation=evaluation)
-        mommy.make(UserProfile, username='contributor1', contributions=[contribution1])
-        mommy.make(UserProfile, username='contributor2', contributions=[contribution2])
+        baker.make(UserProfile, username='testuser1')
+        baker.make(UserProfile, username='testuser2')
+        contribution1 = baker.make(Contribution)
+        semester = baker.make(Semester, participations_are_archived=True)
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=semester), _participant_count=0, _voter_count=0)
+        contribution2 = baker.make(Contribution, evaluation=evaluation)
+        baker.make(UserProfile, username='contributor1', contributions=[contribution1])
+        baker.make(UserProfile, username='contributor2', contributions=[contribution2])
 
         page = self.app.get(self.url, user='manager')
         form = page.forms["user-bulk-delete-form"]
@@ -253,7 +253,7 @@ class TestUserImportView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.user = mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        cls.user = baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
     def test_success_handling(self):
         """
@@ -296,7 +296,7 @@ def test_warning_handling(self):
         """
         Tests whether warnings given from the importer are displayed
         """
-        mommy.make(UserProfile, email="lucilia.manilium@institution.example.com")
+        baker.make(UserProfile, email="lucilia.manilium@institution.example.com")
 
         page = self.app.get(self.url, user='manager')
 
@@ -345,12 +345,12 @@ class TestSemesterView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
-        cls.evaluation1 = mommy.make(Evaluation, name_de="Evaluation 1", name_en="Evaluation 1",
-            course=mommy.make(Course, name_de="A", name_en="B", semester=cls.semester))
-        cls.evaluation2 = mommy.make(Evaluation, name_de="Evaluation 2", name_en="Evaluation 2",
-            course=mommy.make(Course, name_de="B", name_en="A", semester=cls.semester))
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
+        cls.evaluation1 = baker.make(Evaluation, name_de="Evaluation 1", name_en="Evaluation 1",
+            course=baker.make(Course, name_de="A", name_en="B", semester=cls.semester))
+        cls.evaluation2 = baker.make(Evaluation, name_de="Evaluation 2", name_en="Evaluation 2",
+            course=baker.make(Course, name_de="B", name_en="A", semester=cls.semester))
 
     def test_view_list_sorting(self):
         UserProfile.objects.filter(username='manager').update(language='en')
@@ -367,8 +367,8 @@ def test_view_list_sorting(self):
         self.assertLess(position_evaluation1, position_evaluation2)
 
     def test_access_to_semester_with_archived_results(self):
-        mommy.make(UserProfile, username='reviewer', groups=[Group.objects.get(name='Reviewer')])
-        mommy.make(Semester, pk=2, results_are_archived=True)
+        baker.make(UserProfile, username='reviewer', groups=[Group.objects.get(name='Reviewer')])
+        baker.make(Semester, pk=2, results_are_archived=True)
 
         # reviewers shouldn't be allowed to access the semester page
         self.app.get('/staff/semester/2', user='reviewer', status=403)
@@ -378,9 +378,9 @@ def test_access_to_semester_with_archived_results(self):
 
     @override_settings(INSTITUTION_EMAIL_DOMAINS=["institution.com"])
     def test_badge_for_external_responsibles(self):
-        responsible = mommy.make(UserProfile, email='a@institution.com')
-        course = mommy.make(Course, semester=self.semester, responsibles=[responsible])
-        mommy.make(Evaluation, course=course)
+        responsible = baker.make(UserProfile, email='a@institution.com')
+        course = baker.make(Course, semester=self.semester, responsibles=[responsible])
+        baker.make(Evaluation, course=course)
         response = self.app.get(self.url, user='manager')
         self.assertNotContains(response, 'External responsible')
 
@@ -392,7 +392,7 @@ def test_badge_for_external_responsibles(self):
 
 class TestGetEvaluationsWithPrefetchedData(TestCase):
     def test_get_evaluations_with_prefetched_data(self):
-        evaluation = mommy.make(Evaluation, is_single_result=True)
+        evaluation = baker.make(Evaluation, is_single_result=True)
         get_evaluations_with_prefetched_data(evaluation.course.semester)
 
 
@@ -401,7 +401,7 @@ class TestSemesterCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_create(self):
         name_de = 'name_de'
@@ -425,8 +425,8 @@ class TestSemesterEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1, name_de='old_name', name_en='old_name')
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1, name_de='old_name', name_en='old_name')
 
     def test_name_change(self):
         new_name_de = 'new_name_de'
@@ -451,31 +451,31 @@ class TestSemesterDeleteView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_failure(self):
-        semester = mommy.make(Semester)
-        mommy.make(Evaluation, course=mommy.make(Course, semester=semester), state='in_evaluation', voters=[mommy.make(UserProfile)])
+        semester = baker.make(Semester)
+        baker.make(Evaluation, course=baker.make(Course, semester=semester), state='in_evaluation', voters=[baker.make(UserProfile)])
         self.assertFalse(semester.can_be_deleted_by_manager)
         response = self.app.post(self.url, params={'semester_id': semester.pk}, user='manager', expect_errors=True)
         self.assertEqual(response.status_code, 400)
         self.assertTrue(Semester.objects.filter(pk=semester.pk).exists())
 
     def test_success_if_no_courses(self):
-        semester = mommy.make(Semester)
+        semester = baker.make(Semester)
         self.assertTrue(semester.can_be_deleted_by_manager)
         response = self.app.post(self.url, params={'semester_id': semester.pk}, user='manager')
         self.assertEqual(response.status_code, 302)
         self.assertFalse(Semester.objects.filter(pk=semester.pk).exists())
 
     def test_success_if_archived(self):
-        semester = mommy.make(Semester)
-        course = mommy.make(Course, semester=semester)
-        evaluation = mommy.make(Evaluation, course=course, state='published')
+        semester = baker.make(Semester)
+        course = baker.make(Course, semester=semester)
+        evaluation = baker.make(Evaluation, course=course, state='published')
         general_contribution = evaluation.general_contribution
-        responsible_contribution = mommy.make(Contribution, evaluation=evaluation, contributor=mommy.make(UserProfile))
-        textanswer = mommy.make(TextAnswer, contribution=general_contribution, state='PU')
-        ratinganswercounter = mommy.make(RatingAnswerCounter, contribution=responsible_contribution)
+        responsible_contribution = baker.make(Contribution, evaluation=evaluation, contributor=baker.make(UserProfile))
+        textanswer = baker.make(TextAnswer, contribution=general_contribution, state='PU')
+        ratinganswercounter = baker.make(RatingAnswerCounter, contribution=responsible_contribution)
 
         self.assertFalse(semester.can_be_deleted_by_manager)
 
@@ -499,16 +499,16 @@ class TestSemesterAssignView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
-        lecture_type = mommy.make(CourseType, name_de="Vorlesung", name_en="Lecture")
-        seminar_type = mommy.make(CourseType, name_de="Seminar", name_en="Seminar")
-        cls.questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        evaluation1 = mommy.make(Evaluation, course=mommy.make(Course, semester=cls.semester, type=seminar_type))
-        mommy.make(Contribution, contributor=mommy.make(UserProfile), evaluation=evaluation1,
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
+        lecture_type = baker.make(CourseType, name_de="Vorlesung", name_en="Lecture")
+        seminar_type = baker.make(CourseType, name_de="Seminar", name_en="Seminar")
+        cls.questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        evaluation1 = baker.make(Evaluation, course=baker.make(Course, semester=cls.semester, type=seminar_type))
+        baker.make(Contribution, contributor=baker.make(UserProfile), evaluation=evaluation1,
                    can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        evaluation2 = mommy.make(Evaluation, course=mommy.make(Course, semester=cls.semester, type=lecture_type))
-        mommy.make(Contribution, contributor=mommy.make(UserProfile), evaluation=evaluation2,
+        evaluation2 = baker.make(Evaluation, course=baker.make(Course, semester=cls.semester, type=lecture_type))
+        baker.make(Contribution, contributor=baker.make(UserProfile), evaluation=evaluation2,
                    can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
     def test_assign_questionnaires(self):
@@ -530,13 +530,13 @@ class TestSemesterPreparationReminderView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
 
     def test_preparation_reminder(self):
-        user = mommy.make(UserProfile, username='user_to_find')
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester, responsibles=[user]), state='prepared', name_en='name_to_find', name_de='name_to_find')
-        mommy.make(Contribution, evaluation=evaluation, contributor=user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        user = baker.make(UserProfile, username='user_to_find')
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester, responsibles=[user]), state='prepared', name_en='name_to_find', name_de='name_to_find')
+        baker.make(Contribution, evaluation=evaluation, contributor=user, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
         response = self.app.get(self.url, user='manager')
         self.assertContains(response, 'user_to_find')
@@ -544,8 +544,8 @@ def test_preparation_reminder(self):
 
     @patch("evap.staff.views.EmailTemplate.send_to_user")
     def test_remind_all(self, send_to_user_mock):
-        user = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester, responsibles=[user]), state='prepared')
+        user = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester, responsibles=[user]), state='prepared')
 
         response = self.app.post(self.url, user='manager')
         self.assertEqual(response.status_code, 200)
@@ -564,11 +564,11 @@ class TestSendReminderView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
-        responsible = mommy.make(UserProfile, pk=3, email='a.b@example.com')
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=cls.semester, responsibles=[responsible]), state='prepared')
-        mommy.make(Contribution, evaluation=evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
+        responsible = baker.make(UserProfile, pk=3, email='a.b@example.com')
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=cls.semester, responsibles=[responsible]), state='prepared')
+        baker.make(Contribution, evaluation=evaluation, contributor=responsible, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
     def test_form(self):
         page = self.app.get(self.url, user='manager')
@@ -589,12 +589,12 @@ class TestSemesterImportView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(Semester, pk=1)
-        mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        baker.make(Semester, pk=1)
+        baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
     def test_import_valid_file(self):
-        mommy.make(CourseType, name_de="Vorlesung", name_en="Vorlesung")
-        mommy.make(CourseType, name_de="Seminar", name_en="Seminar")
+        baker.make(CourseType, name_de="Vorlesung", name_en="Vorlesung")
+        baker.make(CourseType, name_de="Seminar", name_en="Seminar")
 
         original_user_count = UserProfile.objects.count()
 
@@ -666,7 +666,7 @@ def test_warning_handling(self):
         """
         Tests whether warnings given from the importer are displayed
         """
-        mommy.make(UserProfile, email="lucilia.manilium@institution.example.com")
+        baker.make(UserProfile, email="lucilia.manilium@institution.example.com")
 
         page = self.app.get(self.url, user='manager')
 
@@ -708,8 +708,8 @@ def test_invalid_import_operation(self):
         self.assertEqual(reply.status_code, 400)
 
     def test_missing_evaluation_period(self):
-        mommy.make(CourseType, name_de="Vorlesung", name_en="Vorlesung")
-        mommy.make(CourseType, name_de="Seminar", name_en="Seminar")
+        baker.make(CourseType, name_de="Vorlesung", name_en="Vorlesung")
+        baker.make(CourseType, name_de="Seminar", name_en="Seminar")
 
         page = self.app.get(self.url, user='manager')
 
@@ -729,13 +729,13 @@ class TestSemesterExportView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
-        cls.degree = mommy.make(Degree)
-        cls.course_type = mommy.make(CourseType)
-        cls.evaluation = mommy.make(
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
+        cls.degree = baker.make(Degree)
+        cls.course_type = baker.make(CourseType)
+        cls.evaluation = baker.make(
             Evaluation,
-            course=mommy.make(Course, degrees=[cls.degree], type=cls.course_type, semester=cls.semester)
+            course=baker.make(Course, degrees=[cls.degree], type=cls.course_type, semester=cls.semester)
         )
 
     def test_view_downloads_excel_file(self):
@@ -762,15 +762,15 @@ class TestSemesterRawDataExportView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
-        cls.course_type = mommy.make(CourseType, name_en="Type")
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
+        cls.course_type = baker.make(CourseType, name_en="Type")
 
     def test_view_downloads_csv_file(self):
-        student_user = mommy.make(UserProfile, username='student')
-        mommy.make(Evaluation, course=mommy.make(Course, type=self.course_type, semester=self.semester, name_de="1",
+        student_user = baker.make(UserProfile, username='student')
+        baker.make(Evaluation, course=baker.make(Course, type=self.course_type, semester=self.semester, name_de="1",
             name_en="Course 1"), participants=[student_user], voters=[student_user], name_de="E1", name_en="E1")
-        mommy.make(Evaluation, course=mommy.make(Course, type=self.course_type, semester=self.semester, name_de="2",
+        baker.make(Evaluation, course=baker.make(Course, type=self.course_type, semester=self.semester, name_de="2",
             name_en="Course 2"), participants=[student_user])
 
         response = self.app.get(self.url, user='manager')
@@ -782,7 +782,7 @@ def test_view_downloads_csv_file(self):
         self.assertEqual(response.content, expected_content.encode("utf-8"))
 
     def test_single_result(self):
-        mommy.make(Evaluation, course=mommy.make(Course, type=self.course_type, semester=self.semester, name_de="3",
+        baker.make(Evaluation, course=baker.make(Course, type=self.course_type, semester=self.semester, name_de="3",
             name_en="Single Result"), _participant_count=5, _voter_count=5, is_single_result=True)
 
         response = self.app.get(self.url, user='manager')
@@ -798,19 +798,19 @@ class TestSemesterParticipationDataExportView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.student_user = mommy.make(UserProfile, username='student')
-        cls.student_user2 = mommy.make(UserProfile, username='student2')
-        cls.semester = mommy.make(Semester, pk=1)
-        cls.course_type = mommy.make(CourseType, name_en="Type")
-        cls.evaluation1 = mommy.make(Evaluation, course=mommy.make(Course, type=cls.course_type, semester=cls.semester), participants=[cls.student_user],
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.student_user = baker.make(UserProfile, username='student')
+        cls.student_user2 = baker.make(UserProfile, username='student2')
+        cls.semester = baker.make(Semester, pk=1)
+        cls.course_type = baker.make(CourseType, name_en="Type")
+        cls.evaluation1 = baker.make(Evaluation, course=baker.make(Course, type=cls.course_type, semester=cls.semester), participants=[cls.student_user],
             voters=[cls.student_user], name_de="Veranstaltung 1", name_en="Evaluation 1", is_rewarded=True)
-        cls.evaluation2 = mommy.make(Evaluation, course=mommy.make(Course, type=cls.course_type, semester=cls.semester), participants=[cls.student_user, cls.student_user2],
+        cls.evaluation2 = baker.make(Evaluation, course=baker.make(Course, type=cls.course_type, semester=cls.semester), participants=[cls.student_user, cls.student_user2],
             name_de="Veranstaltung 2", name_en="Evaluation 2", is_rewarded=False)
-        mommy.make(Contribution, evaluation=cls.evaluation1, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(Contribution, evaluation=cls.evaluation2, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(RewardPointGranting, semester=cls.semester, user_profile=cls.student_user, value=23)
-        mommy.make(RewardPointGranting, semester=cls.semester, user_profile=cls.student_user, value=42)
+        baker.make(Contribution, evaluation=cls.evaluation1, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(Contribution, evaluation=cls.evaluation2, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(RewardPointGranting, semester=cls.semester, user_profile=cls.student_user, value=23)
+        baker.make(RewardPointGranting, semester=cls.semester, user_profile=cls.student_user, value=42)
 
     def test_view_downloads_csv_file(self):
         response = self.app.get(self.url, user='manager')
@@ -827,13 +827,13 @@ class TestLoginKeyExportView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
-        cls.external_user = mommy.make(UserProfile, email="user@external.com")
-        cls.internal_user = mommy.make(UserProfile, email="user@institution.example.com")
+        cls.external_user = baker.make(UserProfile, email="user@external.com")
+        cls.internal_user = baker.make(UserProfile, email="user@institution.example.com")
 
-        semester = mommy.make(Semester, pk=1)
-        mommy.make(Evaluation, pk=1, course=mommy.make(Course, semester=semester), participants=[cls.external_user, cls.internal_user], voters=[cls.external_user, cls.internal_user])
+        semester = baker.make(Semester, pk=1)
+        baker.make(Evaluation, pk=1, course=baker.make(Course, semester=semester), participants=[cls.external_user, cls.internal_user], voters=[cls.external_user, cls.internal_user])
 
     def test_login_key_export_works_as_expected(self):
         self.assertEqual(self.external_user.login_key, None)
@@ -854,8 +854,8 @@ class TestEvaluationOperationView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
 
     def helper_publish_evaluation_with_publish_notifications_for(self, evaluation, contributors=True, participants=True):
         page = self.app.get("/staff/semester/1", user="manager")
@@ -873,14 +873,14 @@ def helper_publish_evaluation_with_publish_notifications_for(self, evaluation, c
         evaluation.save()
 
     def test_publish_notifications(self):
-        participant1 = mommy.make(UserProfile, email="foo@example.com")
-        participant2 = mommy.make(UserProfile, email="bar@example.com")
-        contributor1 = mommy.make(UserProfile, email="contributor@example.com")
+        participant1 = baker.make(UserProfile, email="foo@example.com")
+        participant2 = baker.make(UserProfile, email="bar@example.com")
+        contributor1 = baker.make(UserProfile, email="contributor@example.com")
 
-        course = mommy.make(Course, semester=self.semester)
-        evaluation = mommy.make(Evaluation, course=course, state='reviewed',
+        course = baker.make(Course, semester=self.semester)
+        evaluation = baker.make(Evaluation, course=course, state='reviewed',
                                 participants=[participant1, participant2], voters=[participant1, participant2])
-        mommy.make(Contribution, contributor=contributor1, evaluation=evaluation)
+        baker.make(Contribution, contributor=contributor1, evaluation=evaluation)
 
         self.helper_publish_evaluation_with_publish_notifications_for(evaluation, contributors=False, participants=False)
         self.assertEqual(len(mail.outbox), 0)
@@ -920,37 +920,37 @@ def helper_semester_state_views(self, evaluation, old_state, new_state):
         The following tests make sure the evaluation state transitions are triggerable via the UI.
     """
     def test_semester_publish(self):
-        participant1 = mommy.make(UserProfile, email="foo@example.com")
-        participant2 = mommy.make(UserProfile, email="bar@example.com")
-        course = mommy.make(Course, semester=self.semester)
-        evaluation = mommy.make(Evaluation, course=course, state='reviewed',
+        participant1 = baker.make(UserProfile, email="foo@example.com")
+        participant2 = baker.make(UserProfile, email="bar@example.com")
+        course = baker.make(Course, semester=self.semester)
+        evaluation = baker.make(Evaluation, course=course, state='reviewed',
                                 participants=[participant1, participant2], voters=[participant1, participant2])
 
         self.helper_semester_state_views(evaluation, "reviewed", "published")
         self.assertEqual(len(mail.outbox), 2)
 
     def test_semester_reset_1(self):
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester), state='prepared')
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester), state='prepared')
         self.helper_semester_state_views(evaluation, "prepared", "new")
 
     def test_semester_reset_2(self):
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester), state='approved')
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester), state='approved')
         self.helper_semester_state_views(evaluation, "approved", "new")
 
     def test_semester_contributor_ready_1(self):
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester), state='new')
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester), state='new')
         self.helper_semester_state_views(evaluation, "new", "prepared")
 
     def test_semester_contributor_ready_2(self):
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester), state='editor_approved')
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester), state='editor_approved')
         self.helper_semester_state_views(evaluation, "editor_approved", "prepared")
 
     def test_semester_unpublish(self):
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=self.semester), state='published', _participant_count=0, _voter_count=0)
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=self.semester), state='published', _participant_count=0, _voter_count=0)
         self.helper_semester_state_views(evaluation, "published", "reviewed")
 
     def test_operation_start_evaluation(self):
-        evaluation = mommy.make(Evaluation, state='approved', course=mommy.make(Course, semester=self.semester))
+        evaluation = baker.make(Evaluation, state='approved', course=baker.make(Course, semester=self.semester))
         urloptions = '?evaluation={}&target_state=in_evaluation'.format(evaluation.pk)
 
         response = self.app.get(self.url + urloptions, user='manager')
@@ -963,7 +963,7 @@ def test_operation_start_evaluation(self):
         self.assertEqual(evaluation.state, 'in_evaluation')
 
     def test_operation_prepare(self):
-        evaluation = mommy.make(Evaluation, state='new', course=mommy.make(Course, semester=self.semester))
+        evaluation = baker.make(Evaluation, state='new', course=baker.make(Course, semester=self.semester))
         urloptions = '?evaluation={}&target_state=prepared'.format(evaluation.pk)
 
         response = self.app.get(self.url + urloptions, user='manager')
@@ -981,11 +981,11 @@ class TestCourseCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.manager_user = mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, pk=1)
-        cls.course_type = mommy.make(CourseType)
-        cls.degree = mommy.make(Degree)
-        cls.responsible = mommy.make(UserProfile)
+        cls.manager_user = baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, pk=1)
+        cls.course_type = baker.make(CourseType)
+        cls.degree = baker.make(Degree)
+        cls.responsible = baker.make(UserProfile)
 
     def test_course_create(self):
         """
@@ -1017,8 +1017,8 @@ class TestSingleResultCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.manager_user = mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.course = mommy.make(Course, semester=mommy.make(Semester, pk=1))
+        cls.manager_user = baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.course = baker.make(Course, semester=baker.make(Semester, pk=1))
 
     def test_single_result_create(self):
         """
@@ -1047,10 +1047,10 @@ class TestEvaluationCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.manager_user = mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.course = mommy.make(Course, semester=mommy.make(Semester, pk=1))
-        cls.q1 = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        cls.q2 = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        cls.manager_user = baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.course = baker.make(Course, semester=baker.make(Semester, pk=1))
+        cls.q1 = baker.make(Questionnaire, type=Questionnaire.TOP)
+        cls.q2 = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
 
     def test_evaluation_create(self):
         """
@@ -1090,11 +1090,11 @@ class TestCourseEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.user = mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
-        degree = mommy.make(Degree)
-        responsible = mommy.make(UserProfile)
-        cls.course = mommy.make(Course, name_en="Some name", semester=semester, degrees=[degree],
+        cls.user = baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
+        degree = baker.make(Degree)
+        responsible = baker.make(UserProfile)
+        cls.course = baker.make(Course, name_en="Some name", semester=semester, degrees=[degree],
             responsibles=[responsible], pk=1, last_modified_user=cls.user, last_modified_time=datetime.datetime(2000, 1, 1, 0, 0))
 
     def setUp(self):
@@ -1113,7 +1113,7 @@ def test_last_modified_user(self):
         """
             Tests whether saving only changes the last_modified_user if changes were made.
         """
-        test_user = mommy.make(UserProfile, username='test_user', groups=[Group.objects.get(name='Manager')])
+        test_user = baker.make(UserProfile, username='test_user', groups=[Group.objects.get(name='Manager')])
 
         old_name_en = self.course.name_en
         old_last_modified_user = self.course.last_modified_user
@@ -1154,17 +1154,17 @@ class TestEvaluationEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.user = mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
-        degree = mommy.make(Degree)
-        responsible = mommy.make(UserProfile)
-        cls.editor = mommy.make(UserProfile)
-        cls.evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=semester, degrees=[degree], responsibles=[responsible]), pk=1, last_modified_user=cls.user,
+        cls.user = baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
+        degree = baker.make(Degree)
+        responsible = baker.make(UserProfile)
+        cls.editor = baker.make(UserProfile)
+        cls.evaluation = baker.make(Evaluation, course=baker.make(Course, semester=semester, degrees=[degree], responsibles=[responsible]), pk=1, last_modified_user=cls.user,
             vote_start_datetime=datetime.datetime(2099, 1, 1, 0, 0), vote_end_date=datetime.date(2099, 12, 31))
-        mommy.make(Questionnaire, questions=[mommy.make(Question)])
-        cls.evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=responsible, order=0, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(Contribution, evaluation=cls.evaluation, contributor=cls.editor, order=1, can_edit=True)
+        baker.make(Questionnaire, questions=[baker.make(Question)])
+        cls.evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=responsible, order=0, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(Contribution, evaluation=cls.evaluation, contributor=cls.editor, order=1, can_edit=True)
 
     def setUp(self):
         self.evaluation = Evaluation.objects.get(pk=self.evaluation.pk)
@@ -1179,10 +1179,10 @@ def test_edit_evaluation(self):
         self.assertFalse(self.evaluation.contributions.get(contributor=self.editor).can_edit)
 
     def test_participant_removal_reward_point_granting_message(self):
-        already_evaluated = mommy.make(Evaluation, pk=2, course=mommy.make(Course, semester=self.evaluation.course.semester))
+        already_evaluated = baker.make(Evaluation, pk=2, course=baker.make(Course, semester=self.evaluation.course.semester))
         SemesterActivation.objects.create(semester=self.evaluation.course.semester, is_active=True)
-        other = mommy.make(UserProfile, evaluations_participating_in=[self.evaluation])
-        student = mommy.make(UserProfile, email="foo@institution.example.com",
+        other = baker.make(UserProfile, evaluations_participating_in=[self.evaluation])
+        student = baker.make(UserProfile, email="foo@institution.example.com",
             evaluations_participating_in=[self.evaluation, already_evaluated], evaluations_voted_for=[already_evaluated])
 
         page = self.app.get(self.url, user='manager')
@@ -1195,12 +1195,12 @@ def test_participant_removal_reward_point_granting_message(self):
         self.assertIn("The removal as participant has granted the user &quot;{}&quot; 3 reward points for the semester.".format(student.username), page)
 
     def test_remove_participants(self):
-        already_evaluated = mommy.make(Evaluation, pk=2, course=mommy.make(Course, semester=self.evaluation.course.semester))
+        already_evaluated = baker.make(Evaluation, pk=2, course=baker.make(Course, semester=self.evaluation.course.semester))
         SemesterActivation.objects.create(semester=self.evaluation.course.semester, is_active=True)
-        student = mommy.make(UserProfile, evaluations_participating_in=[self.evaluation])
+        student = baker.make(UserProfile, evaluations_participating_in=[self.evaluation])
 
         for name in ["a", "b", "c", "d", "e"]:
-            mommy.make(UserProfile, username=name, email="{}@institution.example.com".format(name),
+            baker.make(UserProfile, username=name, email="{}@institution.example.com".format(name),
                 evaluations_participating_in=[self.evaluation, already_evaluated], evaluations_voted_for=[already_evaluated])
 
         page = self.app.get(self.url, user='manager')
@@ -1214,12 +1214,12 @@ def test_remove_participants(self):
             self.assertIn("The removal as participant has granted the user &quot;{}&quot; 3 reward points for the semester.".format(name), page)
 
     def test_remove_participants_proportional_reward_points(self):
-        already_evaluated = mommy.make(Evaluation, pk=2, course=mommy.make(Course, semester=self.evaluation.course.semester))
+        already_evaluated = baker.make(Evaluation, pk=2, course=baker.make(Course, semester=self.evaluation.course.semester))
         SemesterActivation.objects.create(semester=self.evaluation.course.semester, is_active=True)
-        student = mommy.make(UserProfile, evaluations_participating_in=[self.evaluation])
+        student = baker.make(UserProfile, evaluations_participating_in=[self.evaluation])
 
         for name, points_granted in [("a", 0), ("b", 1), ("c", 2), ("d", 3)]:
-            user = mommy.make(UserProfile, username=name, email="{}@institution.example.com".format(name),
+            user = baker.make(UserProfile, username=name, email="{}@institution.example.com".format(name),
                 evaluations_participating_in=[self.evaluation, already_evaluated], evaluations_voted_for=[already_evaluated])
             RewardPointGranting.objects.create(user_profile=user, semester=self.evaluation.course.semester, value=points_granted)
 
@@ -1240,7 +1240,7 @@ def test_last_modified_user(self):
             Tests whether the button "Save and approve" does only change the
             last_modified_user if changes were made.
         """
-        test_user = mommy.make(UserProfile, username='approve_test_user', groups=[Group.objects.get(name='Manager')])
+        test_user = baker.make(UserProfile, username='approve_test_user', groups=[Group.objects.get(name='Manager')])
 
         old_name_de = self.evaluation.name_de
         old_vote_start_datetime = self.evaluation.vote_start_datetime
@@ -1287,7 +1287,7 @@ def test_last_modified_on_formset_change(self):
         self.assertEqual(self.evaluation.last_modified_user, self.user)
         last_modified_time_before = self.evaluation.last_modified_time
 
-        test_user = mommy.make(
+        test_user = baker.make(
             UserProfile,
             username='approve_test_user',
             groups=[Group.objects.get(name='Manager')]
@@ -1311,7 +1311,7 @@ def test_last_modified_unchanged(self):
         last_modified_user_before = self.evaluation.last_modified_user
         last_modified_time_before = self.evaluation.last_modified_time
 
-        test_user = mommy.make(
+        test_user = baker.make(
             UserProfile,
             username='approve_test_user',
             groups=[Group.objects.get(name='Manager')]
@@ -1333,20 +1333,20 @@ class TestSingleResultEditView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
 
-        responsible = mommy.make(UserProfile)
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=semester, responsibles=[responsible]), pk=1)
-        contribution = mommy.make(Contribution, evaluation=evaluation, contributor=responsible, can_edit=True,
+        responsible = baker.make(UserProfile)
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=semester, responsibles=[responsible]), pk=1)
+        contribution = baker.make(Contribution, evaluation=evaluation, contributor=responsible, can_edit=True,
                                   textanswer_visibility=Contribution.GENERAL_TEXTANSWERS, questionnaires=[Questionnaire.single_result_questionnaire()])
 
         question = Questionnaire.single_result_questionnaire().questions.get()
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution, answer=1, count=5)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution, answer=2, count=15)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution, answer=3, count=40)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution, answer=4, count=60)
-        mommy.make(RatingAnswerCounter, question=question, contribution=contribution, answer=5, count=30)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution, answer=1, count=5)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution, answer=2, count=15)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution, answer=3, count=40)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution, answer=4, count=60)
+        baker.make(RatingAnswerCounter, question=question, contribution=contribution, answer=5, count=30)
 
 
 class TestEvaluationPreviewView(WebTestWith200Check):
@@ -1355,10 +1355,10 @@ class TestEvaluationPreviewView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
-        evaluation = mommy.make(Evaluation, course=mommy.make(Course, semester=semester), pk=1)
-        evaluation.general_contribution.questionnaires.set([mommy.make(Questionnaire)])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
+        evaluation = baker.make(Evaluation, course=baker.make(Course, semester=semester), pk=1)
+        evaluation.general_contribution.questionnaires.set([baker.make(Questionnaire)])
 
 
 class TestEvaluationImportPersonsView(WebTest):
@@ -1369,11 +1369,11 @@ class TestEvaluationImportPersonsView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        semester = mommy.make(Semester, pk=1)
-        cls.manager_user = mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
-        cls.evaluation = mommy.make(Evaluation, pk=1, course=mommy.make(Course, semester=semester))
-        profiles = mommy.make(UserProfile, _quantity=42)
-        cls.evaluation2 = mommy.make(Evaluation, pk=2, course=mommy.make(Course, semester=semester), participants=profiles)
+        semester = baker.make(Semester, pk=1)
+        cls.manager_user = baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        cls.evaluation = baker.make(Evaluation, pk=1, course=baker.make(Course, semester=semester))
+        profiles = baker.make(UserProfile, _quantity=42)
+        cls.evaluation2 = baker.make(Evaluation, pk=2, course=baker.make(Course, semester=semester), participants=profiles)
 
     @classmethod
     def tearDown(cls):
@@ -1460,7 +1460,7 @@ def test_import_participants_warning_handling(self):
         """
         Tests whether warnings given from the importer are displayed
         """
-        mommy.make(UserProfile, email="lucilia.manilium@institution.example.com")
+        baker.make(UserProfile, email="lucilia.manilium@institution.example.com")
 
         page = self.app.get(self.url, user='manager')
 
@@ -1491,7 +1491,7 @@ def test_import_contributors_warning_handling(self):
         """
         Tests whether warnings given from the importer are displayed
         """
-        mommy.make(UserProfile, email="lucilia.manilium@institution.example.com")
+        baker.make(UserProfile, email="lucilia.manilium@institution.example.com")
 
         page = self.app.get(self.url, user='manager')
 
@@ -1556,11 +1556,11 @@ class TestEvaluationEmailView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
-        participant1 = mommy.make(UserProfile, email="foo@example.com")
-        participant2 = mommy.make(UserProfile, email="bar@example.com")
-        mommy.make(Evaluation, pk=1, course=mommy.make(Course, semester=semester), participants=[participant1, participant2])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
+        participant1 = baker.make(UserProfile, email="foo@example.com")
+        participant2 = baker.make(UserProfile, email="bar@example.com")
+        baker.make(Evaluation, pk=1, course=baker.make(Course, semester=semester), participants=[participant1, participant2])
 
     def test_emails_are_sent(self):
         page = self.app.get(self.url, user="manager", status=200)
@@ -1578,19 +1578,19 @@ class TestEvaluationTextAnswerView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
-        student1 = mommy.make(UserProfile)
-        cls.student2 = mommy.make(UserProfile)
-        cls.evaluation = mommy.make(Evaluation, pk=1, course=mommy.make(Course, semester=semester), participants=[student1, cls.student2], voters=[student1], state="in_evaluation")
-        top_general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        mommy.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
+        student1 = baker.make(UserProfile)
+        cls.student2 = baker.make(UserProfile)
+        cls.evaluation = baker.make(Evaluation, pk=1, course=baker.make(Course, semester=semester), participants=[student1, cls.student2], voters=[student1], state="in_evaluation")
+        top_general_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        baker.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
         cls.evaluation.general_contribution.questionnaires.set([top_general_questionnaire])
-        questionnaire = mommy.make(Questionnaire)
-        question = mommy.make(Question, questionnaire=questionnaire, type=Question.TEXT)
-        contribution = mommy.make(Contribution, evaluation=cls.evaluation, contributor=mommy.make(UserProfile), questionnaires=[questionnaire])
+        questionnaire = baker.make(Questionnaire)
+        question = baker.make(Question, questionnaire=questionnaire, type=Question.TEXT)
+        contribution = baker.make(Contribution, evaluation=cls.evaluation, contributor=baker.make(UserProfile), questionnaires=[questionnaire])
         cls.answer = 'should show up'
-        mommy.make(TextAnswer, contribution=contribution, question=question, answer=cls.answer)
+        baker.make(TextAnswer, contribution=contribution, question=question, answer=cls.answer)
 
     def test_textanswers_showing_up(self):
         # in an evaluation with only one voter the view should not be available
@@ -1618,18 +1618,18 @@ class TestEvaluationTextAnswerEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        semester = mommy.make(Semester, pk=1)
-        student1 = mommy.make(UserProfile)
-        cls.student2 = mommy.make(UserProfile)
-        cls.evaluation = mommy.make(Evaluation, pk=1, course=mommy.make(Course, semester=semester), participants=[student1, cls.student2], voters=[student1], state="in_evaluation")
-        top_general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        mommy.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        semester = baker.make(Semester, pk=1)
+        student1 = baker.make(UserProfile)
+        cls.student2 = baker.make(UserProfile)
+        cls.evaluation = baker.make(Evaluation, pk=1, course=baker.make(Course, semester=semester), participants=[student1, cls.student2], voters=[student1], state="in_evaluation")
+        top_general_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        baker.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
         cls.evaluation.general_contribution.questionnaires.set([top_general_questionnaire])
-        questionnaire = mommy.make(Questionnaire)
-        question = mommy.make(Question, questionnaire=questionnaire, type=Question.TEXT)
-        contribution = mommy.make(Contribution, evaluation=cls.evaluation, contributor=mommy.make(UserProfile), questionnaires=[questionnaire])
-        mommy.make(TextAnswer, contribution=contribution, question=question, answer='test answer text', pk='00000000-0000-0000-0000-000000000001')
+        questionnaire = baker.make(Questionnaire)
+        question = baker.make(Question, questionnaire=questionnaire, type=Question.TEXT)
+        contribution = baker.make(Contribution, evaluation=cls.evaluation, contributor=baker.make(UserProfile), questionnaires=[questionnaire])
+        baker.make(TextAnswer, contribution=contribution, question=question, answer='test answer text', pk='00000000-0000-0000-0000-000000000001')
 
     def test_textanswers_showing_up(self):
         # in an evaluation with only one voter the view should not be available
@@ -1657,9 +1657,9 @@ class TestQuestionnaireNewVersionView(WebTest):
     def setUpTestData(cls):
         cls.name_de_orig = 'kurzer name'
         cls.name_en_orig = 'short name'
-        questionnaire = mommy.make(Questionnaire, id=2, name_de=cls.name_de_orig, name_en=cls.name_en_orig)
-        mommy.make(Question, questionnaire=questionnaire)
-        mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        questionnaire = baker.make(Questionnaire, id=2, name_de=cls.name_de_orig, name_en=cls.name_en_orig)
+        baker.make(Question, questionnaire=questionnaire)
+        baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
     def test_changes_old_title(self):
         page = self.app.get(url=self.url, user='manager')
@@ -1694,7 +1694,7 @@ class TestQuestionnaireCreateView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_create_questionnaire(self):
         page = self.app.get(self.url, user="manager")
@@ -1736,10 +1736,10 @@ class TestQuestionnaireIndexView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.contributor_questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        cls.top_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        cls.bottom_questionnaire = mommy.make(Questionnaire, type=Questionnaire.BOTTOM)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.contributor_questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        cls.top_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        cls.bottom_questionnaire = baker.make(Questionnaire, type=Questionnaire.BOTTOM)
 
     def test_ordering(self):
         content = self.app.get(self.url, user="manager").body.decode()
@@ -1756,12 +1756,12 @@ class TestQuestionnaireEditView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        evaluation = mommy.make(Evaluation, state='in_evaluation')
-        cls.questionnaire = mommy.make(Questionnaire, id=2)
-        mommy.make(Contribution, questionnaires=[cls.questionnaire], evaluation=evaluation)
+        evaluation = baker.make(Evaluation, state='in_evaluation')
+        cls.questionnaire = baker.make(Questionnaire, id=2)
+        baker.make(Contribution, questionnaires=[cls.questionnaire], evaluation=evaluation)
 
-        mommy.make(Question, questionnaire=cls.questionnaire)
-        mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        baker.make(Question, questionnaire=cls.questionnaire)
+        baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
     def test_allowed_type_changes_on_used_questionnaire(self):
         # top to bottom
@@ -1795,11 +1795,11 @@ class TestQuestionnaireViewView(WebTestWith200Check):
 
     @classmethod
     def setUpTestData(cls):
-        questionnaire = mommy.make(Questionnaire, id=2)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.TEXT)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.GRADE)
-        mommy.make(Question, questionnaire=questionnaire, type=Question.LIKERT)
-        mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        questionnaire = baker.make(Questionnaire, id=2)
+        baker.make(Question, questionnaire=questionnaire, type=Question.TEXT)
+        baker.make(Question, questionnaire=questionnaire, type=Question.GRADE)
+        baker.make(Question, questionnaire=questionnaire, type=Question.LIKERT)
+        baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
 
 class TestQuestionnaireCopyView(WebTest):
@@ -1807,9 +1807,9 @@ class TestQuestionnaireCopyView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        questionnaire = mommy.make(Questionnaire, id=2)
-        mommy.make(Question, questionnaire=questionnaire)
-        mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        questionnaire = baker.make(Questionnaire, id=2)
+        baker.make(Question, questionnaire=questionnaire)
+        baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
     def test_not_changing_name_fails(self):
         response = self.app.get(self.url, user="manager", status=200)
@@ -1836,10 +1836,10 @@ class TestQuestionnaireDeletionView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.q1 = mommy.make(Questionnaire)
-        cls.q2 = mommy.make(Questionnaire)
-        mommy.make(Contribution, questionnaires=[cls.q1])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.q1 = baker.make(Questionnaire)
+        cls.q2 = baker.make(Questionnaire)
+        baker.make(Contribution, questionnaires=[cls.q1])
 
     def test_questionnaire_deletion(self):
         """
@@ -1862,7 +1862,7 @@ class TestCourseTypeView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_page_displays_something(self):
         CourseType.objects.create(name_de='uZJcsl0rNc', name_en='uZJcsl0rNc')
@@ -1889,9 +1889,9 @@ class TestCourseTypeMergeSelectionView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.main_type = mommy.make(CourseType, name_en="A course type")
-        cls.other_type = mommy.make(CourseType, name_en="Obsolete course type")
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.main_type = baker.make(CourseType, name_en="A course type")
+        cls.other_type = baker.make(CourseType, name_en="Obsolete course type")
 
     def test_same_evaluation_fails(self):
         page = self.app.get(self.url, user="manager", status=200)
@@ -1907,11 +1907,11 @@ class TestCourseTypeMergeView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.main_type = mommy.make(CourseType, pk=1, name_en="A course type")
-        cls.other_type = mommy.make(CourseType, pk=2, name_en="Obsolete course type")
-        mommy.make(Course, type=cls.main_type)
-        mommy.make(Course, type=cls.other_type)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.main_type = baker.make(CourseType, pk=1, name_en="A course type")
+        cls.other_type = baker.make(CourseType, pk=2, name_en="Obsolete course type")
+        baker.make(Course, type=cls.main_type)
+        baker.make(Course, type=cls.other_type)
 
     def test_merge_works(self):
         page = self.app.get(self.url, user="manager", status=200)
@@ -1931,16 +1931,16 @@ class TestEvaluationTextAnswersUpdatePublishView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username="manager.user", groups=[Group.objects.get(name="Manager")])
-        cls.student1 = mommy.make(UserProfile)
-        cls.student2 = mommy.make(UserProfile)
-        cls.evaluation = mommy.make(Evaluation, participants=[cls.student1, cls.student2], voters=[cls.student1], state="in_evaluation")
-        top_general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        mommy.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
+        baker.make(UserProfile, username="manager.user", groups=[Group.objects.get(name="Manager")])
+        cls.student1 = baker.make(UserProfile)
+        cls.student2 = baker.make(UserProfile)
+        cls.evaluation = baker.make(Evaluation, participants=[cls.student1, cls.student2], voters=[cls.student1], state="in_evaluation")
+        top_general_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        baker.make(Question, questionnaire=top_general_questionnaire, type=Question.LIKERT)
         cls.evaluation.general_contribution.questionnaires.set([top_general_questionnaire])
 
     def helper(self, old_state, expected_new_state, action, expect_errors=False):
-        textanswer = mommy.make(TextAnswer, state=old_state)
+        textanswer = baker.make(TextAnswer, state=old_state)
         response = self.app.post(self.url, params={"id": textanswer.id, "action": action, "evaluation_id": self.evaluation.pk}, user="manager.user", expect_errors=expect_errors)
         if expect_errors:
             self.assertEqual(response.status_code, 403)
@@ -1965,13 +1965,13 @@ def test_review_actions(self):
 class ParticipationArchivingTests(WebTest):
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
+        baker.make(UserProfile, username="manager", groups=[Group.objects.get(name="Manager")])
 
     def test_raise_403(self):
         """
             Tests whether inaccessible views on semesters/evaluations with archived participations correctly raise a 403.
         """
-        semester = mommy.make(Semester, participations_are_archived=True)
+        semester = baker.make(Semester, participations_are_archived=True)
 
         semester_url = "/staff/semester/{}/".format(semester.pk)
 
@@ -1986,7 +1986,7 @@ class TestTemplateEditView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_emailtemplate(self):
         """
@@ -2010,7 +2010,7 @@ class TestDegreeView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
 
     def test_degree_form(self):
         """
@@ -2032,18 +2032,18 @@ class TestSemesterQuestionnaireAssignment(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        mommy.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
-        cls.semester = mommy.make(Semester, id=1)
-        cls.course_type_1 = mommy.make(CourseType)
-        cls.course_type_2 = mommy.make(CourseType)
-        cls.responsible = mommy.make(UserProfile)
-        cls.questionnaire_1 = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        cls.questionnaire_2 = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        cls.questionnaire_responsible = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
-        cls.evaluation_1 = mommy.make(Evaluation, course=mommy.make(Course, semester=cls.semester, type=cls.course_type_1, responsibles=[cls.responsible]))
-        cls.evaluation_2 = mommy.make(Evaluation, course=mommy.make(Course, semester=cls.semester, type=cls.course_type_2, responsibles=[cls.responsible]))
-        mommy.make(Contribution, contributor=cls.responsible, evaluation=cls.evaluation_1, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
-        mommy.make(Contribution, contributor=cls.responsible, evaluation=cls.evaluation_2, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(UserProfile, username='manager', groups=[Group.objects.get(name='Manager')])
+        cls.semester = baker.make(Semester, id=1)
+        cls.course_type_1 = baker.make(CourseType)
+        cls.course_type_2 = baker.make(CourseType)
+        cls.responsible = baker.make(UserProfile)
+        cls.questionnaire_1 = baker.make(Questionnaire, type=Questionnaire.TOP)
+        cls.questionnaire_2 = baker.make(Questionnaire, type=Questionnaire.TOP)
+        cls.questionnaire_responsible = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        cls.evaluation_1 = baker.make(Evaluation, course=baker.make(Course, semester=cls.semester, type=cls.course_type_1, responsibles=[cls.responsible]))
+        cls.evaluation_2 = baker.make(Evaluation, course=baker.make(Course, semester=cls.semester, type=cls.course_type_2, responsibles=[cls.responsible]))
+        baker.make(Contribution, contributor=cls.responsible, evaluation=cls.evaluation_1, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
+        baker.make(Contribution, contributor=cls.responsible, evaluation=cls.evaluation_2, can_edit=True, textanswer_visibility=Contribution.GENERAL_TEXTANSWERS)
 
     def test_questionnaire_assignment(self):
         page = self.app.get(self.url, user="manager", status=200)
diff --git a/evap/student/tests/test_views.py b/evap/student/tests/test_views.py
--- a/evap/student/tests/test_views.py
+++ b/evap/student/tests/test_views.py
@@ -2,7 +2,7 @@
 from django.urls import reverse
 
 from django_webtest import WebTest
-from model_mommy import mommy
+from model_bakery import baker
 
 from evap.evaluation.models import UserProfile, Evaluation, Questionnaire, Question, Contribution, TextAnswer, RatingAnswerCounter
 from evap.evaluation.tests.tools import WebTestWith200Check
@@ -16,8 +16,8 @@ class TestStudentIndexView(WebTestWith200Check):
 
     def setUp(self):
         # View is only visible to users participating in at least one evaluation.
-        user = mommy.make(UserProfile, username='student')
-        mommy.make(Evaluation, participants=[user])
+        user = baker.make(UserProfile, username='student')
+        baker.make(Evaluation, participants=[user])
 
 
 @override_settings(INSTITUTION_EMAIL_DOMAINS=["example.com"])
@@ -26,34 +26,34 @@ class TestVoteView(WebTest):
 
     @classmethod
     def setUpTestData(cls):
-        cls.voting_user1 = mommy.make(UserProfile)
-        cls.voting_user2 = mommy.make(UserProfile)
-        cls.contributor1 = mommy.make(UserProfile)
-        cls.contributor2 = mommy.make(UserProfile)
+        cls.voting_user1 = baker.make(UserProfile)
+        cls.voting_user2 = baker.make(UserProfile)
+        cls.contributor1 = baker.make(UserProfile)
+        cls.contributor2 = baker.make(UserProfile)
 
-        cls.evaluation = mommy.make(Evaluation, pk=1, participants=[cls.voting_user1, cls.voting_user2, cls.contributor1], state="in_evaluation")
+        cls.evaluation = baker.make(Evaluation, pk=1, participants=[cls.voting_user1, cls.voting_user2, cls.contributor1], state="in_evaluation")
 
-        cls.top_general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.TOP)
-        cls.bottom_general_questionnaire = mommy.make(Questionnaire, type=Questionnaire.BOTTOM)
-        cls.contributor_questionnaire = mommy.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
+        cls.top_general_questionnaire = baker.make(Questionnaire, type=Questionnaire.TOP)
+        cls.bottom_general_questionnaire = baker.make(Questionnaire, type=Questionnaire.BOTTOM)
+        cls.contributor_questionnaire = baker.make(Questionnaire, type=Questionnaire.CONTRIBUTOR)
 
-        cls.contributor_heading_question = mommy.make(Question, questionnaire=cls.contributor_questionnaire, order=0, type=Question.HEADING)
-        cls.contributor_text_question = mommy.make(Question, questionnaire=cls.contributor_questionnaire, order=1, type=Question.TEXT)
-        cls.contributor_likert_question = mommy.make(Question, questionnaire=cls.contributor_questionnaire, order=2, type=Question.LIKERT)
+        cls.contributor_heading_question = baker.make(Question, questionnaire=cls.contributor_questionnaire, order=0, type=Question.HEADING)
+        cls.contributor_text_question = baker.make(Question, questionnaire=cls.contributor_questionnaire, order=1, type=Question.TEXT)
+        cls.contributor_likert_question = baker.make(Question, questionnaire=cls.contributor_questionnaire, order=2, type=Question.LIKERT)
 
-        cls.top_heading_question = mommy.make(Question, questionnaire=cls.top_general_questionnaire, order=0, type=Question.HEADING)
-        cls.top_text_question = mommy.make(Question, questionnaire=cls.top_general_questionnaire, order=1, type=Question.TEXT)
-        cls.top_likert_question = mommy.make(Question, questionnaire=cls.top_general_questionnaire, order=2, type=Question.LIKERT)
-        cls.top_grade_question = mommy.make(Question, questionnaire=cls.top_general_questionnaire, order=3, type=Question.GRADE)
+        cls.top_heading_question = baker.make(Question, questionnaire=cls.top_general_questionnaire, order=0, type=Question.HEADING)
+        cls.top_text_question = baker.make(Question, questionnaire=cls.top_general_questionnaire, order=1, type=Question.TEXT)
+        cls.top_likert_question = baker.make(Question, questionnaire=cls.top_general_questionnaire, order=2, type=Question.LIKERT)
+        cls.top_grade_question = baker.make(Question, questionnaire=cls.top_general_questionnaire, order=3, type=Question.GRADE)
 
-        cls.bottom_heading_question = mommy.make(Question, questionnaire=cls.bottom_general_questionnaire, order=0, type=Question.HEADING)
-        cls.bottom_text_question = mommy.make(Question, questionnaire=cls.bottom_general_questionnaire, order=1, type=Question.TEXT)
-        cls.bottom_likert_question = mommy.make(Question, questionnaire=cls.bottom_general_questionnaire, order=2, type=Question.LIKERT)
-        cls.bottom_grade_question = mommy.make(Question, questionnaire=cls.bottom_general_questionnaire, order=3, type=Question.GRADE)
+        cls.bottom_heading_question = baker.make(Question, questionnaire=cls.bottom_general_questionnaire, order=0, type=Question.HEADING)
+        cls.bottom_text_question = baker.make(Question, questionnaire=cls.bottom_general_questionnaire, order=1, type=Question.TEXT)
+        cls.bottom_likert_question = baker.make(Question, questionnaire=cls.bottom_general_questionnaire, order=2, type=Question.LIKERT)
+        cls.bottom_grade_question = baker.make(Question, questionnaire=cls.bottom_general_questionnaire, order=3, type=Question.GRADE)
 
-        cls.contribution1 = mommy.make(Contribution, contributor=cls.contributor1, questionnaires=[cls.contributor_questionnaire],
+        cls.contribution1 = baker.make(Contribution, contributor=cls.contributor1, questionnaires=[cls.contributor_questionnaire],
                                        evaluation=cls.evaluation)
-        cls.contribution2 = mommy.make(Contribution, contributor=cls.contributor2, questionnaires=[cls.contributor_questionnaire],
+        cls.contribution2 = baker.make(Contribution, contributor=cls.contributor2, questionnaires=[cls.contributor_questionnaire],
                                        evaluation=cls.evaluation)
 
         cls.evaluation.general_contribution.questionnaires.set([cls.top_general_questionnaire, cls.bottom_general_questionnaire])