def build_courses(self): """ Build up a course tree with multiple test courses """ self.courses = [ CourseFactory.create( org='ElasticsearchFiltering', course='ES101F', run='test_run', display_name='Elasticsearch Filtering test course', ), CourseFactory.create( org='FilterTest', course='FT101', run='test_run', display_name='FilterTest test course', ) ] self.chapter = ItemFactory.create( parent_location=self.courses[0].location, category='chapter', display_name="Week 1", publish_item=True, ) self.chapter2 = ItemFactory.create( parent_location=self.courses[1].location, category='chapter', display_name="Week 1", publish_item=True, )
def test_courseware_page_unfulfilled_prereqs(self): """ Test courseware access when a course has pre-requisite course yet to be completed """ seed_milestone_relationship_types() pre_requisite_course = CourseFactory.create(org="edX", course="900", run="test_run") pre_requisite_courses = [unicode(pre_requisite_course.id)] course = CourseFactory.create( org="edX", course="1000", run="test_run", pre_requisite_courses=pre_requisite_courses ) set_prerequisite_courses(course.id, pre_requisite_courses) test_password = "******" user = UserFactory.create() user.set_password(test_password) user.save() self.login(user.email, test_password) CourseEnrollmentFactory(user=user, course_id=course.id) url = reverse("courseware", args=[unicode(course.id)]) response = self.client.get(url) self.assertRedirects(response, reverse("dashboard")) self.assertEqual(response.status_code, 302) fulfill_course_milestone(pre_requisite_course.id, user) response = self.client.get(url) self.assertEqual(response.status_code, 200)
def setUp(self): patcher = patch('student.models.tracker') self.mock_tracker = patcher.start() self.user = UserFactory.create() self.user.set_password('password') self.user.save() self.instructor = AdminFactory.create() self.cost = 40 self.coupon_code = 'abcde' self.reg_code = 'qwerty' self.percentage_discount = 10 self.course = CourseFactory.create(org='MITx', number='999', display_name='Robot Super Course') self.course_key = self.course.id self.course_mode = CourseMode(course_id=self.course_key, mode_slug="honor", mode_display_name="honor cert", min_price=self.cost) self.course_mode.save() #Saving another testing course mode self.testing_cost = 20 self.testing_course = CourseFactory.create(org='edX', number='888', display_name='Testing Super Course') self.testing_course_mode = CourseMode(course_id=self.testing_course.id, mode_slug="honor", mode_display_name="testing honor cert", min_price=self.testing_cost) self.testing_course_mode.save() verified_course = CourseFactory.create(org='org', number='test', display_name='Test Course') self.verified_course_key = verified_course.id self.cart = Order.get_cart_for_user(self.user) self.addCleanup(patcher.stop)
def setUp(self): super(AboutTestCase, self).setUp() self.course = CourseFactory.create() self.about = ItemFactory.create( category="about", parent_location=self.course.location, data="OOGIE BLOOGIE", display_name="overview" ) self.course_without_about = CourseFactory.create(catalog_visibility=CATALOG_VISIBILITY_NONE) self.about = ItemFactory.create( category="about", parent_location=self.course_without_about.location, data="WITHOUT ABOUT", display_name="overview" ) self.course_with_about = CourseFactory.create(catalog_visibility=CATALOG_VISIBILITY_ABOUT) self.about = ItemFactory.create( category="about", parent_location=self.course_with_about.location, data="WITH ABOUT", display_name="overview" ) self.purchase_course = CourseFactory.create(org='MITx', number='buyme', display_name='Course To Buy') self.course_mode = CourseMode( course_id=self.purchase_course.id, mode_slug=CourseMode.DEFAULT_MODE_SLUG, mode_display_name=CourseMode.DEFAULT_MODE_SLUG, min_price=10 ) self.course_mode.save()
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 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): """ Set up tests """ super(TestInstructorDashboard, self).setUp() self.course = CourseFactory.create( grading_policy={"GRADE_CUTOFFS": {"A": 0.75, "B": 0.63, "C": 0.57, "D": 0.5}}, display_name='<script>alert("XSS")</script>' ) self.course_mode = CourseMode( course_id=self.course.id, mode_slug=CourseMode.DEFAULT_MODE_SLUG, mode_display_name=CourseMode.DEFAULT_MODE.name, min_price=40 ) self.course_info = CourseFactory.create( org="ACME", number="001", run="2017", name="How to defeat the Road Runner" ) self.course_mode.save() # Create instructor account self.instructor = AdminFactory.create() self.client.login(username=self.instructor.username, password="******") # URL for instructor dash self.url = reverse('instructor_dashboard', kwargs={'course_id': text_type(self.course.id)})
def test_courseware_access(self): self.login() course_with_prereq = CourseFactory.create(start=self.LAST_WEEK, mobile_available=True) prerequisite_course = CourseFactory.create() set_prerequisite_courses(course_with_prereq.id, [unicode(prerequisite_course.id)]) # Create list of courses with various expected courseware_access responses and corresponding expected codes courses = [ course_with_prereq, CourseFactory.create(start=self.NEXT_WEEK, mobile_available=True), CourseFactory.create(visible_to_staff_only=True, mobile_available=True), CourseFactory.create(start=self.LAST_WEEK, mobile_available=True, visible_to_staff_only=False), ] expected_error_codes = [ MilestoneAccessError().error_code, # 'unfulfilled_milestones' StartDateError(self.NEXT_WEEK).error_code, # 'course_not_started' VisibilityError().error_code, # 'not_visible_to_user' None, ] # Enroll in all the courses for course in courses: self.enroll(course.id) # Verify courses have the correct response through error code. Last enrolled course is first course in response response = self.api_response() for course_index in range(len(courses)): result = response.data[course_index]['course']['courseware_access'] self.assertEqual(result['error_code'], expected_error_codes[::-1][course_index]) if result['error_code'] is not None: self.assertFalse(result['has_access'])
def setUpClass(cls): super(CertificateGetTests, cls).setUpClass() cls.student = UserFactory() cls.student_no_cert = UserFactory() cls.course_1 = CourseFactory.create( org='edx', number='verified_1', display_name='Verified Course 1' ) cls.course_2 = CourseFactory.create( org='edx', number='verified_2', display_name='Verified Course 2' ) # certificate for the first course GeneratedCertificateFactory.create( user=cls.student, course_id=cls.course_1.id, status=CertificateStatuses.downloadable, mode='verified', download_url='www.google.com', grade="0.88", ) # certificate for the second course GeneratedCertificateFactory.create( user=cls.student, course_id=cls.course_2.id, status=CertificateStatuses.downloadable, mode='honor', download_url='www.gmail.com', grade="0.99", )
def test_get_from_ids_if_exists(self): course_with_overview_1 = CourseFactory.create(emit_signals=True) course_with_overview_2 = CourseFactory.create(emit_signals=True) course_without_overview = CourseFactory.create(emit_signals=False) courses = [course_with_overview_1, course_with_overview_2, course_without_overview] course_ids_to_overviews = CourseOverview.get_from_ids_if_exists( course.id for course in courses ) # We should see the ones that have published CourseOverviews # (when the signals were emitted), but not the one that didn't issue # a publish signal. self.assertEqual(len(course_ids_to_overviews), 2) self.assertIn(course_with_overview_1.id, course_ids_to_overviews) self.assertIn(course_with_overview_2.id, course_ids_to_overviews) self.assertNotIn(course_without_overview.id, course_ids_to_overviews) # But if we set a CourseOverview to be an old version, it shouldn't be # returned by get_from_ids_if_exists() overview_2 = course_ids_to_overviews[course_with_overview_2.id] overview_2.version = CourseOverview.VERSION - 1 overview_2.save() course_ids_to_overviews = CourseOverview.get_from_ids_if_exists( course.id for course in courses ) self.assertEqual(len(course_ids_to_overviews), 1) self.assertIn(course_with_overview_1.id, course_ids_to_overviews)
def test_course_ids_with_certs_for_user(self): # Create one user with certs and one without student_no_certs = UserFactory() student_with_certs = UserFactory() student_with_certs.profile.allow_certificate = True student_with_certs.profile.save() # Set up a couple of courses course_1 = CourseFactory.create() course_2 = CourseFactory.create() # Generate certificates GeneratedCertificateFactory.create( user=student_with_certs, course_id=course_1.id, status=CertificateStatuses.downloadable, mode='honor' ) GeneratedCertificateFactory.create( user=student_with_certs, course_id=course_2.id, status=CertificateStatuses.downloadable, mode='honor' ) # User with no certs should return an empty set. self.assertSetEqual( GeneratedCertificate.course_ids_with_certs_for_user(student_no_certs), set() ) # User with certs should return a set with the two course_ids self.assertSetEqual( GeneratedCertificate.course_ids_with_certs_for_user(student_with_certs), {course_1.id, course_2.id} )
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 setUpClass(cls): super(CourseImportViewTest, cls).setUpClass() cls.course = CourseFactory.create(display_name='test course', run="Testing_course") cls.course_key = cls.course.id cls.restricted_course = CourseFactory.create(display_name='restricted test course', run="Restricted_course") cls.restricted_course_key = cls.restricted_course.id cls.password = '******' cls.student = UserFactory(username='******', password=cls.password) cls.staff = StaffFactory(course_key=cls.course.id, password=cls.password) cls.restricted_staff = StaffFactory(course_key=cls.restricted_course.id, password=cls.password) cls.content_dir = path(tempfile.mkdtemp()) # Create tar test files ----------------------------------------------- # OK course: good_dir = tempfile.mkdtemp(dir=cls.content_dir) # test course being deeper down than top of tar file embedded_dir = os.path.join(good_dir, "grandparent", "parent") os.makedirs(os.path.join(embedded_dir, "course")) with open(os.path.join(embedded_dir, "course.xml"), "w+") as f: f.write('<course url_name="2013_Spring" org="EDx" course="0.00x"/>') with open(os.path.join(embedded_dir, "course", "2013_Spring.xml"), "w+") as f: f.write('<course></course>') cls.good_tar_filename = "good.tar.gz" cls.good_tar_fullpath = os.path.join(cls.content_dir, cls.good_tar_filename) with tarfile.open(cls.good_tar_fullpath, "w:gz") as gtar: gtar.add(good_dir)
def setUp(self): self.user = UserFactory.create() self.course_id = "org/test/Test_Course" CourseFactory.create(org='org', number='test', display_name='Test Course') for i in xrange(1, 5): CourseFactory.create(org='org', number='test', display_name='Test Course {0}'.format(i)) self.cost = 40
def setUp(self): super(IndexPageCourseCardsSortingTests, self).setUp() self.starting_later = CourseFactory.create( org='MITx', number='1000', display_name='Starting later, Announced later', metadata={ 'start': datetime.datetime.now(UTC) + datetime.timedelta(days=4), 'announcement': datetime.datetime.now(UTC) + datetime.timedelta(days=3), } ) self.starting_earlier = CourseFactory.create( org='MITx', number='1001', display_name='Starting earlier, Announced earlier', metadata={ 'start': datetime.datetime.now(UTC) + datetime.timedelta(days=2), 'announcement': datetime.datetime.now(UTC) + datetime.timedelta(days=1), } ) self.course_with_default_start_date = CourseFactory.create( org='MITx', number='1002', display_name='Tech Beta Course', ) self.factory = RequestFactory()
def test_pre_requisite_course_update_and_fetch(self): seed_milestone_relationship_types() url = get_url(self.course.id) resp = self.client.get_json(url) course_detail_json = json.loads(resp.content) # assert pre_requisite_courses is initialized self.assertEqual([], course_detail_json['pre_requisite_courses']) # update pre requisite courses with a new course keys pre_requisite_course = CourseFactory.create(org='edX', course='900', run='test_run') pre_requisite_course2 = CourseFactory.create(org='edX', course='902', run='test_run') pre_requisite_course_keys = [unicode(pre_requisite_course.id), unicode(pre_requisite_course2.id)] course_detail_json['pre_requisite_courses'] = pre_requisite_course_keys self.client.ajax_post(url, course_detail_json) # fetch updated course to assert pre_requisite_courses has new values resp = self.client.get_json(url) course_detail_json = json.loads(resp.content) self.assertEqual(pre_requisite_course_keys, course_detail_json['pre_requisite_courses']) # remove pre requisite course course_detail_json['pre_requisite_courses'] = [] self.client.ajax_post(url, course_detail_json) resp = self.client.get_json(url) course_detail_json = json.loads(resp.content) self.assertEqual([], course_detail_json['pre_requisite_courses'])
def test_course_with_prereq(self): """ Simulate having a course which has closed enrollments that has a pre-req course """ pre_requisite_course = CourseFactory.create( org='edX', course='900', display_name='pre requisite course', ) pre_requisite_courses = [unicode(pre_requisite_course.id)] # for this failure to occur, the enrollment window needs to be in the past course = CourseFactory.create( org='edX', course='1000', display_name='course that has pre requisite', # closed enrollment enrollment_start=datetime.datetime(2013, 1, 1), enrollment_end=datetime.datetime(2014, 1, 1), start=datetime.datetime(2013, 1, 1), end=datetime.datetime(2030, 1, 1), pre_requisite_courses=pre_requisite_courses, ) set_prerequisite_courses(course.id, pre_requisite_courses) resp = self.client.get('/') self.assertEqual(resp.status_code, 200) # make sure both courses are visible in the catalog self.assertIn('pre requisite course', resp.content) self.assertIn('course that has pre requisite', resp.content)
def setUp(self): super(ExternalAuthShibTest, self).setUp() self.course = CourseFactory.create( org='Stanford', number='456', display_name='NO SHIB', user_id=self.user.id, ) self.shib_course = CourseFactory.create( org='Stanford', number='123', display_name='Shib Only', enrollment_domain='shib:https://idp.stanford.edu/', user_id=self.user.id, ) self.user_w_map = UserFactory.create(email='*****@*****.**') self.extauth = ExternalAuthMap(external_id='*****@*****.**', external_email='*****@*****.**', external_domain='shib:https://idp.stanford.edu/', external_credentials="", user=self.user_w_map) self.user_w_map.save() self.extauth.save() self.user_wo_map = UserFactory.create(email='*****@*****.**') self.user_wo_map.save()
def test_factories(self): test_course = CourseFactory.create( org='testx', course='course', run='2014', display_name='fun test course', user_id='testbot' ) self.assertIsInstance(test_course, CourseDescriptor) self.assertEqual(test_course.display_name, 'fun test course') course_from_store = self.store.get_course(test_course.id) self.assertEqual(course_from_store.id.org, 'testx') self.assertEqual(course_from_store.id.course, 'course') self.assertEqual(course_from_store.id.run, '2014') test_chapter = ItemFactory.create( parent_location=test_course.location, category='chapter', display_name='chapter 1' ) self.assertIsInstance(test_chapter, SequenceDescriptor) # refetch parent which should now point to child test_course = self.store.get_course(test_course.id.version_agnostic()) self.assertIn(test_chapter.location, test_course.children) with self.assertRaises(DuplicateCourseError): CourseFactory.create( org='testx', course='course', run='2014', display_name='fun test course', user_id='testbot' )
def setUpClass(cls): """ Creates two courses; one that's just a course module, and one that looks like: course | chapter | sequential | vertical / | \ \ / | \ ---------- / | \ \ / | --- \ / | \ \ html -> problem -> video -> video2 The side-pointing arrows (->) are PRECEDES relationships; the more vertical lines are PARENT_OF relationships. """ super(TestDumpToNeo4jCommandBase, cls).setUpClass() cls.course = CourseFactory.create() cls.chapter = ItemFactory.create(parent=cls.course, category='chapter') cls.sequential = ItemFactory.create(parent=cls.chapter, category='sequential') cls.vertical = ItemFactory.create(parent=cls.sequential, category='vertical') cls.html = ItemFactory.create(parent=cls.vertical, category='html') cls.problem = ItemFactory.create(parent=cls.vertical, category='problem') cls.video = ItemFactory.create(parent=cls.vertical, category='video') cls.video2 = ItemFactory.create(parent=cls.vertical, category='video') cls.course2 = CourseFactory.create() cls.course_strings = [six.text_type(cls.course.id), six.text_type(cls.course2.id)]
def test_eligibility_email_with_providers(self, providers_list, providers_email_message, expected_subject): """ Test the credit requirements, eligibility notification, email for different providers combinations. """ # Configure a course with two credit requirements self.add_credit_course() CourseFactory.create(org='edX', number='DemoX', display_name='Demo_Course') requirements = [ { "namespace": "grade", "name": "grade", "display_name": "Grade", "criteria": { "min_grade": 0.8 }, }, { "namespace": "reverification", "name": "i4x://edX/DemoX/edx-reverification-block/assessment_uuid", "display_name": "Assessment 1", "criteria": {}, } ] api.set_credit_requirements(self.course_key, requirements) user = UserFactory.create(username=self.USER_INFO['username'], password=self.USER_INFO['password']) # Satisfy one of the requirements, but not the other api.set_credit_requirement_status( user.username, self.course_key, requirements[0]["namespace"], requirements[0]["name"] ) # Satisfy the other requirement. And mocked the api to return different kind of data. with mock.patch('openedx.core.djangoapps.credit.email_utils.get_credit_provider_display_names') as mock_method: mock_method.return_value = providers_list api.set_credit_requirement_status( "bob", self.course_key, requirements[1]["namespace"], requirements[1]["name"] ) # Now the user should be eligible self.assertTrue(api.is_user_eligible_for_credit("bob", self.course_key)) # Credit eligibility email should be sent self.assertEqual(len(mail.outbox), 1) # Verify the email subject self.assertEqual(mail.outbox[0].subject, expected_subject) # Now verify them email content email_payload_first = mail.outbox[0].attachments[0]._payload # pylint: disable=protected-access html_content_first = email_payload_first[0]._payload[1]._payload # pylint: disable=protected-access self.assertIn(providers_email_message, html_content_first) # test text email text_content_first = email_payload_first[0]._payload[0]._payload # pylint: disable=protected-access self.assertIn(providers_email_message, text_content_first)
def setUp(self): # use a different hostname to test Microsites since they are # triggered on subdomain mappings # # NOTE: The Microsite Configuration is in lms/envs/test.py. The content for the Test Microsite is in # test_microsites/test_microsite. # # IMPORTANT: For these tests to work, this domain must be defined via # DNS configuration (either local or published) self.course = CourseFactory.create(display_name='Robot_Super_Course', org='TestMicrositeX') self.chapter0 = ItemFactory.create(parent_location=self.course.location, display_name='Overview') self.chapter9 = ItemFactory.create(parent_location=self.course.location, display_name='factory_chapter') self.section0 = ItemFactory.create(parent_location=self.chapter0.location, display_name='Welcome') self.section9 = ItemFactory.create(parent_location=self.chapter9.location, display_name='factory_section') self.course_outside_microsite = CourseFactory.create(display_name='Robot_Course_Outside_Microsite', org='FooX') # have a course which explicitly sets visibility in catalog to False self.course_hidden_visibility = CourseFactory.create( display_name='Hidden_course', org='TestMicrositeX', catalog_visibility=CATALOG_VISIBILITY_NONE, ) # have a course which explicitly sets visibility in catalog and about to true self.course_with_visibility = CourseFactory.create( display_name='visible_course', org='TestMicrositeX', catalog_visibility=CATALOG_VISIBILITY_CATALOG_AND_ABOUT, )
def setUp(self): self.user = UserFactory.create() course = CourseFactory.create(org='org', number='test', display_name='Test Course') self.course_key = course.id for i in xrange(1, 5): CourseFactory.create(org='org', number='test', display_name='Test Course {0}'.format(i)) self.cost = 40
def test_course_listing_org_permissions(self, role): """ Create multiple courses within the same org. Verify that someone with org-wide permissions can access all of them. """ org_course_one = self.store.make_course_key('AwesomeOrg', 'Course1', 'RunBabyRun') CourseFactory.create( org=org_course_one.org, number=org_course_one.course, run=org_course_one.run ) org_course_two = self.store.make_course_key('AwesomeOrg', 'Course2', 'RunBabyRun') CourseFactory.create( org=org_course_two.org, number=org_course_two.course, run=org_course_two.run ) # Two types of org-wide roles have edit permissions: staff and instructor. We test both role.add_users(self.user) with self.assertRaises(AccessListFallback): _accessible_courses_list_from_groups(self.request) courses_list, __ = get_courses_accessible_to_user(self.request) # Verify fetched accessible courses list is a list of CourseSummery instances and test expacted # course count is returned self.assertEqual(len(courses_list), 2) self.assertTrue(all(isinstance(course, CourseSummary) for course in courses_list))
def setUp(self): super(ParamValidatorTest, self).setUp() self.draft_course = CourseFactory.create( start=NEXT_WEEK, enrollment_start=NEXT_WEEK, end=NEXT_WEEK, enrollment_end=NEXT_WEEK, ) self.upcoming_course = CourseFactory.create( start=NEXT_WEEK, enrollment_start=YESTERDAY, end=NEXT_MONTH, enrollment_end=NEXT_WEEK, ) self.current_course = CourseFactory.create( start=PAST_WEEK, enrollment_start=PAST_WEEK, end=NEXT_MONTH, enrollment_end=NEXT_WEEK, ) self.closed_course = CourseFactory.create( start=PAST_WEEK, enrollment_start=PAST_WEEK, end=YESTERDAY, enrollment_end=YESTERDAY, )
def setUp(self): """ Set up courses and enrollments. """ super(TestStudentDashboardWithCCX, self).setUp() # Create a Draft Mongo and a Split Mongo course and enroll a student user in them. self.student_password = "******" self.student = UserFactory.create(username="******", password=self.student_password, is_staff=False) self.draft_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.mongo) self.split_course = CourseFactory.create(default_store=ModuleStoreEnum.Type.split) CourseEnrollment.enroll(self.student, self.draft_course.id) CourseEnrollment.enroll(self.student, self.split_course.id) # Create a CCX coach. self.coach = AdminFactory.create() role = CourseCcxCoachRole(self.split_course.id) role.add_users(self.coach) # Create a CCX course and enroll the user in it. self.ccx = CcxFactory(course_id=self.split_course.id, coach=self.coach) last_week = datetime.datetime.now(UTC()) - datetime.timedelta(days=7) override_field_for_ccx(self.ccx, self.split_course, 'start', last_week) # Required by self.ccx.has_started(). course_key = CCXLocator.from_course_locator(self.split_course.id, self.ccx.id) CourseEnrollment.enroll(self.student, course_key)
def test_access_on_course_with_pre_requisites(self): """ Test course access when a course has pre-requisite course yet to be completed """ 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(user, 'load', course) self.assertFalse(response) self.assertIsInstance(response, access_response.MilestoneAccessError) # Staff can always access course staff = StaffFactory.create(course_key=course.id) self.assertTrue(access._has_access_course(staff, 'load', course)) # User should be able access after completing required course fulfill_course_milestone(pre_requisite_course.id, user) self.assertTrue(access._has_access_course(user, 'load', course))
def test_course_index_view_with_course(self): """Test viewing the index page with an existing course""" CourseFactory.create(display_name="Robot Super Educational Course") resp = self.client.get(reverse("index")) self.assertContains( resp, '<span class="class-name">Robot Super Educational Course</span>', status_code=200, html=True )
def test_course_listing_org_permissions(self, role): """ Create multiple courses within the same org. Verify that someone with org-wide permissions can access all of them. """ org_course_one = SlashSeparatedCourseKey('AwesomeOrg', 'Course1', 'RunBabyRun') CourseFactory.create( org=org_course_one.org, number=org_course_one.course, run=org_course_one.run ) org_course_two = SlashSeparatedCourseKey('AwesomeOrg', 'Course2', 'RunRunRun') CourseFactory.create( org=org_course_two.org, number=org_course_two.course, run=org_course_two.run ) # Two types of org-wide roles have edit permissions: staff and instructor. We test both role.add_users(self.user) with self.assertRaises(AccessListFallback): _accessible_courses_list_from_groups(self.request) courses_list = _accessible_courses_list(self.request) self.assertEqual(len(courses_list), 2)
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 setUp(self): super(AboutSidebarHTMLTestCase, self).setUp() self.course = CourseFactory.create()
def setUpClass(cls): super(TestRenderMessageToString, cls).setUpClass() cls.course = CourseFactory.create() cls.subject_template = 'emails/enroll_email_allowedsubject.txt' cls.message_template = 'emails/enroll_email_allowedmessage.txt'
def setUpClass(cls): super(CourseAboutTestCaseCCX, cls).setUpClass() cls.course = CourseFactory.create()
def create_test_courses(cls): """ We build two simple course structures (one using Split, the other Old Mongo). Each course structure is a non-branching tree from the root Course block down to the Component-level problem block; that is, we make one item for each course hierarchy level. For easy access in the test functions, we return them in a dict like this: { "split": { "course_run": <course block for Split Mongo course>, "section": <chapter block in course run> "subsection": <sequence block in section> "unit": <vertical block in subsection> "component": <problem block in unit> }, "mongo": { "course_run": <course block for (deprecated) Old Mongo course>, ... etc ... } } """ # Make Split Mongo course. with cls.store.default_store(ModuleStoreEnum.Type.split): course_run = CourseFactory.create( org='TestX', number='UrlHelpers', run='split', display_name='URL Helpers Test Course', ) with cls.store.bulk_operations(course_run.id): section = ItemFactory.create( parent_location=course_run.location, category='chapter', display_name="Generated Section", ) subsection = ItemFactory.create( parent_location=section.location, category='sequential', display_name="Generated Subsection", ) unit = ItemFactory.create( parent_location=subsection.location, category='vertical', display_name="Generated Unit", ) component = ItemFactory.create( parent_location=unit.location, category='problem', display_name="Generated Problem Component", ) # Make (deprecated) Old Mongo course. with cls.store.default_store(ModuleStoreEnum.Type.mongo): deprecated_course_run = CourseFactory.create( org='TestX', number='UrlHelpers', run='mongo', display_name='URL Helpers Test Course (Deprecated)', ) with cls.store.bulk_operations(deprecated_course_run.id): deprecated_section = ItemFactory.create( parent_location=deprecated_course_run.location, category='chapter', display_name="Generated Section", ) deprecated_subsection = ItemFactory.create( parent_location=deprecated_section.location, category='sequential', display_name="Generated Subsection", ) deprecated_unit = ItemFactory.create( parent_location=deprecated_subsection.location, category='vertical', display_name="Generated Unit", ) deprecated_component = ItemFactory.create( parent_location=deprecated_unit.location, category='problem', display_name="Generated Problem Component", ) return { ModuleStoreEnum.Type.split: { 'course_run': course_run, 'section': section, 'subsection': subsection, 'unit': unit, 'component': component, }, ModuleStoreEnum.Type.mongo: { 'course_run': deprecated_course_run, 'section': deprecated_section, 'subsection': deprecated_subsection, 'unit': deprecated_unit, 'component': deprecated_component, } }
def setUpClass(cls): super(AboutWithInvitationOnly, cls).setUpClass() cls.course = CourseFactory.create(metadata={"invitation_only": True}) cls.about = ItemFactory.create(category="about", parent_location=cls.course.location, display_name="overview")
def test_spaces_in_image_name(self): # Verify that image names with spaces in them are cleaned course = CourseFactory.create(course_image='before after.jpg') assert course_image_url(course) == f'/c4x/{course.location.org}/{course.location.course}/asset/before_after.jpg' # pylint: disable=line-too-long
def setUpClass(cls): super(TestGetEmailParamsCCX, cls).setUpClass() cls.course = CourseFactory.create()
def test_get_image_url(self): """Test image URL formatting.""" course = CourseFactory.create(org='edX', course='999') assert course_image_url(course) == f'/c4x/edX/999/asset/{course.course_image}'
def test_get_course_func_with_access(self, course_access_func_name, num_mongo_calls): course_access_func = self.COURSE_ACCESS_FUNCS[course_access_func_name] user = UserFactory.create() course = CourseFactory.create(emit_signals=True) with check_mongo_calls(num_mongo_calls): course_access_func(user, 'load', course.id)
def test_get_image_url(self): """Test image URL formatting.""" course = CourseFactory.create(org='edX', course='999') self.assertEqual(course_image_url(course), '/c4x/edX/999/asset/{0}'.format(course.course_image))
def test_non_ascii_image_name(self): # Verify that non-ascii image names are cleaned course = CourseFactory.create(course_image='before_\N{SNOWMAN}_after.jpg') assert course_image_url(course) == f'/c4x/{course.location.org}/{course.location.course}/asset/before___after.jpg' # pylint: disable=line-too-long