Example #1
0
class GradeTestTCSampleData(TestCase):
    def setUp(self):
        self.data = SampleTCData()
        self.data.create_sample_tc_data()
        build_grade_cache()

    def test_course_section_final_grades(self):
        student = self.data.tc_student1
        expected_data = [
            {"section": "bus2-section1",    "grade":3.85},
            {"section": "span-section1",    "grade":3.42},
            {"section": "wlit-section1",    "grade":3.36},
            {"section": "geom10-section1",  "grade":1.75},
            {"section": "phys10-section1",  "grade":3.33},
            {"section": "mchrist-section1", "grade":3.45},
            {"section": "whist-section1",   "grade":3.51}
        ]
        for expected_data in expected_data:
            section = CourseSection.objects.get(name=expected_data["section"])
            expected_grade = expected_data["grade"]
            actual_grade = section.calculate_final_grade(student)
            self.assertEqual(round(actual_grade, 2), expected_grade)

    def test_calculate_gpa_after_each_marking_period(self):
        end_dates = [datetime.date(2014,10,3),datetime.date(2014,11,14),datetime.date(2015,1,23)]
        expected_gpas = [3.31, 3.27, 3.24]
        student = self.data.tc_student1
        for i in range(3):
            gpa = student.calculate_gpa(date_report=end_dates[i])
            self.assertEqual(round(gpa, 2), expected_gpas[i])
Example #2
0
class TwinCitiesGradeCalculationTests(SisTestMixin, TestCase):
    def setUp(self):
        self.data = SampleTCData()
        self.data.create_sample_tc_data()
        self.data.create_sample_tc_benchmark_data()
        self.fetch_useful_data_and_bind_to_self()
        build_grade_cache()

    def fetch_useful_data_and_bind_to_self(self):
        self.student = self.data.tc_student3
        self.marking_period = MarkingPeriod.objects.get( name = "S1-TC" )
        self.course_section = CourseSection.objects.get( name = "bus2-section-TC-2014-2015")

    def get_benchmark_grade(self):
        """ get the benchmark grade for this particular student, 
        course_section and marking_period """
        grade, aggregate_id = gradebook_get_average_and_pk(
            student = self.student, 
            course_section = self.course_section, 
            marking_period = self.marking_period
            )
        return grade

    def force_benchmark_to_recalculate_grades(self):
        """ this wraps a function known to force a recalculation of 
        benchmark grades """
        benchmark_calculate_course_aggregate(
            student = self.student, 
            course_section = self.course_section, 
            marking_period = self.marking_period
            )

    def test_baseline_grade_calculation(self):
        """ assert benchmark is calculating correctly from the sample_data"""
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.70'))

    def test_grade_after_adding_new_category(self):
        """ create new Finals category and assert grades are as expected """
        self.data.create_new_category_and_adjust_all_category_weights()
        Mark.objects.create(
            item = Item.objects.get( name = "Final Exam 1" ),
            student = self.student,
            mark = 4.0
        )
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.75'))

    def test_adding_new_category_for_student_with_no_grade_in_the_new_category(self):
        # check the grade before adding a new category
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.70'))

        # add the new category and force a recalculation
        self.data.create_new_category_and_adjust_all_category_weights()
        self.force_benchmark_to_recalculate_grades()

        # check the new grade
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.74'))
 def handle(self, *args, **options):
     try:
         if Student.objects.first():
             raise CommandError('You cannot run this on a already populated database')
     except OperationalError: # New database
         import django
         if django.get_version()[:3] != '1.7':
             call_command('syncdb', all=True, interactive=False)
         else:
             call_command('migrate', interactive=False)
     self.data = SampleTCData()
     self.data.create_sample_tc_data()
     build_grade_cache()
     self.stdout.write('Success. Good Job!')
Example #4
0
class TwinCitiesGradeCalculationTests(SisTestMixin, TestCase):
    def setUp(self):
        self.data = SampleTCData()
        self.data.create_sample_tc_data()
        self.data.create_sample_tc_benchmark_data()
        self.fetch_useful_data_and_bind_to_self()
        build_grade_cache()

    def fetch_useful_data_and_bind_to_self(self):
        self.student = self.data.tc_student3
        self.marking_period = MarkingPeriod.objects.get(name="S1-TC")
        self.course_section = CourseSection.objects.get(
            name="bus2-section-TC-2014-2015")

    def get_benchmark_grade(self):
        """ get the benchmark grade for this particular student, 
        course_section and marking_period """
        grade, aggregate_id = gradebook_get_average_and_pk(
            student=self.student,
            course_section=self.course_section,
            marking_period=self.marking_period)
        return grade

    def force_benchmark_to_recalculate_grades(self):
        """ this wraps a function known to force a recalculation of 
        benchmark grades """
        benchmark_calculate_course_aggregate(
            student=self.student,
            course_section=self.course_section,
            marking_period=self.marking_period)

    def test_baseline_grade_calculation(self):
        """ assert benchmark is calculating correctly from the sample_data"""
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.70'))

    def test_grade_after_adding_new_category(self):
        """ create new Finals category and assert grades are as expected """
        self.data.create_new_category_and_adjust_all_category_weights()
        Mark.objects.create(item=Item.objects.get(name="Final Exam 1"),
                            student=self.student,
                            mark=4.0)
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.75'))

    def test_adding_new_category_for_student_with_no_grade_in_the_new_category(
            self):
        # check the grade before adding a new category
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.70'))

        # add the new category and force a recalculation
        self.data.create_new_category_and_adjust_all_category_weights()
        self.force_benchmark_to_recalculate_grades()

        # check the new grade
        grade = self.get_benchmark_grade()
        self.assertEqual(grade, Decimal('3.74'))
