def setUpClass(cls):
super(TestGetProblemGradeDistribution, cls).setUpClass()
cls.course = CourseFactory.create(
display_name=u"test course omega \u03a9",
)
with cls.store.bulk_operations(cls.course.id, emit_signals=False):
section = ItemFactory.create(
parent_location=cls.course.location,
category="chapter",
display_name=u"test factory section omega \u03a9",
)
cls.sub_section = ItemFactory.create(
parent_location=section.location,
category="sequential",
display_name=u"test subsection omega \u03a9",
)
cls.unit = ItemFactory.create(
parent_location=cls.sub_section.location,
category="vertical",
metadata={'graded': True, 'format': 'Homework'},
display_name=u"test unit omega \u03a9",
)
cls.items = []
for i in xrange(USER_COUNT - 1):
item = ItemFactory.create(
parent_location=cls.unit.location,
category="problem",
data=StringResponseXMLFactory().build_xml(answer='foo'),
metadata={'rerandomize': 'always'},
display_name=u"test problem omega \u03a9 " + str(i)
)
cls.items.append(item)
cls.item = item
def setUpClass(cls):
# Nose runs setUpClass methods even if a class decorator says to skip
# the class: https://github.com/nose-devs/nose/issues/946
# So, skip the test class here if we are not in the LMS.
if settings.ROOT_URLCONF != 'lms.urls':
raise unittest.SkipTest('Test only valid in lms')
super(TestCrowdsourceHinter, cls).setUpClass()
cls.course = CourseFactory.create(
display_name='CrowdsourceHinter_Test_Course'
)
with cls.store.bulk_operations(cls.course.id, emit_signals=False):
cls.chapter = ItemFactory.create(
parent=cls.course, display_name='Overview'
)
cls.section = ItemFactory.create(
parent=cls.chapter, display_name='Welcome'
)
cls.unit = ItemFactory.create(
parent=cls.section, display_name='New Unit'
)
cls.xblock = ItemFactory.create(
parent=cls.unit,
category='crowdsourcehinter',
display_name='crowdsourcehinter'
)
cls.course_url = reverse(
'courseware_section',
kwargs={
'course_id': cls.course.id.to_deprecated_string(),
'chapter': 'Overview',
'section': 'Welcome',
}
)
def set_up_course(self, enable_subsection_grades=True):
"""
Configures the course for this test.
"""
# pylint: disable=attribute-defined-outside-init,no-member
self.course = CourseFactory.create(
org='edx',
name='course',
run='run',
)
if not enable_subsection_grades:
PersistentGradesEnabledFlag.objects.create(enabled=False)
self.chapter = ItemFactory.create(parent=self.course, category="chapter", display_name="Chapter")
self.sequential = ItemFactory.create(parent=self.chapter, category='sequential', display_name="Open Sequential")
self.problem = ItemFactory.create(parent=self.sequential, category='problem', display_name='problem')
self.score_changed_kwargs = {
'points_possible': 10,
'points_earned': 5,
'user': self.user,
'course_id': unicode(self.course.id),
'usage_id': unicode(self.problem.location),
}
# this call caches the anonymous id on the user object, saving 4 queries in all happy path tests
_ = anonymous_id_for_user(self.user, self.course.id)
def test_xblock_studio_url(self):
# Verify course URL
course_url = u"/course/{}".format(unicode(self.course.id))
self.assertEqual(xblock_studio_url(self.course), course_url)
# Verify chapter URL
chapter = ItemFactory.create(parent_location=self.course.location, category="chapter", display_name="Week 1")
self.assertEqual(xblock_studio_url(chapter), u"{}?show={}".format(course_url, http.urlquote(chapter.location)))
# Verify sequential URL
sequential = ItemFactory.create(
parent_location=chapter.location, category="sequential", display_name="Lesson 1"
)
self.assertEqual(
xblock_studio_url(sequential), u"{}?show={}".format(course_url, http.urlquote(sequential.location))
)
# Verify unit URL
vertical = ItemFactory.create(parent_location=sequential.location, category="vertical", display_name="Unit")
self.assertEqual(xblock_studio_url(vertical), u"/container/{}".format(vertical.location))
# Verify child vertical URL
child_vertical = ItemFactory.create(
parent_location=vertical.location, category="vertical", display_name="Child Vertical"
)
self.assertEqual(xblock_studio_url(child_vertical), u"/container/{}".format(child_vertical.location))
# Verify video URL
video = ItemFactory.create(parent_location=child_vertical.location, category="video", display_name="My Video")
self.assertIsNone(xblock_studio_url(video))
def test_repeated_course_module_instantiation(self, loops, default_store, course_depth):
with modulestore().default_store(default_store):
course = CourseFactory.create()
chapter = ItemFactory(parent=course, category='chapter', graded=True)
section = ItemFactory(parent=chapter, category='sequential')
__ = ItemFactory(parent=section, category='problem')
fake_request = self.factory.get(
reverse('progress', kwargs={'course_id': unicode(course.id)})
)
course = modulestore().get_course(course.id, depth=course_depth)
for _ in xrange(loops):
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
course.id, self.user, course, depth=course_depth
)
course_module = get_module_for_descriptor(
self.user,
fake_request,
course,
field_data_cache,
course.id,
course=course
)
for chapter in course_module.get_children():
for section in chapter.get_children():
for item in section.get_children():
self.assertTrue(item.graded)
def setUpClass(cls):
super(GradesEventIntegrationTest, cls).setUpClass()
cls.store = modulestore()
with cls.store.default_store(ModuleStoreEnum.Type.split):
cls.course = CourseFactory.create()
cls.chapter = ItemFactory.create(
parent=cls.course,
category="chapter",
display_name="Test Chapter"
)
cls.sequence = ItemFactory.create(
parent=cls.chapter,
category='sequential',
display_name="Test Sequential 1",
graded=True,
format="Homework"
)
cls.vertical = ItemFactory.create(
parent=cls.sequence,
category='vertical',
display_name='Test Vertical 1'
)
problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 2',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3']
)
cls.problem = ItemFactory.create(
parent=cls.vertical,
category="problem",
display_name="p1",
data=problem_xml,
metadata={'weight': 2}
)
def setUp(self):
self.course = CourseFactory.create(number='999', display_name='Robot_Super_Course')
self.overview_chapter = ItemFactory.create(display_name='Overview')
self.courseware_chapter = ItemFactory.create(display_name='courseware')
self.test_course = CourseFactory.create(number='666', display_name='Robot_Sub_Course')
self.other_org_course = CourseFactory.create(org='Other_Org_Course')
self.sub_courseware_chapter = ItemFactory.create(
parent_location=self.test_course.location, display_name='courseware'
)
self.sub_overview_chapter = ItemFactory.create(
parent_location=self.sub_courseware_chapter.location,
display_name='Overview'
)
self.welcome_section = ItemFactory.create(
parent_location=self.overview_chapter.location,
display_name='Welcome'
)
self.global_staff_user = GlobalStaffFactory()
self.unenrolled_user = UserFactory(last_name="Unenrolled")
self.enrolled_user = UserFactory(last_name="Enrolled")
CourseEnrollmentFactory(user=self.enrolled_user, course_id=self.course.id)
CourseEnrollmentFactory(user=self.enrolled_user, course_id=self.test_course.id)
self.staff_user = StaffFactory(course=self.course.location)
self.instructor_user = InstructorFactory(
course=self.course.location)
self.org_staff_user = OrgStaffFactory(course=self.course.location)
self.org_instructor_user = OrgInstructorFactory(
course=self.course.location)
def setUp(self):
"""
Creates a basic course structure for our course
"""
super(CourseStatusAPITestCase, self).setUp()
self.section = ItemFactory.create(
parent=self.course,
category='chapter',
)
self.sub_section = ItemFactory.create(
parent=self.section,
category='sequential',
)
self.unit = ItemFactory.create(
parent=self.sub_section,
category='vertical',
)
self.other_sub_section = ItemFactory.create(
parent=self.section,
category='sequential',
)
self.other_unit = ItemFactory.create(
parent=self.other_sub_section,
category='vertical',
)
def setUp(self):
self.partition = UserPartition(
0,
'first_partition',
'First Partition',
[
Group(0, 'alpha'),
Group(1, 'beta')
]
)
self.course = CourseFactory.create(
number=self.COURSE_NUMBER,
user_partitions=[self.partition]
)
self.chapter = ItemFactory.create(
parent_location=self.course.location,
category="chapter",
display_name="test chapter",
)
self.sequential = ItemFactory.create(
parent_location=self.chapter.location,
category="sequential",
display_name="Split Test Tests",
)
self.student = UserFactory.create()
CourseEnrollmentFactory.create(user=self.student, course_id=self.course.id)
self.client.login(username=self.student.username, password='******')
def setUp(self):
super(TestTaskExecution, self).setUp()
self.course = CourseFactory.create(start=datetime(2015, 3, 1))
self.section = ItemFactory.create(parent=self.course, category='chapter', display_name='Test Section')
self.subsection = ItemFactory.create(parent=self.section, category='sequential', display_name='Test Subsection')
self.vertical = ItemFactory.create(parent=self.subsection, category='vertical', display_name='Test Unit')
def setup_course(self):
self.course = CourseFactory.create(data=self.COURSE_DATA)
# Turn off cache.
modulestore().request_cache = None
modulestore().metadata_inheritance_cache_subsystem = None
chapter = ItemFactory.create(
parent_location=self.course.location,
category="sequential",
)
self.section = ItemFactory.create(
parent_location=chapter.location,
category="sequential"
)
# username = robot{0}, password = '******'
self.users = [
UserFactory.create()
for i in range(self.USER_COUNT)
]
for user in self.users:
CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
# login all users for acces to Xmodule
self.clients = {user.username: Client() for user in self.users}
self.login_statuses = [
self.clients[user.username].login(
username=user.username, password='******')
for user in self.users
]
self.assertTrue(all(self.login_statuses))
def setUpClass(cls):
super(TestGradebook, cls).setUpClass()
# Create a course with the desired grading policy (from our class attribute)
kwargs = {}
if cls.grading_policy is not None:
kwargs['grading_policy'] = cls.grading_policy
cls.course = CourseFactory.create(**kwargs)
# Now give it some content
with cls.store.bulk_operations(cls.course.id, emit_signals=False):
chapter = ItemFactory.create(
parent_location=cls.course.location,
category="sequential",
)
section = ItemFactory.create(
parent_location=chapter.location,
category="sequential",
metadata={'graded': True, 'format': 'Homework'}
)
cls.items = [
ItemFactory.create(
parent_location=section.location,
category="problem",
data=StringResponseXMLFactory().build_xml(answer='foo'),
metadata={'rerandomize': 'always'}
)
for __ in xrange(USER_COUNT - 1)
]
def setUpClass(cls):
super(SplitTestBase, cls).setUpClass()
cls.partition = UserPartition(
0,
'first_partition',
'First Partition',
[
Group(0, 'alpha'),
Group(1, 'beta')
]
)
cls.course = CourseFactory.create(
number=cls.COURSE_NUMBER,
user_partitions=[cls.partition]
)
cls.chapter = ItemFactory.create(
parent_location=cls.course.location,
category="chapter",
display_name="test chapter",
)
cls.sequential = ItemFactory.create(
parent_location=cls.chapter.location,
category="sequential",
display_name="Split Test Tests",
)
def setUpClass(cls):
super(TestStudentModuleGrading, cls).setUpClass()
cls.course = CourseFactory.create()
cls.chapter = ItemFactory.create(
parent=cls.course,
category="chapter",
display_name="Test Chapter"
)
cls.sequence = ItemFactory.create(
parent=cls.chapter,
category='sequential',
display_name="Test Sequential 1",
graded=True
)
cls.vertical = ItemFactory.create(
parent=cls.sequence,
category='vertical',
display_name='Test Vertical 1'
)
problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 3',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3']
)
cls.problem = ItemFactory.create(
parent=cls.vertical,
category="problem",
display_name="Test Problem",
data=problem_xml
)
cls.request = get_mock_request(UserFactory())
cls.user = cls.request.user
cls.instructor = UserFactory(username='******', is_staff=True)
def _add_entrance_exam(self):
""" Sets up entrance exam """
with self.store.bulk_operations(self.course.id):
self.course.entrance_exam_enabled = True
self.entrance_exam = ItemFactory.create(
parent=self.course,
category="chapter",
display_name="Entrance Exam Chapter",
is_entrance_exam=True,
in_entrance_exam=True,
)
self.subsection_1 = ItemFactory.create(
parent=self.entrance_exam,
category='sequential',
display_name="The Only Exam Sequential",
graded=True,
in_entrance_exam=True,
)
self.problem_1 = ItemFactory.create(
parent=self.subsection_1,
category='problem',
display_name="The Only Exam Problem",
graded=True,
in_entrance_exam=True,
)
add_entrance_exam_milestone(self.course, self.entrance_exam)
self.course.entrance_exam_minimum_score_pct = 0.50
self.course.entrance_exam_id = unicode(self.entrance_exam.location)
self.store.update_item(self.course, self.user.id)
def setUpClass(cls):
super(TestCCXGrades, cls).setUpClass()
cls._course = course = CourseFactory.create(enable_ccx=True)
# Create a course outline
cls.mooc_start = start = datetime.datetime(
2010, 5, 12, 2, 42, tzinfo=pytz.UTC
)
chapter = ItemFactory.create(
start=start, parent=course, category='sequential'
)
cls.sections = sections = [
ItemFactory.create(
parent=chapter,
category="sequential",
metadata={'graded': True, 'format': 'Homework'})
for _ in xrange(4)
]
# making problems available at class level for possible future use in tests
cls.problems = [
[
ItemFactory.create(
parent=section,
category="problem",
data=StringResponseXMLFactory().build_xml(answer='foo'),
metadata={'rerandomize': 'always'}
) for _ in xrange(4)
] for section in sections
]
def test_resume_course_visibility(self):
SelfPacedConfiguration(enable_course_home_improvements=True).save()
chapter = ItemFactory.create(
category="chapter", parent_location=self.course.location
)
section = ItemFactory.create(
category='section', parent_location=chapter.location
)
section_url = reverse(
'courseware_section',
kwargs={
'section': section.url_name,
'chapter': chapter.url_name,
'course_id': self.course.id
}
)
self.client.get(section_url)
info_url = reverse('info', args=(unicode(self.course.id),))
# Assuring a non-authenticated user cannot see the resume course button.
resume_course_url = self.get_resume_course_url(info_url)
self.assertEqual(resume_course_url, None)
# Assuring an unenrolled user cannot see the resume course button.
self.setup_user()
resume_course_url = self.get_resume_course_url(info_url)
self.assertEqual(resume_course_url, None)
# Assuring an enrolled user can see the resume course button.
self.enroll(self.course)
resume_course_url = self.get_resume_course_url(info_url)
self.assertEqual(resume_course_url, section_url)
def setUpClass(cls):
super(GradeTestBase, cls).setUpClass()
cls.course = CourseFactory.create()
cls.chapter = ItemFactory.create(
parent=cls.course,
category="chapter",
display_name="Test Chapter"
)
cls.sequence = ItemFactory.create(
parent=cls.chapter,
category='sequential',
display_name="Test Sequential 1",
graded=True
)
cls.vertical = ItemFactory.create(
parent=cls.sequence,
category='vertical',
display_name='Test Vertical 1'
)
problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 3',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3']
)
cls.problem = ItemFactory.create(
parent=cls.vertical,
category="problem",
display_name="Test Problem",
data=problem_xml
)
def setUpClass(cls):
super(TestSites, cls).setUpClass()
cls.course = CourseFactory.create(
display_name='Robot_Super_Course',
org='TestSiteX',
emit_signals=True,
)
cls.chapter0 = ItemFactory.create(parent_location=cls.course.location, display_name='Overview')
cls.chapter9 = ItemFactory.create(parent_location=cls.course.location, display_name='factory_chapter')
cls.section0 = ItemFactory.create(parent_location=cls.chapter0.location, display_name='Welcome')
cls.section9 = ItemFactory.create(parent_location=cls.chapter9.location, display_name='factory_section')
cls.course_outside_site = CourseFactory.create(
display_name='Robot_Course_Outside_Site',
org='FooX',
emit_signals=True,
)
# have a course which explicitly sets visibility in catalog to False
cls.course_hidden_visibility = CourseFactory.create(
display_name='Hidden_course',
org='TestSiteX',
catalog_visibility=CATALOG_VISIBILITY_NONE,
emit_signals=True,
)
# have a course which explicitly sets visibility in catalog and about to true
cls.course_with_visibility = CourseFactory.create(
display_name='visible_course',
org='TestSiteX',
course="foo",
catalog_visibility=CATALOG_VISIBILITY_CATALOG_AND_ABOUT,
emit_signals=True,
)
def _test_not_indexable(self, store):
""" test not indexable items """
# Publish the vertical to start with
self.publish_item(store, self.vertical.location)
self.reindex_course(store)
response = self.search()
self.assertEqual(response["total"], 4)
# Add a non-indexable item
ItemFactory.create(
parent_location=self.vertical.location,
category="openassessment",
display_name="Some other content",
publish_item=False,
modulestore=store,
)
self.reindex_course(store)
response = self.search()
self.assertEqual(response["total"], 4)
# even after publishing, we should not find the non-indexable item
self.publish_item(store, self.vertical.location)
self.reindex_course(store)
response = self.search()
self.assertEqual(response["total"], 4)
def _test_course_location_null(self, store):
""" Test that course location information is added to index """
sequential2 = ItemFactory.create(
parent_location=self.chapter.location,
category='sequential',
display_name=None,
modulestore=store,
publish_item=True,
start=datetime(2015, 3, 1, tzinfo=UTC),
)
# add a new vertical
vertical2 = ItemFactory.create(
parent_location=sequential2.location,
category='vertical',
display_name='Subsection 2',
modulestore=store,
publish_item=True,
)
ItemFactory.create(
parent_location=vertical2.location,
category="html",
display_name="Find Me",
publish_item=True,
modulestore=store,
)
self.reindex_course(store)
response = self.search(query_string="Find Me")
self.assertEqual(response["total"], 1)
result = response["results"][0]["data"]
self.assertEqual(result["course_name"], "Search Index Test Course")
self.assertEqual(result["location"], ["Week 1", CoursewareSearchIndexer.UNNAMED_MODULE_NAME, "Subsection 2"])
def setUp(self):
super(TestGetProblemGradeDistribution, self).setUp()
self.request_factory = RequestFactory()
self.instructor = AdminFactory.create()
self.client.login(username=self.instructor.username, password='******')
self.attempts = 3
self.course = CourseFactory.create(
display_name=u"test course omega \u03a9",
)
section = ItemFactory.create(
parent_location=self.course.location,
category="chapter",
display_name=u"test factory section omega \u03a9",
)
self.sub_section = ItemFactory.create(
parent_location=section.location,
category="sequential",
display_name=u"test subsection omega \u03a9",
)
unit = ItemFactory.create(
parent_location=self.sub_section.location,
category="vertical",
metadata={'graded': True, 'format': 'Homework'},
display_name=u"test unit omega \u03a9",
)
self.users = [UserFactory.create(username="******" + str(__)) for __ in xrange(USER_COUNT)]
for user in self.users:
CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
for i in xrange(USER_COUNT - 1):
category = "problem"
self.item = ItemFactory.create(
parent_location=unit.location,
category=category,
data=StringResponseXMLFactory().build_xml(answer='foo'),
metadata={'rerandomize': 'always'},
display_name=u"test problem omega \u03a9 " + str(i)
)
for j, user in enumerate(self.users):
StudentModuleFactory.create(
grade=1 if i < j else 0,
max_grade=1 if i < j else 0.5,
student=user,
course_id=self.course.id,
module_state_key=self.item.location,
state=json.dumps({'attempts': self.attempts}),
)
for j, user in enumerate(self.users):
StudentModuleFactory.create(
course_id=self.course.id,
module_type='sequential',
module_state_key=self.item.location,
)
def setUp(self):
"""
Initial data setup
"""
super(TestHandleItemDeleted, self).setUp()
self.course = CourseFactory.create()
self.course.enable_subsection_gating = True
self.course.save()
self.chapter = ItemFactory.create(
parent=self.course,
category="chapter",
display_name="Chapter"
)
self.open_seq = ItemFactory.create(
parent=self.chapter,
category='sequential',
display_name="Open Sequential"
)
self.gated_seq = ItemFactory.create(
parent=self.chapter,
category='sequential',
display_name="Gated Sequential"
)
gating_api.add_prerequisite(self.course.id, self.open_seq.location)
gating_api.set_required_content(self.course.id, self.gated_seq.location, self.open_seq.location, 100)
def setUp(self):
"""
Fixtures.
"""
super(TestSetDueDateExtension, self).setUp()
self.due = due = datetime.datetime(2010, 5, 12, 2, 42, tzinfo=utc)
course = CourseFactory.create()
week1 = ItemFactory.create(due=due, parent=course)
week2 = ItemFactory.create(due=due, parent=course)
week3 = ItemFactory.create(parent=course)
homework = ItemFactory.create(parent=week1)
assignment = ItemFactory.create(parent=homework, due=due)
user = UserFactory.create()
self.course = course
self.week1 = week1
self.homework = homework
self.assignment = assignment
self.week2 = week2
self.week3 = week3
self.user = user
inject_field_overrides((course, week1, week2, week3, homework, assignment), course, user)
def setUpClass(cls):
super(MasqueradeTestCase, cls).setUpClass()
cls.course = CourseFactory.create(number="masquerade-test", metadata={"start": datetime.now(UTC())})
cls.info_page = ItemFactory.create(
category="course_info", parent_location=cls.course.location, data="OOGIE BLOOGIE", display_name="updates"
)
cls.chapter = ItemFactory.create(
parent_location=cls.course.location, category="chapter", display_name="Test Section"
)
cls.sequential_display_name = "Test Masquerade Subsection"
cls.sequential = ItemFactory.create(
parent_location=cls.chapter.location, category="sequential", display_name=cls.sequential_display_name
)
cls.vertical = ItemFactory.create(
parent_location=cls.sequential.location, category="vertical", display_name="Test Unit"
)
problem_xml = OptionResponseXMLFactory().build_xml(
question_text="The correct answer is Correct",
num_inputs=2,
weight=2,
options=["Correct", "Incorrect"],
correct_option="Correct",
)
cls.problem_display_name = "TestMasqueradeProblem"
cls.problem = ItemFactory.create(
parent_location=cls.vertical.location,
category="problem",
data=problem_xml,
display_name=cls.problem_display_name,
)
def setUp(self):
"""
Fixtures.
"""
super(TestDataDumps, self).setUp()
due = datetime.datetime(2010, 5, 12, 2, 42, tzinfo=UTC)
course = CourseFactory.create()
week1 = ItemFactory.create(due=due, parent=course)
week2 = ItemFactory.create(due=due, parent=course)
homework = ItemFactory.create(
parent=week1,
due=due
)
user1 = UserFactory.create()
user2 = UserFactory.create()
self.course = course
self.week1 = week1
self.homework = homework
self.week2 = week2
self.user1 = user1
self.user2 = user2
signals.extract_dates(None, course.id)
def setup_course(self, default_store=None):
"""
Helper method to create the course.
"""
if not default_store:
default_store = self.store.default_modulestore.get_modulestore_type()
with self.store.default_store(default_store):
self.course = CourseFactory.create(**self.course_options())
chapter = ItemFactory.create(parent=self.course, category='chapter')
self.vertical_block = ItemFactory.create(
parent_location=chapter.location,
category='vertical',
display_name="Vertical"
)
self.html_block = ItemFactory.create(
parent=self.vertical_block,
category='html',
data="<p>Test HTML Content<p>"
)
# block_name_to_be_tested can be `html_block` or `vertical_block`.
# These attributes help ensure the positive and negative tests are in sync.
self.block_to_be_tested = getattr(self, self.block_name_to_be_tested)
self.block_specific_chrome_html_elements = self.BLOCK_SPECIFIC_CHROME_HTML_ELEMENTS[
self.block_name_to_be_tested
]
def setUp(self):
"""
Create a simple course with a video component.
"""
super(AuthoringMixinTestCase, self).setUp()
self.course = CourseFactory.create()
chapter = ItemFactory.create(
category='chapter',
parent_location=self.course.location,
display_name='Test Chapter'
)
sequential = ItemFactory.create(
category='sequential',
parent_location=chapter.location,
display_name='Test Sequential'
)
vertical = ItemFactory.create(
category='vertical',
parent_location=sequential.location,
display_name='Test Vertical'
)
video = ItemFactory.create(
category='video',
parent_location=vertical.location,
display_name='Test Vertical'
)
self.vertical_location = vertical.location
self.video_location = video.location
self.pet_groups = [Group(1, 'Cat Lovers'), Group(2, 'Dog Lovers')]
def setUp(self):
super(GradesServiceTests, self).setUp()
self.service = GradesService()
self.course = CourseFactory.create(org='edX', number='DemoX', display_name='Demo_Course', run='Spring2019')
self.subsection = ItemFactory.create(parent=self.course, category="subsection", display_name="Subsection")
self.subsection_without_grade = ItemFactory.create(
parent=self.course,
category="subsection",
display_name="Subsection without grade"
)
self.user = UserFactory()
self.grade = PersistentSubsectionGrade.update_or_create_grade(
user_id=self.user.id,
course_id=self.course.id,
usage_key=self.subsection.location,
first_attempted=None,
visible_blocks=[],
earned_all=6.0,
possible_all=6.0,
earned_graded=5.0,
possible_graded=5.0
)
self.signal_patcher = patch('lms.djangoapps.grades.signals.signals.SUBSECTION_OVERRIDE_CHANGED.send')
self.mock_signal = self.signal_patcher.start()
self.id_patcher = patch('lms.djangoapps.grades.services.create_new_event_transaction_id')
self.mock_create_id = self.id_patcher.start()
self.mock_create_id.return_value = 1
self.type_patcher = patch('lms.djangoapps.grades.services.set_event_transaction_type')
self.mock_set_type = self.type_patcher.start()
self.flag_patcher = patch('lms.djangoapps.grades.services.waffle_flags')
self.mock_waffle_flags = self.flag_patcher.start()
self.mock_waffle_flags.return_value = {
REJECTED_EXAM_OVERRIDES_GRADE: MockWaffleFlag(True)
}
def _test_not_indexing_unpublished_content(self, store):
""" add a new one, only appers in index once added """
# Publish the vertical to start with
self.publish_item(store, self.vertical.location)
self.reindex_course(store)
response = self.search()
self.assertEqual(response["total"], 4)
# Now add a new unit to the existing vertical
ItemFactory.create(
parent_location=self.vertical.location,
category="html",
display_name="Some other content",
publish_item=False,
modulestore=store,
)
self.reindex_course(store)
response = self.search()
self.assertEqual(response["total"], 4)
# Now publish it and we should find it
# Publish the vertical as is, and everything should be available
self.publish_item(store, self.vertical.location)
self.reindex_course(store)
response = self.search()
self.assertEqual(response["total"], 5)
def test_review_problems(self, num_desired):
"""
If a user has enough problems to review, they should
receive a response where there are review problems for them to try.
"""
self.enroll_student(self.STUDENTS[0]['email'],
self.STUDENTS[0]['password'], self.course_actual)
self.enroll_student(self.STUDENTS[0]['email'],
self.STUDENTS[0]['password'], self.course_review)
# Loading problems so the learner has enough problems in the CSM
self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': self.section1_actual.location.name,
}))
self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': self.section2_actual.location.name,
}))
self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': self.section3_actual.location.name,
}))
with self.store.bulk_operations(self.course_actual.id,
emit_signals=False):
review_section_actual = ItemFactory.create(
parent=self.chapter_actual, display_name='Review Subsection')
review_unit_actual = ItemFactory.create(
parent=review_section_actual, display_name='Review Unit')
review_xblock_actual = ItemFactory.create( # pylint: disable=unused-variable
parent=review_unit_actual,
category='review',
display_name='Review Tool',
num_desired=num_desired)
# Loading the review section
response = self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': review_section_actual.location.name,
}))
expected_header_text = 'Review Problems'
# The problems are defaulted to correct upon load
# This happens because the problems "raw_possible" field is 0 and the
# "raw_earned" field is also 0.
expected_correctness_text = 'correct'
expected_problems = [
'Review Problem 1', 'Review Problem 2', 'Review Problem 3',
'Review Problem 4', 'Review Problem 5', 'Review Problem 6'
]
self.assertIn(expected_header_text, response.content)
self.assertEqual(response.content.count(expected_correctness_text),
num_desired)
# Since the problems are randomly selected, we have to check
# the correct number of problems are returned.
count = 0
for problem in expected_problems:
if problem in response.content:
count += 1
self.assertEqual(count, num_desired)
self.assertEqual(response.content.count(self.URL_BEGINNING),
num_desired)
def setUp(self):
"""
Test case scaffolding
"""
super(EntranceExamTestCases, self).setUp()
self.course = CourseFactory.create(metadata={
'entrance_exam_enabled': True,
})
self.chapter = ItemFactory.create(parent=self.course,
display_name='Overview')
ItemFactory.create(parent=self.chapter, display_name='Welcome')
ItemFactory.create(parent=self.course,
category='chapter',
display_name="Week 1")
self.chapter_subsection = ItemFactory.create(parent=self.chapter,
category='sequential',
display_name="Lesson 1")
chapter_vertical = ItemFactory.create(
parent=self.chapter_subsection,
category='vertical',
display_name='Lesson 1 Vertical - Unit 1')
ItemFactory.create(parent=chapter_vertical,
category="problem",
display_name="Problem - Unit 1 Problem 1")
ItemFactory.create(parent=chapter_vertical,
category="problem",
display_name="Problem - Unit 1 Problem 2")
ItemFactory.create(category="instructor",
parent=self.course,
data="Instructor Tab",
display_name="Instructor")
self.entrance_exam = ItemFactory.create(
parent=self.course,
category="chapter",
display_name="Entrance Exam Section - Chapter 1",
is_entrance_exam=True,
in_entrance_exam=True)
self.exam_1 = ItemFactory.create(
parent=self.entrance_exam,
category='sequential',
display_name="Exam Sequential - Subsection 1",
graded=True,
in_entrance_exam=True)
subsection = ItemFactory.create(parent=self.exam_1,
category='vertical',
display_name='Exam Vertical - Unit 1')
problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 3',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3'])
self.problem_1 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 1",
data=problem_xml)
self.problem_2 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 2")
seed_milestone_relationship_types()
add_entrance_exam_milestone(self.course, self.entrance_exam)
self.course.entrance_exam_enabled = True
self.course.entrance_exam_minimum_score_pct = 0.50
self.course.entrance_exam_id = unicode(
self.entrance_exam.scope_ids.usage_id)
self.anonymous_user = AnonymousUserFactory()
self.request = get_request_for_user(UserFactory())
modulestore().update_item(self.course, self.request.user.id) # pylint: disable=no-member
self.client.login(username=self.request.user.username, password="******")
CourseEnrollment.enroll(self.request.user, self.course.id)
self.expected_locked_toc = ([{
'active':
True,
'sections': [{
'url_name': u'Exam_Sequential_-_Subsection_1',
'display_name': u'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}],
'url_name':
u'Entrance_Exam_Section_-_Chapter_1',
'display_name':
u'Entrance Exam Section - Chapter 1',
'display_id':
u'entrance-exam-section-chapter-1',
}])
self.expected_unlocked_toc = ([{
'active':
False,
'sections': [{
'url_name': u'Welcome',
'display_name': u'Welcome',
'graded': False,
'format': '',
'due': None,
'active': False
}, {
'url_name': u'Lesson_1',
'display_name': u'Lesson 1',
'graded': False,
'format': '',
'due': None,
'active': False
}],
'url_name':
u'Overview',
'display_name':
u'Overview',
'display_id':
u'overview'
}, {
'active': False,
'sections': [],
'url_name': u'Week_1',
'display_name': u'Week 1',
'display_id': u'week-1'
}, {
'active': False,
'sections': [],
'url_name': u'Instructor',
'display_name': u'Instructor',
'display_id': u'instructor'
}, {
'active':
True,
'sections': [{
'url_name': u'Exam_Sequential_-_Subsection_1',
'display_name': u'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}],
'url_name':
u'Entrance_Exam_Section_-_Chapter_1',
'display_name':
u'Entrance Exam Section - Chapter 1',
'display_id':
u'entrance-exam-section-chapter-1'
}])
def setUp(self):
super(GroupAccessTestCase, self).setUp()
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
[
Extension("memory", USER_PARTITION_SCHEME_NAMESPACE,
MemoryUserPartitionScheme(), None),
Extension("random", USER_PARTITION_SCHEME_NAMESPACE,
MemoryUserPartitionScheme(), None)
],
namespace=USER_PARTITION_SCHEME_NAMESPACE)
self.cat_group = Group(10, 'cats')
self.dog_group = Group(20, 'dogs')
self.worm_group = Group(30, 'worms')
self.animal_partition = UserPartition(
0,
'Pet Partition',
'which animal are you?',
[self.cat_group, self.dog_group, self.worm_group],
scheme=UserPartition.get_scheme("memory"),
)
self.red_group = Group(1000, 'red')
self.blue_group = Group(2000, 'blue')
self.gray_group = Group(3000, 'gray')
self.color_partition = UserPartition(
100,
'Color Partition',
'what color are you?',
[self.red_group, self.blue_group, self.gray_group],
scheme=UserPartition.get_scheme("memory"),
)
self.course = CourseFactory.create(
user_partitions=[self.animal_partition, self.color_partition], )
with self.store.bulk_operations(self.course.id, emit_signals=False):
chapter = ItemFactory.create(category='chapter',
parent=self.course)
section = ItemFactory.create(category='sequential', parent=chapter)
vertical = ItemFactory.create(category='vertical', parent=section)
component = ItemFactory.create(category='problem', parent=vertical)
self.chapter_location = chapter.location
self.section_location = section.location
self.vertical_location = vertical.location
self.component_location = component.location
self.red_cat = UserFactory() # student in red and cat groups
self.set_user_group(self.red_cat, self.animal_partition,
self.cat_group)
self.set_user_group(self.red_cat, self.color_partition, self.red_group)
self.blue_dog = UserFactory() # student in blue and dog groups
self.set_user_group(self.blue_dog, self.animal_partition,
self.dog_group)
self.set_user_group(self.blue_dog, self.color_partition,
self.blue_group)
self.white_mouse = UserFactory() # student in no group
self.gray_worm = UserFactory() # student in deleted group
self.set_user_group(self.gray_worm, self.animal_partition,
self.worm_group)
self.set_user_group(self.gray_worm, self.color_partition,
self.gray_group)
# delete the gray/worm groups from the partitions now so we can test scenarios
# for user whose group is missing.
self.animal_partition.groups.pop()
self.color_partition.groups.pop()
# add a staff user, whose access will be unconditional in spite of group access.
self.staff = StaffFactory.create(course_key=self.course.id)
def setUpClass(cls):
# Nose runs setUpClass methods even if a class decorator says to skip
# the class: https://github.com/nose-devs/nose/issues/946
# So, skip the test class here if we are not in the LMS.
if settings.ROOT_URLCONF != 'lms.urls':
raise unittest.SkipTest('Test only valid in lms')
super(TestRecommender, cls).setUpClass()
cls.course = CourseFactory.create(
display_name='Recommender_Test_Course')
with cls.store.bulk_operations(cls.course.id, emit_signals=False):
cls.chapter = ItemFactory.create(parent=cls.course,
display_name='Overview')
cls.section = ItemFactory.create(parent=cls.chapter,
display_name='Welcome')
cls.unit = ItemFactory.create(parent=cls.section,
display_name='New Unit')
cls.xblock = ItemFactory.create(parent=cls.unit,
category='recommender',
display_name='recommender')
cls.xblock2 = ItemFactory.create(parent=cls.unit,
category='recommender',
display_name='recommender_second')
cls.course_url = reverse('courseware_section',
kwargs={
'course_id': text_type(cls.course.id),
'chapter': 'Overview',
'section': 'Welcome',
})
cls.resource_urls = [
("https://courses.edx.org/courses/MITx/3.091X/"
"2013_Fall/courseware/SP13_Week_4/"
"SP13_Periodic_Trends_and_Bonding/"),
("https://courses.edx.org/courses/MITx/3.091X/"
"2013_Fall/courseware/SP13_Week_4/SP13_Covalent_Bonding/")
]
cls.test_recommendations = {
cls.resource_urls[0]: {
"title":
"Covalent bonding and periodic trends",
"url":
cls.resource_urls[0],
"description": ("http://people.csail.mit.edu/swli/edx/"
"recommendation/img/videopage1.png"),
"descriptionText": ("short description for Covalent bonding "
"and periodic trends")
},
cls.resource_urls[1]: {
"title":
"Polar covalent bonds and electronegativity",
"url":
cls.resource_urls[1],
"description": ("http://people.csail.mit.edu/swli/edx/"
"recommendation/img/videopage2.png"),
"descriptionText": ("short description for Polar covalent "
"bonds and electronegativity")
}
}
def test_spoc_gradebook_mongo_calls(self):
"""
Test that the MongoDB cache is used in API to return grades
"""
# prepare course structure
course = ItemFactory.create(
parent_location=self.course.location,
category="course",
display_name="Test course",
)
students = []
for i in xrange(20):
username = "******" % i
student = UserFactory.create(username=username)
CourseEnrollmentFactory.create(user=student,
course_id=self.course.id)
students.append(student)
chapter = ItemFactory.create(
parent=course,
category='chapter',
display_name="Chapter",
publish_item=True,
start=datetime.datetime(2015, 3, 1, tzinfo=UTC),
)
sequential = ItemFactory.create(
parent=chapter,
category='sequential',
display_name="Lesson",
publish_item=True,
start=datetime.datetime(2015, 3, 1, tzinfo=UTC),
metadata={
'graded': True,
'format': 'Homework'
},
)
vertical = ItemFactory.create(
parent=sequential,
category='vertical',
display_name='Subsection',
publish_item=True,
start=datetime.datetime(2015, 4, 1, tzinfo=UTC),
)
for i in xrange(10):
problem = ItemFactory.create(
category="problem",
parent=vertical,
display_name="A Problem Block %d" % i,
weight=1,
publish_item=False,
metadata={'rerandomize': 'always'},
)
for j in students:
grade = i % 2
StudentModuleFactory.create(grade=grade,
max_grade=1,
student=j,
course_id=self.course.id,
module_state_key=problem.location)
# check MongoDB calls count
url = reverse('spoc_gradebook', kwargs={'course_id': self.course.id})
with check_mongo_calls(9):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def setUpTestData(cls):
cls.chapter0 = ItemFactory.create(parent=cls.course,
display_name='Overview')
cls.chapter9 = ItemFactory.create(parent=cls.course,
display_name='factory_chapter')
cls.section0 = ItemFactory.create(parent=cls.chapter0,
display_name='Welcome')
cls.section9 = ItemFactory.create(parent=cls.chapter9,
display_name='factory_section')
cls.unit0 = ItemFactory.create(parent=cls.section0,
display_name='New Unit 0')
cls.chapterchrome = ItemFactory.create(parent=cls.course,
display_name='Chrome')
cls.chromelesssection = ItemFactory.create(parent=cls.chapterchrome,
display_name='chromeless',
chrome='none')
cls.accordionsection = ItemFactory.create(parent=cls.chapterchrome,
display_name='accordion',
chrome='accordion')
cls.tabssection = ItemFactory.create(parent=cls.chapterchrome,
display_name='tabs',
chrome='tabs')
cls.defaultchromesection = ItemFactory.create(
parent=cls.chapterchrome,
display_name='defaultchrome',
)
cls.fullchromesection = ItemFactory.create(parent=cls.chapterchrome,
display_name='fullchrome',
chrome='accordion,tabs')
cls.tabtest = ItemFactory.create(parent=cls.chapterchrome,
display_name='progress_tab',
default_tab='progress')
cls.staff_user = GlobalStaffFactory()
cls.user = UserFactory()
def setUpClass(cls):
# Nose runs setUpClass methods even if a class decorator says to skip
# the class: https://github.com/nose-devs/nose/issues/946
# So, skip the test class here if we are not in the LMS.
if settings.ROOT_URLCONF != 'lms.urls':
raise unittest.SkipTest('Test only valid in lms')
super(TestReviewXBlock, cls).setUpClass()
# Set up for the actual course
cls.course_actual = CourseFactory.create(
display_name='Review_Test_Course_ACTUAL',
org='DillonX',
number='DAD101x',
run='3T2017')
# There are multiple sections so the learner can load different
# problems, but should only be shown review problems from what they have loaded
with cls.store.bulk_operations(cls.course_actual.id,
emit_signals=False):
cls.chapter_actual = ItemFactory.create(parent=cls.course_actual,
display_name='Overview')
cls.section1_actual = ItemFactory.create(parent=cls.chapter_actual,
display_name='Section 1')
cls.unit1_actual = ItemFactory.create(parent=cls.section1_actual,
display_name='New Unit 1')
cls.xblock1_actual = ItemFactory.create(parent=cls.unit1_actual,
category='problem',
display_name='Problem 1')
cls.xblock2_actual = ItemFactory.create(parent=cls.unit1_actual,
category='problem',
display_name='Problem 2')
cls.xblock3_actual = ItemFactory.create(parent=cls.unit1_actual,
category='problem',
display_name='Problem 3')
cls.xblock4_actual = ItemFactory.create(parent=cls.unit1_actual,
category='problem',
display_name='Problem 4')
cls.section2_actual = ItemFactory.create(parent=cls.chapter_actual,
display_name='Section 2')
cls.unit2_actual = ItemFactory.create(parent=cls.section2_actual,
display_name='New Unit 2')
cls.xblock5_actual = ItemFactory.create(parent=cls.unit2_actual,
category='problem',
display_name='Problem 5')
cls.section3_actual = ItemFactory.create(parent=cls.chapter_actual,
display_name='Section 3')
cls.unit3_actual = ItemFactory.create(parent=cls.section3_actual,
display_name='New Unit 3')
cls.xblock6_actual = ItemFactory.create(parent=cls.unit3_actual,
category='problem',
display_name='Problem 6')
cls.course_actual_url = reverse('courseware_section',
kwargs={
'course_id':
unicode(cls.course_actual.id),
'chapter':
'Overview',
'section':
'Welcome',
})
# Set up for the review course where the review problems are hosted
cls.course_review = CourseFactory.create(
display_name='Review_Test_Course_REVIEW',
org='DillonX',
number='DAD101x_review',
run='3T2017')
with cls.store.bulk_operations(cls.course_review.id,
emit_signals=True):
cls.chapter_review = ItemFactory.create(parent=cls.course_review,
display_name='Overview')
cls.section_review = ItemFactory.create(parent=cls.chapter_review,
display_name='Welcome')
cls.unit1_review = ItemFactory.create(parent=cls.section_review,
display_name='New Unit 1')
cls.xblock1_review = ItemFactory.create(parent=cls.unit1_review,
category='problem',
display_name='Problem 1')
cls.xblock2_review = ItemFactory.create(parent=cls.unit1_review,
category='problem',
display_name='Problem 2')
cls.xblock3_review = ItemFactory.create(parent=cls.unit1_review,
category='problem',
display_name='Problem 3')
cls.xblock4_review = ItemFactory.create(parent=cls.unit1_review,
category='problem',
display_name='Problem 4')
cls.unit2_review = ItemFactory.create(parent=cls.section_review,
display_name='New Unit 2')
cls.xblock5_review = ItemFactory.create(parent=cls.unit2_review,
category='problem',
display_name='Problem 5')
cls.unit3_review = ItemFactory.create(parent=cls.section_review,
display_name='New Unit 3')
cls.xblock6_review = ItemFactory.create(parent=cls.unit3_review,
category='problem',
display_name='Problem 6')
cls.course_review_url = reverse('courseware_section',
kwargs={
'course_id':
unicode(cls.course_review.id),
'chapter':
'Overview',
'section':
'Welcome',
})
def test_dashboard_with_resume_buttons_and_view_buttons(self):
'''
The Test creates a four-course-card dashboard. The user completes course
blocks in the even-numbered course cards. The test checks that courses
with completion data have course cards with "Resume Course" buttons;
those without have "View Course" buttons.
'''
self.override_waffle_switch(True)
isEven = lambda n: n % 2 == 0
num_course_cards = 4
html_for_view_buttons = []
html_for_resume_buttons = []
for i in range(num_course_cards):
course = CourseFactory.create()
course_enrollment = CourseEnrollmentFactory(
user=self.user,
course_id=course.id
)
course_key = course_enrollment.course_id
course_key_string = str(course_key)
last_completed_block_string = ''
course_run_string = self._pull_course_run_from_course_key(
course_key_string)
# Submit completed course blocks in even-numbered courses.
if isEven(i):
block_keys = [
ItemFactory.create(
category='video',
parent_location=course.location,
display_name='Video {0}'.format(unicode(number))
).location
for number in xrange(5)
]
last_completed_block_string = str(block_keys[-1])
submit_completions_for_testing(self.user, course_key, block_keys)
html_for_view_buttons.append(
self._get_html_for_view_course_button(
course_key_string,
course_run_string
)
)
html_for_resume_buttons.append(
self._get_html_for_resume_course_button(
course_key_string,
last_completed_block_string,
course_run_string
)
)
with patch('completion.utilities.visual_progress_enabled', return_value=True):
response = self.client.get(reverse('dashboard'))
html_for_view_buttons = [
self._remove_whitespace_from_html_string(button)
for button in html_for_view_buttons
]
html_for_resume_buttons = [
self._remove_whitespace_from_html_string(button)
for button in html_for_resume_buttons
]
dashboard_html = self._remove_whitespace_from_html_string(response.content)
for i in range(num_course_cards):
expected_button = None
unexpected_button = None
if isEven(i):
expected_button = html_for_resume_buttons[i]
unexpected_button = html_for_view_buttons[i]
else:
expected_button = html_for_view_buttons[i]
unexpected_button = html_for_resume_buttons[i]
self.assertIn(
expected_button,
dashboard_html
)
self.assertNotIn(
unexpected_button,
dashboard_html
)
def test_library_import(self):
"""
Try importing a known good library archive, and verify that the
contents of the library have completely replaced the old contents.
"""
# Create some blocks to overwrite
library = LibraryFactory.create(modulestore=self.store)
lib_key = library.location.library_key
test_block = ItemFactory.create(
category="vertical",
parent_location=library.location,
user_id=self.user.id,
publish_item=False,
)
test_block2 = ItemFactory.create(
category="vertical",
parent_location=library.location,
user_id=self.user.id,
publish_item=False
)
# Create a library and blocks that should remain unmolested.
unchanged_lib = LibraryFactory.create()
unchanged_key = unchanged_lib.location.library_key
test_block3 = ItemFactory.create(
category="vertical",
parent_location=unchanged_lib.location,
user_id=self.user.id,
publish_item=False
)
test_block4 = ItemFactory.create(
category="vertical",
parent_location=unchanged_lib.location,
user_id=self.user.id,
publish_item=False
)
# Refresh library.
library = self.store.get_library(lib_key)
children = [self.store.get_item(child).url_name for child in library.children]
self.assertEqual(len(children), 2)
self.assertIn(test_block.url_name, children)
self.assertIn(test_block2.url_name, children)
unchanged_lib = self.store.get_library(unchanged_key)
children = [self.store.get_item(child).url_name for child in unchanged_lib.children]
self.assertEqual(len(children), 2)
self.assertIn(test_block3.url_name, children)
self.assertIn(test_block4.url_name, children)
extract_dir = path(tempfile.mkdtemp(dir=settings.DATA_DIR))
# the extract_dir needs to be passed as a relative dir to
# import_library_from_xml
extract_dir_relative = path.relpath(extract_dir, settings.DATA_DIR)
try:
with tarfile.open(path(TEST_DATA_DIR) / 'imports' / 'library.HhJfPD.tar.gz') as tar:
safetar_extractall(tar, extract_dir)
library_items = import_library_from_xml(
self.store,
self.user.id,
settings.GITHUB_REPO_ROOT,
[extract_dir_relative / 'library'],
load_error_modules=False,
static_content_store=contentstore(),
target_id=lib_key
)
finally:
shutil.rmtree(extract_dir)
self.assertEqual(lib_key, library_items[0].location.library_key)
library = self.store.get_library(lib_key)
children = [self.store.get_item(child).url_name for child in library.children]
self.assertEqual(len(children), 3)
self.assertNotIn(test_block.url_name, children)
self.assertNotIn(test_block2.url_name, children)
unchanged_lib = self.store.get_library(unchanged_key)
children = [self.store.get_item(child).url_name for child in unchanged_lib.children]
self.assertEqual(len(children), 2)
self.assertIn(test_block3.url_name, children)
self.assertIn(test_block4.url_name, children)
def test_too_few_review_problems(self, num_desired):
"""
If a user does not have enough problems to review, they should
receive a response to go out and try more problems so they have
material to review.
Testing loading 4 problems and asking for 5 and then loading every
problem and asking for more than that.
"""
self.enroll_student(self.STUDENTS[0]['email'],
self.STUDENTS[0]['password'], self.course_actual)
self.enroll_student(self.STUDENTS[0]['email'],
self.STUDENTS[0]['password'], self.course_review)
# Want to load fewer problems than num_desired
self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': self.section1_actual.location.name,
}))
if num_desired > 6:
self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': self.section2_actual.location.name,
}))
self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': self.section3_actual.location.name,
}))
with self.store.bulk_operations(self.course_actual.id,
emit_signals=False):
review_section_actual = ItemFactory.create(
parent=self.chapter_actual, display_name='Review Subsection')
review_unit_actual = ItemFactory.create(
parent=review_section_actual, display_name='Review Unit')
review_xblock_actual = ItemFactory.create( # pylint: disable=unused-variable
parent=review_unit_actual,
category='review',
display_name='Review Tool',
num_desired=num_desired)
# Loading the review section
response = self.client.get(
reverse('courseware_section',
kwargs={
'course_id': self.course_actual.id,
'chapter': self.chapter_actual.location.name,
'section': review_section_actual.location.name,
}))
expected_h2 = 'Nothing to review'
self.assertIn(expected_h2, response.content)
def setUp(self):
super(TestRebindModule, self).setUp()
self.homework = self.add_graded_section_to_course('homework')
self.lti = ItemFactory.create(category='lti', parent=self.homework)
self.user = UserFactory.create()
self.anon_user = AnonymousUser()
def _add_simple_content_block(self):
""" Adds simple HTML block to library """
return ItemFactory.create(
category="html", parent_location=self.library.location,
user_id=self.user.id, publish_item=False
)
def setup_data(self, store_type=ModuleStoreEnum.Type.mongo):
""" Create courses and add some test blocks. """
with self.store.default_store(store_type):
self.course = CourseFactory.create(
display_name='An Introduction to API Testing')
self.course_id = text_type(self.course.id)
with self.store.bulk_operations(self.course.id):
self.chapter_1 = ItemFactory.create(
parent_location=self.course.location,
category='chapter',
display_name='Week 1')
self.chapter_2 = ItemFactory.create(
parent_location=self.course.location,
category='chapter',
display_name='Week 2')
self.sequential_1 = ItemFactory.create(
parent_location=self.chapter_1.location,
category='sequential',
display_name='Lesson 1')
self.sequential_2 = ItemFactory.create(
parent_location=self.chapter_1.location,
category='sequential',
display_name='Lesson 2')
self.vertical_1 = ItemFactory.create(
parent_location=self.sequential_1.location,
category='vertical',
display_name='Subsection 1')
self.vertical_2 = ItemFactory.create(
parent_location=self.sequential_2.location,
category='vertical',
display_name='Subsection 2')
self.vertical_3 = ItemFactory.create(
parent_location=self.sequential_2.location,
category='vertical',
display_name='Subsection 3')
self.html_1 = ItemFactory.create(
parent_location=self.vertical_2.location,
category='html',
display_name='Details 1')
self.path = [
PathItem(self.chapter_1.location, self.chapter_1.display_name),
PathItem(self.sequential_2.location,
self.sequential_2.display_name),
]
self.bookmark_1 = BookmarkFactory.create(
user=self.user,
course_key=self.course_id,
usage_key=self.sequential_1.location,
xblock_cache=XBlockCache.create({
'display_name':
self.sequential_1.display_name,
'usage_key':
self.sequential_1.location,
}),
)
self.bookmark_2 = BookmarkFactory.create(
user=self.user,
course_key=self.course_id,
usage_key=self.sequential_2.location,
xblock_cache=XBlockCache.create({
'display_name':
self.sequential_2.display_name,
'usage_key':
self.sequential_2.location,
}),
)
self.bookmark_3 = BookmarkFactory.create(
user=self.user,
course_key=self.course_id,
usage_key=self.vertical_3.location,
xblock_cache=XBlockCache.create({
'display_name':
self.vertical_3.display_name,
'usage_key':
self.vertical_3.location,
}),
)
self.bookmark_4 = BookmarkFactory.create(
user=self.user,
course_key=self.course_id,
usage_key=self.chapter_2.location,
xblock_cache=XBlockCache.create({
'display_name':
self.chapter_2.display_name,
'usage_key':
self.chapter_2.location,
}),
)
self.other_course = CourseFactory.create(
display_name='An Introduction to API Testing 2')
with self.store.bulk_operations(self.other_course.id):
self.other_chapter_1 = ItemFactory.create(
parent_location=self.other_course.location,
category='chapter',
display_name='Other Week 1')
self.other_sequential_1 = ItemFactory.create(
parent_location=self.other_chapter_1.location,
category='sequential',
display_name='Other Lesson 1')
self.other_sequential_2 = ItemFactory.create(
parent_location=self.other_chapter_1.location,
category='sequential',
display_name='Other Lesson 2')
self.other_vertical_1 = ItemFactory.create(
parent_location=self.other_sequential_1.location,
category='vertical',
display_name='Other Subsection 1')
self.other_vertical_2 = ItemFactory.create(
parent_location=self.other_sequential_1.location,
category='vertical',
display_name='Other Subsection 2')
# self.other_vertical_1 has two parents
self.other_sequential_2.children.append(
self.other_vertical_1.location)
modulestore().update_item(self.other_sequential_2, self.admin.id)
self.other_bookmark_1 = BookmarkFactory.create(
user=self.user,
course_key=text_type(self.other_course.id),
usage_key=self.other_vertical_1.location,
xblock_cache=XBlockCache.create({
'display_name':
self.other_vertical_1.display_name,
'usage_key':
self.other_vertical_1.location,
}),
)
def setUpClass(cls):
"""
Set up an array of various courses to be tested.
"""
# setUpClassAndTestData() already calls setUpClass on SharedModuleStoreTestCase
# pylint: disable=super-method-not-called
with super(TestCourseOutlinePage, cls).setUpClassAndTestData():
cls.courses = []
course = CourseFactory.create()
with cls.store.bulk_operations(course.id):
chapter = ItemFactory.create(category='chapter', parent_location=course.location)
sequential = ItemFactory.create(category='sequential', parent_location=chapter.location)
vertical = ItemFactory.create(category='vertical', parent_location=sequential.location)
course.children = [chapter]
chapter.children = [sequential]
sequential.children = [vertical]
cls.courses.append(course)
course = CourseFactory.create()
with cls.store.bulk_operations(course.id):
chapter = ItemFactory.create(category='chapter', parent_location=course.location)
sequential = ItemFactory.create(category='sequential', parent_location=chapter.location)
sequential2 = ItemFactory.create(category='sequential', parent_location=chapter.location)
vertical = ItemFactory.create(
category='vertical',
parent_location=sequential.location,
display_name="Vertical 1"
)
vertical2 = ItemFactory.create(
category='vertical',
parent_location=sequential2.location,
display_name="Vertical 2"
)
course.children = [chapter]
chapter.children = [sequential, sequential2]
sequential.children = [vertical]
sequential2.children = [vertical2]
cls.courses.append(course)
course = CourseFactory.create()
with cls.store.bulk_operations(course.id):
chapter = ItemFactory.create(category='chapter', parent_location=course.location)
sequential = ItemFactory.create(
category='sequential',
parent_location=chapter.location,
due=datetime.datetime.now(),
graded=True,
format='Homework',
)
vertical = ItemFactory.create(category='vertical', parent_location=sequential.location)
course.children = [chapter]
chapter.children = [sequential]
sequential.children = [vertical]
cls.courses.append(course)
def test_item_factory(self):
"""Test that the item factory works correctly."""
course = CourseFactory.create()
item = ItemFactory.create(parent_location=course.location)
self.assertIsInstance(item, SequenceDescriptor)
def test_has_access_in_preview_mode_with_group(self):
"""
Test that a user masquerading as a member of a group sees appropriate content in preview mode.
"""
# Note about UserPartition and UserPartition Group IDs: these must not conflict with IDs used
# by dynamic user partitions.
partition_id = MINIMUM_STATIC_PARTITION_ID
group_0_id = MINIMUM_STATIC_PARTITION_ID + 1
group_1_id = MINIMUM_STATIC_PARTITION_ID + 2
user_partition = UserPartition(
partition_id,
'Test User Partition',
'', [Group(group_0_id, 'Group 1'),
Group(group_1_id, 'Group 2')],
scheme_id='cohort')
self.course.user_partitions.append(user_partition)
self.course.cohort_config = {'cohorted': True}
chapter = ItemFactory.create(category="chapter",
parent_location=self.course.location)
chapter.group_access = {partition_id: [group_0_id]}
modulestore().update_item(self.course, ModuleStoreEnum.UserID.test)
# User should not be able to preview when masquerading as student (and not in the group above).
with patch('courseware.access.get_user_role') as mock_user_role:
mock_user_role.return_value = 'student'
self.assertFalse(
bool(
access.has_access(self.global_staff,
'load',
chapter,
course_key=self.course.id)))
# Should be able to preview when in staff or instructor role.
for mocked_role in ['staff', 'instructor']:
with patch('courseware.access.get_user_role') as mock_user_role:
mock_user_role.return_value = mocked_role
self.assertTrue(
bool(
access.has_access(self.global_staff,
'load',
chapter,
course_key=self.course.id)))
# Now install masquerade group and set staff as a member of that.
self.assertEqual(
200,
masquerade_as_group_member(self.global_staff, self.course,
partition_id, group_0_id))
# Can load the chapter since user is in the group.
self.assertTrue(
bool(
access.has_access(self.global_staff,
'load',
chapter,
course_key=self.course.id)))
# Move the user to be a part of the second group.
self.assertEqual(
200,
masquerade_as_group_member(self.global_staff, self.course,
partition_id, group_1_id))
# Cannot load the chapter since user is in a different group.
self.assertFalse(
bool(
access.has_access(self.global_staff,
'load',
chapter,
course_key=self.course.id)))
def setUpClass(cls):
super(TestScoreForModule, cls).setUpClass()
cls.course = CourseFactory.create()
cls.a = ItemFactory.create(parent=cls.course,
category="chapter",
display_name="a")
cls.b = ItemFactory.create(parent=cls.a,
category="sequential",
display_name="b")
cls.c = ItemFactory.create(parent=cls.a,
category="sequential",
display_name="c")
cls.d = ItemFactory.create(parent=cls.b,
category="vertical",
display_name="d")
cls.e = ItemFactory.create(parent=cls.b,
category="vertical",
display_name="e")
cls.f = ItemFactory.create(parent=cls.b,
category="vertical",
display_name="f")
cls.g = ItemFactory.create(parent=cls.c,
category="vertical",
display_name="g")
cls.h = ItemFactory.create(parent=cls.d,
category="problem",
display_name="h")
cls.i = ItemFactory.create(parent=cls.d,
category="problem",
display_name="i")
cls.j = ItemFactory.create(parent=cls.e,
category="problem",
display_name="j")
cls.k = ItemFactory.create(parent=cls.e,
category="html",
display_name="k")
cls.l = ItemFactory.create(parent=cls.e,
category="problem",
display_name="l")
cls.m = ItemFactory.create(parent=cls.f,
category="html",
display_name="m")
cls.n = ItemFactory.create(parent=cls.g,
category="problem",
display_name="n")
cls.request = get_mock_request(UserFactory())
CourseEnrollment.enroll(cls.request.user, cls.course.id)
answer_problem(cls.course, cls.request, cls.h, score=2, max_value=5)
answer_problem(cls.course, cls.request, cls.i, score=3, max_value=5)
answer_problem(cls.course, cls.request, cls.j, score=0, max_value=1)
answer_problem(cls.course, cls.request, cls.l, score=1, max_value=3)
answer_problem(cls.course, cls.request, cls.n, score=3, max_value=10)
cls.course_grade = CourseGradeFactory(cls.request.user).create(
cls.course)
def setUp(self):
super().setUp()
self.course = CourseFactory.create()
for i in range(4):
ItemFactory(parent=self.course, category="sequential", display_name="Section {}".format(i))
def test_studio_user_permissions(self):
"""
Test that user could attach to the problem only libraries that he has access (or which were created by him).
This test was created on the basis of bug described in the pull requests on github:
https://github.com/edx/edx-platform/pull/11331
https://github.com/edx/edx-platform/pull/11611
"""
self._create_library(org='admin_org_1',
library='lib_adm_1',
display_name='admin_lib_1')
self._create_library(org='admin_org_2',
library='lib_adm_2',
display_name='admin_lib_2')
self._login_as_non_staff_user()
self._create_library(org='staff_org_1',
library='lib_staff_1',
display_name='staff_lib_1')
self._create_library(org='staff_org_2',
library='lib_staff_2',
display_name='staff_lib_2')
with modulestore().default_store(ModuleStoreEnum.Type.split):
course = CourseFactory.create()
instructor_role = CourseInstructorRole(course.id)
auth.add_users(self.user, instructor_role, self.non_staff_user)
lib_block = ItemFactory.create(category='library_content',
parent_location=course.location,
user_id=self.non_staff_user.id,
publish_item=False)
def _get_settings_html():
"""
Helper function to get block settings HTML
Used to check the available libraries.
"""
edit_view_url = reverse_usage_url("xblock_view_handler",
lib_block.location,
{"view_name": STUDIO_VIEW})
resp = self.client.get_json(edit_view_url)
self.assertEquals(resp.status_code, 200)
return parse_json(resp)['html']
self._login_as_staff_user()
staff_settings_html = _get_settings_html()
self.assertIn('staff_lib_1', staff_settings_html)
self.assertIn('staff_lib_2', staff_settings_html)
self.assertIn('admin_lib_1', staff_settings_html)
self.assertIn('admin_lib_2', staff_settings_html)
self._login_as_non_staff_user()
response = self.client.get_json(LIBRARY_REST_URL)
staff_libs = parse_json(response)
self.assertEquals(2, len(staff_libs))
non_staff_settings_html = _get_settings_html()
self.assertIn('staff_lib_1', non_staff_settings_html)
self.assertIn('staff_lib_2', non_staff_settings_html)
self.assertNotIn('admin_lib_1', non_staff_settings_html)
self.assertNotIn('admin_lib_2', non_staff_settings_html)
def setUpClass(cls):
super(TestGetModuleScore, cls).setUpClass()
cls.course = CourseFactory.create()
cls.chapter = ItemFactory.create(parent=cls.course,
category="chapter",
display_name="Test Chapter")
cls.seq1 = ItemFactory.create(parent=cls.chapter,
category='sequential',
display_name="Test Sequential 1",
graded=True)
cls.seq2 = ItemFactory.create(parent=cls.chapter,
category='sequential',
display_name="Test Sequential 2",
graded=True)
cls.seq3 = ItemFactory.create(parent=cls.chapter,
category='sequential',
display_name="Test Sequential 3",
graded=True)
cls.vert1 = ItemFactory.create(parent=cls.seq1,
category='vertical',
display_name='Test Vertical 1')
cls.vert2 = ItemFactory.create(parent=cls.seq2,
category='vertical',
display_name='Test Vertical 2')
cls.vert3 = ItemFactory.create(parent=cls.seq3,
category='vertical',
display_name='Test Vertical 3')
cls.randomize = ItemFactory.create(parent=cls.vert2,
category='randomize',
display_name='Test Randomize')
cls.library_content = ItemFactory.create(
parent=cls.vert3,
category='library_content',
display_name='Test Library Content')
problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 3',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3'])
cls.problem1 = ItemFactory.create(parent=cls.vert1,
category="problem",
display_name="Test Problem 1",
data=problem_xml)
cls.problem2 = ItemFactory.create(parent=cls.vert1,
category="problem",
display_name="Test Problem 2",
data=problem_xml)
cls.problem3 = ItemFactory.create(parent=cls.randomize,
category="problem",
display_name="Test Problem 3",
data=problem_xml)
cls.problem4 = ItemFactory.create(parent=cls.randomize,
category="problem",
display_name="Test Problem 4",
data=problem_xml)
cls.problem5 = ItemFactory.create(parent=cls.library_content,
category="problem",
display_name="Test Problem 5",
data=problem_xml)
cls.problem6 = ItemFactory.create(parent=cls.library_content,
category="problem",
display_name="Test Problem 6",
data=problem_xml)
def setUp(self):
super(TestCourseUpdateResolver, self).setUp()
self.course = CourseFactory(highlights_enabled_for_messaging=True, self_paced=True)
with self.store.bulk_operations(self.course.id):
ItemFactory.create(parent=self.course, category='chapter', highlights=[u'good stuff'])
def setUpClass(cls):
super(TestFindUnit, cls).setUpClass()
cls.course = CourseFactory.create()
with cls.store.bulk_operations(cls.course.id, emit_signals=False):
week1 = ItemFactory.create(parent=cls.course)
cls.homework = ItemFactory.create(parent=week1)
def set_up_course(self,
enable_persistent_grades=True,
create_multiple_subsections=False,
course_end=None):
"""
Configures the course for this test.
"""
self.course = CourseFactory.create(org='edx',
name='course',
run='run',
end=course_end)
if not enable_persistent_grades:
PersistentGradesEnabledFlag.objects.create(enabled=False)
self.chapter = ItemFactory.create(parent=self.course,
category="chapter",
display_name="Chapter")
self.sequential = ItemFactory.create(parent=self.chapter,
category='sequential',
display_name="Sequential1")
self.problem = ItemFactory.create(parent=self.sequential,
category='problem',
display_name='Problem')
if create_multiple_subsections:
seq2 = ItemFactory.create(parent=self.chapter,
category='sequential')
ItemFactory.create(parent=seq2, category='problem')
self.frozen_now_datetime = datetime.now().replace(tzinfo=pytz.UTC)
self.frozen_now_timestamp = to_timestamp(self.frozen_now_datetime)
self.problem_weighted_score_changed_kwargs = OrderedDict([
('weighted_earned', 1.0),
('weighted_possible', 2.0),
('user_id', self.user.id),
('anonymous_user_id', 5),
('course_id', unicode(self.course.id)),
('usage_id', unicode(self.problem.location)),
('only_if_higher', None),
('modified', self.frozen_now_datetime),
('score_db_table',
ScoreDatabaseTableEnum.courseware_student_module),
])
create_new_event_transaction_id()
self.recalculate_subsection_grade_kwargs = OrderedDict([
('user_id', self.user.id),
('course_id', unicode(self.course.id)),
('usage_id', unicode(self.problem.location)),
('anonymous_user_id', 5),
('only_if_higher', None),
('expected_modified_time', self.frozen_now_timestamp),
('score_deleted', False),
('event_transaction_id', unicode(get_event_transaction_id())),
('event_transaction_type', u'edx.grades.problem.submitted'),
('score_db_table',
ScoreDatabaseTableEnum.courseware_student_module),
])
# this call caches the anonymous id on the user object, saving 4 queries in all happy path tests
_ = anonymous_id_for_user(self.user, self.course.id)
def initialize_course(cls, course):
"""
Sets up the structure of the test course.
"""
course.self_paced = True
cls.store.update_item(course, cls.staff.id)
cls.section = ItemFactory.create(
parent_location=course.location,
category="chapter",
)
cls.subsection1 = ItemFactory.create(
parent_location=cls.section.location,
category="sequential",
)
unit1 = ItemFactory.create(
parent_location=cls.subsection1.location,
category="vertical",
)
ItemFactory.create(
parent_location=unit1.location,
category="video",
)
ItemFactory.create(
parent_location=unit1.location,
category="problem",
)
cls.subsection2 = ItemFactory.create(
parent_location=cls.section.location,
category="sequential",
)
unit2 = ItemFactory.create(
parent_location=cls.subsection2.location,
category="vertical",
)
unit3 = ItemFactory.create(
parent_location=cls.subsection2.location,
category="vertical",
)
ItemFactory.create(
parent_location=unit3.location,
category="video",
)
ItemFactory.create(
parent_location=unit3.location,
category="video",
)
def setup_course_with_grading(self, start=None, end=None):
grading_course = CourseFactory.create(
start=start,
end=end,
org='gradeX',
run='GRAD1',
display_name="Test Grading Course",
grading_policy={
"GRADER": [
{
"type": "Homework",
"min_count": 1,
"drop_count": 0,
"short_label": "HW",
"weight": 0.5
},
{
"type": "Midterm Exam",
"min_count": 1,
"drop_count": 0,
"short_label": "ME",
"weight": 0.5
},
],
"GRADE_CUTOFFS": {
'A': .9,
'B': .33
}
},
)
test_data = '<html>{}</html>'.format(str(uuid.uuid4()))
chapter1 = ItemFactory.create(
category="chapter",
parent_location=grading_course.location,
display_name="Chapter 1",
)
chapter2 = ItemFactory.create(
category="chapter",
parent_location=grading_course.location,
display_name="Chapter 2",
)
ItemFactory.create(
category="sequential",
parent_location=chapter1.location,
display_name="Sequence 1",
)
sequential2 = ItemFactory.create(
category="sequential",
parent_location=chapter2.location,
display_name="Sequence 2",
graded=True,
metadata={
'rerandomize': 'always',
'graded': True,
'format': "Homework"
},
)
vertical1 = ItemFactory.create(
category="vertical",
parent_location=sequential2.location,
display_name="Vertical 1",
)
sequential3 = ItemFactory.create(
category="sequential",
parent_location=chapter2.location,
display_name="Sequence 3",
graded=True,
metadata={
'rerandomize': 'always',
'graded': True,
'format': "Midterm Exam"
},
)
vertical2 = ItemFactory.create(
category="vertical",
parent_location=sequential3.location,
display_name="Vertical 2",
)
item = ItemFactory.create(
parent_location=vertical1.location,
category='mentoring',
display_name=u"test mentoring homework",
)
item2 = ItemFactory.create(
parent_location=vertical2.location,
category='mentoring',
display_name=u"test mentoring midterm",
)
grading_course = self.store.get_course(grading_course.id)
setattr(grading_course, 'homework_assignment', item)
setattr(grading_course, 'midterm_assignment', item2)
return grading_course
def setUp(self):
"""
Preparation for the test execution
"""
super(StructuredTagsAsideTestCase, self).setUp()
self.aside_name = 'tagging_aside'
self.aside_tag_dif = 'difficulty'
self.aside_tag_dif_value = 'Hard'
self.aside_tag_dif_value2 = 'Easy'
self.aside_tag_lo = 'learning_outcome'
course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split)
self.course = ItemFactory.create(
parent_location=course.location,
category="course",
display_name="Test course",
)
self.chapter = ItemFactory.create(
parent_location=self.course.location,
category='chapter',
display_name="Week 1",
publish_item=True,
start=datetime(2015, 3, 1, tzinfo=UTC),
)
self.sequential = ItemFactory.create(
parent_location=self.chapter.location,
category='sequential',
display_name="Lesson 1",
publish_item=True,
start=datetime(2015, 3, 1, tzinfo=UTC),
)
self.vertical = ItemFactory.create(
parent_location=self.sequential.location,
category='vertical',
display_name='Subsection 1',
publish_item=True,
start=datetime(2015, 4, 1, tzinfo=UTC),
)
self.problem = ItemFactory.create(
category="problem",
parent_location=self.vertical.location,
display_name="A Problem Block",
weight=1,
user_id=self.user.id,
publish_item=False,
)
self.video = ItemFactory.create(parent_location=self.vertical.location,
category='video',
display_name='My Video',
user_id=self.user.id)
_init_data = [{
'name': 'difficulty',
'title': 'Difficulty',
'values': ['Easy', 'Medium', 'Hard'],
}, {
'name':
'learning_outcome',
'title':
'Learning outcome',
'values':
['Learned nothing', 'Learned a few things', 'Learned everything']
}]
for tag in _init_data:
category = TagCategories.objects.create(name=tag['name'],
title=tag['title'])
for val in tag['values']:
TagAvailableValues.objects.create(category=category, value=val)
config = StudioConfig.current()
config.enabled = True
config.save()
def set_up_course(cls):
"""
Set up a course for testing gated content.
"""
cls.course = CourseFactory.create(org='edX',
number='EDX101',
run='EDX101_RUN1',
display_name='edX 101')
with modulestore().bulk_operations(cls.course.id):
cls.course.enable_subsection_gating = True
grading_policy = {
"GRADER": [{
"type": "Homework",
"min_count": 3,
"drop_count": 0,
"short_label": "HW",
"weight": 1.0
}]
}
cls.course.grading_policy = grading_policy
cls.course.save()
cls.store.update_item(cls.course, 0)
# create chapter
cls.chapter1 = ItemFactory.create(
parent_location=cls.course.location,
category='chapter',
display_name='chapter 1')
# create sequentials
cls.seq1 = ItemFactory.create(
parent_location=cls.chapter1.location,
category='sequential',
display_name='gating sequential 1',
graded=True,
format='Homework',
)
cls.seq2 = ItemFactory.create(
parent_location=cls.chapter1.location,
category='sequential',
display_name='gated sequential 2',
graded=True,
format='Homework',
)
cls.seq3 = ItemFactory.create(
parent_location=cls.chapter1.location,
category='sequential',
display_name='sequential 3',
graded=True,
format='Homework',
)
# create problem
cls.gating_prob1 = ItemFactory.create(
parent_location=cls.seq1.location,
category='problem',
display_name='gating problem 1',
)
cls.gated_prob2 = ItemFactory.create(
parent_location=cls.seq2.location,
category='problem',
display_name='gated problem 2',
)
cls.prob3 = ItemFactory.create(
parent_location=cls.seq3.location,
category='problem',
display_name='problem 3',
)
def setUp(self):
super(TestRecommender, self).setUp()
self.course = CourseFactory.create(
display_name='Recommender_Test_Course')
self.chapter = ItemFactory.create(parent=self.course,
display_name='Overview')
self.section = ItemFactory.create(parent=self.chapter,
display_name='Welcome')
self.unit = ItemFactory.create(parent=self.section,
display_name='New Unit')
self.xblock = ItemFactory.create(parent=self.unit,
category='recommender',
display_name='recommender')
self.xblock2 = ItemFactory.create(parent=self.unit,
category='recommender',
display_name='recommender_second')
self.course_url = reverse('courseware_section',
kwargs={
'course_id':
self.course.id.to_deprecated_string(),
'chapter':
'Overview',
'section':
'Welcome',
})
self.resource_urls = [
("https://courses.edx.org/courses/MITx/3.091X/"
"2013_Fall/courseware/SP13_Week_4/"
"SP13_Periodic_Trends_and_Bonding/"),
("https://courses.edx.org/courses/MITx/3.091X/"
"2013_Fall/courseware/SP13_Week_4/SP13_Covalent_Bonding/")
]
self.test_recommendations = {
self.resource_urls[0]: {
"title":
"Covalent bonding and periodic trends",
"url":
self.resource_urls[0],
"description": ("http://people.csail.mit.edu/swli/edx/"
"recommendation/img/videopage1.png"),
"descriptionText": ("short description for Covalent bonding "
"and periodic trends")
},
self.resource_urls[1]: {
"title":
"Polar covalent bonds and electronegativity",
"url":
self.resource_urls[1],
"description": ("http://people.csail.mit.edu/swli/edx/"
"recommendation/img/videopage2.png"),
"descriptionText": ("short description for Polar covalent "
"bonds and electronegativity")
}
}
for idx, student in enumerate(self.STUDENTS):
username = "******".format(idx)
self.create_account(username, student['email'],
student['password'])
self.activate_user(student['email'])
self.staff_user = GlobalStaffFactory()
def setUp(self):
super(TestNavigation, self).setUp()
self.test_course = CourseFactory.create()
self.course = CourseFactory.create()
self.chapter0 = ItemFactory.create(parent=self.course,
display_name='Overview')
self.chapter9 = ItemFactory.create(parent=self.course,
display_name='factory_chapter')
self.section0 = ItemFactory.create(parent=self.chapter0,
display_name='Welcome')
self.section9 = ItemFactory.create(parent=self.chapter9,
display_name='factory_section')
self.unit0 = ItemFactory.create(parent=self.section0,
display_name='New Unit')
self.chapterchrome = ItemFactory.create(parent=self.course,
display_name='Chrome')
self.chromelesssection = ItemFactory.create(parent=self.chapterchrome,
display_name='chromeless',
chrome='none')
self.accordionsection = ItemFactory.create(parent=self.chapterchrome,
display_name='accordion',
chrome='accordion')
self.tabssection = ItemFactory.create(parent=self.chapterchrome,
display_name='tabs',
chrome='tabs')
self.defaultchromesection = ItemFactory.create(
parent=self.chapterchrome,
display_name='defaultchrome',
)
self.fullchromesection = ItemFactory.create(parent=self.chapterchrome,
display_name='fullchrome',
chrome='accordion,tabs')
self.tabtest = ItemFactory.create(parent=self.chapterchrome,
display_name='progress_tab',
default_tab='progress')
# Create student accounts and activate them.
for i in range(len(self.STUDENT_INFO)):
email, password = self.STUDENT_INFO[i]
username = '******'.format(i)
self.create_account(username, email, password)
self.activate_user(email)
self.staff_user = GlobalStaffFactory()
def test_unit_in_section(self):
"""
Test when the structure is Course -> Section -> Unit.
Studio disallows this, but it's possible to craft in OLX. This type of
structure is unsupported. We should fail with a CourseStructureError, as
that will emit useful debug information.
"""
# Course -> Section -> Unit (No Sequence)
with self.store.bulk_operations(self.course_key):
section_1 = ItemFactory.create(
parent=self.draft_course,
category='chapter',
display_name="Section",
)
# This Unit should be skipped
ItemFactory.create(parent=section_1,
category='vertical',
display_name="u1")
ItemFactory.create(parent=section_1,
category='sequential',
display_name="standard_seq")
ItemFactory.create(parent=section_1,
category='sequential',
display_name="pset_seq")
ItemFactory.create(parent=section_1,
category='sequential',
display_name="video_seq")
# This should work fine
section_2 = ItemFactory.create(
parent=self.draft_course,
category='chapter',
display_name="Section 2",
)
# Second error message here
ItemFactory.create(parent=section_2,
category='vertical',
display_name="u2")
outline, errs = get_outline_from_modulestore(self.course_key)
assert len(outline.sections) == 2
assert len(outline.sections[0].sequences) == 3
assert len(outline.sections[1].sequences) == 0
assert len(outline.sequences) == 3
# Version-less usage keys
unit_1_loc = self.course_key.make_usage_key('vertical', 'u1')
unit_2_loc = self.course_key.make_usage_key('vertical', 'u2')
assert errs[0].usage_key == unit_1_loc
assert errs[1].usage_key == unit_2_loc
