def test_view_excel_file_sorted(self):
semester = baker.make(Semester)
course_type = baker.make(CourseType)
degree = baker.make(Degree)
evaluation1 = baker.make(
Evaluation,
state=Evaluation.State.PUBLISHED,
course=baker.make(Course,
degrees=[degree],
type=course_type,
semester=semester,
name_de="A",
name_en="B"),
name_de="Evaluation1",
name_en="Evaluation1",
)
evaluation2 = baker.make(
Evaluation,
state=Evaluation.State.PUBLISHED,
course=baker.make(Course,
degrees=[degree],
type=course_type,
semester=semester,
name_de="B",
name_en="A"),
name_de="Evaluation2",
name_en="Evaluation2",
)
cache_results(evaluation1)
cache_results(evaluation2)
content_de = BytesIO()
with translation.override("de"):
ResultsExporter().export(content_de, [semester],
[([degree.id], [course_type.id])], True,
True)
content_en = BytesIO()
with translation.override("en"):
ResultsExporter().export(content_en, [semester],
[([degree.id], [course_type.id])], True,
True)
content_de.seek(0)
content_en.seek(0)
# Load responses as Excel files and check for correct sorting
workbook = xlrd.open_workbook(file_contents=content_de.read())
self.assertEqual(workbook.sheets()[0].row_values(0)[1],
"A – Evaluation1\n")
self.assertEqual(workbook.sheets()[0].row_values(0)[2],
"B – Evaluation2\n")
workbook = xlrd.open_workbook(file_contents=content_en.read())
self.assertEqual(workbook.sheets()[0].row_values(0)[1],
"A – Evaluation2\n")
self.assertEqual(workbook.sheets()[0].row_values(0)[2],
"B – Evaluation1\n")
def test_course_type_ordering(self):
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=Evaluation.State.PUBLISHED,
_participant_count=2,
_voter_count=2,
)
evaluation_2 = baker.make(
Evaluation,
course=baker.make(Course, semester=semester, degrees=[degree], type=course_type_2),
state=Evaluation.State.PUBLISHED,
_participant_count=2,
_voter_count=2,
)
cache_results(evaluation_1)
cache_results(evaluation_2)
questionnaire = baker.make(Questionnaire)
question = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire)
evaluation_1.general_contribution.questionnaires.set([questionnaire])
make_rating_answer_counters(question, evaluation_1.general_contribution)
evaluation_2.general_contribution.questionnaires.set([questionnaire])
make_rating_answer_counters(question, evaluation_2.general_contribution)
binary_content = BytesIO()
ResultsExporter().export(
binary_content, [semester], [([degree.id], [course_type_1.id, course_type_2.id])], True, True
)
binary_content.seek(0)
workbook = xlrd.open_workbook(file_contents=binary_content.read())
self.assertEqual(workbook.sheets()[0].row_values(0)[1], evaluation_1.full_name + "\n")
self.assertEqual(workbook.sheets()[0].row_values(0)[2], evaluation_2.full_name + "\n")
course_type_2.order = 0
course_type_2.save()
binary_content = BytesIO()
ResultsExporter().export(
binary_content, [semester], [([degree.id], [course_type_1.id, course_type_2.id])], True, True
)
binary_content.seek(0)
workbook = xlrd.open_workbook(file_contents=binary_content.read())
self.assertEqual(workbook.sheets()[0].row_values(0)[1], evaluation_2.full_name + "\n")
self.assertEqual(workbook.sheets()[0].row_values(0)[2], evaluation_1.full_name + "\n")
def test_grade_color_calculation(self):
exporter = ResultsExporter()
self.assertEqual(exporter.STEP, 0.2)
self.assertEqual(exporter.normalize_number(1.94999999999), 1.8)
# self.assertEqual(exporter.normalize_number(1.95), 2.0) # floats ftw
self.assertEqual(exporter.normalize_number(1.95000000001), 2.0)
self.assertEqual(exporter.normalize_number(1.99999999999), 2.0)
self.assertEqual(exporter.normalize_number(2.0), 2.0)
self.assertEqual(exporter.normalize_number(2.00000000001), 2.0)
self.assertEqual(exporter.normalize_number(2.1), 2.0)
self.assertEqual(exporter.normalize_number(2.149999999999), 2.0)
# self.assertEqual(exporter.normalize_number(2.15), 2.2) # floats again
self.assertEqual(exporter.normalize_number(2.150000000001), 2.2)
self.assertEqual(exporter.normalize_number(2.8), 2.8)
def test_heading_question_filtering(self):
degree = baker.make(Degree)
evaluation = baker.make(Evaluation,
course=baker.make(Course, degrees=[degree]),
state='published',
_participant_count=2,
_voter_count=2)
contributor = baker.make(UserProfile)
evaluation.general_contribution.questionnaires.set(
[baker.make(Questionnaire)])
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 = baker.make(Contribution,
evaluation=evaluation,
questionnaires=[questionnaire],
contributor=contributor)
baker.make(RatingAnswerCounter,
question=likert_question,
contribution=contribution,
answer=3,
count=100)
cache_results(evaluation)
binary_content = BytesIO()
ResultsExporter().export(
binary_content, [evaluation.course.semester], [([
course_degree.id
for course_degree in evaluation.course.degrees.all()
], [evaluation.course.type.id])], True, True)
binary_content.seek(0)
workbook = xlrd.open_workbook(file_contents=binary_content.read())
self.assertEqual(workbook.sheets()[0].row_values(4)[0],
questionnaire.name)
self.assertEqual(workbook.sheets()[0].row_values(5)[0],
heading_question.text)
self.assertEqual(workbook.sheets()[0].row_values(6)[0],
likert_question.text)
self.assertEqual(workbook.sheets()[0].row_values(7)[0], "")
def test_multiple_sheets(self):
binary_content = BytesIO()
semester = baker.make(Semester)
ResultsExporter().export(binary_content, [semester], [([], []), ([], [])])
binary_content.seek(0)
workbook = xlrd.open_workbook(file_contents=binary_content.read())
self.assertEqual(len(workbook.sheets()), 2)
def export_contributor_results(contributor):
filename = "Evaluation_{}.xls".format(contributor.full_name)
response = FileResponse(filename, content_type="application/vnd.ms-excel")
ResultsExporter().export(
response,
Semester.objects.all(),
[(Degree.objects.all(), CourseType.objects.all())],
include_not_enough_voters=True,
include_unpublished=False,
contributor=contributor)
return response
def test_questionnaire_ordering(self):
degree = baker.make(Degree)
evaluation = baker.make(
Evaluation,
course__degrees=[degree],
state=Evaluation.State.PUBLISHED,
_participant_count=2,
_voter_count=2,
)
questionnaire_1 = baker.make(Questionnaire, order=1, type=Questionnaire.Type.TOP)
questionnaire_2 = baker.make(Questionnaire, order=4, type=Questionnaire.Type.TOP)
questionnaire_3 = baker.make(Questionnaire, order=1, type=Questionnaire.Type.BOTTOM)
questionnaire_4 = baker.make(Questionnaire, order=4, type=Questionnaire.Type.BOTTOM)
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]
)
make_rating_answer_counters(question_1, evaluation.general_contribution)
make_rating_answer_counters(question_2, evaluation.general_contribution)
make_rating_answer_counters(question_3, evaluation.general_contribution)
make_rating_answer_counters(question_4, evaluation.general_contribution)
cache_results(evaluation)
binary_content = BytesIO()
ResultsExporter().export(
binary_content,
[evaluation.course.semester],
[([course_degree.id for course_degree in evaluation.course.degrees.all()], [evaluation.course.type.id])],
True,
True,
)
binary_content.seek(0)
workbook = xlrd.open_workbook(file_contents=binary_content.read())
self.assertEqual(workbook.sheets()[0].row_values(4)[0], questionnaire_1.name)
self.assertEqual(workbook.sheets()[0].row_values(5)[0], question_1.text)
self.assertEqual(workbook.sheets()[0].row_values(7)[0], questionnaire_2.name)
self.assertEqual(workbook.sheets()[0].row_values(8)[0], question_2.text)
self.assertEqual(workbook.sheets()[0].row_values(10)[0], questionnaire_3.name)
self.assertEqual(workbook.sheets()[0].row_values(11)[0], question_3.text)
self.assertEqual(workbook.sheets()[0].row_values(13)[0], questionnaire_4.name)
self.assertEqual(workbook.sheets()[0].row_values(14)[0], question_4.text)
def get_export_sheet(semester, degree, course_types, include_unpublished=True, include_not_enough_voters=True):
binary_content = BytesIO()
ResultsExporter().export(
binary_content,
[semester],
[([degree.id], course_types)],
include_unpublished=include_unpublished,
include_not_enough_voters=include_not_enough_voters,
)
binary_content.seek(0)
workbook = xlrd.open_workbook(file_contents=binary_content.read())
return workbook.sheets()[0]
def test_no_degree_or_course_type(self):
evaluation = baker.make(Evaluation)
with self.assertRaises(AssertionError):
ResultsExporter().export(BytesIO(), [evaluation.course.semester],
[])