class Command(BaseCommand):
    help = 'Populate blank database with data for TC testing'

    def handle(self, *args, **options):
        try:
            if Student.objects.first():
                raise CommandError('You cannot run this on a already populated database')
        except OperationalError: # New database
            import django
            if django.get_version()[:3] != '1.7':
                call_command('syncdb', all=True, interactive=False)
            else:
                call_command('migrate', interactive=False)
        self.data = SampleTCData()
        self.data.create_sample_tc_data()
        build_grade_cache()
        self.stdout.write('Success. Good Job!')
 def setUp(self):
     self.data = SampleTCData()
     self.data.create_sample_tc_data()
     build_grade_cache()
class GradeTestTCSampleData(TestCase):
    def setUp(self):
        self.data = SampleTCData()
        self.data.create_sample_tc_data()
        build_grade_cache()

    def verify_accuracy_of_grade_in_section_hash(self, student, section_hash):
        section_name = section_hash["name"]
        expected_grade = section_hash["grade"]
        course_section = CourseSection.objects.get(name=section_name)
        actual_grade = round(course_section.calculate_final_grade(student), 2)
        self.assertEqual(actual_grade, expected_grade)

    def test_course_section_final_grades(self):
        student = self.data.tc_student1
        expected_data = [{
            "name": "bus2-section-TC-2014-2015",
            "grade": 3.85
        }, {
            "name": "span-section-TC-2014-2015",
            "grade": 3.42
        }, {
            "name": "wlit-section-TC-2014-2015",
            "grade": 3.36
        }, {
            "name": "geom10-section-TC-2014-2015",
            "grade": 1.75
        }, {
            "name": "phys10-section-TC-2014-2015",
            "grade": 3.33
        }, {
            "name": "mchrist-section-TC-2014-2015",
            "grade": 3.45
        }, {
            "name": "whist-section-TC-2014-2015",
            "grade": 3.51
        }]
        for section_hash in expected_data:
            self.verify_accuracy_of_grade_in_section_hash(
                student, section_hash)

    def test_student2_course_section_final_grades(self):
        student = self.data.tc_student2
        expected_data = [{
            "name": "bus2-section-TC-2014-2015",
            "grade": 3.17
        }, {
            "name": "span-section-TC-2014-2015",
            "grade": 3.33
        }, {
            "name": "wlit-section-TC-2014-2015",
            "grade": 3.17
        }, {
            "name": "geom10-section-TC-2014-2015",
            "grade": 3.17
        }, {
            "name": "phys10-section-TC-2014-2015",
            "grade": 3.50
        }, {
            "name": "mchrist-section-TC-2014-2015",
            "grade": 3.17
        }, {
            "name": "whist-section-TC-2014-2015",
            "grade": 3.33
        }, {
            "name": "bus3-section-TC-2015-2016",
            "grade": 3.17
        }, {
            "name": "span3-section-TC-2015-2016",
            "grade": 4.00
        }, {
            "name": "alg11-section-TC-2015-2016",
            "grade": 3.00
        }, {
            "name": "chem11-section-TC-2015-2016",
            "grade": 3.83
        }, {
            "name": "ushist-section-TC-2015-2016",
            "grade": 3.17
        }]
        for section_hash in expected_data:
            self.verify_accuracy_of_grade_in_section_hash(
                student, section_hash)

    def test_calculate_gpa_after_each_marking_period(self):
        end_dates = [
            datetime.date(2014, 10, 3),
            datetime.date(2014, 11, 14),
            datetime.date(2015, 1, 23)
        ]
        expected_gpas = [3.31, 3.27, 3.24]
        student = self.data.tc_student1
        for i in range(3):
            gpa = student.calculate_gpa(date_report=end_dates[i])
            self.assertEqual(round(gpa, 2), expected_gpas[i])

    def test_student_2_year_grades(self):
        student = self.data.tc_student2
        year_grade_1 = StudentYearGrade.objects.get(student=student,
                                                    year=self.data.year1)
        year_grade_2 = StudentYearGrade.objects.get(student=student,
                                                    year=self.data.year2)
        self.assertEqual(round(year_grade_1.grade, 2), 3.26)
        self.assertEqual(round(year_grade_2.grade, 2), 3.43)

    def test_student2_lifetime_gpa(self):
        student = self.data.tc_student2
        year1_credits = 7
        year2_credits = 5
        year1_gpa = 3.26
        year2_gpa = 3.43
        total_points = (year1_gpa * year1_credits) + (year2_gpa *
                                                      year2_credits)
        total_credits = year1_credits + year2_credits
        expected_gpa = total_points / total_credits
        actual_gpa = student.calculate_gpa()
        self.assertEqual(round(expected_gpa, 2), round(actual_gpa, 2))
 def setUp(self):
     self.data = SampleTCData()
     self.data.create_sample_tc_data()
     build_grade_cache()
