def setUpClass(cls):
super().setUpClass()
cls.store = modulestore()
cls.course = ToyCourseFactory.create(
end=datetime(2028, 1, 1, 1, 1, 1),
enrollment_start=datetime(2020, 1, 1, 1, 1, 1),
enrollment_end=datetime(2028, 1, 1, 1, 1, 1),
emit_signals=True,
modulestore=cls.store,
certificate_available_date=_NEXT_WEEK,
certificates_display_behavior=CertificatesDisplayBehaviors.
END_WITH_DATE)
cls.chapter = ItemFactory(parent=cls.course, category='chapter')
cls.sequence = ItemFactory(parent=cls.chapter,
category='sequential',
display_name='sequence')
cls.unit = ItemFactory.create(parent=cls.sequence,
category='vertical',
display_name="Vertical")
cls.user = UserFactory(username='******',
email='*****@*****.**',
password='******',
is_staff=False)
cls.instructor = UserFactory(username='******',
email='*****@*****.**',
password='******',
is_staff=False)
CourseInstructorRole(cls.course.id).add_users(cls.instructor)
cls.url = f'/api/courseware/course/{cls.course.id}'
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 setUp(self):
super(TestStudentViewTransformer, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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):
"""
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 setUpClass(cls):
super().setUpClass()
cls.store = modulestore()
cls.course = ToyCourseFactory.create(
end=datetime(2028, 1, 1, 1, 1, 1),
enrollment_start=datetime(2020, 1, 1, 1, 1, 1),
enrollment_end=datetime(2028, 1, 1, 1, 1, 1),
emit_signals=True,
modulestore=cls.store,
)
cls.chapter = ItemFactory(parent=cls.course, category='chapter')
cls.sequence = ItemFactory(parent=cls.chapter,
category='sequential',
display_name='sequence')
cls.unit = ItemFactory.create(parent=cls.sequence,
category='vertical',
display_name="Vertical")
cls.user = UserFactory(username='******',
email=u'*****@*****.**',
password='******',
is_staff=False)
cls.instructor = UserFactory(username='******',
email=u'*****@*****.**',
password='******',
is_staff=False)
CourseInstructorRole(cls.course.id).add_users(cls.instructor)
cls.url = '/api/courseware/course/{}'.format(cls.course.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 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='******')
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.
course_key = ToyCourseFactory.create().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 test_rerun(self, pacing_type, expected_self_paced_value):
course_run = ToyCourseFactory()
start = datetime.datetime.now(pytz.UTC).replace(microsecond=0)
end = start + datetime.timedelta(days=30)
user = UserFactory()
role = 'instructor'
run = '3T2017'
url = reverse('api:v1:course_run-rerun', kwargs={'pk': str(course_run.id)})
data = {
'run': run,
'schedule': {
'start': serialize_datetime(start),
'end': serialize_datetime(end),
},
'team': [
{
'user': user.username,
'role': role,
}
],
'pacing_type': pacing_type,
}
response = self.client.post(url, data, format='json')
assert response.status_code == 201
course_run_key = CourseKey.from_string(response.data['id'])
course_run = modulestore().get_course(course_run_key)
assert course_run.id.run == run
assert course_run.self_paced is expected_self_paced_value
self.assert_course_run_schedule(course_run, start, end)
self.assert_access_role(course_run, user, role)
self.assert_course_access_role_count(course_run, 1)
def setUp(self):
super().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 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 test_rerun_duplicate_run(self):
course_run = ToyCourseFactory()
url = reverse('api:v1:course_run-rerun', kwargs={'pk': str(course_run.id)})
data = {
'run': course_run.id.run,
}
response = self.client.post(url, data, format='json')
assert response.status_code == 400
assert response.data == {'run': ['Course run {key} already exists'.format(key=course_run.id)]}
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(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 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 setUpClass(cls):
"""
Set up a course for use in these tests
"""
super().setUpClass()
with cls.store.default_store(ModuleStoreEnum.Type.split):
cls.course = ToyCourseFactory.create(modulestore=cls.store)
assert str(cls.course.id).startswith(
"course-v1:"), "This test is for split mongo course exports only"
cls.unit_key = cls.course.id.make_usage_key('vertical',
'vertical_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 test_rerun_invalid_number(self):
course_run = ToyCourseFactory()
url = reverse('api:v1:course_run-rerun', kwargs={'pk': str(course_run.id)})
data = {
'run': '2T2019',
'number': '!@#$%^&*()',
}
response = self.client.post(url, data, format='json')
assert response.status_code == 400
assert response.data == {'non_field_errors': [
'Invalid key supplied. Ensure there are no special characters in the Course Number.'
]}
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_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_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 test_rerun(self, pacing_type, expected_self_paced_value, number):
original_course_run = ToyCourseFactory()
add_organization({
'name': 'Test Organization',
'short_name': original_course_run.id.org,
'description': 'Testing Organization Description',
})
start = datetime.datetime.now(pytz.UTC).replace(microsecond=0)
end = start + datetime.timedelta(days=30)
user = UserFactory()
role = 'instructor'
run = '3T2017'
url = reverse('api:v1:course_run-rerun',
kwargs={'pk': str(original_course_run.id)})
data = {
'run': run,
'schedule': {
'start': serialize_datetime(start),
'end': serialize_datetime(end),
},
'team': [{
'user': user.username,
'role': role,
}],
'pacing_type': pacing_type,
}
# If number is supplied, this should become the course number used in the course run key
# If not, it should default to the original course run number that the rerun is based on.
if number:
data.update({'number': number})
response = self.client.post(url, data, format='json')
assert response.status_code == 201
course_run_key = CourseKey.from_string(response.data['id'])
course_run = modulestore().get_course(course_run_key)
assert course_run.id.run == run
assert course_run.self_paced is expected_self_paced_value
if number:
assert course_run.id.course == number
assert course_run.id.course != original_course_run.id.course
else:
assert course_run.id.course == original_course_run.id.course
self.assert_course_run_schedule(course_run, start, end)
self.assert_access_role(course_run, user, role)
self.assert_course_access_role_count(course_run, 1)
course_orgs = get_course_organizations(course_run_key)
self.assertEqual(len(course_orgs), 1)
self.assertEqual(course_orgs[0]['short_name'],
original_course_run.id.org)
def setUp(self):
super(RoleClassTestCase, self).setUp()
# For course ID, syntax edx/classname/classdate is important
# because xmodel.course_module.id_to_location looks for a string to split
self.course_id = ToyCourseFactory.create().id
self.student_role = models.Role.objects.get_or_create(name="Student", course_id=self.course_id)[0]
self.student_role.add_permission("delete_thread")
self.student_2_role = models.Role.objects.get_or_create(name="Student", course_id=self.course_id)[0]
self.TA_role = models.Role.objects.get_or_create(name="Community TA", course_id=self.course_id)[0]
self.course_id_2 = CourseKey.from_string("edX/6.002x/2012_Fall")
self.TA_role_2 = models.Role.objects.get_or_create(name="Community TA", course_id=self.course_id_2)[0]
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 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 setUpClass(cls):
super().setUpClass()
cls.store = modulestore()
cls.course = ToyCourseFactory.create(
end=datetime(2028, 1, 1, 1, 1, 1),
enrollment_start=datetime(2020, 1, 1, 1, 1, 1),
enrollment_end=datetime(2028, 1, 1, 1, 1, 1),
emit_signals=True,
modulestore=cls.store,
)
cls.user = UserFactory(username='******',
email=u'*****@*****.**',
password='******',
is_staff=False)
cls.url = '/api/courseware/course/{}'.format(cls.course.id)
def test_permissions_query_load(self):
"""
Tests that the permissions queries are cached when rendering numerous discussion XBlocks.
"""
user = UserFactory()
course = ToyCourseFactory()
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',
))
# 2 queries are required to do first discussion xblock render:
# * django_comment_client_role
# * lms_xblock_xblockasidesconfig
# If the query for roles returned a non-empty result set, there would be
# an additional query against django_comment_client_permission, but there
# are no roles associated with this test.
num_queries = 2
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 test_permissions_query_load(self):
"""
Tests that the permissions queries are cached when rendering numerous discussion XBlocks.
"""
user = UserFactory()
course = ToyCourseFactory()
course_key = course.id
course_usage_key = self.store.make_course_usage_key(course_key)
discussions = []
for counter in range(5):
discussion_id = f'test_discussion_{counter}'
discussions.append(
ItemFactory.create(
parent_location=course_usage_key,
category='discussion',
discussion_id=discussion_id,
discussion_category='Category discussion',
discussion_target='Target Discussion',
))
# 7 queries are required to do first discussion xblock render:
# * split_modulestore_django_splitmodulestorecourseindex x2
# * waffle_utils_wafflecourseoverridemodel
# * waffle_utils_waffleorgoverridemodel
# * waffle_flag
# * django_comment_client_role
# * lms_xblock_xblockasidesconfig
num_queries = 7
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'),
request_token='request_token',
)
with self.assertNumQueries(num_queries):
fragment = discussion_xblock.render('student_view')
# Permissions are cached, so only 1 query required for subsequent renders
# to check the waffle flag
num_queries = 1
html = fragment.content
assert 'data-user-create-comment="false"' in html
assert 'data-user-create-subcomment="false"' in html
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(
str(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 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 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):
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 setUp(self):
super(RoleClassTestCase, self).setUp()
# For course ID, syntax edx/classname/classdate is important
# because xmodel.course_module.id_to_location looks for a string to split
self.course_id = ToyCourseFactory.create().id
self.student_role = models.Role.objects.get_or_create(name="Student",
course_id=self.course_id)[0]
self.student_role.add_permission("delete_thread")
self.student_2_role = models.Role.objects.get_or_create(name="Student",
course_id=self.course_id)[0]
self.TA_role = models.Role.objects.get_or_create(name="Community TA",
course_id=self.course_id)[0]
self.course_id_2 = CourseKey.from_string("edX/6.002x/2012_Fall")
self.TA_role_2 = models.Role.objects.get_or_create(name="Community TA",
course_id=self.course_id_2)[0]
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):
"""
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 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='******')
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 setup_course_metadata(self, request):
"""
Setup course metadata and related database entries for provider state setup.
"""
course_key = CourseKey.from_string(self.COURSE_KEY)
self.clean_db(request.user, course_key)
self.start_modulestore_isolation()
demo_course = ToyCourseFactory.create(
org=course_key.org,
course=course_key.course,
run=course_key.run,
display_name="Demonstration Course",
modulestore=self.store,
start=datetime(2024, 1, 1, 1, 1, 1),
end=datetime(2028, 1, 1, 1, 1, 1),
enrollment_start=datetime(2020, 1, 1, 1, 1, 1),
enrollment_end=datetime(2028, 1, 1, 1, 1, 1),
license="all-rights-reserved",
)
CourseModeFactory(
course_id=demo_course.id,
mode_slug=CourseMode.AUDIT,
)
CourseModeFactory(
course_id=demo_course.id,
mode_slug=CourseMode.VERIFIED,
expiration_datetime=datetime(3028, 1, 1),
min_price=149,
sku='ABCD1234',
)
CourseEnrollment.enroll(request.user, demo_course.id, CourseMode.AUDIT)
CourseDurationLimitConfig.objects.create(enabled=True,
enabled_as_of=datetime(
2018, 1, 1))
def setUp(self):
super(TestMongoCoursesLoad, self).setUp()
self.setup_user()
self.toy_course_key = ToyCourseFactory.create().id
def setUp(self):
"""
Make sure that course is reloaded every time--clear out the modulestore.
"""
super(TestCohorts, self).setUp()
self.toy_course_key = ToyCourseFactory.create().id
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 setUpClass(cls):
super(TestBlockSerializerBase, cls).setUpClass()
cls.course = ToyCourseFactory.create()
def setUp(self):
super(TestMongoCoursesLoad, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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 setUp(self):
"""
Make sure that course is reloaded every time--clear out the modulestore.
"""
super(TestCohorts, self).setUp()
self.toy_course_key = ToyCourseFactory.create().id
def setUp(self):
super(TestMongoCoursesLoad, self).setUp()
self.setup_user()
self.toy_course_key = ToyCourseFactory.create().id
