def test_single_result_anonymization(self): questionnaire = Questionnaire.single_result_questionnaire() 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) answer_count_before = 0 choices = [ choice for choice in CHOICES[question.type].values if choice != NO_ANSWER ] answer_counts = [random.randint(50, 100) for answer in choices] answer_count_before = sum(answer_counts) make_rating_answer_counters(question, single_result.general_contribution, answer_counts) management.call_command("anonymize", stdout=StringIO()) self.assertLessEqual(RatingAnswerCounter.objects.count(), len(choices)) self.assertEqual( RatingAnswerCounter.objects.aggregate(Sum("count"))["count__sum"], answer_count_before)
def test_calculation_unipolar_results(self): contributor1 = baker.make(UserProfile) student = baker.make(UserProfile) evaluation = baker.make( Evaluation, state=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]) make_rating_answer_counters(question, contribution1, [5, 15, 40, 60, 30]) cache_results(evaluation) evaluation_results = get_results(evaluation) self.assertEqual(len(evaluation_results.questionnaire_results), 1) questionnaire_result = evaluation_results.questionnaire_results[0] self.assertEqual(len(questionnaire_result.question_results), 1) question_result = questionnaire_result.question_results[0] self.assertEqual(question_result.count_sum, 150) self.assertAlmostEqual(question_result.average, float(109) / 30) self.assertEqual(question_result.counts, (5, 15, 40, 60, 30))
def test_result_calculation_with_no_contributor_rating_question(self): evaluation = baker.make( Evaluation, state=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]) make_rating_answer_counters(self.question_grade, evaluation.general_contribution, [1, 0, 0, 0, 0]) cache_results(evaluation) distribution = calculate_average_distribution(evaluation) self.assertEqual(distribution[0], 1)
def test_course_grade(self): degree = baker.make(Degree) course = baker.make(Course, degrees=[degree]) evaluations = baker.make( Evaluation, course=course, name_en=iter(["eval0", "eval1", "eval2"]), name_de=iter(["eval0", "eval1", "eval2"]), state=Evaluation.State.PUBLISHED, _voter_count=5, _participant_count=10, _quantity=3, ) grades_per_eval = [[1, 1, 0, 0, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 0]] expected_average = 2.0 questionnaire = baker.make(Questionnaire) question = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire) for grades, e in zip(grades_per_eval, evaluations): make_rating_answer_counters(question, e.general_contribution, grades) e.general_contribution.questionnaires.set([questionnaire]) for evaluation in evaluations: cache_results(evaluation) sheet = self.get_export_sheet(course.semester, degree, [course.type.id]) self.assertEqual(sheet.row_values(12)[1], expected_average) self.assertEqual(sheet.row_values(12)[2], expected_average) self.assertEqual(sheet.row_values(12)[3], expected_average)
def test_calculate_average_course_distribution(self): make_rating_answer_counters(self.question_grade, self.contribution1, [2, 0, 0, 0, 0]) course = self.evaluation.course single_result = baker.make( Evaluation, name_de="Single Result", name_en="Single Result", course=course, weight=3, is_single_result=True, vote_start_datetime=datetime.now(), vote_end_date=datetime.now().date(), state=Evaluation.State.PUBLISHED, ) single_result_questionnaire = Questionnaire.single_result_questionnaire( ) single_result_question = single_result_questionnaire.questions.first() contribution = baker.make(Contribution, evaluation=single_result, contributor=None, questionnaires=[single_result_questionnaire]) make_rating_answer_counters(single_result_question, contribution, [0, 1, 1, 0, 0]) cache_results(single_result) cache_results(self.evaluation) distribution = calculate_average_course_distribution(course) self.assertEqual(distribution[0], 0.25) self.assertEqual(distribution[1], 0.375) self.assertEqual(distribution[2], 0.375) self.assertEqual(distribution[3], 0) self.assertEqual(distribution[4], 0)
def test_correct_grades_and_bottom_numbers(self): degree = baker.make(Degree) evaluation = baker.make( Evaluation, _voter_count=5, _participant_count=10, course__degrees=[degree], state=Evaluation.State.PUBLISHED, ) questionnaire1 = baker.make(Questionnaire, order=1) questionnaire2 = baker.make(Questionnaire, order=2) question1 = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire1) question2 = baker.make(Question, type=Question.LIKERT, questionnaire=questionnaire2) make_rating_answer_counters(question1, evaluation.general_contribution, [1, 0, 1, 0, 0]) make_rating_answer_counters(question2, evaluation.general_contribution, [0, 1, 0, 1, 0]) evaluation.general_contribution.questionnaires.set([questionnaire1, questionnaire2]) cache_results(evaluation) sheet = self.get_export_sheet(evaluation.course.semester, degree, [evaluation.course.type.id]) self.assertEqual(sheet.row_values(5)[1], 2.0) # question 1 average self.assertEqual(sheet.row_values(8)[1], 3.0) # question 2 average self.assertEqual(sheet.row_values(10)[1], 2.5) # Average grade self.assertEqual(sheet.row_values(11)[1], "5/10") # Voters / Participants self.assertEqual(sheet.row_values(12)[1], "50%") # Voter percentage
def test_distribution_without_general_grade_question(self): make_rating_answer_counters(self.question_grade, self.contribution1, [1, 0, 1, 0, 0]) make_rating_answer_counters(self.question_grade, self.contribution2, [0, 1, 0, 1, 0]) make_rating_answer_counters(self.question_likert, self.contribution1, [0, 0, 3, 0, 3]) make_rating_answer_counters(self.question_likert, self.general_contribution, [0, 0, 0, 0, 5]) make_rating_answer_counters(self.question_likert_2, self.general_contribution, [0, 0, 3, 0, 0]) cache_results(self.evaluation) # 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) # contributions: (6 / 8) * (0.2, 0, 0.5, 0, 0.3) + (2 / 8) * (0, 0.5, 0, 0.5, 0) = (0.15, 0.125, 0.375, 0.125, 0.225) # general_non_grade: (0, 0, 0.375, 0, 0.625) # total: 0.375 * (0.15, 0.125, 0.375, 0.125, 0.225) + 0.625 * (0, 0, 0.375, 0, 0.625) = (0.05625, 0.046875, 0.375, 0.046875, 0.475) distribution = calculate_average_distribution(self.evaluation) self.assertAlmostEqual(distribution[0], 0.05625) self.assertAlmostEqual(distribution[1], 0.046875) self.assertAlmostEqual(distribution[2], 0.375) self.assertAlmostEqual(distribution[3], 0.046875) self.assertAlmostEqual(distribution[4], 0.475)
def test_single_result_can_be_deleted_only_in_reviewed(self): responsible = baker.make(UserProfile) evaluation = baker.make(Evaluation, is_single_result=True) contribution = baker.make( Contribution, evaluation=evaluation, contributor=responsible, questionnaires=[Questionnaire.single_result_questionnaire()], role=Contribution.Role.EDITOR, textanswer_visibility=Contribution.TextAnswerVisibility.GENERAL_TEXTANSWERS, ) make_rating_answer_counters(Questionnaire.single_result_questionnaire().questions.first(), contribution) evaluation.skip_review_single_result() evaluation.publish() evaluation.save() self.assertTrue(Evaluation.objects.filter(pk=evaluation.pk).exists()) self.assertFalse(evaluation.can_be_deleted_by_manager) evaluation.unpublish() self.assertTrue(evaluation.can_be_deleted_by_manager) RatingAnswerCounter.objects.filter(contribution__evaluation=evaluation).delete() evaluation.delete() self.assertFalse(Evaluation.objects.filter(pk=evaluation.pk).exists())
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_single_result_can_be_published(): """Regression test for #1238""" 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, questionnaires=[Questionnaire.single_result_questionnaire()], role=Contribution.Role.EDITOR, textanswer_visibility=Contribution.TextAnswerVisibility.GENERAL_TEXTANSWERS, ) make_rating_answer_counters(Questionnaire.single_result_questionnaire().questions.first(), contribution) single_result.skip_review_single_result() single_result.publish() # used to crash
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 test_calculation_bipolar_results(self): contributor1 = baker.make(UserProfile) student = baker.make(UserProfile) evaluation = baker.make( Evaluation, state=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]) make_rating_answer_counters(question, contribution1, [5, 5, 15, 30, 25, 15, 10]) cache_results(evaluation) evaluation_results = get_results(evaluation) self.assertEqual(len(evaluation_results.questionnaire_results), 1) questionnaire_result = evaluation_results.questionnaire_results[0] self.assertEqual(len(questionnaire_result.question_results), 1) question_result = questionnaire_result.question_results[0] self.assertEqual(question_result.count_sum, 105) self.assertAlmostEqual(question_result.average, 2.58730158) self.assertEqual(question_result.counts, (5, 5, 15, 30, 25, 15, 10)) self.assertEqual(question_result.minus_balance_count, 32.5) distribution = normalized_distribution(question_result.counts) self.assertAlmostEqual(distribution[0], 0.04761904) self.assertAlmostEqual(distribution[1], 0.04761904) self.assertAlmostEqual(distribution[2], 0.1428571) self.assertAlmostEqual(distribution[3], 0.28571428) self.assertAlmostEqual(distribution[4], 0.2380952) self.assertAlmostEqual(distribution[5], 0.1428571) self.assertAlmostEqual(distribution[6], 0.09523809)
def test_unipolarized_unipolar(self): answer_counters = make_rating_answer_counters( self.question_likert, self.general_contribution, [5, 3, 1, 1, 0]) result = RatingResult(self.question_likert, answer_counters) distribution = unipolarized_distribution(result) self.assertAlmostEqual(distribution[0], 0.5) self.assertAlmostEqual(distribution[1], 0.3) self.assertAlmostEqual(distribution[2], 0.1) self.assertAlmostEqual(distribution[3], 0.1) self.assertAlmostEqual(distribution[4], 0.0)
def test_yes_no_question_result(self): degree = baker.make(Degree) evaluation = baker.make( Evaluation, _voter_count=6, _participant_count=10, course__degrees=[degree], state=Evaluation.State.PUBLISHED, ) questionnaire = baker.make(Questionnaire) question = baker.make(Question, type=Question.POSITIVE_YES_NO, questionnaire=questionnaire) make_rating_answer_counters(question, evaluation.general_contribution, [4, 2]) evaluation.general_contribution.questionnaires.set([questionnaire]) cache_results(evaluation) sheet = self.get_export_sheet(evaluation.course.semester, degree, [evaluation.course.type.id]) self.assertEqual(sheet.row_values(5)[0], question.text) self.assertEqual(sheet.row_values(5)[1], "67%")
def test_unipolarized_bipolar(self): answer_counters = make_rating_answer_counters( self.question_bipolar, self.general_contribution, [0, 1, 4, 8, 2, 2, 3]) result = RatingResult(self.question_bipolar, answer_counters) distribution = unipolarized_distribution(result) self.assertAlmostEqual(distribution[0], 0.4) self.assertAlmostEqual(distribution[1], 0.2) self.assertAlmostEqual(distribution[2], 0.15) self.assertAlmostEqual(distribution[3], 0.1) self.assertAlmostEqual(distribution[4], 0.15)
def test_heading_question_filtering(self): degree = baker.make(Degree) evaluation = baker.make( Evaluation, course__degrees=[degree], state=Evaluation.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 ) make_rating_answer_counters(likert_question, 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.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_unipolarized_yesno(self): question_yesno = baker.make(Question, questionnaire=self.questionnaire, type=Question.POSITIVE_YES_NO) answer_counters = make_rating_answer_counters( question_yesno, self.general_contribution, [57, 43]) result = RatingResult(question_yesno, answer_counters) distribution = unipolarized_distribution(result) self.assertAlmostEqual(distribution[0], 0.57) self.assertEqual(distribution[1], 0) self.assertEqual(distribution[2], 0) self.assertEqual(distribution[3], 0) self.assertAlmostEqual(distribution[4], 0.43)
def test_exclude_used_but_unanswered_questionnaires(self): degree = baker.make(Degree) evaluation = baker.make( Evaluation, _voter_count=10, _participant_count=10, state=Evaluation.State.PUBLISHED, course__degrees=[degree], ) used_questionnaire = baker.make(Questionnaire) used_question = baker.make(Question, type=Question.LIKERT, questionnaire=used_questionnaire) unused_questionnaire = baker.make(Questionnaire) unused_question = baker.make(Question, type=Question.LIKERT, questionnaire=unused_questionnaire) evaluation.general_contribution.questionnaires.set([used_questionnaire, unused_questionnaire]) make_rating_answer_counters(used_question, evaluation.general_contribution) cache_results(evaluation) sheet = self.get_export_sheet(evaluation.course.semester, degree, [evaluation.course.type.id]) self.assertEqual(sheet.row_values(4)[0], used_questionnaire.name) self.assertEqual(sheet.row_values(5)[0], used_question.text) self.assertNotIn(unused_questionnaire.name, sheet.col_values(0)) self.assertNotIn(unused_question.text, sheet.col_values(0))
def test_get_single_result_rating_result(self): single_result_evaluation = baker.make(Evaluation, state=Evaluation.State.PUBLISHED, is_single_result=True) questionnaire = Questionnaire.single_result_questionnaire() contribution = baker.make( Contribution, contributor=baker.make(UserProfile), evaluation=single_result_evaluation, questionnaires=[questionnaire], role=Contribution.Role.EDITOR, textanswer_visibility=Contribution.TextAnswerVisibility. GENERAL_TEXTANSWERS, ) make_rating_answer_counters(questionnaire.questions.first(), contribution, [1, 0, 0, 1, 0]) cache_results(single_result_evaluation) 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_no_empty_rating_answer_counters_left(self): counters = [] for question in chain(self.contributor_questions, self.general_questions): counts = [ 1 for choice in CHOICES[question.type].values if choice != NO_ANSWER ] counters.extend( make_rating_answer_counters(question, self.contribution, counts, False)) RatingAnswerCounter.objects.bulk_create(counters) old_count = RatingAnswerCounter.objects.count() management.call_command("anonymize", stdout=StringIO()) new_count = RatingAnswerCounter.objects.count() self.assertLess(new_count, old_count) for counter in RatingAnswerCounter.objects.all(): self.assertGreater(counter.count, 0)
def test_answer_count_unchanged(self): answers_per_question = defaultdict(int) counters = [] for question in chain(self.contributor_questions, self.general_questions): counts = [ random.randint(10, 100) for choice in CHOICES[question.type].values if choice != NO_ANSWER ] counters.extend( make_rating_answer_counters(question, self.contribution, counts, False)) answers_per_question[question] += sum(counts) RatingAnswerCounter.objects.bulk_create(counters) management.call_command("anonymize", stdout=StringIO()) for question in chain(self.contributor_questions, self.general_questions): answer_count = RatingAnswerCounter.objects.filter( question=question).aggregate(Sum("count"))["count__sum"] self.assertEqual(answers_per_question[question], answer_count)
def test_distribution_with_general_grade_question(self): counters = [ *make_rating_answer_counters(self.question_grade, self.contribution1, [1, 0, 1, 0, 0], False), *make_rating_answer_counters(self.question_grade, self.contribution2, [0, 1, 0, 1, 0], False), *make_rating_answer_counters(self.question_likert, self.contribution1, [0, 0, 3, 0, 3], False), *make_rating_answer_counters(self.question_likert, self.general_contribution, [0, 0, 0, 0, 5], False), *make_rating_answer_counters(self.question_likert_2, self.general_contribution, [0, 0, 3, 0, 0], False), *make_rating_answer_counters(self.question_grade, self.general_contribution, [0, 10, 0, 0, 0], False), ] RatingAnswerCounter.objects.bulk_create(counters) cache_results(self.evaluation) # contributions and general_non_grade are as above # general_grade: (0, 1, 0, 0, 0) # total: 0.3 * (0.15, 0.125, 0.375, 0.125, 0.225) + 0.2 * (0, 1, 0, 0, 0) + 0.5 * (0, 0, 0.375, 0, 0.625) = (0.045, 0.2375, 0.3, 0.0375, 0.38) distribution = calculate_average_distribution(self.evaluation) self.assertAlmostEqual(distribution[0], 0.045) self.assertAlmostEqual(distribution[1], 0.2375) self.assertAlmostEqual(distribution[2], 0.3) self.assertAlmostEqual(distribution[3], 0.0375) self.assertAlmostEqual(distribution[4], 0.38)
def test_contributor_result_export(self): degree = baker.make(Degree) contributor = baker.make(UserProfile) other_contributor = baker.make(UserProfile) evaluation_1 = baker.make( Evaluation, course=baker.make(Course, degrees=[degree], responsibles=[contributor]), state=Evaluation.State.PUBLISHED, _participant_count=10, _voter_count=1, ) evaluation_2 = baker.make( Evaluation, course=baker.make(Course, degrees=[degree], responsibles=[other_contributor]), state=Evaluation.State.PUBLISHED, _participant_count=2, _voter_count=2, ) contribution = baker.make(Contribution, evaluation=evaluation_2, contributor=contributor) other_contribution = baker.make(Contribution, evaluation=evaluation_2, contributor=other_contributor) general_questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.TOP) contributor_questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.CONTRIBUTOR) general_question = baker.make(Question, type=Question.LIKERT, questionnaire=general_questionnaire) contributor_question = baker.make(Question, type=Question.LIKERT, questionnaire=contributor_questionnaire) evaluation_1.general_contribution.questionnaires.set([general_questionnaire]) make_rating_answer_counters(general_question, evaluation_1.general_contribution, [2, 0, 0, 0, 0]) evaluation_2.general_contribution.questionnaires.set([general_questionnaire]) make_rating_answer_counters(general_question, evaluation_2.general_contribution, [0, 0, 0, 2, 0]) contribution.questionnaires.set([contributor_questionnaire]) make_rating_answer_counters(contributor_question, contribution, [0, 0, 2, 0, 0]) other_contribution.questionnaires.set([contributor_questionnaire]) make_rating_answer_counters(contributor_question, other_contribution, [0, 2, 0, 0, 0]) cache_results(evaluation_1) cache_results(evaluation_2) binary_content = export_contributor_results(contributor).content workbook = xlrd.open_workbook(file_contents=binary_content) self.assertEqual( workbook.sheets()[0].row_values(0)[1], f"{evaluation_1.full_name}\n{evaluation_1.course.semester.name}\n{contributor.full_name}", ) self.assertEqual( workbook.sheets()[0].row_values(0)[2], f"{evaluation_2.full_name}\n{evaluation_2.course.semester.name}\n{other_contributor.full_name}", ) self.assertEqual(workbook.sheets()[0].row_values(4)[0], general_questionnaire.name) self.assertEqual(workbook.sheets()[0].row_values(5)[0], general_question.text) self.assertEqual(workbook.sheets()[0].row_values(5)[2], 4.0) self.assertEqual( workbook.sheets()[0].row_values(7)[0], f"{contributor_questionnaire.name} ({contributor.full_name})", ) self.assertEqual(workbook.sheets()[0].row_values(8)[0], contributor_question.text) self.assertEqual(workbook.sheets()[0].row_values(8)[2], 3.0) self.assertEqual(workbook.sheets()[0].row_values(10)[0], "Overall Average Grade") self.assertEqual(workbook.sheets()[0].row_values(10)[2], 3.25)
def test_average_grade(self): question_grade2 = baker.make(Question, questionnaire=self.questionnaire, type=Question.GRADE) make_rating_answer_counters(self.question_grade, self.contribution1, [0, 1, 0, 0, 0]) make_rating_answer_counters(self.question_grade, self.contribution2, [0, 0, 0, 2, 0]) make_rating_answer_counters(question_grade2, self.contribution1, [1, 0, 0, 0, 0]) make_rating_answer_counters(self.question_likert, self.contribution1, [0, 0, 4, 0, 0]) make_rating_answer_counters(self.question_likert, self.general_contribution, [0, 0, 0, 0, 5]) make_rating_answer_counters(self.question_likert_2, self.general_contribution, [0, 0, 3, 0, 0]) make_rating_answer_counters(self.question_bipolar, self.general_contribution, [0, 0, 0, 0, 0, 0, 2]) make_rating_answer_counters(self.question_bipolar_2, self.general_contribution, [0, 0, 4, 0, 0, 0, 0]) cache_results(self.evaluation) 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 contributor2_average = 4 contributors_average = ( (4 * contributor1_average) + (2 * contributor2_average)) / (4 + 2) # 2.9333333 general_non_grade_average = ( (5 * 5) + (3 * 3) + (2 * 5) + (4 * 7 / 3)) / (5 + 3 + 2 + 4) # 3.80952380 contributors_percentage = settings.CONTRIBUTIONS_WEIGHT / ( settings.CONTRIBUTIONS_WEIGHT + settings.GENERAL_NON_GRADE_QUESTIONS_WEIGHT) # 0.375 general_non_grade_percentage = settings.GENERAL_NON_GRADE_QUESTIONS_WEIGHT / ( settings.CONTRIBUTIONS_WEIGHT + settings.GENERAL_NON_GRADE_QUESTIONS_WEIGHT) # 0.625 total_grade = (contributors_percentage * contributors_average + general_non_grade_percentage * general_non_grade_average ) # 1.1 + 2.38095238 = 3.48095238 average_grade = distribution_to_grade( calculate_average_distribution(self.evaluation)) self.assertAlmostEqual(average_grade, total_grade) self.assertAlmostEqual(average_grade, 3.48095238)