class GradeTestTCSampleData(TestCase):
    def setUp(self):
        self.data = SampleTCData()
        self.data.create_sample_tc_data()
        build_grade_cache()

    def verify_accuracy_of_grade_in_section_hash(self,student,section_hash):
        section_name = section_hash["name"]
        expected_grade = section_hash["grade"]
        course_section = CourseSection.objects.get(name=section_name)
        actual_grade = round(course_section.calculate_final_grade(student), 2)
        self.assertEqual(actual_grade, expected_grade)

    def test_course_section_final_grades(self):
        student = self.data.tc_student1
        expected_data = [
            {"name": "bus2-section-TC-2014-2015",    "grade":3.85},
            {"name": "span-section-TC-2014-2015",    "grade":3.42},
            {"name": "wlit-section-TC-2014-2015",    "grade":3.36},
            {"name": "geom10-section-TC-2014-2015",  "grade":1.75},
            {"name": "phys10-section-TC-2014-2015",  "grade":3.33},
            {"name": "mchrist-section-TC-2014-2015", "grade":3.45},
            {"name": "whist-section-TC-2014-2015",   "grade":3.51}
        ]
        for section_hash in expected_data:
            self.verify_accuracy_of_grade_in_section_hash(student,section_hash)

    def test_student2_course_section_final_grades(self):
        student = self.data.tc_student2
        expected_data = [
            {"name": "bus2-section-TC-2014-2015",    "grade":3.17},
            {"name": "span-section-TC-2014-2015",    "grade":3.33},
            {"name": "wlit-section-TC-2014-2015",    "grade":3.17},
            {"name": "geom10-section-TC-2014-2015",  "grade":3.17},
            {"name": "phys10-section-TC-2014-2015",  "grade":3.50},
            {"name": "mchrist-section-TC-2014-2015", "grade":3.17},
            {"name": "whist-section-TC-2014-2015",   "grade":3.33},
            {"name": "bus3-section-TC-2015-2016",    "grade":3.17},
            {"name": "span3-section-TC-2015-2016",   "grade":4.00},
            {"name": "alg11-section-TC-2015-2016",   "grade":3.00},
            {"name": "chem11-section-TC-2015-2016",  "grade":3.83},
            {"name": "ushist-section-TC-2015-2016",  "grade":3.17}
        ]
        for section_hash in expected_data:
            self.verify_accuracy_of_grade_in_section_hash(student,section_hash)

    def test_calculate_gpa_after_each_marking_period(self):
        end_dates = [datetime.date(2014,10,3),datetime.date(2014,11,14),datetime.date(2015,1,23)]
        expected_gpas = [3.31, 3.27, 3.24]
        student = self.data.tc_student1
        for i in range(3):
            gpa = student.calculate_gpa(date_report=end_dates[i])
            self.assertEqual(round(gpa, 2), expected_gpas[i])

    def test_student_2_year_grades(self):
        student = self.data.tc_student2
        year_grade_1 = StudentYearGrade.objects.get(student = student, year = self.data.year1)
        year_grade_2 = StudentYearGrade.objects.get(student = student, year = self.data.year2)
        self.assertEqual(round(year_grade_1.grade,2), 3.26)
        self.assertEqual(round(year_grade_2.grade,2), 3.43)

    def test_student2_lifetime_gpa(self):
        student = self.data.tc_student2
        year1_credits = 7
        year2_credits = 5
        year1_gpa = 3.26
        year2_gpa = 3.43
        total_points = (year1_gpa * year1_credits) + (year2_gpa * year2_credits)
        total_credits = year1_credits + year2_credits
        expected_gpa = total_points / total_credits
        actual_gpa = student.calculate_gpa()
        self.assertEqual(round(expected_gpa, 2), round(actual_gpa, 2))
Example #10
0
 def setUp(self):
     self.data = SampleTCData()
     self.data.create_sample_tc_data()
     self.data.create_sample_tc_benchmark_data()
     self.fetch_useful_data_and_bind_to_self()
     build_grade_cache()
Example #11
0
 def setUp(self):
     self.data = SampleTCData()
     self.data.create_sample_tc_data()
     self.data.create_sample_tc_benchmark_data()
     self.fetch_useful_data_and_bind_to_self()
     build_grade_cache()