def setUpTestData(cls):
with open(cls.filename_valid, "rb") as excel_file:
cls.valid_excel_content = excel_file.read()
with open(cls.filename_invalid, "rb") as excel_file:
cls.invalid_excel_content = excel_file.read()
with open(cls.filename_random, "rb") as excel_file:
cls.random_excel_content = excel_file.read()
cls.duplicate_excel_content = excel_data.create_memory_excel_file(excel_data.duplicate_user_import_filedata)
cls.numerical_excel_content = excel_data.create_memory_excel_file(
excel_data.numerical_data_in_user_data_filedata
)
def test_replace_consecutive_and_trailing_spaces(self):
excel_content = excel_data.create_memory_excel_file(
excel_data.test_enrollment_data_consecutive_and_trailing_spaces_filedata
)
success_messages, __, __ = EnrollmentImporter.process(excel_content, self.semester, None, None, test_run=True)
self.assertIn("The import run will create 1 courses/evaluations and 3 users", "".join(success_messages))
def test_degrees_are_merged(self):
excel_content = excel_data.create_memory_excel_file(excel_data.test_enrollment_data_degree_merge_filedata)
success_messages, warnings_test, errors = EnrollmentImporter.process(
excel_content, self.semester, None, None, test_run=True
)
self.assertIn("The import run will create 1 courses/evaluations and 3 users", "".join(success_messages))
self.assertEqual(errors, {})
self.assertEqual(
warnings_test[ImporterWarning.DEGREE],
[
'Sheet "MA Belegungen", row 3: The course\'s "Build" degree differs from it\'s degree in a previous row. '
"Both degrees have been set for the course."
],
)
self.assertEqual(len(warnings_test), 1)
success_messages, warnings_no_test, errors = EnrollmentImporter.process(
excel_content, self.semester, self.vote_start_datetime, self.vote_end_date, test_run=False
)
self.assertIn(
"Successfully created 1 courses/evaluations, 2 participants and 1 contributors", "".join(success_messages)
)
self.assertEqual(errors, {})
self.assertEqual(warnings_no_test, warnings_test)
self.assertEqual(Course.objects.all().count(), 1)
self.assertEqual(Evaluation.objects.all().count(), 1)
course = Course.objects.get(name_de="Bauen")
self.assertSetEqual(set(course.degrees.all()), set(Degree.objects.filter(name_de__in=["Master", "Bachelor"])))
def test_enrollment_importer_high_enrollment_warning(self):
excel_content = excel_data.create_memory_excel_file(
excel_data.test_enrollment_data_filedata)
__, warnings_test, __ = EnrollmentImporter.process(excel_content,
self.semester,
None,
None,
test_run=True)
__, warnings_no_test, __ = EnrollmentImporter.process(
excel_content,
self.semester,
self.vote_start_datetime,
self.vote_end_date,
test_run=False)
self.assertEqual(warnings_test, warnings_no_test)
self.assertCountEqual(
warnings_test[ImporterWarning.MANY], {
"Warning: User [email protected] has 6 enrollments, which is a lot.",
"Warning: User [email protected] has 6 enrollments, which is a lot.",
"Warning: User [email protected] has 6 enrollments, which is a lot.",
"Warning: User [email protected] has 6 enrollments, which is a lot.",
"Warning: User [email protected] has 5 enrollments, which is a lot.",
"Warning: User [email protected] has 4 enrollments, which is a lot."
})
def test_valid_file_import(self):
excel_content = excel_data.create_memory_excel_file(excel_data.test_enrollment_data_filedata)
success_messages, warnings, errors = EnrollmentImporter.process(
excel_content, self.semester, None, None, test_run=True
)
self.assertIn("The import run will create 23 courses/evaluations and 23 users:", "".join(success_messages))
# check for one random user instead of for all 23
self.assertIn("Ferdi Itaque ([email protected])", "".join(success_messages))
self.assertEqual(errors, {})
self.assertEqual(warnings, {})
old_user_count = UserProfile.objects.all().count()
success_messages, warnings, errors = EnrollmentImporter.process(
excel_content, self.semester, self.vote_start_datetime, self.vote_end_date, test_run=False
)
self.assertIn(
"Successfully created 23 courses/evaluations, 6 participants and 17 contributors:",
"".join(success_messages),
)
self.assertIn("Ferdi Itaque ([email protected])", "".join(success_messages))
self.assertEqual(errors, {})
self.assertEqual(warnings, {})
self.assertEqual(Evaluation.objects.all().count(), 23)
expected_user_count = old_user_count + 23
self.assertEqual(UserProfile.objects.all().count(), expected_user_count)
def test_course_type_and_degrees_are_retrieved_with_import_names(self):
excel_content = excel_data.create_memory_excel_file(
excel_data.test_enrollment_data_import_names_filedata)
success_messages, warnings, errors = EnrollmentImporter.process(
excel_content,
self.semester,
self.vote_start_datetime,
self.vote_end_date,
test_run=False)
self.assertIn(
"Successfully created 2 courses/evaluations, 4 students and 2 contributors:",
"".join(success_messages))
self.assertEqual(errors, {})
self.assertEqual(warnings, {})
self.assertEqual(Course.objects.all().count(), 2)
course_spelling = Course.objects.get(name_en="Spelling")
self.assertEqual(course_spelling.type.name_de, "Vorlesung")
self.assertEqual(
list(course_spelling.degrees.values_list("name_en", flat=True)),
["Bachelor"])
course_build = Course.objects.get(name_en="Build")
self.assertEqual(course_build.type.name_de, "Seminar")
self.assertEqual(
list(course_build.degrees.values_list("name_en", flat=True)),
["Master"])
def setUpTestData(cls):
cls.semester = baker.make(Semester)
cls.vote_start_datetime = datetime(2017, 1, 10)
cls.vote_end_date = date(2017, 3, 10)
baker.make(CourseType, name_de="Seminar", import_names=["Seminar", "S"])
baker.make(CourseType, name_de="Vorlesung", import_names=["Vorlesung", "V"])
Degree.objects.filter(name_de="Bachelor").update(import_names=["Bachelor", "B. Sc."])
Degree.objects.filter(name_de="Master").update(import_names=["Master", "M. Sc."])
cls.default_excel_content = excel_data.create_memory_excel_file(excel_data.test_enrollment_data_filedata)
def test_errors_are_merged(self):
excel_content = excel_data.create_memory_excel_file(excel_data.test_enrollment_data_error_merge_filedata)
__, warnings, errors = EnrollmentImporter.process(
excel_content, self.semester, self.vote_start_datetime, self.vote_end_date, test_run=False
)
self.assertIn("Both degrees have been set for the course", "".join(warnings[ImporterWarning.DEGREE]))
self.assertIn("is probably not, but must be", "".join(errors[ImporterError.IS_GRADED]))
self.assertIn("jaminar", "".join(errors[ImporterError.COURSE_TYPE_MISSING]))
self.assertIn("Beginner", "".join(errors[ImporterError.DEGREE_MISSING]))
self.assertIn("Grandmaster", "".join(errors[ImporterError.DEGREE_MISSING]))
def test_unknown_degree_error(self):
excel_content = excel_data.create_memory_excel_file(
excel_data.test_unknown_degree_error_filedata)
__, __, errors = EnrollmentImporter.process(excel_content,
baker.make(Semester),
None,
None,
test_run=False)
missing_degree_errors = errors[ImporterError.DEGREE_MISSING]
self.assertEqual(len(missing_degree_errors), 1)
self.assertIn("manually create it first", missing_degree_errors[0])
def test_invalid_file_error(self):
excel_content = excel_data.create_memory_excel_file(
excel_data.invalid_enrollment_data_filedata)
original_user_count = UserProfile.objects.count()
__, __, errors_test = EnrollmentImporter.process(excel_content,
self.semester,
None,
None,
test_run=True)
__, __, errors_no_test = EnrollmentImporter.process(excel_content,
self.semester,
None,
None,
test_run=False)
self.assertEqual(errors_test, errors_no_test)
self.assertCountEqual(
errors_test[ImporterError.USER],
{
"Sheet \"MA Belegungen\", row 3: The users's data (email: [email protected]) differs from it's data in a previous row.",
'Sheet "MA Belegungen", row 7: Email address is missing.',
'Sheet "MA Belegungen", row 10: Email address is missing.',
},
)
self.assertCountEqual(
errors_test[ImporterError.COURSE],
{
'Sheet "MA Belegungen", row 18: The German name for course "Bought" already exists for another course.',
'Sheet "MA Belegungen", row 20: The course\'s "Cost" data differs from it\'s data in a previous row.',
},
)
self.assertEqual(
errors_test[ImporterError.DEGREE_MISSING],
[
'Error: No degree is associated with the import name "Diploma". Please manually create it first.'
],
)
self.assertEqual(
errors_test[ImporterError.COURSE_TYPE_MISSING],
[
'Error: No course type is associated with the import name "Praktikum". Please manually create it first.'
],
)
self.assertEqual(
errors_test[ImporterError.IS_GRADED],
['"is_graded" of course Deal is maybe, but must be yes or no'])
self.assertEqual(errors_test[ImporterError.GENERAL], [
"Errors occurred while parsing the input data. No data was imported."
])
self.assertEqual(len(errors_test), 6)
self.assertEqual(UserProfile.objects.count(), original_user_count)
def test_duplicate_course_error(self):
excel_content = excel_data.create_memory_excel_file(excel_data.test_enrollment_data_filedata)
semester = baker.make(Semester)
baker.make(Course, name_de="Stehlen", name_en="Stehlen", semester=semester)
baker.make(Course, name_de="Shine", name_en="Shine", semester=semester)
__, __, errors = EnrollmentImporter.process(excel_content, semester, None, None, test_run=False)
self.assertCountEqual(
errors[ImporterError.COURSE],
{
"Course Stehlen does already exist in this semester.",
"Course Shine does already exist in this semester.",
},
)
