def setUp(self):
super().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.course_started.id,
self.user_completed_pre_requisite)
self.user_staff = UserFactory.create(is_staff=True)
self.user_anonymous = AnonymousUserFactory.create()
def setUp(self):
super(UserServiceTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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):
super(UserRoleTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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().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().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):
super(RolesTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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().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 test_anonymous_user(self):
self.request.user = AnonymousUserFactory()
self.process_request()
self.assertContextSetTo({
'course_id': self.course_id,
'course_user_tags': {}
})
def setUp(self):
super(AccessTestCase, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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):
super().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):
super(TestUserPreferenceMiddleware, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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'
self.session_middleware.process_request(self.request)
self.client = Client()
def setUp(self):
super().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'
self.session_middleware.process_request(self.request)
self.client = Client()
def test_get_catalog_courses_anonymous_user(courses, course_group):
"""
Tests multiple courses in a single group for anonymous user
"""
user = AnonymousUserFactory()
MultilingualCourseFactory(course=courses['test_course1'],
multilingual_course_group=course_group)
MultilingualCourseFactory(course=courses['test_course2'],
multilingual_course_group=course_group)
assert len(
MultilingualCourseGroup.objects.
get_user_program_prereq_courses_and_all_non_prereq_courses(user)) == 1
def setUp(self):
super(CountryMiddlewareTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
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_course_catalog_access_num_queries(self, user_attr_name, action,
course_attr_name):
ContentTypeGatingConfig.objects.create(enabled=True,
enabled_as_of=datetime.datetime(
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 = 2
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
elif user_attr_name == 'user_anonymous' and action == 'see_exists':
if course_attr_name == 'course_started':
num_queries = 1
else:
num_queries = 0
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):
"""
Test case scaffolding
"""
super().setUp()
self.course = CourseFactory.create(
metadata={
'entrance_exam_enabled': True,
}
)
with self.store.bulk_operations(self.course.id):
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 = str(self.entrance_exam.scope_ids.usage_id)
self.anonymous_user = AnonymousUserFactory()
self.addCleanup(set_current_request, None)
self.request = get_mock_request(UserFactory())
modulestore().update_item(self.course, self.request.user.id)
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': 'Exam_Sequential_-_Subsection_1',
'display_name': 'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}
],
'url_name': 'Entrance_Exam_Section_-_Chapter_1',
'display_name': 'Entrance Exam Section - Chapter 1',
'display_id': 'entrance-exam-section-chapter-1',
}
]
)
self.expected_unlocked_toc = (
[
{
'active': False,
'sections': [
{
'url_name': 'Welcome',
'display_name': 'Welcome',
'graded': False,
'format': '',
'due': None,
'active': False
},
{
'url_name': 'Lesson_1',
'display_name': 'Lesson 1',
'graded': False,
'format': '',
'due': None,
'active': False
}
],
'url_name': 'Overview',
'display_name': 'Overview',
'display_id': 'overview'
},
{
'active': False,
'sections': [],
'url_name': 'Week_1',
'display_name': 'Week 1',
'display_id': 'week-1'
},
{
'active': False,
'sections': [],
'url_name': 'Instructor',
'display_name': 'Instructor',
'display_id': 'instructor'
},
{
'active': True,
'sections': [
{
'url_name': 'Exam_Sequential_-_Subsection_1',
'display_name': 'Exam Sequential - Subsection 1',
'graded': True,
'format': '',
'due': None,
'active': True
}
],
'url_name': 'Entrance_Exam_Section_-_Chapter_1',
'display_name': 'Entrance Exam Section - Chapter 1',
'display_id': '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, [])
