Esempio n. 1
0
    def test_get_active_students(self):
        counts, actives, users = ProgressReport.get_active_students(self.course.id)
        self.assertEquals(counts, 7)
        self.assertEquals(actives, 6)
        self.assertItemsEqual(users, self.students[:4] + self.students[5:])

        fake_course = CourseFactory.create(display_name="fake")
        with self.assertRaises(UserDoesNotExists):
            counts, actives, users = ProgressReport.get_active_students(fake_course.id)
Esempio n. 2
0
    def setUp(self):
        self.output = StringIO.StringIO()
        self.gzipfile = StringIO.StringIO()
        self.course = CourseFactory.create(
            display_name=self.COURSE_NAME,
        )
        self.course.raw_grader = [{
            'drop_count': 0,
            'min_count': 1,
            'short_label': 'Final',
            'type': 'Final Exam',
            'weight': 1.0
        }]
        self.course.grade_cutoffs = {'Pass': 0.1}
        self.students = [
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            StaffFactory.create(username='******', course_key=self.course.id),
            InstructorFactory.create(username='******', course_key=self.course.id),
        ]
        UserStandingFactory.create(
            user=self.students[4],
            account_status=UserStanding.ACCOUNT_DISABLED,
            changed_by=self.students[6]
        )

        for user in self.students:
            CourseEnrollmentFactory.create(user=user, course_id=self.course.id)

        self.pgreport = ProgressReport(self.course.id)
        self.pgreport2 = ProgressReport(self.course.id, lambda state: state)

        self.chapter = ItemFactory.create(
            parent_location=self.course.location,
            category="chapter",
            display_name="Week 1"
        )
        self.chapter.save()
        self.section = ItemFactory.create(
            parent_location=self.chapter.location,
            category="sequential",
            display_name="Lesson 1"
        )
        self.section.save()
        self.vertical = ItemFactory.create(
            parent_location=self.section.location,
            category="vertical",
            display_name="Unit1"
        )
        self.vertical.save()
        self.html = ItemFactory.create(
            parent_location=self.vertical.location,
            category="html",
            data={'data': "<html>foobar</html>"}
        )
        self.html.save()
        """
        course.children = [week1.location.url(), week2.location.url(),
                           week3.location.url()]
        """
        from capa.tests.response_xml_factory import OptionResponseXMLFactory
        self.problem_xml = OptionResponseXMLFactory().build_xml(
            question_text='The correct answer is Correct',
            num_inputs=2,
            weight=2,
            options=['Correct', 'Incorrect'],
            correct_option='Correct'
        )

        self.problems = []
        for num in xrange(1, 3):
            self.problems.append(ItemFactory.create(
                parent_location=self.vertical.location,
                category='problem',
                display_name='problem_' + str(num),
                metadata={'graded': True, 'format': 'Final Exam'},
                data=self.problem_xml
            ))
            self.problems[num - 1].save()

        for problem in self.problems:
            problem.correct_map = {
                unicode(problem.location) + "_2_1": {
                    "hint": "",
                    "hintmode": "",
                    "correctness": "correct",
                    "npoints": "",
                    "msg": "",
                    "queuestate": ""
                },
                unicode(problem.location) + "_2_2": {
                    "hint": "",
                    "hintmode": "",
                    "correctness": "incorrect",
                    "npoints": "",
                    "msg": "",
                    "queuestate": ""
                }
            }

            problem.student_answers = {
                unicode(problem.location) + "_2_1": "Correct",
                unicode(problem.location) + "_2_2": "Incorrect"
            }

            problem.input_state = {
                unicode(problem.location) + "_2_1": {},
                unicode(problem.location) + "_2_2": {}
            }

        self.course.save()

        patcher = patch('pgreport.views.logging')
        self.log_mock = patcher.start()
        self.addCleanup(patcher.stop)

        """
Esempio n. 3
0
class ProgressReportTestCase(ModuleStoreTestCase):
    """ Test Progress Report """
    COURSE_NAME = "test_pgreport"
    COURSE_NUM = 3

    def setUp(self):
        self.output = StringIO.StringIO()
        self.gzipfile = StringIO.StringIO()
        self.course = CourseFactory.create(
            display_name=self.COURSE_NAME,
        )
        self.course.raw_grader = [{
            'drop_count': 0,
            'min_count': 1,
            'short_label': 'Final',
            'type': 'Final Exam',
            'weight': 1.0
        }]
        self.course.grade_cutoffs = {'Pass': 0.1}
        self.students = [
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            UserFactory.create(username='******'),
            StaffFactory.create(username='******', course_key=self.course.id),
            InstructorFactory.create(username='******', course_key=self.course.id),
        ]
        UserStandingFactory.create(
            user=self.students[4],
            account_status=UserStanding.ACCOUNT_DISABLED,
            changed_by=self.students[6]
        )

        for user in self.students:
            CourseEnrollmentFactory.create(user=user, course_id=self.course.id)

        self.pgreport = ProgressReport(self.course.id)
        self.pgreport2 = ProgressReport(self.course.id, lambda state: state)

        self.chapter = ItemFactory.create(
            parent_location=self.course.location,
            category="chapter",
            display_name="Week 1"
        )
        self.chapter.save()
        self.section = ItemFactory.create(
            parent_location=self.chapter.location,
            category="sequential",
            display_name="Lesson 1"
        )
        self.section.save()
        self.vertical = ItemFactory.create(
            parent_location=self.section.location,
            category="vertical",
            display_name="Unit1"
        )
        self.vertical.save()
        self.html = ItemFactory.create(
            parent_location=self.vertical.location,
            category="html",
            data={'data': "<html>foobar</html>"}
        )
        self.html.save()
        """
        course.children = [week1.location.url(), week2.location.url(),
                           week3.location.url()]
        """
        from capa.tests.response_xml_factory import OptionResponseXMLFactory
        self.problem_xml = OptionResponseXMLFactory().build_xml(
            question_text='The correct answer is Correct',
            num_inputs=2,
            weight=2,
            options=['Correct', 'Incorrect'],
            correct_option='Correct'
        )

        self.problems = []
        for num in xrange(1, 3):
            self.problems.append(ItemFactory.create(
                parent_location=self.vertical.location,
                category='problem',
                display_name='problem_' + str(num),
                metadata={'graded': True, 'format': 'Final Exam'},
                data=self.problem_xml
            ))
            self.problems[num - 1].save()

        for problem in self.problems:
            problem.correct_map = {
                unicode(problem.location) + "_2_1": {
                    "hint": "",
                    "hintmode": "",
                    "correctness": "correct",
                    "npoints": "",
                    "msg": "",
                    "queuestate": ""
                },
                unicode(problem.location) + "_2_2": {
                    "hint": "",
                    "hintmode": "",
                    "correctness": "incorrect",
                    "npoints": "",
                    "msg": "",
                    "queuestate": ""
                }
            }

            problem.student_answers = {
                unicode(problem.location) + "_2_1": "Correct",
                unicode(problem.location) + "_2_2": "Incorrect"
            }

            problem.input_state = {
                unicode(problem.location) + "_2_1": {},
                unicode(problem.location) + "_2_2": {}
            }

        self.course.save()

        patcher = patch('pgreport.views.logging')
        self.log_mock = patcher.start()
        self.addCleanup(patcher.stop)

        """
        from xmodule.modulestore import Location
        import json
        for user in self.students:
            StudentModuleFactory.create(
                grade=1,
                max_grade=1,
                student=user,
                course_id=self.course.id,
                #module_state_key=Location(self.problem).url(),
                module_state_key=self.problem.location.url(),
                #state = json.dumps({'attempts': self.attempts, 'done':True})
                state = json.dumps({'done':True})
            )

        ./lms/djangoapps/courseware/management/commands/tests/test_dump_course.py
        def load_courses(self):
        cp xmport-course common/test/data and modify TEST_DATA_MIXED_MODULESTORE
        """

    def tearDown(self):
        self.output.close()
        self.gzipfile.close()

    def test_get_active_students(self):
        counts, actives, users = ProgressReport.get_active_students(self.course.id)
        self.assertEquals(counts, 7)
        self.assertEquals(actives, 6)
        self.assertItemsEqual(users, self.students[:4] + self.students[5:])

        fake_course = CourseFactory.create(display_name="fake")
        with self.assertRaises(UserDoesNotExists):
            counts, actives, users = ProgressReport.get_active_students(fake_course.id)

    def test_create_request(self):
        from django.core.handlers.wsgi import WSGIRequest
        request = self.pgreport._create_request()
        self.assertIsInstance(request, WSGIRequest)

    def test_calc_statistics(self):
        self.pgreport.module_statistics = {
            self.problems[0].location: [1.0, 5.6, 3.4, 9.8, 20.2],
            self.problems[1].location: [5.0, 10.6, 8.4, 2.8, 134.8]}
        calc_statistics = self.pgreport._calc_statistics()
        self.assertEquals(calc_statistics[self.problems[0].location]["mean"], 8.0)
        self.assertEquals(calc_statistics[self.problems[0].location]["median"], 5.6)
        self.assertEquals(calc_statistics[self.problems[0].location]["variance"], 45.6)
        self.assertEquals(
            calc_statistics[self.problems[0].location]["standard_deviation"], 6.753)

        self.assertEquals(calc_statistics[self.problems[1].location]["mean"], 32.32)
        self.assertEquals(calc_statistics[self.problems[1].location]["median"], 8.4)
        self.assertEquals(calc_statistics[self.problems[1].location]["variance"], 2632.778)
        self.assertEquals(
            calc_statistics[self.problems[1].location]["standard_deviation"], 51.311)

    def test_get_correctmap(self):
        corrects = self.pgreport._get_correctmap(self.problems[0])
        self.assertEquals(
            corrects, {
                unicode(self.problems[0].location) + "_2_1": 1,
                unicode(self.problems[0].location) + "_2_2": 0
            }
        )

    def test_get_student_answers(self):
        answers1 = self.pgreport._get_student_answers(self.problems[0])
        self.problems[1].student_answers = {
            unicode(self.problems[1].location) + "_2_1": ["answer1", "answer2", 5]
        }
        answers2 = self.pgreport._get_student_answers(self.problems[1])

        self.assertEquals(
            answers1, {
                unicode(self.problems[0].location) + "_2_1": {"Correct": 1},
                unicode(self.problems[0].location) + "_2_2": {"Incorrect": 1}
            }
        )
        self.assertEquals(answers2, {
            unicode(self.problems[1].location) + "_2_1": ANY})
        self.assertEquals(
            answers2[unicode(self.problems[1].location) + "_2_1"],
            {"answer1": 1, 5: 1, "answer2": 1}
        )

    def test_get_module_data(self):
        module_mock = MagicMock()
        module_data = self.pgreport._get_module_data(module_mock)
        self.assertEquals(module_data, {
            'start': module_mock.start,
            'display_name': module_mock.display_name,
            'student_answers': {},
            'weight': module_mock.weight,
            'correct_map': {},
            'type': module_mock.category,
            'due': module_mock.due,
            'score/total': module_mock.get_progress()
        })

    def test_increment_student_answers(self):
        name = unicode(self.problems[0].location)
        unit_id1 = name + "_2_1"
        unit_id2 = name + "_2_2"
        unit_id3 = name + "_2_3"
        answer = {"Correct": 1}
        self.pgreport.module_summary[name] = {
            "student_answers": {
                unit_id1: {"Correct": 1}, unit_id2: {"Incorrect": 1}},
        }

        self.pgreport._increment_student_answers(name, answer, unit_id1)
        self.pgreport._increment_student_answers(name, answer, unit_id2)
        self.pgreport._increment_student_answers(name, answer, unit_id3)
        self.assertEquals(self.pgreport.module_summary[name]["student_answers"], {
            unit_id1: {"Correct": 2},
            unit_id2: {"Correct": 1, "Incorrect": 1},
            unit_id3: {"Correct": 1}})

    def test_increment_student_correctmap(self):
        name = unicode(self.problems[0].location)
        unit_id1 = name + "_2_1"
        unit_id2 = name + "_2_2"
        unit_id3 = name + "_2_3"
        self.pgreport.module_summary[name] = {
            "correct_map": {unit_id1: 1, unit_id2: 2},
        }
        self.pgreport._increment_student_correctmap(name, 1, unit_id1)
        self.pgreport._increment_student_correctmap(name, 1, unit_id2)
        self.pgreport._increment_student_correctmap(name, 1, unit_id3)
        self.assertEquals(self.pgreport.module_summary[name]["correct_map"], {
            unit_id1: 2, unit_id2: 3, unit_id3: 1})

    @unittest.skip("This test is not yet modified.")
    def test_collect_module_summary(self):
        module_mock = MagicMock()
        progress_mock = MagicMock()
        progress_mock.frac.return_value = (2.0, 3.0)
        module_mock.get_progress.return_value = progress_mock
        module_mock.location = self.problems[0].location

        self.pgreport.collect_module_summary(module_mock)
        self.assertEquals(self.pgreport.module_summary[module_mock.location], {
            'count': 1,
            'display_name': module_mock.display_name,
            'weight': module_mock.weight,
            'type': module_mock.category,
            'total_score': 3.0,
            'due': module_mock.due,
            'score/total': progress_mock,
            'submit_count': 1,
            'start': module_mock.start,
            'student_answers': {},
            'max_score': 2.0,
            'correct_map': {}
        })

        module_mock.is_submitted.return_value = False
        module_data = {
            "student_answers": {
                unicode(module_mock.location) + "_2_1": {"Correct": 1},
                unicode(module_mock.location) + "_2_2": [{"answer1": 1}, {"answer2": 2}]},
            "correct_map": {
                unicode(module_mock.location) + "_2_1": 1,
                unicode(module_mock.location) + "_2_2": 2}
        }

        with patch(
            'pgreport.views.ProgressReport._get_module_data',
            return_value=module_data
        ) as pgmock:
            self.pgreport.collect_module_summary(module_mock)

        self.assertEquals(
            self.pgreport.module_summary[module_mock.location], {
                'count': 2,
                'display_name': module_mock.display_name,
                'weight': module_mock.weight,
                'type': module_mock.category,
                'total_score': 6.0,
                'due': module_mock.due,
                'score/total': progress_mock,
                'submit_count': 1,
                'start': module_mock.start,
                'student_answers': {
                    unicode(module_mock.location) + '_2_1': {'Correct': 1},
                    unicode(module_mock.location) + '_2_2': {'answer1': 1, 'answer2': 2}
                },
                'max_score': 4.0,
                'correct_map': module_data["correct_map"]
            }
        )

    def test_yield_student_summary(self):
        module_mock = MagicMock()
        module_mock.location = self.problems[0].location

        csvheader = [
            'username', 'location', 'last_login', 'grade', 'percent',
            'start', 'display_name', 'student_answers', 'weight', 'correct_map',
            'type', 'due', 'score/total'
        ]
        rows = []
        mg = MagicMock()
        location_list = {
            u'chapter': [self.chapter.location],
            u'problem': [self.problems[0].location],
            u'sequential': [self.section.location],
            u'vertical': [self.vertical.location]
        }

        grade_mock = MagicMock(return_value={'grade': True, 'percent': 1.0})
        with nested(
            patch('pgreport.views.grades'),
            patch('pgreport.views.get_module_for_student',
                side_effect=[module_mock, module_mock]),
        ) as (grmock, gemock):
            grmock.grade = grade_mock
            #self.pgreport.update_state = lambda state: state
            self.pgreport.students = User.objects.filter(id__in=[1, 2])
            self.pgreport.location_list = location_list
            for row in self.pgreport.yield_students_progress():
                rows.append(row)

        def create_csvrow(csvrows):
            for i in [0, 1]:
                csvrows.append([
                    unicode(self.students[i].username), self.problems[0].location,
                    self.students[i].last_login.strftime("%Y/%m/%d %H:%M:%S %Z"),
                    True, 1.0, module_mock.start, module_mock.display_name,
                    {}, module_mock.weight, {}, module_mock.category,
                    module_mock.due, module_mock.get_progress(),
                ])
            return csvrows

        grmock.grade.assert_called_with(ANY, ANY, ANY)
        gemock.assert_called_with(ANY, ANY)
        self.assertEquals(rows, create_csvrow([csvheader]))

    """
    def test_yield_student_summary_with_update_state(self):
        module_mock = MagicMock()
        module_mock.location = self.problems[0].location

        csvheader = [
            'username', 'location', 'last_login', 'grade', 'percent',
            'start', 'display_name', 'student_answers', 'weight', 'correct_map',
            'type', 'due', 'score/total'
        ]
        rows = []
        mg = MagicMock()
        location_list = {
            u'chapter': [self.chapter.location],
            u'problem': [self.problems[0].location],
            u'sequential': [self.section.location],
            u'vertical': [self.vertical.location]
        }

        grade_mock = MagicMock(return_value={'grade': True, 'percent': 1.0})
        with nested(
            patch('pgreport.views.grades'),
            patch(
                'pgreport.views.get_module_for_student',
                side_effect=[module_mock, module_mock]
            ),
        ) as (grmock, gemock):
            grmock.grade = grade_mock
            self.pgreport.update_state = lambda state: state
            self.pgreport.students = User.objects.filter(id__in=[1, 2])
            self.pgreport.location_list = location_list
            for row in self.pgreport.yield_students_progress():
                rows.append(row)

        def create_csvrow(csvrows):
            for i in [0, 1]:
                csvrows.append([
                    unicode(self.students[i].username), self.problems[0].location,
                    self.students[i].last_login.strftime("%Y/%m/%d %H:%M:%S %Z"),
                    True, 1.0, module_mock.start, module_mock.display_name,
                    {}, module_mock.weight, {}, module_mock.category,
                    module_mock.due, module_mock.get_progress(),
                ])
            return csvrows

        grmock.grade.assert_called_with(ANY, ANY, ANY)
        gemock.assert_called_with(ANY, ANY, ANY)
        self.assertEquals(rows, create_csvrow([csvheader]))
    """

    def test_get_children_rec(self):
        course_mock = MagicMock()
        course_mock.location = self.course.location
        chapter_mock = MagicMock()
        chapter_mock.has_children = True
        chapter_mock.category = self.chapter.category
        chapter_mock.location = self.chapter.location
        chapter_mock.display_name = self.chapter.display_name
        sequential_mock = MagicMock()
        sequential_mock.has_children = True
        sequential_mock.category = self.section.category
        sequential_mock.location = self.section.location
        sequential_mock.display_name = self.section.display_name
        vertical_mock = MagicMock()
        vertical_mock.has_children = True
        vertical_mock.category = self.vertical.category
        vertical_mock.location = self.vertical.location
        vertical_mock.display_name = self.vertical.display_name

        chapter_mock.get_children.return_value = [sequential_mock]
        sequential_mock.get_children.return_value = [vertical_mock]
        vertical_mock.get_children.return_value = self.problems
        course_mock.get_children.return_value = [chapter_mock]

        self.pgreport._get_children_rec(course_mock)

        self.assertEquals(self.pgreport.location_list, {
            u'chapter': [self.chapter.location],
            u'problem': [self.problems[0].location, self.problems[1].location],
            u'sequential': [self.section.location],
            u'vertical': [self.vertical.location]
        })

        self.assertEquals(self.pgreport.location_parent, [
            {
                self.problems[0].location: [
                    self.chapter.display_name,
                    self.section.display_name,
                    self.vertical.display_name
                ]
            },
            {
                self.problems[1].location: [
                    self.chapter.display_name,
                    self.section.display_name,
                    self.vertical.display_name
                ]
            },
        ])

    @patch('sys.stdout', new_callable=StringIO.StringIO)
    @patch('pgreport.views.cache')
    @patch('pgreport.views.ProgressReport.collect_module_summary')
    def test_get_raw(self, cmmock, camock, symock):
        with self.assertRaises(InvalidCommand):
            self.pgreport.get_raw(command="fake")

        summary = self.pgreport2.get_raw(command="summary")
        self.assertEquals(summary, {
            'enrollments': 7, 'active_students': 6, 'module_tree': []})

        location_list = {
            u'chapter': [self.chapter.location],
            u'problem': [self.problems[0].location, self.problems[1].location],
            u'sequential': [self.section.location],
            u'vertical': [self.vertical.location]
        }
        module_summary = {'module_summary': {'dummy': 'dummy'}}

        mg = MagicMock()
        with nested(
            patch('pgreport.views.grades', return_value={'grade': True, 'percent': 1.0}),
            patch('pgreport.views.get_module_for_student', side_effect=[
                None, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg]),
        ) as (grmock, gemock):
            self.pgreport.location_list = location_list
            self.pgreport.module_summary = module_summary
            modules = self.pgreport.get_raw(command="modules")

        with nested(
            patch('pgreport.views.grades', return_value={'grade': True, 'percent': 1.0}),
            patch('pgreport.views.get_module_for_student', side_effect=[
                None, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg, mg]),
        ) as (grmock, gemock):
            self.pgreport.location_list = location_list
            self.pgreport.module_summary = module_summary
            summary, modules = self.pgreport.get_raw()

        grmock.grade.assert_called_with(self.students[6], ANY, ANY)
        gemock.assert_any_called_with(self.students[6], self.course, self.problems[0].location)

    @unittest.skip("This test is not yet modified.")
    def test_get_pgreport_csv(self):
        gzipdata = gzip.GzipFile(fileobj=self.gzipfile, mode='wb')
        gzipdata.write("row1\nrow2\nrow3\n")
        gzipdata.close()

        scontent_mock = MagicMock()
        cstore_mock = MagicMock()
        content_mock = MagicMock()
        content_mock.stream_data.return_value = self.gzipfile.getvalue()
        cstore_mock.find.return_value = content_mock

        with nested(
            patch('pgreport.views.StaticContent', return_value=scontent_mock),
            patch('pgreport.views.contentstore', return_value=cstore_mock),
            patch('sys.stdout', new_callable=StringIO.StringIO)
        ) as (smock, cmock, stdmock):

            get_pgreport_csv(self.course.id)

        smock.compute_location.assert_called_once_with(ANY, "progress_students.csv.gz")
        cmock.assert_called_once_with()
        cmock.return_value.find.assert_called_once_with(ANY, throw_on_not_found=True, as_stream=True)
        content_mock.stream_data.assert_called_once_with()
        self.assertEquals(stdmock.getvalue(), 'row1\nrow2\nrow3\n')

        cstore_mock.find.side_effect = NotFoundError()
        with patch('pgreport.views.contentstore', return_value=cstore_mock):
            with self.assertRaises(NotFoundError):
                get_pgreport_csv(self.course.id)

    @unittest.skip("This test is not yet modified.")
    def test_create_pgreport_csv(self):
        rows = [
            ["username", "loc", "last_login"],
            [self.students[0].username, unicode(self.problems[0].location), "2014/1/1"],
            [self.students[1].username, unicode(self.problems[1].location), "2014/1/1"],
        ]

        progress_mock = MagicMock()
        progress_mock.get_raw.return_value = rows
        scontent_mock = MagicMock()
        cstore_mock = MagicMock()
        cstore_mock.fs.new_file().__exit__.return_value = False

        with nested(
            patch('pgreport.views.StaticContent', return_value=scontent_mock),
            patch('pgreport.views.contentstore', return_value=cstore_mock),
            patch('pgreport.views.ProgressReport', return_value=progress_mock),
        ) as (smock, cmock, pmock):
            create_pgreport_csv(self.course.id)

        smock.compute_location.assert_called_once_with(ANY, "progress_students.csv.gz")
        cmock.assert_called_once_with()
        cmock.return_value.find.assert_called_once_with(ANY)
        cmock.return_value.find.return_value.get_id.assert_called_once_with()

        progress_mock.get_raw.return_value = rows
        cstore_mock.fs.new_file().__enter__().write.side_effect = GridFSError()
        with nested(
            patch('pgreport.views.StaticContent', return_value=scontent_mock),
            patch('pgreport.views.contentstore', return_value=cstore_mock),
            patch('pgreport.views.ProgressReport', return_value=progress_mock),
        ) as (smock, cmock, pmock):
            with self.assertRaises(GridFSError):
                create_pgreport_csv(self.course.id)

    def test_delete_pgreport_csv(self):
        cstore_mock = MagicMock()
        content_mock = MagicMock()

        with nested(
            patch('pgreport.views.StaticContent', return_value=content_mock),
            patch('pgreport.views.contentstore', return_value=cstore_mock),
        ) as (scmock, csmock):
            delete_pgreport_csv(self.course.id)

        scmock.compute_location.assert_called_once_with(ANY, "progress_students.csv.gz")
        csmock.assert_called_once_with()
        csmock.return_value.find.assert_called_once_with(ANY)
        csmock.return_value.delete.assert_called_once_with(ANY)

    def test_get_pgreport_table(self):
        module_summary = {
            'location': unicode(self.problems[0].location),
            'count': 1,
            'display_name': "display_name",
            'weight': "weight",
            'type': "category",
            'total_score': 3.0,
            'due': "due",
            'score/total': "score-total",
            'submit_count': 1,
            'start': "start",
            'student_answers': {},
            'max_score': 2.0,
            'correct_map': {}
        }
        filter_mock = MagicMock()
        pgmodule_mock = MagicMock()
        filter_mock.values.return_value = [module_summary]
        pgmodule_mock.objects.filter.return_value = filter_mock

        with patch('pgreport.views.ProgressModules', pgmodule_mock):
            summary, modules = get_pgreport_table(self.course.id)

        filter_mock.values.assert_called_once_with()
        pgmodule_mock.objects.filter.assert_called_with(course_id=self.course.id)

        self.assertEquals(summary, {
            'enrollments': 7, 'active_students': 6,
            'module_tree': [
                {self.html.location: [u'Week 1', u'Lesson 1', u'Unit1']},
                {self.problems[0].location: [u'Week 1', u'Lesson 1', u'Unit1']},
                {self.problems[1].location: [u'Week 1', u'Lesson 1', u'Unit1']}
            ]
        })
        self.assertEquals(modules, {unicode(self.problems[0].location): module_summary})

    @unittest.skip("This test is not yet modified.")
    def test_update_pgreport_table(self):
        with patch('pgreport.views.ProgressModules') as pmock:
            update_pgreport_table(self.course.id)

        pmock.assert_any_call(
            count=6, display_name=self.problems[0].display_name,
            weight=None, standard_deviation=0.0, correct_map={}, median=0.0, due=None,
            submit_count=0, start=datetime.datetime(2030, 1, 1, 0, 0, tzinfo=UTC),
            location=self.problems[0].location, course_id=self.course.id, variance=0.0,
            student_answers={}, max_score=0.0, total_score=12.0, mean=0.0
        )

        with patch('pgreport.views.ProgressModules', side_effect=DatabaseError()):
            with self.assertRaises(DatabaseError):
                update_pgreport_table(self.course.id)