def test_course_catalog_access_num_queries(self, user_attr_name, action, course_attr_name):
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime.date(2018, 1, 1))
course = getattr(self, course_attr_name)
# get a fresh user object that won't have any cached role information
if user_attr_name == 'user_anonymous':
user = AnonymousUserFactory()
else:
user = getattr(self, user_attr_name)
user = User.objects.get(id=user.id)
if user_attr_name == 'user_staff' and action == 'see_exists':
# always checks staff role, and if the course has started, check the duration configuration
if course_attr_name == 'course_started':
num_queries = 4
else:
num_queries = 1
elif user_attr_name == 'user_normal' and action == 'see_exists':
if course_attr_name == 'course_started':
num_queries = 4
else:
# checks staff role and enrollment data
num_queries = 2
else:
# if the course has started, check the duration configuration
if action == 'see_exists' and course_attr_name == 'course_started':
num_queries = 3
else:
num_queries = 0
course_overview = CourseOverview.get_from_id(course.id)
with self.assertNumQueries(num_queries, table_blacklist=QUERY_COUNT_TABLE_BLACKLIST):
bool(access.has_access(user, action, course_overview, course_key=course.id))
def setUp(self):
self.course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall')
self.anonymous_user = AnonymousUserFactory()
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
self.course_staff = StaffFactory(course_key=self.course_key)
self.course_instructor = InstructorFactory(course_key=self.course_key)
def setUp(self):
super(CourseOverviewAccessTestCase, self).setUp()
today = datetime.datetime.now(pytz.UTC)
last_week = today - datetime.timedelta(days=7)
next_week = today + datetime.timedelta(days=7)
self.course_default = CourseFactory.create()
self.course_started = CourseFactory.create(start=last_week)
self.course_not_started = CourseFactory.create(start=next_week, days_early_for_beta=10)
self.course_staff_only = CourseFactory.create(visible_to_staff_only=True)
self.course_mobile_available = CourseFactory.create(mobile_available=True)
self.course_with_pre_requisite = CourseFactory.create(
pre_requisite_courses=[str(self.course_started.id)]
)
self.course_with_pre_requisites = CourseFactory.create(
pre_requisite_courses=[str(self.course_started.id), str(self.course_not_started.id)]
)
self.user_normal = UserFactory.create()
self.user_beta_tester = BetaTesterFactory.create(course_key=self.course_not_started.id)
self.user_completed_pre_requisite = UserFactory.create()
fulfill_course_milestone(self.user_completed_pre_requisite, self.course_started.id)
self.user_staff = UserFactory.create(is_staff=True)
self.user_anonymous = AnonymousUserFactory.create()
def test_course_catalog_access_num_queries(self, user_attr_name, action,
course_attr_name):
course = getattr(self, course_attr_name)
# get a fresh user object that won't have any cached role information
if user_attr_name == 'user_anonymous':
user = AnonymousUserFactory()
else:
user = getattr(self, user_attr_name)
user = User.objects.get(id=user.id)
if user_attr_name == 'user_staff' and action == 'see_exists' and course_attr_name == 'course_not_started':
# checks staff role
num_queries = 1
elif user_attr_name == 'user_normal' and action == 'see_exists' and course_attr_name != 'course_started':
# checks staff role and enrollment data
num_queries = 2
else:
num_queries = 0
course_overview = CourseOverview.get_from_id(course.id)
with self.assertNumQueries(num_queries):
bool(
access.has_access(user,
action,
course_overview,
course_key=course.id))
def test_fetching_program_discounted_price_as_anonymous_user(self):
"""
Anonymous users should see the purchase button same way the authenticated users do
when the program is eligible for one click purchase.
"""
self._prepare_program_for_discounted_price_calculation_endpoint()
mock_discount_data = {
'total_incl_tax_excl_discounts': 200.0,
'currency': 'USD',
'total_incl_tax': 50.0
}
httpretty.register_uri(
httpretty.GET,
self.ECOMMERCE_CALCULATE_DISCOUNT_ENDPOINT,
body=json.dumps(mock_discount_data),
content_type='application/json'
)
data = ProgramMarketingDataExtender(self.program, AnonymousUserFactory()).extend()
self._update_discount_data(mock_discount_data)
self.assertEqual(
data['skus'],
[course['course_runs'][0]['seats'][0]['sku'] for course in self.program['courses']]
)
self.assertEqual(data['discount_data'], mock_discount_data)
def setUp(self):
self.course = Location('i4x://edX/toy/course/2012_Fall')
self.anonymous_user = AnonymousUserFactory()
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
self.course_staff = StaffFactory(course=self.course)
self.course_instructor = InstructorFactory(course=self.course)
def setUp(self):
super(UserServiceTestCase, self).setUp()
self.user = UserFactory(username="******", email="*****@*****.**")
self.user.profile.name = "Test Tester"
set_user_preference(self.user, 'pref-lang', 'en')
set_user_preference(self.user, 'time_zone', 'US/Pacific')
set_user_preference(self.user, 'not_white_listed', 'hidden_value')
self.anon_user = AnonymousUserFactory()
def setUp(self):
self.country_middleware = CountryMiddleware()
self.session_middleware = SessionMiddleware()
self.authenticated_user = UserFactory.create()
self.anonymous_user = AnonymousUserFactory.create()
self.request_factory = RequestFactory()
self.patcher = patch.object(pygeoip.GeoIP, 'country_code_by_addr', self.mock_country_code_by_addr)
self.patcher.start()
def setUp(self):
super(UserRoleTestCase, self).setUp()
self.course_key = CourseLocator('edX', 'toy', '2012_Fall')
self.anonymous_user = AnonymousUserFactory()
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
self.course_staff = StaffFactory(course_key=self.course_key)
self.course_instructor = InstructorFactory(course_key=self.course_key)
def setUp(self):
super(RolesTestCase, self).setUp()
self.course_key = CourseKey.from_string('edX/toy/2012_Fall')
self.course_loc = self.course_key.make_usage_key('course', '2012_Fall')
self.anonymous_user = AnonymousUserFactory()
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
self.course_staff = StaffFactory(course_key=self.course_key)
self.course_instructor = InstructorFactory(course_key=self.course_key)
def setUp(self):
super(AccessTestCase, self).setUp()
course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall')
self.course = course_key.make_usage_key('course', course_key.run)
self.anonymous_user = AnonymousUserFactory()
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
self.course_staff = StaffFactory(course_key=self.course.course_key)
self.course_instructor = InstructorFactory(course_key=self.course.course_key)
def test_anonymous_user(self):
self.request.user = AnonymousUserFactory()
self.process_request()
self.assertContextSetTo({
'course_id': self.course_id,
'course_user_tags': {}
})
def setUp(self):
self.country_middleware = CountryMiddleware()
self.session_middleware = SessionMiddleware()
self.authenticated_user = UserFactory.create()
self.anonymous_user = AnonymousUserFactory.create()
self.request_factory = RequestFactory()
self.patcher = patch.object(pygeoip.GeoIP, 'country_code_by_addr',
self.mock_country_code_by_addr)
self.patcher.start()
def setUp(self):
super(TestUserPreferenceMiddleware, self).setUp()
self.middleware = LanguagePreferenceMiddleware()
self.session_middleware = SessionMiddleware()
self.user = UserFactory.create()
self.anonymous_user = AnonymousUserFactory()
self.request = RequestFactory().get('/somewhere')
self.request.user = self.user
self.request.META['HTTP_ACCEPT_LANGUAGE'] = 'ar;q=1.0' # pylint: disable=no-member
self.session_middleware.process_request(self.request)
def setUp(self):
super(AccessTestCase, self).setUp()
self.course = CourseFactory.create(org='edX', course='toy', run='test_run')
self.anonymous_user = AnonymousUserFactory()
self.beta_user = BetaTesterFactory(course_key=self.course.id)
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
self.course_staff = StaffFactory(course_key=self.course.id)
self.course_instructor = InstructorFactory(course_key=self.course.id)
self.staff = GlobalStaffFactory()
def setUp(self):
course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall')
self.course = course_key.make_usage_key('course', course_key.run)
self.anonymous_user = AnonymousUserFactory()
self.student = UserFactory()
self.global_staff = UserFactory(is_staff=True)
# TODO please change the StaffFactory and InstructorFactory parameters ASAP!
self.course_staff = StaffFactory(course=self.course.course_key)
self.course_instructor = InstructorFactory(
course=self.course.course_key)
def setUp(self):
"""Create required infrastructure for tests"""
super(TestUserCCXList, self).setUp()
self.course = CourseFactory.create()
coach = AdminFactory.create()
role = CourseCcxCoachRole(self.course.id)
role.add_users(coach)
self.ccx = CcxFactory(course_id=self.course.id, coach=coach)
enrollment = CourseEnrollmentFactory.create(course_id=self.course.id)
self.user = enrollment.user
self.anonymous = AnonymousUserFactory.create()
def setUp(self):
"""Create required infrastructure for tests"""
super(TestUserCCXList, self).setUp()
self.course = CourseFactory.create()
coach = AdminFactory.create()
role = CourseCcxCoachRole(self.course.id)
role.add_users(coach)
self.ccx = CcxFactory(course_id=self.course.id, coach=coach)
enrollment = CourseEnrollmentFactory.create(course_id=self.course.id)
self.user = enrollment.user
self.anonymous = AnonymousUserFactory.create()
def setUp(self):
super(CountryMiddlewareTests, self).setUp()
self.country_middleware = CountryMiddleware()
self.session_middleware = SessionMiddleware()
self.authenticated_user = UserFactory.create()
self.anonymous_user = AnonymousUserFactory.create()
self.request_factory = RequestFactory()
patcher = patch.object(maxminddb, 'open_database')
patcher.start()
country_patcher = patch.object(geoip2.database.Reader, 'country', self.mock_country)
country_patcher.start()
self.addCleanup(patcher.stop)
self.addCleanup(country_patcher.stop)
def setUp(self):
super(CountryMiddlewareTests, self).setUp()
self.country_middleware = CountryMiddleware()
self.session_middleware = SessionMiddleware()
self.authenticated_user = UserFactory.create()
self.anonymous_user = AnonymousUserFactory.create()
self.request_factory = RequestFactory()
patcher = patch.object(maxminddb, 'open_database')
patcher.start()
country_patcher = patch.object(geoip2.database.Reader, 'country', self.mock_country)
country_patcher.start()
self.addCleanup(patcher.stop)
self.addCleanup(country_patcher.stop)
def test_get_programs_anonymous_user(self, _mock_cache, mock_get_catalog_data):
programs = [factories.Program() for __ in range(3)]
mock_get_catalog_data.return_value = programs
anonymous_user = AnonymousUserFactory()
# The user is an Anonymous user but the Catalog Service User has not been created yet.
data = utils.get_programs(anonymous_user)
# This should not return programs.
self.assertEqual(data, [])
UserFactory(username='******')
# After creating the service user above,
data = utils.get_programs(anonymous_user)
# the programs should be returned successfully.
self.assertEqual(data, programs)
def test_get_program_types(self, _mock_cache, mock_get_catalog_data):
program_types = [factories.ProgramType() for __ in range(3)]
mock_get_catalog_data.return_value = program_types
# Creating Anonymous user but the Catalog Service User has not been created yet.
anonymous_user = AnonymousUserFactory()
data = utils.get_program_types(anonymous_user)
# This should not return programs.
self.assertEqual(data, [])
# Creating Catalog Service User user
UserFactory(username='******')
data = utils.get_program_types(anonymous_user)
# the programs should be returned successfully.
self.assertEqual(data, program_types)
# Catalog integration is disabled now.
self.catalog_integration = self.create_catalog_integration(enabled=False)
data = utils.get_program_types(anonymous_user)
# This should not return programs.
self.assertEqual(data, [])
def setUp(self):
super(UserServiceTestCase, self).setUp()
self.user = UserFactory(username="******", email="*****@*****.**")
self.user.profile.name = "Test Tester"
self.anon_user = AnonymousUserFactory()
def test_refresh_jwt_cookies_anonymous_user(self):
anonymous_user = AnonymousUserFactory()
response = cookies_api.refresh_jwt_cookies(self.request, HttpResponse(), anonymous_user)
self._assert_cookies_present(response, [])
def setUp(self):
self.user = UserFactory(username="******", email="*****@*****.**")
self.user.profile.name = "Test Tester"
self.anon_user = AnonymousUserFactory()
def setUp(self):
"""
Test case scaffolding
"""
super(EntranceExamTestCases, self).setUp()
self.course = CourseFactory.create(
metadata={
'entrance_exam_enabled': True,
}
)
self.chapter = ItemFactory.create(
parent=self.course,
display_name='Overview'
)
self.welcome = ItemFactory.create(
parent=self.chapter,
display_name='Welcome'
)
ItemFactory.create(
parent=self.course,
category='chapter',
display_name="Week 1"
)
self.chapter_subsection = ItemFactory.create(
parent=self.chapter,
category='sequential',
display_name="Lesson 1"
)
chapter_vertical = ItemFactory.create(
parent=self.chapter_subsection,
category='vertical',
display_name='Lesson 1 Vertical - Unit 1'
)
ItemFactory.create(
parent=chapter_vertical,
category="problem",
display_name="Problem - Unit 1 Problem 1"
)
ItemFactory.create(
parent=chapter_vertical,
category="problem",
display_name="Problem - Unit 1 Problem 2"
)
ItemFactory.create(
category="instructor",
parent=self.course,
data="Instructor Tab",
display_name="Instructor"
)
self.entrance_exam = ItemFactory.create(
parent=self.course,
category="chapter",
display_name="Entrance Exam Section - Chapter 1",
is_entrance_exam=True,
in_entrance_exam=True
)
self.exam_1 = ItemFactory.create(
parent=self.entrance_exam,
category='sequential',
display_name="Exam Sequential - Subsection 1",
graded=True,
in_entrance_exam=True
)
subsection = ItemFactory.create(
parent=self.exam_1,
category='vertical',
display_name='Exam Vertical - Unit 1'
)
problem_xml = MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 3',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3']
)
self.problem_1 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 1",
data=problem_xml
)
self.problem_2 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 2"
)
add_entrance_exam_milestone(self.course, self.entrance_exam)
self.course.entrance_exam_enabled = True
self.course.entrance_exam_minimum_score_pct = 0.50
self.course.entrance_exam_id = unicode(self.entrance_exam.scope_ids.usage_id)
self.anonymous_user = AnonymousUserFactory()
self.request = get_request_for_user(UserFactory())
modulestore().update_item(self.course, self.request.user.id) # pylint: disable=no-member
self.client.login(username=self.request.user.username, password="******")
CourseEnrollment.enroll(self.request.user, self.course.id)
self.expected_locked_toc = (
[
{
'active': True,
'sections': [
{
'url_name': u'Exam_Sequential_-_Subsection_1',
'display_name': u'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}
],
'url_name': u'Entrance_Exam_Section_-_Chapter_1',
'display_name': u'Entrance Exam Section - Chapter 1',
'display_id': u'entrance-exam-section-chapter-1',
}
]
)
self.expected_unlocked_toc = (
[
{
'active': False,
'sections': [
{
'url_name': u'Welcome',
'display_name': u'Welcome',
'graded': False,
'format': '',
'due': None,
'active': False
},
{
'url_name': u'Lesson_1',
'display_name': u'Lesson 1',
'graded': False,
'format': '',
'due': None,
'active': False
}
],
'url_name': u'Overview',
'display_name': u'Overview',
'display_id': u'overview'
},
{
'active': False,
'sections': [],
'url_name': u'Week_1',
'display_name': u'Week 1',
'display_id': u'week-1'
},
{
'active': False,
'sections': [],
'url_name': u'Instructor',
'display_name': u'Instructor',
'display_id': u'instructor'
},
{
'active': True,
'sections': [
{
'url_name': u'Exam_Sequential_-_Subsection_1',
'display_name': u'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}
],
'url_name': u'Entrance_Exam_Section_-_Chapter_1',
'display_name': u'Entrance Exam Section - Chapter 1',
'display_id': u'entrance-exam-section-chapter-1'
}
]
)
def setUp(self):
"""
Test case scaffolding
"""
super(EntranceExamTestCases, self).setUp()
self.course = CourseFactory.create(metadata={
'entrance_exam_enabled': True,
})
self.chapter = ItemFactory.create(parent=self.course,
display_name='Overview')
ItemFactory.create(parent=self.chapter, display_name='Welcome')
ItemFactory.create(parent=self.course,
category='chapter',
display_name="Week 1")
self.chapter_subsection = ItemFactory.create(parent=self.chapter,
category='sequential',
display_name="Lesson 1")
chapter_vertical = ItemFactory.create(
parent=self.chapter_subsection,
category='vertical',
display_name='Lesson 1 Vertical - Unit 1')
ItemFactory.create(parent=chapter_vertical,
category="problem",
display_name="Problem - Unit 1 Problem 1")
ItemFactory.create(parent=chapter_vertical,
category="problem",
display_name="Problem - Unit 1 Problem 2")
ItemFactory.create(category="instructor",
parent=self.course,
data="Instructor Tab",
display_name="Instructor")
self.entrance_exam = ItemFactory.create(
parent=self.course,
category="chapter",
display_name="Entrance Exam Section - Chapter 1",
is_entrance_exam=True,
in_entrance_exam=True)
self.exam_1 = ItemFactory.create(
parent=self.entrance_exam,
category='sequential',
display_name="Exam Sequential - Subsection 1",
graded=True,
in_entrance_exam=True)
subsection = ItemFactory.create(parent=self.exam_1,
category='vertical',
display_name='Exam Vertical - Unit 1')
self.problem_1 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 1")
self.problem_2 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 2")
self.problem_3 = ItemFactory.create(
parent=subsection,
category="problem",
display_name="Exam Problem - Problem 3")
if settings.FEATURES.get('ENTRANCE_EXAMS', False):
namespace_choices = get_namespace_choices()
milestone_namespace = generate_milestone_namespace(
namespace_choices.get('ENTRANCE_EXAM'), self.course.id)
self.milestone = {
'name': 'Test Milestone',
'namespace': milestone_namespace,
'description': 'Testing Courseware Entrance Exam Chapter',
}
seed_milestone_relationship_types()
self.milestone_relationship_types = get_milestone_relationship_types(
)
self.milestone = add_milestone(self.milestone)
add_course_milestone(unicode(self.course.id),
self.milestone_relationship_types['REQUIRES'],
self.milestone)
add_course_content_milestone(
unicode(self.course.id), unicode(self.entrance_exam.location),
self.milestone_relationship_types['FULFILLS'], self.milestone)
self.anonymous_user = AnonymousUserFactory()
user = UserFactory()
self.request = RequestFactory()
self.request.user = user
self.request.COOKIES = {}
self.request.META = {}
self.request.is_secure = lambda: True
self.request.get_host = lambda: "edx.org"
self.request.method = 'GET'
self.field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
self.course.id, user, self.entrance_exam)
self.course.entrance_exam_enabled = True
self.course.entrance_exam_minimum_score_pct = 0.50
self.course.entrance_exam_id = unicode(
self.entrance_exam.scope_ids.usage_id)
modulestore().update_item(self.course, user.id) # pylint: disable=no-member
self.client.login(username=self.request.user.username, password="******")
CourseEnrollment.enroll(self.request.user, self.course.id)
self.expected_locked_toc = ([{
'active':
True,
'sections': [{
'url_name': u'Exam_Sequential_-_Subsection_1',
'display_name': u'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}],
'url_name':
u'Entrance_Exam_Section_-_Chapter_1',
'display_name':
u'Entrance Exam Section - Chapter 1'
}])
self.expected_unlocked_toc = ([{
'active':
False,
'sections': [{
'url_name': u'Welcome',
'display_name': u'Welcome',
'graded': False,
'format': '',
'due': None,
'active': False
}, {
'url_name': u'Lesson_1',
'display_name': u'Lesson 1',
'graded': False,
'format': '',
'due': None,
'active': False
}],
'url_name':
u'Overview',
'display_name':
u'Overview'
}, {
'active': False,
'sections': [],
'url_name': u'Week_1',
'display_name': u'Week 1'
}, {
'active': False,
'sections': [],
'url_name': u'Instructor',
'display_name': u'Instructor'
}, {
'active':
True,
'sections': [{
'url_name': u'Exam_Sequential_-_Subsection_1',
'display_name': u'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}],
'url_name':
u'Entrance_Exam_Section_-_Chapter_1',
'display_name':
u'Entrance Exam Section - Chapter 1'
}])
def test_set_logged_in_cookies_anonymous_user(self):
anonymous_user = AnonymousUserFactory()
response = cookies_api.set_logged_in_cookies(self.request, HttpResponse(), anonymous_user)
self._assert_cookies_present(response, [])
