def setUp(self):
        """
        Regenerate a course with cohort configuration, partition and groups,
        and a student for each test.
        """
        super(TestGetCohortedUserPartition, self).setUp()
        self.course_key = ToyCourseFactory.create().id
        self.course = modulestore().get_course(self.course_key)
        self.student = UserFactory.create()

        self.random_user_partition = UserPartition(
            1,
            'Random Partition',
            'Should not be returned',
            [Group(0, 'Group 0'), Group(1, 'Group 1')],
            scheme=RandomUserPartitionScheme
        )

        self.cohort_user_partition = UserPartition(
            0,
            'Cohort Partition 1',
            'Should be returned',
            [Group(10, 'Group 10'), Group(20, 'Group 20')],
            scheme=CohortPartitionScheme
        )

        self.second_cohort_user_partition = UserPartition(
            2,
            'Cohort Partition 2',
            'Should not be returned',
            [Group(10, 'Group 10'), Group(1, 'Group 1')],
            scheme=CohortPartitionScheme
        )

    def test_discussion_student_view_data(self):
        """
        Tests that course block api returns student_view_data for discussion module
        """
        course_key = ToyCourseFactory.create().id
        course_usage_key = self.store.make_course_usage_key(course_key)
        user = UserFactory.create()
        self.client.login(username=user.username, password='test')
        CourseEnrollmentFactory.create(user=user, course_id=course_key)
        discussion_id = "test_discussion_module_id"
        ItemFactory.create(
            parent_location=course_usage_key,
            category='discussion',
            discussion_id=discussion_id,
            discussion_category='Category discussion',
            discussion_target='Target Discussion',
        )

        url = reverse('blocks_in_block_tree', kwargs={'usage_key_string': unicode(course_usage_key)})
        query_params = {
            'depth': 'all',
            'username': user.username,
            'block_types_filter': 'discussion',
            'student_view_data': 'discussion'
        }
        response = self.client.get(url, query_params)
        self.assertEquals(response.status_code, 200)
        self.assertEquals(response.data['root'], unicode(course_usage_key))  # pylint: disable=no-member
        for block_key_string, block_data in response.data['blocks'].iteritems():  # pylint: disable=no-member
            block_key = deserialize_usage_key(block_key_string, course_key)
            self.assertEquals(block_data['id'], block_key_string)
            self.assertEquals(block_data['type'], block_key.block_type)
            self.assertEquals(block_data['display_name'], self.store.get_item(block_key).display_name or '')
            self.assertEqual(block_data['student_view_data'], {"topic_id": discussion_id})

    def test_parents(self, modulestore_type):
        with self.store.default_store(modulestore_type):

            # setting up our own local course tree here, since it needs to be
            # created with the correct modulestore type.

            if modulestore_type == 'xml':
                course_key = self.store.make_course_key('edX', 'toy', '2012_Fall')
            else:
                course_key = ToyCourseFactory.create(run='2012_Fall_copy').id
            course = self.store.get_course(course_key)

            self.assertIsNone(course.get_parent())

            def recurse(parent):
                """
                Descend the course tree and ensure the result of get_parent()
                is the expected one.
                """
                visited = []
                for child in parent.get_children():
                    self.assertEqual(parent.location, child.get_parent().location)
                    visited.append(child)
                    visited += recurse(child)
                return visited

            visited = recurse(course)
            self.assertEqual(len(visited), 28)

    def setUpClass(cls):
        super(TestBlockSerializerBase, cls).setUpClass()

        cls.course = ToyCourseFactory.create()

        # Hide the html block
        key = cls.course.id.make_usage_key('html', 'secret:toylab')
        cls.html_block = cls.store.get_item(key)
        cls.html_block.visible_to_staff_only = True
        cls.store.update_item(cls.html_block, ModuleStoreEnum.UserID.test)

    def create_course(**kwargs):
        """
        Create a course for use in test cases
        """

        return ToyCourseFactory.create(
            end=datetime(2015, 9, 19, 18, 0, 0),
            enrollment_start=datetime(2015, 6, 15, 0, 0, 0),
            enrollment_end=datetime(2015, 7, 15, 0, 0, 0),
            **kwargs
        )

    def setUpClass(cls):
        super(TestBlocksView, cls).setUpClass()

        # create a toy course
        cls.course_key = ToyCourseFactory.create().id
        cls.course_usage_key = cls.store.make_course_usage_key(cls.course_key)
        cls.non_orphaned_block_usage_keys = set(
            unicode(item.location)
            for item in cls.store.get_items(cls.course_key)
            # remove all orphaned items in the course, except for the root 'course' block
            if cls.store.get_parent_location(item.location) or item.category == 'course'
        )

 def setUp(self):
     super(TestOverrideDataTransformer, self).setUp()
     self.course_key = ToyCourseFactory.create().id
     self.course_usage_key = self.store.make_course_usage_key(self.course_key)
     self.block_structure = BlockStructureFactory.create_from_modulestore(self.course_usage_key, self.store)
     self.course = course = modulestore().get_course(self.course_key)
     section = course.get_children()[0]
     subsection = section.get_children()[0]
     self.block = self.store.create_child(
         self.learner.id, subsection.location, 'html', 'new_component'
     )
     CourseEnrollmentFactory.create(user=self.learner, course_id=self.course_key, is_active=True)

    def setup_course(cls):
        """
        Create a sample course
        """
        cls.course_key = ToyCourseFactory.create().id

        cls.non_orphaned_block_usage_keys = set(
            unicode(item.location)
            for item in cls.store.get_items(cls.course_key)
            # remove all orphaned items in the course, except for the root 'course' block
            if cls.store.get_parent_location(item.location) or item.category == 'course'
        )

    def setUp(self):
        """
        Regenerate a test course and cohorts for each test
        """
        super(TestCohortsAndPartitionGroups, self).setUp()

        self.test_course_key = ToyCourseFactory.create().id
        self.course = modulestore().get_course(self.test_course_key)

        self.first_cohort = CohortFactory(course_id=self.course.id, name="FirstCohort")
        self.second_cohort = CohortFactory(course_id=self.course.id, name="SecondCohort")

        self.partition_id = 1
        self.group1_id = 10
        self.group2_id = 20

    def setUp(self):
        """
        Regenerate a course with cohort configuration, partition and groups,
        and a student for each test.
        """
        super(TestCohortPartitionScheme, self).setUp()

        self.course_key = ToyCourseFactory.create().id
        self.course = modulestore().get_course(self.course_key)
        config_course_cohorts(self.course, is_cohorted=True)

        self.groups = [Group(10, "Group 10"), Group(20, "Group 20")]
        self.user_partition = UserPartition(
            0, "Test Partition", "for testing purposes", self.groups, scheme=CohortPartitionScheme
        )
        self.student = UserFactory.create()

    def setUpClass(cls):
        super(TestBlocksView, cls).setUpClass()

        # create a toy course
        cls.course = ToyCourseFactory.create(
            modulestore=cls.store,
            due=datetime(3013, 9, 18, 11, 30, 00),
        )
        cls.course_key = cls.course.id
        cls.course_usage_key = cls.store.make_course_usage_key(cls.course_key)

        cls.non_orphaned_block_usage_keys = set(
            six.text_type(item.location)
            for item in cls.store.get_items(cls.course_key)
            # remove all orphaned items in the course, except for the root 'course' block
            if cls.store.get_parent_location(item.location) or item.category == 'course'
        )

    def test_permissions_query_load(self):
        """
        Tests that the permissions queries are cached when rendering numerous discussion XBlocks.
        """
        user = UserFactory.create()
        course = ToyCourseFactory.create()
        course_key = course.id
        course_usage_key = self.store.make_course_usage_key(course_key)
        discussions = []

        for counter in range(5):
            discussion_id = "test_discussion_{}".format(counter)
            discussions.append(
                ItemFactory.create(
                    parent_location=course_usage_key,
                    category="discussion",
                    discussion_id=discussion_id,
                    discussion_category="Category discussion",
                    discussion_target="Target Discussion",
                )
            )

        # 3 queries are required to do first discussion xblock render:
        # * django_comment_client_role
        # * django_comment_client_permission
        # * lms_xblock_xblockasidesconfig
        num_queries = 3
        for discussion in discussions:
            discussion_xblock = get_module_for_descriptor_internal(
                user=user,
                descriptor=discussion,
                student_data=mock.Mock(name="student_data"),
                course_id=course.id,
                track_function=mock.Mock(name="track_function"),
                xqueue_callback_url_prefix=mock.Mock(name="xqueue_callback_url_prefix"),
                request_token="request_token",
            )
            with self.assertNumQueries(num_queries):
                fragment = discussion_xblock.render("student_view")

            # Permissions are cached, so no queries required for subsequent renders
            num_queries = 0

            html = fragment.content
            self.assertIn('data-user-create-comment="false"', html)
            self.assertIn('data-user-create-subcomment="false"', html)

 def setUpClass(cls):
     """
     Set up a user, course, and discussion XBlock for use by tests.
     """
     super(TestXBlockInCourse, cls).setUpClass()
     cls.user = UserFactory.create()
     cls.course = ToyCourseFactory.create()
     cls.course_key = cls.course.id
     cls.course_usage_key = cls.store.make_course_usage_key(cls.course_key)
     cls.discussion_id = "test_discussion_xblock_id"
     cls.discussion = ItemFactory.create(
         parent_location=cls.course_usage_key,
         category='discussion',
         discussion_id=cls.discussion_id,
         discussion_category='Category discussion',
         discussion_target='Target Discussion',
     )
     CourseEnrollmentFactory.create(user=cls.user, course_id=cls.course_key)

 def setUp(self):
     super(TestStudentViewTransformer, self).setUp()
     self.course_key = ToyCourseFactory.create().id
     self.course_usage_key = self.store.make_course_usage_key(self.course_key)
     self.block_structure = BlockStructureFactory.create_from_modulestore(self.course_usage_key, self.store)

 def setUp(self):
     super(TestMongoCoursesLoad, self).setUp()
     self.setup_user()
     self.toy_course_key = ToyCourseFactory.create().id

 def setUpClass(cls):
     super(TestCohortOauth, cls).setUpClass()
     cls.user = UserFactory(username=USERNAME, email=USER_MAIL, password=cls.password)
     cls.staff_user = UserFactory(is_staff=True, password=cls.password)
     cls.course_key = ToyCourseFactory.create().id
     cls.course_str = unicode(cls.course_key)

    def setUpClass(cls):
        super(TestBlockSerializerBase, cls).setUpClass()

        cls.course = ToyCourseFactory.create()