def test__has_access_course_desc_can_enroll(self): u = Mock() yesterday = datetime.datetime.now(UTC()) - datetime.timedelta(days=1) tomorrow = datetime.datetime.now(UTC()) + datetime.timedelta(days=1) c = Mock(enrollment_start=yesterday, enrollment_end=tomorrow, enrollment_domain='') # User can enroll if it is between the start and end dates self.assertTrue(access._has_access_course_desc(u, c, 'enroll')) # User can enroll if authenticated and specifically allowed for that course # even outside the open enrollment period u = Mock(email='*****@*****.**', is_staff=False) u.is_authenticated.return_value = True c = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id='edX/test/2012_Fall', enrollment_domain='') allowed = CourseEnrollmentAllowedFactory(email=u.email, course_id=c.id) self.assertTrue(access._has_access_course_desc(u, c, 'enroll')) # Staff can always enroll even outside the open enrollment period u = Mock(email='*****@*****.**', is_staff=True) u.is_authenticated.return_value = True c = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id='edX/test/Whenever', enrollment_domain='') self.assertTrue(access._has_access_course_desc(u, c, 'enroll'))
def test_access_on_course_with_pre_requisites(self): """ Test course access when a course has pre-requisite course yet to be completed """ seed_milestone_relationship_types() user = UserFactory.create() pre_requisite_course = CourseFactory.create(org="test_org", number="788", run="test_run") pre_requisite_courses = [unicode(pre_requisite_course.id)] course = CourseFactory.create( org="test_org", number="786", run="test_run", pre_requisite_courses=pre_requisite_courses ) set_prerequisite_courses(course.id, pre_requisite_courses) # user should not be able to load course even if enrolled CourseEnrollmentFactory(user=user, course_id=course.id) response = access._has_access_course_desc(user, "view_courseware_with_prerequisites", course) self.assertFalse(response) self.assertIsInstance(response, access_response.MilestoneError) # Staff can always access course staff = StaffFactory.create(course_key=course.id) self.assertTrue(access._has_access_course_desc(staff, "view_courseware_with_prerequisites", course)) # User should be able access after completing required course fulfill_course_milestone(pre_requisite_course.id, user) self.assertTrue(access._has_access_course_desc(user, "view_courseware_with_prerequisites", course))
def test_access_on_course_with_pre_requisites(self): """ Test course access when a course has pre-requisite course yet to be completed """ seed_milestone_relationship_types() user = UserFactory.create() pre_requisite_course = CourseFactory.create( org='test_org', number='788', run='test_run' ) pre_requisite_courses = [unicode(pre_requisite_course.id)] course = CourseFactory.create( org='test_org', number='786', run='test_run', pre_requisite_courses=pre_requisite_courses ) set_prerequisite_courses(course.id, pre_requisite_courses) #user should not be able to load course even if enrolled CourseEnrollmentFactory(user=user, course_id=course.id) self.assertFalse(access._has_access_course_desc(user, 'view_courseware_with_prerequisites', course)) # Staff can always access course staff = StaffFactory.create(course_key=course.id) self.assertTrue(access._has_access_course_desc(staff, 'view_courseware_with_prerequisites', course)) # User should be able access after completing required course fulfill_course_milestone(pre_requisite_course.id, user) self.assertTrue(access._has_access_course_desc(user, 'view_courseware_with_prerequisites', course))
def test__has_access_course_desc_can_enroll(self): u = Mock() yesterday = datetime.datetime.now(pytz.utc) - datetime.timedelta(days=1) tomorrow = datetime.datetime.now(pytz.utc) + datetime.timedelta(days=1) c = Mock(enrollment_start=yesterday, enrollment_end=tomorrow, enrollment_domain='') # User can enroll if it is between the start and end dates self.assertTrue(access._has_access_course_desc(u, c, 'enroll')) # User can enroll if authenticated and specifically allowed for that course # even outside the open enrollment period u = Mock(email='*****@*****.**', is_staff=False) u.is_authenticated.return_value = True c = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id='edX/test/2012_Fall', enrollment_domain='') allowed = CourseEnrollmentAllowedFactory(email=u.email, course_id=c.id) self.assertTrue(access._has_access_course_desc(u, c, 'enroll')) # Staff can always enroll even outside the open enrollment period u = Mock(email='*****@*****.**', is_staff=True) u.is_authenticated.return_value = True c = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id='edX/test/Whenever', enrollment_domain='') self.assertTrue(access._has_access_course_desc(u, c, 'enroll'))
def test__has_access_course_desc_can_enroll(self): u = Mock() yesterday = time.gmtime(time.time() - 86400) tomorrow = time.gmtime(time.time() + 86400) c = Mock(enrollment_start=yesterday, enrollment_end=tomorrow) # User can enroll if it is between the start and end dates self.assertTrue(access._has_access_course_desc(u, c, "enroll")) # User can enroll if authenticated and specifically allowed for that course # even outside the open enrollment period u = Mock(email="*****@*****.**", is_staff=False) u.is_authenticated.return_value = True c = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id="edX/test/2012_Fall") allowed = CourseEnrollmentAllowedFactory(email=u.email, course_id=c.id) self.assertTrue(access._has_access_course_desc(u, c, "enroll")) # Staff can always enroll even outside the open enrollment period u = Mock(email="*****@*****.**", is_staff=True) u.is_authenticated.return_value = True c = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id="edX/test/Whenever") self.assertTrue(access._has_access_course_desc(u, c, "enroll"))
def test__access_on_mobile(self, mobile_available, student_expected, staff_expected): """ Test course access on mobile for staff and students. """ descriptor = Mock(user_partitions=[]) descriptor._class_tags = {} descriptor.visible_to_staff_only = False descriptor.mobile_available = mobile_available self.assertEqual( bool(access._has_access_course_desc(self.student, "load_mobile", descriptor)), student_expected ) self.assertEqual(bool(access._has_access_course_desc(self.staff, "load_mobile", descriptor)), staff_expected)
def test__has_access_course_desc_can_enroll(self): yesterday = datetime.datetime.now(pytz.utc) - datetime.timedelta(days=1) tomorrow = datetime.datetime.now(pytz.utc) + datetime.timedelta(days=1) # Non-staff can enroll if authenticated and specifically allowed for that course # even outside the open enrollment period user = UserFactory.create() course = Mock( enrollment_start=tomorrow, enrollment_end=tomorrow, id=SlashSeparatedCourseKey("edX", "test", "2012_Fall"), enrollment_domain="", ) CourseEnrollmentAllowedFactory(email=user.email, course_id=course.id) self.assertTrue(access._has_access_course_desc(user, "enroll", course)) # Staff can always enroll even outside the open enrollment period user = StaffFactory.create(course_key=course.id) self.assertTrue(access._has_access_course_desc(user, "enroll", course)) # Non-staff cannot enroll if it is between the start and end dates and invitation only # and not specifically allowed course = Mock( enrollment_start=yesterday, enrollment_end=tomorrow, id=SlashSeparatedCourseKey("edX", "test", "2012_Fall"), enrollment_domain="", invitation_only=True, ) user = UserFactory.create() self.assertFalse(access._has_access_course_desc(user, "enroll", course)) # Non-staff can enroll if it is between the start and end dates and not invitation only course = Mock( enrollment_start=yesterday, enrollment_end=tomorrow, id=SlashSeparatedCourseKey("edX", "test", "2012_Fall"), enrollment_domain="", invitation_only=False, ) self.assertTrue(access._has_access_course_desc(user, "enroll", course)) # Non-staff cannot enroll outside the open enrollment period if not specifically allowed course = Mock( enrollment_start=tomorrow, enrollment_end=tomorrow, id=SlashSeparatedCourseKey("edX", "test", "2012_Fall"), enrollment_domain="", invitation_only=False, ) self.assertFalse(access._has_access_course_desc(user, "enroll", course))
def test_see_exists(self, ispublic): """ Test if user can see course """ user = UserFactory.create(is_staff=False) course = Mock(ispublic=ispublic) self.assertEquals(bool(access._has_access_course_desc(user, "see_exists", course)), ispublic)
def test__has_access_course_desc_can_enroll(self): yesterday = datetime.datetime.now( pytz.utc) - datetime.timedelta(days=1) tomorrow = datetime.datetime.now(pytz.utc) + datetime.timedelta(days=1) # Non-staff can enroll if authenticated and specifically allowed for that course # even outside the open enrollment period user = UserFactory.create() course = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), enrollment_domain='') CourseEnrollmentAllowedFactory(email=user.email, course_id=course.id) self.assertTrue(access._has_access_course_desc(user, 'enroll', course)) # Staff can always enroll even outside the open enrollment period user = StaffFactory.create(course_key=course.id) self.assertTrue(access._has_access_course_desc(user, 'enroll', course)) # Non-staff cannot enroll if it is between the start and end dates and invitation only # and not specifically allowed course = Mock(enrollment_start=yesterday, enrollment_end=tomorrow, id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), enrollment_domain='', invitation_only=True) user = UserFactory.create() self.assertFalse(access._has_access_course_desc( user, 'enroll', course)) # Non-staff can enroll if it is between the start and end dates and not invitation only course = Mock(enrollment_start=yesterday, enrollment_end=tomorrow, id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), enrollment_domain='', invitation_only=False) self.assertTrue(access._has_access_course_desc(user, 'enroll', course)) # Non-staff cannot enroll outside the open enrollment period if not specifically allowed course = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), enrollment_domain='', invitation_only=False) self.assertFalse(access._has_access_course_desc( user, 'enroll', course))
def test__access_on_mobile(self, mobile_available, student_expected, staff_expected): """ Test course access on mobile for staff and students. """ descriptor = Mock(user_partitions=[]) descriptor._class_tags = {} descriptor.visible_to_staff_only = False descriptor.mobile_available = mobile_available self.assertEqual( bool( access._has_access_course_desc(self.student, 'load_mobile', descriptor)), student_expected) self.assertEqual( bool( access._has_access_course_desc(self.staff, 'load_mobile', descriptor)), staff_expected)
def test_see_exists(self, ispublic): """ Test if user can see course """ user = UserFactory.create(is_staff=False) course = Mock(ispublic=ispublic) self.assertEquals( bool(access._has_access_course_desc(user, 'see_exists', course)), ispublic)
def test__has_access_course_desc_can_enroll(self): user = Mock() yesterday = datetime.datetime.now( pytz.utc) - datetime.timedelta(days=1) tomorrow = datetime.datetime.now(pytz.utc) + datetime.timedelta(days=1) course = Mock(enrollment_start=yesterday, enrollment_end=tomorrow, enrollment_domain='') # User can enroll if it is between the start and end dates self.assertTrue(access._has_access_course_desc(user, 'enroll', course)) # User can enroll if authenticated and specifically allowed for that course # even outside the open enrollment period user = Mock(email='*****@*****.**', is_staff=False) user.is_authenticated.return_value = True course = Mock(enrollment_start=tomorrow, enrollment_end=tomorrow, id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), enrollment_domain='') CourseEnrollmentAllowedFactory(email=user.email, course_id=course.id) self.assertTrue(access._has_access_course_desc(user, 'enroll', course)) # Staff can always enroll even outside the open enrollment period user = Mock(email='*****@*****.**', is_staff=True) user.is_authenticated.return_value = True course = Mock( enrollment_start=tomorrow, enrollment_end=tomorrow, id=SlashSeparatedCourseKey('edX', 'test', 'Whenever'), enrollment_domain='', ) self.assertTrue(access._has_access_course_desc(user, 'enroll', course))
def test__catalog_visibility(self): """ Tests the catalog visibility tri-states """ user = UserFactory.create() course_id = SlashSeparatedCourseKey("edX", "test", "2012_Fall") staff = StaffFactory.create(course_key=course_id) course = Mock(id=course_id, catalog_visibility=CATALOG_VISIBILITY_CATALOG_AND_ABOUT) self.assertTrue(access._has_access_course_desc(user, "see_in_catalog", course)) self.assertTrue(access._has_access_course_desc(user, "see_about_page", course)) self.assertTrue(access._has_access_course_desc(staff, "see_in_catalog", course)) self.assertTrue(access._has_access_course_desc(staff, "see_about_page", course)) # Now set visibility to just about page course = Mock( id=SlashSeparatedCourseKey("edX", "test", "2012_Fall"), catalog_visibility=CATALOG_VISIBILITY_ABOUT ) self.assertFalse(access._has_access_course_desc(user, "see_in_catalog", course)) self.assertTrue(access._has_access_course_desc(user, "see_about_page", course)) self.assertTrue(access._has_access_course_desc(staff, "see_in_catalog", course)) self.assertTrue(access._has_access_course_desc(staff, "see_about_page", course)) # Now set visibility to none, which means neither in catalog nor about pages course = Mock( id=SlashSeparatedCourseKey("edX", "test", "2012_Fall"), catalog_visibility=CATALOG_VISIBILITY_NONE ) self.assertFalse(access._has_access_course_desc(user, "see_in_catalog", course)) self.assertFalse(access._has_access_course_desc(user, "see_about_page", course)) self.assertTrue(access._has_access_course_desc(staff, "see_in_catalog", course)) self.assertTrue(access._has_access_course_desc(staff, "see_about_page", course))
def test__catalog_visibility(self): """ Tests the catalog visibility tri-states """ user = UserFactory.create() course_id = SlashSeparatedCourseKey('edX', 'test', '2012_Fall') staff = StaffFactory.create(course_key=course_id) course = Mock( id=course_id, catalog_visibility=CATALOG_VISIBILITY_CATALOG_AND_ABOUT ) self.assertTrue(access._has_access_course_desc(user, 'see_in_catalog', course)) self.assertTrue(access._has_access_course_desc(user, 'see_about_page', course)) self.assertTrue(access._has_access_course_desc(staff, 'see_in_catalog', course)) self.assertTrue(access._has_access_course_desc(staff, 'see_about_page', course)) # Now set visibility to just about page course = Mock( id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), catalog_visibility=CATALOG_VISIBILITY_ABOUT ) self.assertFalse(access._has_access_course_desc(user, 'see_in_catalog', course)) self.assertTrue(access._has_access_course_desc(user, 'see_about_page', course)) self.assertTrue(access._has_access_course_desc(staff, 'see_in_catalog', course)) self.assertTrue(access._has_access_course_desc(staff, 'see_about_page', course)) # Now set visibility to none, which means neither in catalog nor about pages course = Mock( id=SlashSeparatedCourseKey('edX', 'test', '2012_Fall'), catalog_visibility=CATALOG_VISIBILITY_NONE ) self.assertFalse(access._has_access_course_desc(user, 'see_in_catalog', course)) self.assertFalse(access._has_access_course_desc(user, 'see_about_page', course)) self.assertTrue(access._has_access_course_desc(staff, 'see_in_catalog', course)) self.assertTrue(access._has_access_course_desc(staff, 'see_about_page', course))