5d9e7e9fe5
When considering whether a subsection is complete as an assignment, skip any "hierarchy" types (sequential, vertical, etc) that don't have children. If the user can't see the content, don't risk marking it as complete. AA-726
460 lines
19 KiB
Python
460 lines
19 KiB
Python
"""
|
|
Tests for course access
|
|
"""
|
|
|
|
|
|
import datetime
|
|
import itertools
|
|
|
|
from unittest import mock
|
|
import pytest
|
|
import ddt
|
|
import pytz
|
|
from completion.models import BlockCompletion
|
|
from completion.test_utils import CompletionWaffleTestMixin
|
|
from crum import set_current_request
|
|
from django.conf import settings
|
|
from django.test.client import RequestFactory
|
|
from django.test.utils import override_settings
|
|
from django.urls import reverse
|
|
from opaque_keys.edx.keys import CourseKey
|
|
|
|
from lms.djangoapps.courseware.courses import (
|
|
course_open_for_self_enrollment,
|
|
get_cms_block_link,
|
|
get_cms_course_link,
|
|
get_course_about_section,
|
|
get_course_assignments,
|
|
get_course_by_id,
|
|
get_course_chapter_ids,
|
|
get_course_info_section,
|
|
get_course_overview_with_access,
|
|
get_course_with_access,
|
|
get_courses,
|
|
get_current_child
|
|
)
|
|
from lms.djangoapps.courseware.model_data import FieldDataCache
|
|
from lms.djangoapps.courseware.module_render import get_module_for_descriptor
|
|
from lms.djangoapps.courseware.courseware_access_exception import CoursewareAccessException
|
|
from openedx.core.djangolib.testing.utils import get_mock_request
|
|
from openedx.core.lib.courses import course_image_url
|
|
from common.djangoapps.student.tests.factories import UserFactory
|
|
from xmodule.modulestore import ModuleStoreEnum
|
|
from xmodule.modulestore.django import _get_modulestore_branch_setting, modulestore
|
|
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
|
|
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory, check_mongo_calls
|
|
from xmodule.modulestore.xml_importer import import_course_from_xml
|
|
from xmodule.tests.xml import XModuleXmlImportTest
|
|
from xmodule.tests.xml import factories as xml
|
|
|
|
CMS_BASE_TEST = 'testcms'
|
|
TEST_DATA_DIR = settings.COMMON_TEST_DATA_ROOT
|
|
|
|
|
|
@ddt.ddt
|
|
class CoursesTest(ModuleStoreTestCase):
|
|
"""Test methods related to fetching courses."""
|
|
ENABLED_SIGNALS = ['course_published']
|
|
GET_COURSE_WITH_ACCESS = 'get_course_with_access'
|
|
GET_COURSE_OVERVIEW_WITH_ACCESS = 'get_course_overview_with_access'
|
|
COURSE_ACCESS_FUNCS = {
|
|
GET_COURSE_WITH_ACCESS: get_course_with_access,
|
|
GET_COURSE_OVERVIEW_WITH_ACCESS: get_course_overview_with_access,
|
|
}
|
|
|
|
@override_settings(CMS_BASE=CMS_BASE_TEST)
|
|
def test_get_cms_course_block_link(self):
|
|
"""
|
|
Tests that get_cms_course_link_by_id and get_cms_block_link_by_id return the right thing
|
|
"""
|
|
self.course = CourseFactory.create( # lint-amnesty, pylint: disable=attribute-defined-outside-init
|
|
org='org', number='num', display_name='name'
|
|
)
|
|
|
|
cms_url = "//{}/course/{}".format(CMS_BASE_TEST, str(self.course.id))
|
|
assert cms_url == get_cms_course_link(self.course)
|
|
cms_url = "//{}/course/{}".format(CMS_BASE_TEST, str(self.course.location))
|
|
assert cms_url == get_cms_block_link(self.course, 'course')
|
|
|
|
@ddt.data(GET_COURSE_WITH_ACCESS, GET_COURSE_OVERVIEW_WITH_ACCESS)
|
|
def test_get_course_func_with_access_error(self, course_access_func_name):
|
|
course_access_func = self.COURSE_ACCESS_FUNCS[course_access_func_name]
|
|
user = UserFactory.create()
|
|
course = CourseFactory.create(visible_to_staff_only=True)
|
|
|
|
with pytest.raises(CoursewareAccessException) as error:
|
|
course_access_func(user, 'load', course.id)
|
|
assert str(error.value) == 'Course not found.'
|
|
assert error.value.access_response.error_code == 'not_visible_to_user'
|
|
assert not error.value.access_response.has_access
|
|
|
|
@ddt.data(
|
|
(GET_COURSE_WITH_ACCESS, 1),
|
|
(GET_COURSE_OVERVIEW_WITH_ACCESS, 0),
|
|
)
|
|
@ddt.unpack
|
|
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_courses_by_org(self):
|
|
"""
|
|
Verify that org filtering performs as expected, and that an empty result
|
|
is returned if the org passed by the caller does not match the designated
|
|
org.
|
|
"""
|
|
primary = 'primary'
|
|
alternate = 'alternate'
|
|
|
|
def _fake_get_value(value, default=None):
|
|
"""Used to stub out site_configuration.helpers.get_value()."""
|
|
if value == 'course_org_filter':
|
|
return alternate
|
|
|
|
return default
|
|
|
|
user = UserFactory.create()
|
|
|
|
# Pass `emit_signals=True` so that these courses are cached with CourseOverviews.
|
|
primary_course = CourseFactory.create(org=primary, emit_signals=True)
|
|
alternate_course = CourseFactory.create(org=alternate, emit_signals=True)
|
|
|
|
assert primary_course.org != alternate_course.org
|
|
|
|
unfiltered_courses = get_courses(user)
|
|
for org in [primary_course.org, alternate_course.org]:
|
|
assert any((course.org == org) for course in unfiltered_courses)
|
|
|
|
filtered_courses = get_courses(user, org=primary)
|
|
assert all((course.org == primary_course.org) for course in filtered_courses)
|
|
|
|
with mock.patch(
|
|
'openedx.core.djangoapps.site_configuration.helpers.get_value',
|
|
autospec=True,
|
|
) as mock_get_value:
|
|
mock_get_value.side_effect = _fake_get_value
|
|
|
|
# Request filtering for an org distinct from the designated org.
|
|
no_courses = get_courses(user, org=primary)
|
|
assert list(no_courses) == []
|
|
|
|
# Request filtering for an org matching the designated org.
|
|
site_courses = get_courses(user, org=alternate)
|
|
assert all((course.org == alternate_course.org) for course in site_courses)
|
|
|
|
def test_get_courses_with_filter(self):
|
|
"""
|
|
Verify that filtering performs as expected.
|
|
"""
|
|
user = UserFactory.create()
|
|
mobile_course = CourseFactory.create(emit_signals=True)
|
|
non_mobile_course =\
|
|
CourseFactory.create(mobile_available=False, emit_signals=True)
|
|
|
|
test_cases = (
|
|
(None, {non_mobile_course.id, mobile_course.id}),
|
|
(dict(mobile_available=True), {mobile_course.id}),
|
|
(dict(mobile_available=False), {non_mobile_course.id}),
|
|
)
|
|
for filter_, expected_courses in test_cases:
|
|
assert {course.id for course in get_courses(user, filter_=filter_)} ==\
|
|
expected_courses, f'testing get_courses with filter_={filter_}'
|
|
|
|
def test_get_current_child(self):
|
|
mock_xmodule = mock.MagicMock()
|
|
assert get_current_child(mock_xmodule) is None
|
|
|
|
mock_xmodule.position = -1
|
|
mock_xmodule.get_display_items.return_value = ['one', 'two', 'three']
|
|
assert get_current_child(mock_xmodule) == 'one'
|
|
|
|
mock_xmodule.position = 2
|
|
assert get_current_child(mock_xmodule) == 'two'
|
|
assert get_current_child(mock_xmodule, requested_child='first') == 'one'
|
|
assert get_current_child(mock_xmodule, requested_child='last') == 'three'
|
|
|
|
mock_xmodule.position = 3
|
|
mock_xmodule.get_display_items.return_value = []
|
|
assert get_current_child(mock_xmodule) is None
|
|
|
|
|
|
class ModuleStoreBranchSettingTest(ModuleStoreTestCase):
|
|
"""Test methods related to the modulestore branch setting."""
|
|
@mock.patch(
|
|
'xmodule.modulestore.django.get_current_request_hostname',
|
|
mock.Mock(return_value='preview.localhost')
|
|
)
|
|
@override_settings(
|
|
HOSTNAME_MODULESTORE_DEFAULT_MAPPINGS={r'preview\.': ModuleStoreEnum.Branch.draft_preferred},
|
|
MODULESTORE_BRANCH='fake_default_branch',
|
|
)
|
|
def test_default_modulestore_preview_mapping(self):
|
|
assert _get_modulestore_branch_setting() == ModuleStoreEnum.Branch.draft_preferred
|
|
|
|
@mock.patch(
|
|
'xmodule.modulestore.django.get_current_request_hostname',
|
|
mock.Mock(return_value='localhost')
|
|
)
|
|
@override_settings(
|
|
HOSTNAME_MODULESTORE_DEFAULT_MAPPINGS={r'preview\.': ModuleStoreEnum.Branch.draft_preferred},
|
|
MODULESTORE_BRANCH='fake_default_branch',
|
|
)
|
|
def test_default_modulestore_branch_mapping(self):
|
|
assert _get_modulestore_branch_setting() == 'fake_default_branch'
|
|
|
|
|
|
@override_settings(CMS_BASE=CMS_BASE_TEST)
|
|
class MongoCourseImageTestCase(ModuleStoreTestCase):
|
|
"""Tests for course image URLs when using a mongo modulestore."""
|
|
|
|
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_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
|
|
|
|
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 test_static_asset_path_course_image_default(self):
|
|
"""
|
|
Test that without course_image being set, but static_asset_path
|
|
being set that we get the right course_image url.
|
|
"""
|
|
course = CourseFactory.create(static_asset_path="foo")
|
|
assert course_image_url(course) == '/static/foo/images/course_image.jpg'
|
|
|
|
def test_static_asset_path_course_image_set(self):
|
|
"""
|
|
Test that with course_image and static_asset_path both
|
|
being set, that we get the right course_image url.
|
|
"""
|
|
course = CourseFactory.create(course_image='things_stuff.jpg',
|
|
static_asset_path="foo")
|
|
assert course_image_url(course) == '/static/foo/things_stuff.jpg'
|
|
|
|
|
|
class XmlCourseImageTestCase(XModuleXmlImportTest):
|
|
"""Tests for course image URLs when using an xml modulestore."""
|
|
|
|
def test_get_image_url(self):
|
|
"""Test image URL formatting."""
|
|
course = self.process_xml(xml.CourseFactory.build())
|
|
assert course_image_url(course) == '/static/xml_test_course/images/course_image.jpg'
|
|
|
|
def test_non_ascii_image_name(self):
|
|
course = self.process_xml(xml.CourseFactory.build(course_image='before_\N{SNOWMAN}_after.jpg'))
|
|
assert course_image_url(course) == '/static/xml_test_course/before_☃_after.jpg'
|
|
|
|
def test_spaces_in_image_name(self):
|
|
course = self.process_xml(xml.CourseFactory.build(course_image='before after.jpg'))
|
|
assert course_image_url(course) == '/static/xml_test_course/before after.jpg'
|
|
|
|
|
|
class CoursesRenderTest(ModuleStoreTestCase):
|
|
"""Test methods related to rendering courses content."""
|
|
|
|
# TODO: this test relies on the specific setup of the toy course.
|
|
# It should be rewritten to build the course it needs and then test that.
|
|
def setUp(self):
|
|
"""
|
|
Set up the course and user context
|
|
"""
|
|
super().setUp()
|
|
|
|
store = modulestore()
|
|
course_items = import_course_from_xml(store, self.user.id, TEST_DATA_DIR, ['toy'])
|
|
course_key = course_items[0].id
|
|
self.course = get_course_by_id(course_key)
|
|
self.addCleanup(set_current_request, None)
|
|
self.request = get_mock_request(UserFactory.create())
|
|
|
|
def test_get_course_info_section_render(self):
|
|
# Test render works okay
|
|
course_info = get_course_info_section(self.request, self.request.user, self.course, 'handouts')
|
|
assert course_info == "<a href='/c4x/edX/toy/asset/handouts_sample_handout.txt'>Sample</a>"
|
|
|
|
# Test when render raises an exception
|
|
with mock.patch('lms.djangoapps.courseware.courses.get_module') as mock_module_render:
|
|
mock_module_render.return_value = mock.MagicMock(
|
|
render=mock.Mock(side_effect=Exception('Render failed!'))
|
|
)
|
|
course_info = get_course_info_section(self.request, self.request.user, self.course, 'handouts')
|
|
assert 'this module is temporarily unavailable' in course_info
|
|
|
|
def test_get_course_about_section_render(self):
|
|
|
|
# Test render works okay
|
|
course_about = get_course_about_section(self.request, self.course, 'short_description')
|
|
assert course_about == 'A course about toys.'
|
|
|
|
# Test when render raises an exception
|
|
with mock.patch('lms.djangoapps.courseware.courses.get_module') as mock_module_render:
|
|
mock_module_render.return_value = mock.MagicMock(
|
|
render=mock.Mock(side_effect=Exception('Render failed!'))
|
|
)
|
|
course_about = get_course_about_section(self.request, self.course, 'short_description')
|
|
assert 'this module is temporarily unavailable' in course_about
|
|
|
|
|
|
class CourseEnrollmentOpenTests(ModuleStoreTestCase): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.now = datetime.datetime.now().replace(tzinfo=pytz.UTC)
|
|
|
|
def test_course_enrollment_open(self):
|
|
start = self.now - datetime.timedelta(days=1)
|
|
end = self.now + datetime.timedelta(days=1)
|
|
course = CourseFactory(enrollment_start=start, enrollment_end=end)
|
|
assert course_open_for_self_enrollment(course.id)
|
|
|
|
def test_course_enrollment_closed_future(self):
|
|
start = self.now + datetime.timedelta(days=1)
|
|
end = self.now + datetime.timedelta(days=2)
|
|
course = CourseFactory(enrollment_start=start, enrollment_end=end)
|
|
assert not course_open_for_self_enrollment(course.id)
|
|
|
|
def test_course_enrollment_closed_past(self):
|
|
start = self.now - datetime.timedelta(days=2)
|
|
end = self.now - datetime.timedelta(days=1)
|
|
course = CourseFactory(enrollment_start=start, enrollment_end=end)
|
|
assert not course_open_for_self_enrollment(course.id)
|
|
|
|
def test_course_enrollment_dates_missing(self):
|
|
course = CourseFactory()
|
|
assert course_open_for_self_enrollment(course.id)
|
|
|
|
def test_course_enrollment_dates_missing_start(self):
|
|
end = self.now + datetime.timedelta(days=1)
|
|
course = CourseFactory(enrollment_end=end)
|
|
assert course_open_for_self_enrollment(course.id)
|
|
|
|
end = self.now - datetime.timedelta(days=1)
|
|
course = CourseFactory(enrollment_end=end)
|
|
assert not course_open_for_self_enrollment(course.id)
|
|
|
|
def test_course_enrollment_dates_missing_end(self):
|
|
start = self.now - datetime.timedelta(days=1)
|
|
course = CourseFactory(enrollment_start=start)
|
|
assert course_open_for_self_enrollment(course.id)
|
|
|
|
start = self.now + datetime.timedelta(days=1)
|
|
course = CourseFactory(enrollment_start=start)
|
|
assert not course_open_for_self_enrollment(course.id)
|
|
|
|
|
|
@ddt.ddt
|
|
class CourseInstantiationTests(ModuleStoreTestCase):
|
|
"""
|
|
Tests around instantiating a course multiple times in the same request.
|
|
"""
|
|
def setUp(self):
|
|
super().setUp()
|
|
|
|
self.factory = RequestFactory()
|
|
|
|
@ddt.data(*itertools.product(range(5), [ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split], [None, 0, 5]))
|
|
@ddt.unpack
|
|
def test_repeated_course_module_instantiation(self, loops, default_store, course_depth):
|
|
|
|
with modulestore().default_store(default_store):
|
|
course = CourseFactory.create()
|
|
chapter = ItemFactory(parent=course, category='chapter', graded=True)
|
|
section = ItemFactory(parent=chapter, category='sequential')
|
|
__ = ItemFactory(parent=section, category='problem')
|
|
|
|
fake_request = self.factory.get(
|
|
reverse('progress', kwargs={'course_id': str(course.id)})
|
|
)
|
|
|
|
course = modulestore().get_course(course.id, depth=course_depth)
|
|
|
|
for _ in range(loops):
|
|
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
|
|
course.id, self.user, course, depth=course_depth
|
|
)
|
|
course_module = get_module_for_descriptor(
|
|
self.user,
|
|
fake_request,
|
|
course,
|
|
field_data_cache,
|
|
course.id,
|
|
course=course
|
|
)
|
|
for chapter in course_module.get_children():
|
|
for section in chapter.get_children():
|
|
for item in section.get_children():
|
|
assert item.graded
|
|
|
|
|
|
class TestGetCourseChapters(ModuleStoreTestCase):
|
|
"""
|
|
Tests for the `get_course_chapter_ids` function.
|
|
"""
|
|
|
|
def test_get_non_existant_course(self):
|
|
"""
|
|
Test non-existant course returns empty list.
|
|
"""
|
|
assert get_course_chapter_ids(None) == []
|
|
# build a fake key
|
|
fake_course_key = CourseKey.from_string('course-v1:FakeOrg+CN1+CR-FALLNEVER1')
|
|
assert get_course_chapter_ids(fake_course_key) == []
|
|
|
|
def test_get_chapters(self):
|
|
"""
|
|
Test get_course_chapter_ids returns expected result.
|
|
"""
|
|
course = CourseFactory()
|
|
ItemFactory(parent=course, category='chapter')
|
|
ItemFactory(parent=course, category='chapter')
|
|
course_chapter_ids = get_course_chapter_ids(course.location.course_key)
|
|
assert len(course_chapter_ids) == 2
|
|
assert course_chapter_ids == [str(child) for child in course.children]
|
|
|
|
|
|
class TestGetCourseAssignments(CompletionWaffleTestMixin, ModuleStoreTestCase):
|
|
"""
|
|
Tests for the `get_course_assignments` function.
|
|
"""
|
|
|
|
def test_completion_ignores_non_scored_items(self):
|
|
"""
|
|
Test that we treat a sequential with incomplete (but not scored) items (like a video maybe) as complete.
|
|
"""
|
|
course = CourseFactory()
|
|
chapter = ItemFactory(parent=course, category='chapter', graded=True, due=datetime.datetime.now())
|
|
sequential = ItemFactory(parent=chapter, category='sequential')
|
|
problem = ItemFactory(parent=sequential, category='problem', has_score=True)
|
|
ItemFactory(parent=sequential, category='video', has_score=False)
|
|
|
|
self.override_waffle_switch(True)
|
|
BlockCompletion.objects.submit_completion(self.user, problem.location, 1)
|
|
|
|
assignments = get_course_assignments(course.location.context_key, self.user, None)
|
|
assert len(assignments) == 1
|
|
assert assignments[0].complete
|
|
|
|
def test_completion_does_not_count_empty_sequentials(self):
|
|
"""
|
|
Test that we treat a sequential with no content as incomplete.
|
|
|
|
This can happen with unreleased assignments, for example (start date in future).
|
|
"""
|
|
course = CourseFactory()
|
|
chapter = ItemFactory(parent=course, category='chapter', graded=True, due=datetime.datetime.now())
|
|
ItemFactory(parent=chapter, category='sequential')
|
|
|
|
assignments = get_course_assignments(course.location.context_key, self.user, None)
|
|
assert len(assignments) == 1
|
|
assert not assignments[0].complete
|