def test_course_listing_with_actions_in_progress(self): sourse_course_key = CourseLocator('source-Org', 'source-Course', 'source-Run') num_courses_to_create = 3 courses = [ self._create_course_with_access_groups(CourseLocator('Org', 'CreatedCourse' + str(num), 'Run'), self.user) for num in range(num_courses_to_create) ] courses_in_progress = [ self._create_course_with_access_groups(CourseLocator('Org', 'InProgressCourse' + str(num), 'Run'), self.user) for num in range(num_courses_to_create) ] # simulate initiation of course actions for course in courses_in_progress: CourseRerunState.objects.initiated( sourse_course_key, destination_course_key=course.id, user=self.user, display_name="test course" ) # verify return values for method in (_accessible_courses_list_from_groups, _accessible_courses_list): def set_of_course_keys(course_list, key_attribute_name='id'): """Returns a python set of course keys by accessing the key with the given attribute name.""" return set(getattr(c, key_attribute_name) for c in course_list) found_courses, unsucceeded_course_actions = method(self.request) self.assertSetEqual(set_of_course_keys(courses + courses_in_progress), set_of_course_keys(found_courses)) self.assertSetEqual( set_of_course_keys(courses_in_progress), set_of_course_keys(unsucceeded_course_actions, 'course_key') )
class FilenamePrefixGeneratorTestCase(TestCase): """ Tests for course_filename_prefix_generator """ @ddt.data(CourseLocator(org='foo', course='bar', run='baz'), CourseKey.from_string('foo/bar/baz')) def test_locators(self, course_key): self.assertEqual(course_filename_prefix_generator(course_key), u'foo_bar_baz') @ddt.data(CourseLocator(org='foo', course='bar', run='baz'), CourseKey.from_string('foo/bar/baz')) def test_custom_separator(self, course_key): self.assertEqual(course_filename_prefix_generator(course_key, separator='-'), u'foo-bar-baz')
def test_kwargs_in_update_state(self): destination_course_key = CourseLocator("org", "course", "run") source_course_key = CourseLocator("source_org", "source_course", "source_run") CourseRerunState.objects.update_state( course_key=destination_course_key, new_state='state1', allow_not_found=True, source_course_key=source_course_key, ) found_action_state = CourseRerunState.objects.find_first(course_key=destination_course_key) self.assertEquals(source_course_key, found_action_state.source_course_key)
def test_course_listing_errored_deleted_courses(self): """ Create good courses, courses that won't load, and deleted courses which still have roles. Test course listing. """ course_location = CourseLocator('testOrg', 'testCourse', 'RunBabyRun') self._create_course_with_access_groups(course_location, self.user) course_location = CourseLocator('doomedCourse', 'testCourse', 'RunBabyRun') course = self._create_course_with_access_groups( course_location, self.user) course.delete() courses_list, __ = _accessible_courses_list_from_groups(self.request) self.assertEqual(len(courses_list), 1, courses_list)
class FilenameGeneratorTestCase(TestCase): """ Tests for course_and_time_based_filename_generator """ NOW = datetime.strptime('1974-06-22T01:02:03', '%Y-%m-%dT%H:%M:%S').replace(tzinfo=UTC) def setUp(self): super(FilenameGeneratorTestCase, self).setUp() datetime_patcher = patch.object(util.file, 'datetime', Mock(wraps=datetime)) mocked_datetime = datetime_patcher.start() mocked_datetime.now.return_value = self.NOW self.addCleanup(datetime_patcher.stop) @ddt.data(CourseLocator(org='foo', course='bar', run='baz'), CourseKey.from_string('foo/bar/baz')) def test_filename_generator(self, course_key): """ Tests that the generator creates names based on course_id, base name, and date. """ self.assertEqual( u'foo_bar_baz_file_1974-06-22-010203', course_and_time_based_filename_generator(course_key, 'file')) self.assertEqual( u'foo_bar_baz_base_name_ø_1974-06-22-010203', course_and_time_based_filename_generator(course_key, ' base` name ø '))
def setUp(self): super(TestCourseRerunStateManager, self).setUp() self.source_course_key = CourseLocator("source_org", "source_course_num", "source_run") self.course_key = CourseLocator("test_org", "test_course_num", "test_run") self.created_user = UserFactory() self.display_name = "destination course name" self.expected_rerun_state = { 'created_user': self.created_user, 'updated_user': self.created_user, 'course_key': self.course_key, 'source_course_key': self.source_course_key, "display_name": self.display_name, 'action': CourseRerunUIStateManager.ACTION, 'should_display': True, 'message': "", }
def test_cert_grade(self, persisted_grade, cert_grade): """ Tests that the higher of the persisted grade and the grade from the certs table is used on the learner dashboard. """ expected_grade = max(filter(lambda x: x is not None, [persisted_grade, cert_grade])) user = Mock(username="******", id="1") survey_url = "http://a_survey.com" course = Mock( end_of_course_survey_url=survey_url, certificates_display_behavior='end', id=CourseLocator(org="x", course="y", run="z"), ) if cert_grade is not None: cert_status = {'status': 'generating', 'grade': six.text_type(cert_grade), 'mode': 'honor'} else: cert_status = {'status': 'generating', 'mode': 'honor'} with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read') as patch_persisted_grade: patch_persisted_grade.return_value = Mock(percent=persisted_grade) self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': six.text_type(expected_grade), 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False, } )
def setUp(self): super(TestStatus, self).setUp() # Clear the cache between test runs. cache.clear() self.course_key = CourseLocator(org='TestOrg', course='TestCourse', run='TestRun')
def test_cert_grade_no_grades(self): """ Tests that the default cert info is returned when the learner has no persisted grade or grade in the certs table. """ user = Mock(username="******", id="1") survey_url = "http://a_survey.com" course = Mock( end_of_course_survey_url=survey_url, certificates_display_behavior='end', id=CourseLocator(org="x", course="y", run="z"), ) cert_status = {'status': 'generating', 'mode': 'honor'} with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read') as patch_persisted_grade: patch_persisted_grade.return_value = None self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'processing', 'show_survey_button': False, 'can_unenroll': True, } )
def test_enrollment_by_email(self): user = User.objects.create(username="******", email="*****@*****.**") course_id = CourseLocator("edX", "Test101", "2013") CourseEnrollment.enroll_by_email("*****@*****.**", course_id) assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id) # This won't throw an exception, even though the user is not found assert CourseEnrollment.enroll_by_email('*****@*****.**', course_id) is None self.assert_no_events_were_emitted() self.assertRaises(User.DoesNotExist, CourseEnrollment.enroll_by_email, "*****@*****.**", course_id, ignore_errors=False) self.assert_no_events_were_emitted() # Now unenroll them by email CourseEnrollment.unenroll_by_email("*****@*****.**", course_id) assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_unenrollment_event_was_emitted(user, course_id) # Harmless second unenroll CourseEnrollment.unenroll_by_email("*****@*****.**", course_id) assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # Unenroll on non-existent user shouldn't throw an error CourseEnrollment.unenroll_by_email("*****@*****.**", course_id) self.assert_no_events_were_emitted()
def setUp(self): super(TestStatus, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments # Clear the cache between test runs. cache.clear() self.course_key = CourseLocator(org='TestOrg', course='TestCourse', run='TestRun')
def create_course_states(starting_course_num, ending_course_num, state, should_display=True): """ Creates a list of course state tuples by creating unique course locators with course-numbers from starting_course_num to ending_course_num. """ CourseState = namedtuple('CourseState', 'course_key, state, should_display') return [ CourseState(CourseLocator("org", "course", "run" + str(num)), state, should_display) for num in range(starting_course_num, ending_course_num) ]
def test_enrollment_multiple_classes(self): user = User(username="******", email="*****@*****.**") course_id1 = CourseLocator("edX", "Test101", "2013") course_id2 = CourseLocator("MITx", "6.003z", "2012") CourseEnrollment.enroll(user, course_id1) self.assert_enrollment_event_was_emitted(user, course_id1) CourseEnrollment.enroll(user, course_id2) self.assert_enrollment_event_was_emitted(user, course_id2) assert CourseEnrollment.is_enrolled(user, course_id1) assert CourseEnrollment.is_enrolled(user, course_id2) CourseEnrollment.unenroll(user, course_id1) self.assert_unenrollment_event_was_emitted(user, course_id1) assert not CourseEnrollment.is_enrolled(user, course_id1) assert CourseEnrollment.is_enrolled(user, course_id2) CourseEnrollment.unenroll(user, course_id2) self.assert_unenrollment_event_was_emitted(user, course_id2) assert not CourseEnrollment.is_enrolled(user, course_id1) assert not CourseEnrollment.is_enrolled(user, course_id2)
def setUp(self): super(TestHandlerUrl, self).setUp() self.block = BlockMock(name='block', scope_ids=ScopeIds(None, None, None, 'dummy')) self.course_key = CourseLocator("org", "course", "run") self.runtime = LmsModuleSystem( static_url='/static', track_function=Mock(), get_module=Mock(), render_template=Mock(), replace_urls=str, course_id=self.course_key, descriptor_runtime=Mock(), )
def setUp(self): super().setUp() self.block = BlockMock(name='block', scope_ids=ScopeIds(None, None, None, 'dummy')) self.course_key = CourseLocator("org", "course", "run") self.runtime = LmsModuleSystem( static_url='/static', track_function=Mock(), get_module=Mock(), course_id=self.course_key, user=Mock(), descriptor_runtime=Mock(), )
def test_enrollment_non_existent_user(self): # Testing enrollment of newly unsaved user (i.e. no database entry) user = User(username="******", email="*****@*****.**") course_id = CourseLocator("edX", "Test101", "2013") assert not CourseEnrollment.is_enrolled(user, course_id) # Unenroll does nothing CourseEnrollment.unenroll(user, course_id) self.assert_no_events_were_emitted() # Implicit save() happens on new User object when enrolling, so this # should still work CourseEnrollment.enroll(user, course_id) assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id)
def test_change_enrollment_modes(self): user = User.objects.create(username="******", email="*****@*****.**") course_id = CourseLocator("edX", "Test101", "2013") CourseEnrollment.enroll(user, course_id, "audit") self.assert_enrollment_event_was_emitted(user, course_id) CourseEnrollment.enroll(user, course_id, "honor") self.assert_enrollment_mode_change_event_was_emitted(user, course_id, "honor") # same enrollment mode does not emit an event CourseEnrollment.enroll(user, course_id, "honor") self.assert_no_events_were_emitted() CourseEnrollment.enroll(user, course_id, "audit") self.assert_enrollment_mode_change_event_was_emitted(user, course_id, "audit")
def setUp(self): super().setUp() self.course_id = CourseLocator("org", "course", "run") self.user = UserFactory.create() self.runtime = LmsModuleSystem( static_url='/static', track_function=Mock(), get_module=Mock(), user=self.user, course_id=self.course_id, descriptor_runtime=Mock(), ) self.scope = 'course' self.key = 'key1' self.mock_block = Mock() self.mock_block.service_declaration.return_value = 'needs'
def test_update_transcription_service_credentials_for_vem(self, mock_client, mock_logger): """ Test that if waffle flag `ENABLE_VEM_PIPELINE` is on for course, then credentials are successfully posted to VEM. """ self.add_vem_client() course_key = CourseLocator("test_org", "test_course_num", "test_run") credentials_payload = { 'username': '******', 'api_key': '12345678', 'course_key': course_key } mock_client.request.return_value.ok = True # Try updating the transcription service credentials with override_waffle_flag(waffle_flags()[ENABLE_VEM_PIPELINE], active=True): error_response, is_updated = update_3rd_party_transcription_service_credentials(**credentials_payload) # Making sure log.exception is not called. self.assertDictEqual(error_response, {}) self.assertFalse(mock_logger.exception.called) self.assertTrue(is_updated)
def test_courses_list_with_ccx_courses(self): """ Tests that CCX courses are filtered in course listing. """ # Create a course and assign access roles to user. course_location = CourseLocator('Org1', 'Course1', 'Course1') course = self._create_course_with_access_groups( course_location, self.user) # Create a ccx course key and add assign access roles to user. ccx_course_key = CCXLocator.from_course_locator(course.id, '1') self._add_role_access_to_user(self.user, ccx_course_key) # Test that CCX courses are filtered out. courses_list, __ = _accessible_courses_list_from_groups(self.request) self.assertEqual(len(courses_list), 1) self.assertNotIn(ccx_course_key, [course.id for course in courses_list]) # Get all courses which user has access. instructor_courses = UserBasedRole( self.user, CourseInstructorRole.ROLE).courses_with_role() staff_courses = UserBasedRole( self.user, CourseStaffRole.ROLE).courses_with_role() all_courses = (instructor_courses | staff_courses) # Verify that CCX course exists in access but filtered by `_accessible_courses_list_from_groups`. self.assertIn(ccx_course_key, [access.course_id for access in all_courses]) # Verify that CCX courses are filtered out while iterating over all courses mocked_ccx_course = Mock(id=ccx_course_key) with patch( 'openedx.core.djangoapps.content.course_overviews.models.CourseOverview.get_all_courses', return_value=[mocked_ccx_course], ): courses_iter, __ = _accessible_courses_iter_for_tests(self.request) self.assertEqual(len(list(courses_iter)), 0)
def setUp(self): super(TestUserServiceAPI, self).setUp() self.course_id = CourseLocator("org", "course", "run") self.user = UserFactory.create() def mock_get_real_user(_anon_id): """Just returns the test user""" return self.user self.runtime = LmsModuleSystem( static_url='/static', track_function=Mock(), get_module=Mock(), render_template=Mock(), replace_urls=str, course_id=self.course_id, get_real_user=mock_get_real_user, descriptor_runtime=Mock(), ) self.scope = 'course' self.key = 'key1' self.mock_block = Mock() self.mock_block.service_declaration.return_value = 'needs'
def test_activation(self): user = User.objects.create(username="******", email="*****@*****.**") course_id = CourseLocator("edX", "Test101", "2013") assert not CourseEnrollment.is_enrolled(user, course_id) # Creating an enrollment doesn't actually enroll a student # (calling CourseEnrollment.enroll() would have) enrollment = CourseEnrollment.get_or_create_enrollment(user, course_id) assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # Until you explicitly activate it enrollment.activate() assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id) # Activating something that's already active does nothing enrollment.activate() assert CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # Now deactive enrollment.deactivate() assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_unenrollment_event_was_emitted(user, course_id) # Deactivating something that's already inactive does nothing enrollment.deactivate() assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # A deactivated enrollment should be activated if enroll() is called # for that user/course_id combination CourseEnrollment.enroll(user, course_id) assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id)
def test_cert_info(self): user = UserFactory.create() survey_url = "http://a_survey.com" course = CourseOverviewFactory.create( end_of_course_survey_url=survey_url, certificates_display_behavior='end', ) cert = GeneratedCertificateFactory.create( user=user, course_id=course.id, status=CertificateStatuses.downloadable, mode='honor', grade='67', download_url='http://s3.edx/cert') assert _cert_info(user, course, None) ==\ {'status': 'processing', 'show_survey_button': False, 'can_unenroll': True} cert_status = {'status': 'unavailable', 'mode': 'honor', 'uuid': None} assert _cert_info(user, course, cert_status) == { 'status': 'processing', 'show_survey_button': False, 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True } cert_status = { 'status': 'generating', 'grade': '0.67', 'mode': 'honor', 'uuid': None } with patch( 'lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read' ) as patch_persisted_grade: patch_persisted_grade.return_value = Mock(percent=1.0) assert _cert_info(user, course, cert_status) == { 'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '1.0', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False } cert_status = { 'status': 'generating', 'grade': '0.67', 'mode': 'honor', 'uuid': None } assert _cert_info(user, course, cert_status) == { 'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False } cert_status = { 'status': 'downloadable', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine', } assert _cert_info(user, course, cert_status) == { 'status': 'downloadable', 'download_url': cert.download_url, 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False } cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine', } assert _cert_info(user, course, cert_status) == { 'status': 'notpassing', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True } # Test a course that doesn't have a survey specified course2 = Mock(end_of_course_survey_url=None, id=CourseLocator(org="a", course="b", run="c")) cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine' } assert _cert_info(user, course2, cert_status) == { 'status': 'notpassing', 'show_survey_button': False, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True } # test when the display is unavailable or notpassing, we get the correct results out course2.certificates_display_behavior = 'early_no_info' cert_status = {'status': 'unavailable', 'mode': 'honor', 'uuid': None} assert _cert_info(user, course2, cert_status) == { 'status': 'processing', 'show_survey_button': False, 'can_unenroll': True } cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine' } assert _cert_info(user, course2, cert_status) == { 'status': 'processing', 'show_survey_button': False, 'can_unenroll': True }
class FilenamePrefixGeneratorTestCase(TestCase): """ Tests for course_filename_prefix_generator """ @ddt.data( CourseLocator(org='foo', course='bar', run='baz'), CourseKey.from_string('foo/bar/baz'), CCXLocator.from_course_locator( CourseLocator(org='foo', course='bar', run='baz'), '1'), ) def test_locators(self, course_key): """ Test filename prefix genaration from multiple course key formats. Test that the filename prefix is generated from a CCX course locator or a course key. If the filename is generated for a CCX course but the related 'ENABLE_COURSE_FILENAME_CCX_SUFFIX' feature is not turned on, the generated filename shouldn't contain the CCX course ID. """ assert course_filename_prefix_generator(course_key) == 'foo_bar_baz' @ddt.data( [CourseLocator(org='foo', course='bar', run='baz'), 'foo_bar_baz'], [CourseKey.from_string('foo/bar/baz'), 'foo_bar_baz'], [ CCXLocator.from_course_locator( CourseLocator(org='foo', course='bar', run='baz'), '1'), 'foo_bar_baz_ccx_1' ], ) @ddt.unpack @override_settings(FEATURES={'ENABLE_COURSE_FILENAME_CCX_SUFFIX': True}) def test_include_ccx_id(self, course_key, expected_filename): """ Test filename prefix genaration from multiple course key formats. Test that the filename prefix is generated from a CCX course locator or a course key. If the filename is generated for a CCX course but the related 'ENABLE_COURSE_FILENAME_CCX_SUFFIX' feature is not turned on, the generated filename shouldn't contain the CCX course ID. """ assert course_filename_prefix_generator( course_key) == expected_filename @ddt.data(CourseLocator(org='foo', course='bar', run='baz'), CourseKey.from_string('foo/bar/baz')) def test_custom_separator(self, course_key): """ Test filename prefix is generated with a custom separator. The filename should be build up from the course locator separated by a custom separator. """ assert course_filename_prefix_generator(course_key, separator='-') == 'foo-bar-baz' @ddt.data( [CourseLocator(org='foo', course='bar', run='baz'), 'foo-bar-baz'], [CourseKey.from_string('foo/bar/baz'), 'foo-bar-baz'], [ CCXLocator.from_course_locator( CourseLocator(org='foo', course='bar', run='baz'), '1'), 'foo-bar-baz-ccx-1' ], ) @ddt.unpack @override_settings(FEATURES={'ENABLE_COURSE_FILENAME_CCX_SUFFIX': True}) def test_custom_separator_including_ccx_id(self, course_key, expected_filename): """ Test filename prefix is generated with a custom separator. The filename should be build up from the course locator separated by a custom separator including the CCX ID if the related 'ENABLE_COURSE_FILENAME_CCX_SUFFIX' is turned on. """ assert course_filename_prefix_generator( course_key, separator='-') == expected_filename
def location(self): """Create a functional BlockUsageLocator for testing URL generation.""" course_key = CourseLocator(org="mockx", course="100", run="2015") return BlockUsageLocator(course_key, block_type='mock_type', block_id="mock_id")
def setUp(self): super().setUp() self.course_key = CourseLocator("test_org", "test_course_num", "test_run")
def setUp(self): super(TestCourseActionStateManagerBase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments self.course_key = CourseLocator("test_org", "test_course_num", "test_run")
def test_cert_info(self): user = Mock(username="******", id="1") survey_url = "http://a_survey.com" course = Mock( end_of_course_survey_url=survey_url, certificates_display_behavior='end', id=CourseLocator(org="x", course="y", run="z"), ) self.assertEqual( _cert_info(user, course, None), { 'status': 'processing', 'show_survey_button': False, 'can_unenroll': True, } ) cert_status = {'status': 'unavailable'} self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'processing', 'show_survey_button': False, 'mode': None, 'linked_in_url': None, 'can_unenroll': True, } ) cert_status = {'status': 'generating', 'grade': '0.67', 'mode': 'honor'} with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read') as patch_persisted_grade: patch_persisted_grade.return_value = Mock(percent=1.0) self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '1.0', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False, } ) cert_status = {'status': 'generating', 'grade': '0.67', 'mode': 'honor'} self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False, } ) download_url = 'http://s3.edx/cert' cert_status = { 'status': 'downloadable', 'grade': '0.67', 'download_url': download_url, 'mode': 'honor' } self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'downloadable', 'download_url': download_url, 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False, } ) cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': download_url, 'mode': 'honor' } self.assertEqual( _cert_info(user, course, cert_status), { 'status': 'notpassing', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True, } ) # Test a course that doesn't have a survey specified course2 = Mock(end_of_course_survey_url=None, id=CourseLocator(org="a", course="b", run="c")) cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': download_url, 'mode': 'honor' } self.assertEqual( _cert_info(user, course2, cert_status), { 'status': 'notpassing', 'show_survey_button': False, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True, } ) # test when the display is unavailable or notpassing, we get the correct results out course2.certificates_display_behavior = 'early_no_info' cert_status = {'status': 'unavailable'} self.assertEqual( _cert_info(user, course2, cert_status), { 'status': 'processing', 'show_survey_button': False, 'can_unenroll': True, } ) cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': download_url, 'mode': 'honor' } self.assertEqual( _cert_info(user, course2, cert_status), { 'status': 'processing', 'show_survey_button': False, 'can_unenroll': True, } )
def setUp(self): super(TestCourseActionStateManagerBase, self).setUp() self.course_key = CourseLocator("test_org", "test_course_num", "test_run")