def setUp(self):
super(RolesTest, self).setUp()
actions.login(COURSE_ADMIN_EMAIL, is_admin=True)
payload_dict = {
'name': COURSE_NAME,
'title': 'Roles Test',
'admin_email': COURSE_ADMIN_EMAIL
}
request = {
'payload':
transforms.dumps(payload_dict),
'xsrf_token':
crypto.XsrfTokenManager.create_xsrf_token('add-course-put')
}
response = self.testapp.put(
'/rest/courses/item?%s' %
urllib.urlencode({'request': transforms.dumps(request)}), {})
self.assertEquals(response.status_int, 200)
sites.setup_courses('course:/%s::ns_%s, course:/:/' %
(COURSE_NAME, COURSE_NAME))
actions.logout()
config.Registry.test_overrides[roles.GCB_ADMIN_LIST.name] = (
'[%s]' % SITE_ADMIN_EMAIL)
# pylint: disable-msg=protected-access
self.old_registered_permission = roles.Roles._REGISTERED_PERMISSIONS
roles.Roles._REGISTERED_PERMISSIONS = {}
config.Registry.test_overrides[models.CAN_USE_MEMCACHE.name] = True
def setUp(self):
super(WhitelistTest, self).setUp()
config.Registry.test_overrides[
course_explorer.GCB_ENABLE_COURSE_EXPLORER_PAGE.name] = True
actions.login(ADMIN_EMAIL, is_admin=True)
payload_dict = {
'name': COURSE_NAME,
'title': 'Whitelist Test',
'admin_email': ADMIN_EMAIL
}
request = {
'payload':
transforms.dumps(payload_dict),
'xsrf_token':
crypto.XsrfTokenManager.create_xsrf_token('add-course-put')
}
response = self.testapp.put(
'/rest/courses/item?%s' %
urllib.urlencode({'request': transforms.dumps(request)}), {})
self.assertEquals(response.status_int, 200)
sites.setup_courses('course:/%s::ns_%s, course:/:/' %
(COURSE_NAME, COURSE_NAME))
actions.logout()
def test_multiple_course(self):
"""Tests when multiple courses are available."""
sites.setup_courses('course:/test::ns_test, course:/:/')
name = 'Test completed course'
email = 'Student'
# Make the course available.
get_environ_old = sites.ApplicationContext.get_environ
def get_environ_new(self):
environ = get_environ_old(self)
environ['course']['now_available'] = True
return environ
sites.ApplicationContext.get_environ = get_environ_new
actions.login(email)
actions.register(self, name)
response = self.get('/explorer/courses')
# Assert if 'View course list' text is shown on my course page.
actions.assert_contains('View course list', response.body)
# Clean up app_context.
sites.ApplicationContext.get_environ = get_environ_old
sites.reset_courses()
def setUp(self):
super(GuideTests, self).setUp()
entries = []
for name, availability in self.ALL_COURSES:
self._import_sample_course(ns=name, availability=availability)
entries.append("course:/%s::ns_%s\n" % (name, name))
sites.setup_courses("".join(entries))
def setUp(self):
"""Configures EtlMainTestCase."""
super(EtlTestBase, self).setUp()
self.url_prefix = '/test'
self.namespace = 'ns_test'
self.raw = 'course:%s::%s' % (self.url_prefix, self.namespace)
sites.setup_courses(self.raw + ', course:/:/')
def test_unicode_pages(self):
# TODO(emichael): Remove try, except, else when the unicode issue
# is fixed in dev_appserver.
try:
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None,
app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.now_available = True
lesson_a = course.add_lesson(unit)
lesson_a.notes = search_unit_test.UNICODE_PAGE_URL
lesson_a.now_available = True
course.update_unit(unit)
course.save()
self.index_test_course()
self.swap(logging, 'error', self.error_report)
response = self.get('/test/search?query=paradox')
self.assertEqual('', self.logged_error)
self.assertNotIn('unavailable', response.body)
self.assertIn('gcb-search-result', response.body)
except AssertionError:
# Failing due to known unicode issue
pass
else:
raise AssertionError('Unicode search test should have failed. The '
'issue might now be fixed in dev_appserver.')
def test_unicode_pages(self):
# TODO(emichael): Remove try, except, else when the unicode issue
# is fixed in dev_appserver.
try:
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None,
app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.now_available = True
lesson_a = course.add_lesson(unit)
lesson_a.notes = search_unit_test.UNICODE_PAGE_URL
lesson_a.now_available = True
course.update_unit(unit)
course.save()
self.index_test_course()
self.swap(logging, 'error', self.error_report)
response = self.get('/test/search?query=paradox')
self.assertEqual('', self.logged_error)
self.assertNotIn('unavailable', response.body)
self.assertIn('gcb-search-result', response.body)
except AssertionError:
# Failing due to known unicode issue
pass
else:
raise AssertionError('Unicode search test should have failed. The '
'issue might now be fixed in dev_appserver.')
def test_private_units_and_lessons(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
lesson11 = course.add_lesson(unit1)
lesson11.notes = search_unit_tests.VALID_PAGE_URL
lesson11.objectives = search_unit_tests.VALID_PAGE
lesson11.video = 'portal'
unit2 = course.add_unit()
lesson21 = course.add_lesson(unit2)
lesson21.notes = search_unit_tests.VALID_PAGE_URL
lesson21.objectives = search_unit_tests.VALID_PAGE
lesson21.video = 'portal'
unit1.availability = courses.AVAILABILITY_AVAILABLE
lesson11.availability = courses.AVAILABILITY_UNAVAILABLE
course.update_unit(unit1)
unit2.availability = courses.AVAILABILITY_UNAVAILABLE
lesson21.availability = courses.AVAILABILITY_AVAILABLE
course.update_unit(unit2)
course.save()
self.index_test_course()
response = self.get('/test/search?query=cogito%20ergo%20sum')
self.assertNotIn('gcb-search-result', response.body)
response = self.get('/test/search?query=apple')
self.assertNotIn('gcb-search-result', response.body)
self.assertNotIn('v=portal', response.body)
def test_get_entity_id_wrapper_in_progress_works(self):
"""Tests get_entity_id wrappers in progress.ProgressStats."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
progress_stats = ProgressStats(course)
unit1 = course.add_unit()
assert_equals(
progress_stats._get_unit_ids_of_type_unit(), [unit1.unit_id])
assessment1 = course.add_assessment()
assert_equals(
progress_stats._get_assessment_ids(), [assessment1.unit_id])
lesson11 = course.add_lesson(unit1)
lesson12 = course.add_lesson(unit1)
assert_equals(
progress_stats._get_lesson_ids(unit1.unit_id),
[lesson11.lesson_id, lesson12.lesson_id])
lesson11.has_activity = True
course.set_activity_content(lesson11, u'var activity=[]', [])
assert_equals(
progress_stats._get_activity_ids(unit1.unit_id, lesson11.lesson_id),
[0])
assert_equals(
progress_stats._get_activity_ids(unit1.unit_id, lesson12.lesson_id),
[])
def test_external_links(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.availability = courses.AVAILABILITY_AVAILABLE
lesson_a = course.add_lesson(unit)
lesson_a.notes = search_unit_tests.VALID_PAGE_URL
objectives_link = 'http://objectiveslink.null/'
lesson_a.objectives = '<a href="%s"></a><a href="%s"></a>' % (
search_unit_tests.LINKED_PAGE_URL, objectives_link)
lesson_a.availability = courses.AVAILABILITY_AVAILABLE
course.update_unit(unit)
course.save()
self.index_test_course()
response = self.get('/test/search?query=What%20hath%20God%20wrought')
self.assertIn('gcb-search-result', response.body)
response = self.get('/test/search?query=Cogito')
self.assertIn('gcb-search-result', response.body)
self.assertIn(search_unit_tests.VALID_PAGE_URL, response.body)
self.assertIn(objectives_link, response.body)
self.assertNotIn(search_unit_tests.PDF_URL, response.body)
# If this test fails, indexing will crawl the entire web
response = self.get('/test/search?query=ABORT')
self.assertNotIn('gcb-search-result', response.body)
self.assertNotIn(search_unit_tests.SECOND_LINK_PAGE_URL, response.body)
def test_private_units_and_lessons(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
lesson11 = course.add_lesson(unit1)
lesson11.notes = search_unit_tests.VALID_PAGE_URL
lesson11.objectives = search_unit_tests.VALID_PAGE
lesson11.video = 'portal'
unit2 = course.add_unit()
lesson21 = course.add_lesson(unit2)
lesson21.notes = search_unit_tests.VALID_PAGE_URL
lesson21.objectives = search_unit_tests.VALID_PAGE
lesson21.video = 'portal'
unit1.availability = courses.AVAILABILITY_AVAILABLE
lesson11.availability = courses.AVAILABILITY_UNAVAILABLE
course.update_unit(unit1)
unit2.availability = courses.AVAILABILITY_UNAVAILABLE
lesson21.availability = courses.AVAILABILITY_AVAILABLE
course.update_unit(unit2)
course.save()
self.index_test_course()
response = self.get('/test/search?query=cogito%20ergo%20sum')
self.assertNotIn('gcb-search-result', response.body)
response = self.get('/test/search?query=apple')
self.assertNotIn('gcb-search-result', response.body)
self.assertNotIn('v=portal', response.body)
def setUp(self):
super(GuideTests, self).setUp()
entries = []
for name, availability in self.ALL_COURSES:
self._import_sample_course(ns=name, availability=availability)
entries.append('course:/%s::ns_%s\n' % (name, name))
sites.setup_courses(''.join(entries))
def test_compute_entity_dict_constructs_dict_correctly(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
progress_stats = ProgressStats(course)
course_dict = progress_stats.compute_entity_dict('course', [])
assert_equals(course_dict, {
'label': 'UNTITLED COURSE', 'u': {}, 's': {}})
def test_external_links(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.availability = courses.AVAILABILITY_AVAILABLE
lesson_a = course.add_lesson(unit)
lesson_a.notes = search_unit_tests.VALID_PAGE_URL
objectives_link = 'http://objectiveslink.null/'
lesson_a.objectives = '<a href="%s"></a><a href="%s"></a>' % (
search_unit_tests.LINKED_PAGE_URL, objectives_link)
lesson_a.availability = courses.AVAILABILITY_AVAILABLE
course.update_unit(unit)
course.save()
self.index_test_course()
response = self.get('/test/search?query=What%20hath%20God%20wrought')
self.assertIn('gcb-search-result', response.body)
response = self.get('/test/search?query=Cogito')
self.assertIn('gcb-search-result', response.body)
self.assertIn(search_unit_tests.VALID_PAGE_URL, response.body)
self.assertIn(objectives_link, response.body)
self.assertNotIn(search_unit_tests.PDF_URL, response.body)
# If this test fails, indexing will crawl the entire web
response = self.get('/test/search?query=ABORT')
self.assertNotIn('gcb-search-result', response.body)
self.assertNotIn(search_unit_tests.SECOND_LINK_PAGE_URL, response.body)
def update_course_config(name, settings):
"""Merge settings into the saved course.yaml configuration.
Args:
name: Name of the course. E.g., 'my_test_course'.
settings: A nested dict of name/value settings. Names for items here
can be found in modules/dashboard/course_settings.py in
create_course_registry. See below in simple_add_course()
for an example.
Returns:
Context object for the modified course.
"""
site_type = 'course'
namespace = 'ns_%s' % name
slug = '/%s' % name
rule = '%s:%s::%s' % (site_type, slug, namespace)
context = sites.get_all_courses(rule)[0]
environ = courses.deep_dict_merge(settings,
courses.Course.get_environ(context))
course = courses.Course(handler=None, app_context=context)
course.save_settings(environ)
course_config = config.Registry.test_overrides.get(
sites.GCB_COURSES_CONFIG.name, 'course:/:/')
if rule not in course_config:
course_config = '%s, %s' % (rule, course_config)
sites.setup_courses(course_config)
return context
def test_multiple_course(self):
"""Tests when multiple courses are available."""
sites.setup_courses('course:/test::ns_test, course:/:/')
name = 'Test completed course'
email = 'Student'
# Make the course available.
get_environ_old = sites.ApplicationContext.get_environ
def get_environ_new(self):
environ = get_environ_old(self)
environ['course']['now_available'] = True
return environ
sites.ApplicationContext.get_environ = get_environ_new
actions.login(email)
actions.register(self, name)
response = self.get('/explorer/courses')
# Assert if 'View course list' text is shown on my course page.
actions.assert_contains('View course list', response.body)
# Clean up app_context.
sites.ApplicationContext.get_environ = get_environ_old
sites.reset_courses()
def setUp(self):
super(RolesTest, self).setUp()
actions.login(COURSE_ADMIN_EMAIL, is_admin=True)
payload_dict = {
'name': COURSE_NAME,
'title': 'Roles Test',
'admin_email': COURSE_ADMIN_EMAIL}
request = {
'payload': transforms.dumps(payload_dict),
'xsrf_token': crypto.XsrfTokenManager.create_xsrf_token(
'add-course-put')}
response = self.testapp.put('/rest/courses/item?%s' % urllib.urlencode(
{'request': transforms.dumps(request)}), {})
self.assertEquals(response.status_int, 200)
sites.setup_courses('course:/%s::ns_%s, course:/:/' % (
COURSE_NAME, COURSE_NAME))
actions.logout()
config.Registry.test_overrides[roles.GCB_ADMIN_LIST.name] = (
'[%s]' % SITE_ADMIN_EMAIL)
# pylint: disable-msg=protected-access
self.old_registered_permission = roles.Roles._REGISTERED_PERMISSIONS
roles.Roles._REGISTERED_PERMISSIONS = {}
config.Registry.test_overrides[models.CAN_USE_MEMCACHE.name] = True
def test_compute_entity_dict_constructs_dict_correctly(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
progress_stats = ProgressStats(course)
course_dict = progress_stats.compute_entity_dict('course', [])
assert_equals(course_dict, {
'label': 'UNTITLED COURSE', 'u': {}, 's': {}})
def test_get_entity_id_wrapper_in_progress_works(self):
"""Tests get_entity_id wrappers in progress.ProgressStats."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
progress_stats = ProgressStats(course)
unit1 = course.add_unit()
# pylint: disable-msg=protected-access
assert_equals(
progress_stats._get_unit_ids_of_type_unit(), [unit1.unit_id])
assessment1 = course.add_assessment()
assert_equals(
progress_stats._get_assessment_ids(), [assessment1.unit_id])
lesson11 = course.add_lesson(unit1)
lesson12 = course.add_lesson(unit1)
assert_equals(
progress_stats._get_lesson_ids(unit1.unit_id),
[lesson11.lesson_id, lesson12.lesson_id])
lesson11.has_activity = True
course.set_activity_content(lesson11, u'var activity=[]', [])
assert_equals(
progress_stats._get_activity_ids(unit1.unit_id, lesson11.lesson_id),
[0])
assert_equals(
progress_stats._get_activity_ids(unit1.unit_id, lesson12.lesson_id),
[])
def test_compute_question_stats_on_empty_course_returns_empty_dicts(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
app_context = sites.get_all_courses()[0]
question_stats_computer = analytics.ComputeQuestionStats(app_context)
id_to_questions, id_to_assessments = question_stats_computer.run()
assert_equals({}, id_to_questions)
assert_equals({}, id_to_assessments)
def setUp(self):
super(UnsubscribeHandlerTests, self).setUp()
self.slug = "a"
self.namespace = "ns_a"
sites.setup_courses("course:/%s::%s" % (self.slug, self.namespace))
self.app_context = actions.MockAppContext(namespace=self.namespace, slug=self.slug)
self.handler = actions.MockHandler(base_href="http://localhost/", app_context=self.app_context)
self.email = "*****@*****.**"
actions.login(self.email, is_admin=True)
def test_compute_question_stats_on_empty_course_returns_empty_dicts(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
app_context = sites.get_all_courses()[0]
question_stats_computer = (
synchronous_providers.QuestionStatsGenerator(app_context))
id_to_questions, id_to_assessments = question_stats_computer.run()
assert_equals({}, id_to_questions)
assert_equals({}, id_to_assessments)
def test_compute_question_stats_on_empty_course_returns_empty_dicts(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
app_context = sites.get_all_courses()[0]
question_stats_computer = (
synchronous_providers.QuestionStatsGenerator(app_context))
id_to_questions, id_to_assessments = question_stats_computer.run()
assert_equals({}, id_to_questions)
assert_equals({}, id_to_assessments)
def setUp(self):
super(UnsubscribeHandlerTests, self).setUp()
self.slug = 'a'
self.namespace = 'ns_a'
sites.setup_courses('course:/%s::%s' % (self.slug, self.namespace))
self.app_context = actions.MockAppContext(namespace=self.namespace,
slug=self.slug)
self.handler = actions.MockHandler(base_href='http://localhost/',
app_context=self.app_context)
self.email = '*****@*****.**'
actions.login(self.email, is_admin=True)
def setUp(self):
super(UnsubscribeHandlerTests, self).setUp()
self.base = '/a'
self.namespace = 'ns_a'
sites.setup_courses('course:/a::ns_a')
self.app_context = actions.MockAppContext(
namespace=self.namespace, slug='a')
self.handler = actions.MockHandler(
base_href='http://localhost/',
app_context=self.app_context)
self.email = '*****@*****.**'
actions.login(self.email, is_admin=True)
def setUp(self):
super(WebservFunctionalTests, self).setUp()
sites.setup_courses('')
# make sure we know of all course availability values; if these change,
# we will need to revise how to apply rights to webserv content
self.assertEquals([
'private', 'public', 'registration_optional',
'registration_required'
], (sorted(courses.COURSE_AVAILABILITY_POLICIES.keys())))
self.assertEquals(['course', 'private', 'public'],
sorted(courses.AVAILABILITY_VALUES))
def setUp(self):
super(WebservFunctionalTests, self).setUp()
sites.setup_courses('')
# make sure we know of all course availability values; if these change,
# we will need to revise how to apply rights to webserv content
self.assertEquals([
'private', 'public',
'registration_optional', 'registration_required'], (
sorted(courses.COURSE_AVAILABILITY_POLICIES.keys())))
self.assertEquals(
['course', 'private', 'public'],
sorted(courses.AVAILABILITY_VALUES))
def setUp(self):
"""Configures EtlMainTestCase."""
super(EtlTestBase, self).setUp()
self.test_environ = copy.deepcopy(os.environ)
# In etl.main, use test auth scheme to avoid interactive login.
self.test_environ['SERVER_SOFTWARE'] = remote.TEST_SERVER_SOFTWARE
self.url_prefix = '/test'
self.namespace = 'ns_test'
self.raw = 'course:%s::%s' % (self.url_prefix, self.namespace)
self.swap(os, 'environ', self.test_environ)
sites.setup_courses(self.raw + ', course:/:/')
self.log_stream = cStringIO.StringIO()
self.old_log_handlers = list(etl._LOG.handlers)
etl._LOG.handlers = [logging.StreamHandler(self.log_stream)]
def setUp(self):
"""Configures EtlMainTestCase."""
super(EtlTestBase, self).setUp()
self.test_environ = copy.deepcopy(os.environ)
# In etl.main, use test auth scheme to avoid interactive login.
self.test_environ['SERVER_SOFTWARE'] = remote.TEST_SERVER_SOFTWARE
self.url_prefix = '/test'
self.namespace = 'ns_test'
self.raw = 'course:%s::%s' % (self.url_prefix, self.namespace)
self.swap(os, 'environ', self.test_environ)
sites.setup_courses(self.raw + ', course:/:/')
self.log_stream = cStringIO.StringIO()
self.old_log_handlers = list(etl._LOG.handlers)
etl._LOG.handlers = [logging.StreamHandler(self.log_stream)]
def test_get_summarized_question_list_from_event(self):
"""Tests the transform functions per event type."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
question_aggregator = (synchronous_providers.QuestionStatsGenerator
.MultipleChoiceQuestionAggregator(course))
event_payloads = open(os.path.join(
appengine_config.BUNDLE_ROOT,
'tests/unit/common/event_payloads.json')).read()
event_payload_dict = transforms.loads(event_payloads)
for event_info in event_payload_dict.values():
questions = question_aggregator._process_event(
event_info['event_source'], event_info['event_data'])
assert_equals(questions, event_info['transformed_dict_list'])
def test_get_summarized_question_list_from_event(self):
"""Tests the transform functions per event type."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
question_aggregator = (synchronous_providers.QuestionStatsGenerator.
MultipleChoiceQuestionAggregator(course))
event_payloads = open(
os.path.join(appengine_config.BUNDLE_ROOT,
'tests/unit/common/event_payloads.json')).read()
event_payload_dict = transforms.loads(event_payloads)
for event_info in event_payload_dict.values():
questions = question_aggregator._process_event(
event_info['event_source'], event_info['event_data'])
assert_equals(questions, event_info['transformed_dict_list'])
def test_unicode_pages(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.availability = courses.AVAILABILITY_AVAILABLE
lesson_a = course.add_lesson(unit)
lesson_a.notes = search_unit_tests.UNICODE_PAGE_URL
lesson_a.availability = courses.AVAILABILITY_AVAILABLE
course.update_unit(unit)
course.save()
self.index_test_course()
self.swap(logging, 'error', self.error_report)
response = self.get('/test/search?query=paradox')
self.assertEqual('', self.logged_error)
self.assertNotIn('unavailable', response.body)
self.assertIn('gcb-search-result', response.body)
def test_youtube(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
default_namespace = namespace_manager.get_namespace()
try:
namespace_manager.set_namespace('ns_test')
course = courses.Course(None,
app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.now_available = True
lesson_a = course.add_lesson(unit)
lesson_a.video = 'portal'
lesson_a.now_available = True
lesson_b = course.add_lesson(unit)
lesson_b.objectives = '<gcb-youtube videoid="glados">'
lesson_b.now_available = True
course.update_unit(unit)
course.save()
entity = announcements.AnnouncementEntity()
entity.html = '<gcb-youtube videoid="aperature">'
entity.title = 'Sample Announcement'
entity.date = datetime.datetime.now().date()
entity.is_draft = False
entity.put()
self.index_test_course()
response = self.get('/test/search?query=apple')
self.assertIn('gcb-search-result', response.body)
self.assertIn('start=3.14', response.body)
self.assertIn('v=portal', response.body)
self.assertIn('v=glados', response.body)
self.assertIn('v=aperature', response.body)
self.assertIn('lemon', response.body)
self.assertIn('Medicus Quis', response.body)
self.assertIn('- YouTube', response.body)
self.assertIn('http://thumbnail.null', response.body)
# Test to make sure empty notes field doesn't cause a urlfetch
response = self.get('/test/search?query=cogito')
self.assertNotIn('gcb-search-result', response.body)
finally:
namespace_manager.set_namespace(default_namespace)
def test_youtube(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
default_namespace = namespace_manager.get_namespace()
try:
namespace_manager.set_namespace('ns_test')
course = courses.Course(None,
app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.now_available = True
lesson_a = course.add_lesson(unit)
lesson_a.video = 'portal'
lesson_a.now_available = True
lesson_b = course.add_lesson(unit)
lesson_b.objectives = '<gcb-youtube videoid="glados">'
lesson_b.now_available = True
course.update_unit(unit)
course.save()
entity = announcements.AnnouncementEntity()
entity.html = '<gcb-youtube videoid="aperature">'
entity.title = 'Sample Announcement'
entity.date = datetime.datetime.now().date()
entity.is_draft = False
entity.put()
self.index_test_course()
response = self.get('/test/search?query=apple')
self.assertIn('gcb-search-result', response.body)
self.assertIn('start=3.14', response.body)
self.assertIn('v=portal', response.body)
self.assertIn('v=glados', response.body)
self.assertIn('v=aperature', response.body)
self.assertIn('lemon', response.body)
self.assertIn('Medicus Quis', response.body)
self.assertIn('- YouTube', response.body)
self.assertIn('http://thumbnail.null', response.body)
# Test to make sure empty notes field doesn't cause a urlfetch
response = self.get('/test/search?query=cogito')
self.assertNotIn('gcb-search-result', response.body)
finally:
namespace_manager.set_namespace(default_namespace)
def test_unicode_pages(self):
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None,
app_context=sites.get_all_courses()[0])
unit = course.add_unit()
unit.availability = courses.AVAILABILITY_AVAILABLE
lesson_a = course.add_lesson(unit)
lesson_a.notes = search_unit_tests.UNICODE_PAGE_URL
lesson_a.availability = courses.AVAILABILITY_AVAILABLE
course.update_unit(unit)
course.save()
self.index_test_course()
self.swap(logging, 'error', self.error_report)
response = self.get('/test/search?query=paradox')
self.assertEqual('', self.logged_error)
self.assertNotIn('unavailable', response.body)
self.assertIn('gcb-search-result', response.body)
def setUp(self):
super(WhitelistTest, self).setUp()
config.Registry.test_overrides[
course_explorer.GCB_ENABLE_COURSE_EXPLORER_PAGE.name] = True
actions.login(ADMIN_EMAIL, is_admin=True)
payload_dict = {
'name': COURSE_NAME,
'title': 'Whitelist Test',
'admin_email': ADMIN_EMAIL}
request = {
'payload': transforms.dumps(payload_dict),
'xsrf_token': crypto.XsrfTokenManager.create_xsrf_token(
'add-course-put')}
response = self.testapp.put('/rest/courses/item?%s' % urllib.urlencode(
{'request': transforms.dumps(request)}), {})
self.assertEquals(response.status_int, 200)
sites.setup_courses('course:/%s::ns_%s, course:/:/' % (
COURSE_NAME, COURSE_NAME))
actions.logout()
def setUp(self):
super(RolesTest, self).setUp()
actions.login(COURSE_ADMIN_EMAIL, is_admin=True)
payload_dict = {"name": COURSE_NAME, "title": "Roles Test", "admin_email": COURSE_ADMIN_EMAIL}
request = {
"payload": transforms.dumps(payload_dict),
"xsrf_token": crypto.XsrfTokenManager.create_xsrf_token("add-course-put"),
}
response = self.testapp.put(
"/rest/courses/item?%s" % urllib.urlencode({"request": transforms.dumps(request)}), {}
)
self.assertEquals(response.status_int, 200)
sites.setup_courses("course:/%s::ns_%s, course:/:/" % (COURSE_NAME, COURSE_NAME))
actions.logout()
config.Registry.test_overrides[roles.GCB_ADMIN_LIST.name] = "[%s]" % SITE_ADMIN_EMAIL
self.old_registered_permission = roles.Roles._REGISTERED_PERMISSIONS
roles.Roles._REGISTERED_PERMISSIONS = {}
config.Registry.test_overrides[models.CAN_USE_MEMCACHE.name] = True
def test_get_entity_label_wrapper_in_progress_works(self):
"""Tests get_entity_label wrappers in progress.ProgressStats."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
progress_stats = ProgressStats(course)
unit1 = course.add_unit()
# pylint: disable-msg=protected-access
assert_equals(
progress_stats._get_unit_label(unit1.unit_id),
'Unit %s' % unit1.index)
assessment1 = course.add_assessment()
assert_equals(
progress_stats._get_assessment_label(assessment1.unit_id),
assessment1.title)
lesson11 = course.add_lesson(unit1)
lesson12 = course.add_lesson(unit1)
assert_equals(
progress_stats._get_lesson_label(unit1.unit_id, lesson11.lesson_id),
lesson11.index)
lesson11.has_activity = True
course.set_activity_content(lesson11, u'var activity=[]', [])
assert_equals(
progress_stats._get_activity_label(
unit1.unit_id, lesson11.lesson_id, 0), 'L1.1')
assert_equals(
progress_stats._get_activity_label(
unit1.unit_id, lesson12.lesson_id, 0), 'L1.2')
lesson12.objectives = """
<question quid="123" weight="1" instanceid=1></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="456" instanceid=2></question-group>
yet_more_random_text
"""
assert_equals(
progress_stats._get_component_ids(
unit1.unit_id, lesson12.lesson_id, 0), [u'1', u'2'])
def _init_course(self, slug):
course = self._import_sample_course()
sites.setup_courses('course:/%s::ns_webserv' % slug)
return course
def test_compute_entity_dict_for_non_empty_course_correctly(self):
"""Tests correct entity_structure is built."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
assessment1 = course.add_assessment()
progress_stats = ProgressStats(course)
expected = {
'label': 'UNTITLED COURSE',
'u':
[{
'child_id': unit1.unit_id,
'child_val': {
'label': 'Unit %s' % unit1.index,
'l': [],
's': []
}
}],
's':
[{
'child_id': assessment1.unit_id,
'child_val': {'label': assessment1.title}
}]
}
assert_equals(
expected, progress_stats.compute_entity_dict('course', []))
lesson11 = course.add_lesson(unit1)
expected = {
's': [{
'child_id': assessment1.unit_id,
'child_val': {
'label': assessment1.title}
}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
's': [],
'l': [{
'child_id': lesson11.lesson_id,
'child_val': {
'a': [],
'h': [{
'child_id': 0,
'child_val': {
'c': [],
'label': 'L1.1'
}}],
'label': lesson11.index
}}],
'label': 'Unit %s' % unit1.index}
}],
'label': 'UNTITLED COURSE'
}
assert_equals(
expected, progress_stats.compute_entity_dict('course', []))
lesson11.objectives = """
<question quid="123" weight="1" instanceid="1"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="456" instanceid="2"></question-group>
yet_more_random_text
"""
expected = {
'label': 'UNTITLED COURSE',
's': [{
'child_id': assessment1.unit_id,
'child_val': {'label': assessment1.title}}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
'label': 'Unit %s' % unit1.index,
's': [],
'l': [{
'child_id': lesson11.lesson_id,
'child_val': {
'label': lesson11.index,
'a': [],
'h': [{
'child_id': 0,
'child_val': {
'c': [{
'child_id': '1',
'child_val': {
'label': 'L1.1.1'
}}, {
'child_id': '2',
'child_val': {
'label': 'L1.1.2'
}
}],
'label': 'L1.1'
}
}]
}
}]
}
}]
}
assert_equals(
expected, progress_stats.compute_entity_dict('course', []))
def _get_sample_v15_course(self):
"""Creates a course with different types of questions and returns it."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
lesson1 = course.add_lesson(unit1)
assessment_old = course.add_assessment()
assessment_old.title = 'Old assessment'
assessment_new = course.add_assessment()
assessment_new.title = 'New assessment'
assessment_peer = course.add_assessment()
assessment_peer.title = 'Peer review assessment'
# Create a multiple choice question.
mcq_new_dict = {
'description': 'mcq_new',
'type': 0, # Multiple choice question.
'choices': [{
'text': 'answer',
'score': 1.0
}],
'version': '1.5'
}
mcq_new_dto = models.QuestionDTO(None, mcq_new_dict)
mcq_new_id = models.QuestionDAO.save(mcq_new_dto)
# Create a short answer question.
frq_new_dict = {
'defaultFeedback': '',
'rows': 1,
'description': 'short answer',
'hint': '',
'graders': [{
'matcher': 'case_insensitive',
'score': '1.0',
'response': 'hi',
'feedback': ''
}],
'question': 'short answer question',
'version': '1.5',
'type': 1, # Short answer question.
'columns': 100
}
frq_new_dto = models.QuestionDTO(None, frq_new_dict)
frq_new_id = models.QuestionDAO.save(frq_new_dto)
# Create a question group.
question_group_dict = {
'description': 'question_group',
'items': [
{'question': str(mcq_new_id)},
{'question': str(frq_new_id)},
{'question': str(mcq_new_id)}
],
'version': '1.5',
'introduction': ''
}
question_group_dto = models.QuestionGroupDTO(None, question_group_dict)
question_group_id = models.QuestionGroupDAO.save(question_group_dto)
# Add a MC question and a question group to leesson1.
lesson1.objectives = """
<question quid="%s" weight="1" instanceid="QN"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="%s" instanceid="QG"></question-group>
""" % (mcq_new_id, question_group_id)
# Add a MC question, a short answer question, and a question group to
# new style assessment.
assessment_new.html_content = """
<question quid="%s" weight="1" instanceid="QN2"></question>
<question quid="%s" weight="1" instanceid="FRQ2"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="%s" instanceid="QG2"></question-group>
""" % (mcq_new_id, frq_new_id, question_group_id)
return course
def _init_course(self, slug):
course = self._import_sample_course()
sites.setup_courses('course:/%s::ns_webserv' % slug)
return course
def setUp(self):
super(CourseElementsTest, self).setUp()
sites.setup_courses('course:/test::ns_test, course:/:/')
self._course = courses.Course(
None, app_context=sites.get_all_courses()[0])
actions.login('*****@*****.**', is_admin=True)
def test_compute_entity_dict_constructs_dict_for_empty_course_correctly(
self):
"""Tests correct entity_structure is built."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
assessment1 = course.add_assessment()
progress_stats = ProgressStats(course)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{'label': 'UNTITLED COURSE', 'u': {unit1.unit_id: {
'label': 'Unit %s' % unit1.index, 'l': {}}}, 's': {
assessment1.unit_id: {'label': assessment1.title}}})
lesson11 = course.add_lesson(unit1)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{
"s": {
assessment1.unit_id: {
"label": assessment1.title
}
},
"u": {
unit1.unit_id: {
"l": {
lesson11.lesson_id: {
"a": {},
"h": {
0: {
"c": {},
"label": "L1.1"
}
},
"label": lesson11.index
}
},
"label": "Unit %s" % unit1.index
}
},
'label': 'UNTITLED COURSE'
})
lesson11.objectives = """
<question quid="123" weight="1" instanceid="1"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="456" instanceid="2"></question-group>
yet_more_random_text
"""
assert_equals(
progress_stats.compute_entity_dict('course', []),
{
"s": {
assessment1.unit_id: {
"label": assessment1.title
}
},
"u": {
unit1.unit_id: {
"l": {
lesson11.lesson_id: {
"a": {},
"h": {
0: {
"c": {
u'1': {
"label": "L1.1.1"
},
u'2': {
"label": "L1.1.2"
}
},
"label": "L1.1"
}
},
"label": lesson11.index
}
},
"label": "Unit %s" % unit1.index
}
},
"label": 'UNTITLED COURSE'
})
def test_compute_entity_dict_constructs_dict_for_empty_course_correctly(
self):
"""Tests correct entity_structure is built."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
assessment1 = course.add_assessment()
progress_stats = ProgressStats(course)
# pylint: disable-msg=g-inconsistent-quotes
assert_equals(
progress_stats.compute_entity_dict('course', []),
{'label': 'UNTITLED COURSE', 'u': {unit1.unit_id: {
'label': 'Unit %s' % unit1.index, 'l': {}}}, 's': {
assessment1.unit_id: {'label': assessment1.title}}})
lesson11 = course.add_lesson(unit1)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{
"s": {
assessment1.unit_id: {
"label": assessment1.title
}
},
"u": {
unit1.unit_id: {
"l": {
lesson11.lesson_id: {
"a": {},
"h": {
0: {
"c": {},
"label": "L1.1"
}
},
"label": lesson11.index
}
},
"label": "Unit %s" % unit1.index
}
},
'label': 'UNTITLED COURSE'
})
lesson11.objectives = """
<question quid="123" weight="1" instanceid="1"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="456" instanceid="2"></question-group>
yet_more_random_text
"""
assert_equals(
progress_stats.compute_entity_dict('course', []),
{
"s": {
assessment1.unit_id: {
"label": assessment1.title
}
},
"u": {
unit1.unit_id: {
"l": {
lesson11.lesson_id: {
"a": {},
"h": {
0: {
"c": {
u'1': {
"label": "L1.1.1"
},
u'2': {
"label": "L1.1.2"
}
},
"label": "L1.1"
}
},
"label": lesson11.index
}
},
"label": "Unit %s" % unit1.index
}
},
"label": 'UNTITLED COURSE'
})
def _get_sample_v15_course(self):
"""Creates a course with different types of questions and returns it."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
lesson1 = course.add_lesson(unit1)
assessment_old = course.add_assessment()
assessment_old.title = 'Old assessment'
assessment_new = course.add_assessment()
assessment_new.title = 'New assessment'
assessment_peer = course.add_assessment()
assessment_peer.title = 'Peer review assessment'
# Create a multiple choice question.
mcq_new_id = 1
mcq_new_dict = {
'description': 'mcq_new',
'type': 0, # Multiple choice question.
'choices': [{
'text': 'answer',
'score': 1.0
}],
'version': '1.5'
}
mcq_new_dto = models.QuestionDTO(mcq_new_id, mcq_new_dict)
# Create a short answer question.
frq_new_id = 2
frq_new_dict = {
'defaultFeedback': '',
'rows': 1,
'description': 'short answer',
'hint': '',
'graders': [{
'matcher': 'case_insensitive',
'score': '1.0',
'response': 'hi',
'feedback': ''
}],
'question': 'short answer question',
'version': '1.5',
'type': 1, # Short answer question.
'columns': 100
}
frq_new_dto = models.QuestionDTO(frq_new_id, frq_new_dict)
# Save these questions to datastore.
models.QuestionDAO.save_all([mcq_new_dto, frq_new_dto])
# Create a question group.
question_group_id = 3
question_group_dict = {
'description': 'question_group',
'items': [
{'question': str(mcq_new_id)},
{'question': str(frq_new_id)},
{'question': str(mcq_new_id)}
],
'version': '1.5',
'introduction': ''
}
question_group_dto = models.QuestionGroupDTO(
question_group_id, question_group_dict)
# Save the question group to datastore.
models.QuestionGroupDAO.save_all([question_group_dto])
# Add a MC question and a question group to leesson1.
lesson1.objectives = """
<question quid="1" weight="1" instanceid="QN"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="3" instanceid="QG"></question-group>
"""
# Add a MC question, a short answer question, and a question group to
# new style assessment.
assessment_new.html_content = """
<question quid="1" weight="1" instanceid="QN2"></question>
<question quid="2" weight="1" instanceid="FRQ2"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="3" instanceid="QG2"></question-group>
"""
return course
def test_entity_dict_for_pre_post_assessment(self):
"""Tests correct entity_structure is built."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
pre_assessment = course.add_assessment()
pre_assessment.title = 'Pre Assessment'
post_assessment = course.add_assessment()
post_assessment.title = 'Post Assessment'
# Neither pre nor post assessment for unit
unit1.pre_assessment = None
unit1.post_assessment = None
progress_stats = ProgressStats(course)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{'s': {
pre_assessment.unit_id: {'label': 'Pre Assessment'},
post_assessment.unit_id: {'label': 'Post Assessment'}},
'u': {unit1.unit_id: {
's': {},
'l': {},
'label': 'Unit 1'}},
'label': 'UNTITLED COURSE'})
# Only pre
unit1.pre_assessment = pre_assessment.unit_id
unit1.post_assessment = None
progress_stats = ProgressStats(course)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{'s': {post_assessment.unit_id: {'label': 'Post Assessment'}},
'u': {unit1.unit_id: {
's': {pre_assessment.unit_id: {'label': 'Pre Assessment'}},
'l': {},
'label': 'Unit 1'}},
'label': 'UNTITLED COURSE'})
# Only post
unit1.pre_assessment = None
unit1.post_assessment = post_assessment.unit_id
progress_stats = ProgressStats(course)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{'s': {pre_assessment.unit_id: {'label': 'Pre Assessment'}},
'u': {unit1.unit_id: {
's': {post_assessment.unit_id: {'label': 'Post Assessment'}},
'l': {},
'label': 'Unit 1'}},
'label': 'UNTITLED COURSE'})
# Pre and post assessment set.
unit1.pre_assessment = pre_assessment.unit_id
unit1.post_assessment = post_assessment.unit_id
progress_stats = ProgressStats(course)
assert_equals(
progress_stats.compute_entity_dict('course', []),
{'s': {},
'u': {unit1.unit_id: {
's': {
pre_assessment.unit_id: {'label': 'Pre Assessment'},
post_assessment.unit_id: {'label': 'Post Assessment'}},
'l': {},
'label': 'Unit 1'}},
'label': 'UNTITLED COURSE'})
def test_compute_entity_dict_for_non_empty_course_correctly(self):
"""Tests correct entity_structure is built."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
assessment1 = course.add_assessment()
progress_stats = ProgressStats(course)
expected = {
'label':
'UNTITLED COURSE',
'u': [{
'child_id': unit1.unit_id,
'child_val': {
'label': 'Unit %s' % unit1.index,
'l': [],
's': []
}
}],
's': [{
'child_id': assessment1.unit_id,
'child_val': {
'label': assessment1.title
}
}]
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
lesson11 = course.add_lesson(unit1)
expected = {
's': [{
'child_id': assessment1.unit_id,
'child_val': {
'label': assessment1.title
}
}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
's': [],
'l': [{
'child_id': lesson11.lesson_id,
'child_val': {
'a': [],
'h': [{
'child_id': 0,
'child_val': {
'c': [],
'label': 'L1.1'
}
}],
'label':
lesson11.index
}
}],
'label':
'Unit %s' % unit1.index
}
}],
'label':
'UNTITLED COURSE'
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
lesson11.objectives = """
<question quid="123" weight="1" instanceid="1"></question>
random_text
<gcb-youtube videoid="Kdg2drcUjYI" instanceid="VD"></gcb-youtube>
more_random_text
<question-group qgid="456" instanceid="2"></question-group>
yet_more_random_text
"""
expected = {
'label':
'UNTITLED COURSE',
's': [{
'child_id': assessment1.unit_id,
'child_val': {
'label': assessment1.title
}
}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
'label':
'Unit %s' % unit1.index,
's': [],
'l': [{
'child_id': lesson11.lesson_id,
'child_val': {
'label':
lesson11.index,
'a': [],
'h': [{
'child_id': 0,
'child_val': {
'c': [{
'child_id': '1',
'child_val': {
'label': 'L1.1.1'
}
}, {
'child_id': '2',
'child_val': {
'label': 'L1.1.2'
}
}],
'label':
'L1.1'
}
}]
}
}]
}
}]
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
def test_entity_dict_for_pre_post_assessment(self):
"""Tests correct entity_structure is built."""
sites.setup_courses('course:/test::ns_test, course:/:/')
course = courses.Course(None, app_context=sites.get_all_courses()[0])
unit1 = course.add_unit()
pre_assessment = course.add_assessment()
pre_assessment.title = 'Pre Assessment'
post_assessment = course.add_assessment()
post_assessment.title = 'Post Assessment'
# Neither pre nor post assessment for unit
unit1.pre_assessment = None
unit1.post_assessment = None
progress_stats = ProgressStats(course)
expected = {
's': [{
'child_id': pre_assessment.unit_id,
'child_val': {
'label': 'Pre Assessment'
}
}, {
'child_id': post_assessment.unit_id,
'child_val': {
'label': 'Post Assessment'
}
}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
's': [],
'l': [],
'label': 'Unit 1'
}
}],
'label':
'UNTITLED COURSE'
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
# Only pre
unit1.pre_assessment = pre_assessment.unit_id
unit1.post_assessment = None
progress_stats = ProgressStats(course)
expected = {
's': [{
'child_id': post_assessment.unit_id,
'child_val': {
'label': 'Post Assessment'
}
}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
's': [{
'child_id': pre_assessment.unit_id,
'child_val': {
'label': 'Pre Assessment'
}
}],
'l': [],
'label':
'Unit 1'
}
}],
'label':
'UNTITLED COURSE'
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
# Only post
unit1.pre_assessment = None
unit1.post_assessment = post_assessment.unit_id
progress_stats = ProgressStats(course)
expected = {
's': [{
'child_id': pre_assessment.unit_id,
'child_val': {
'label': 'Pre Assessment'
}
}],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
's': [{
'child_id': post_assessment.unit_id,
'child_val': {
'label': 'Post Assessment'
}
}],
'l': [],
'label':
'Unit 1'
}
}],
'label':
'UNTITLED COURSE'
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
# Pre and post assessment set.
unit1.pre_assessment = pre_assessment.unit_id
unit1.post_assessment = post_assessment.unit_id
progress_stats = ProgressStats(course)
expected = {
's': [],
'u': [{
'child_id': unit1.unit_id,
'child_val': {
's': [{
'child_id': pre_assessment.unit_id,
'child_val': {
'label': 'Pre Assessment'
}
}, {
'child_id': post_assessment.unit_id,
'child_val': {
'label': 'Post Assessment'
}
}],
'l': [],
'label':
'Unit 1'
}
}],
'label':
'UNTITLED COURSE'
}
assert_equals(expected,
progress_stats.compute_entity_dict('course', []))
