def test_transform_with_content_gating_partition(self):
self.setup_partitions_and_course()
CourseModeFactory.create(course_id=self.course.id, mode_slug='audit')
CourseModeFactory.create(course_id=self.course.id, mode_slug='verified')
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime(2018, 1, 1))
partition = create_content_gating_partition(self.course)
self.user_partitions.append(partition)
cohort = self.partition_cohorts[0][1]
add_user_to_cohort(cohort, self.user.username)
with patch(
'lms.djangoapps.course_blocks.transformers.user_partitions.get_partition_from_id',
return_value=partition
), patch(
'lms.djangoapps.course_blocks.transformers.user_partitions._MergedGroupAccess.get_allowed_groups',
return_value={51: set([])}
):
trans_block_structure = get_course_blocks(
self.user,
self.course.location,
self.transformers,
)
xblocks_denial_reason = [trans_block_structure.get_xblock_field(b, 'authorization_denial_reason')
for b in trans_block_structure.get_block_keys()]
self.assertSetEqual(set(xblocks_denial_reason), set([u'Feature-based Enrollments']))
def test_acess_denied_fragment_for_null_request(self):
"""
Verifies the access denied fragment is visible when HTTP request is not available.
Given the HTTP request instance is None
Then set the mobile_app context variable to False
And the fragment should be created successfully
"""
mock_request = None
mock_course = Mock(id=self.course_key, user_partitions={})
mock_block = Mock(scope_ids=Mock(usage_id=Mock(course_key=mock_course.id)))
CourseModeFactory.create(course_id=mock_course.id, mode_slug='verified')
global_staff = GlobalStaffFactory.create()
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime(2018, 1, 1))
partition = create_content_gating_partition(mock_course)
with patch(
'crum.get_current_request',
return_value=mock_request
), patch(
'openedx.features.content_type_gating.partitions.ContentTypeGatingPartition._is_audit_enrollment',
return_value=True
):
fragment = partition.access_denied_fragment(mock_block, global_staff, GroupFactory(), 'test_allowed_group')
self.assertIsNotNone(fragment)
def test_access_denied_fragment_for_masquerading(self):
"""
Test that a global staff sees gated content flag when viewing course as `Learner in Audit`
Note: Global staff doesn't require to be enrolled in course.
"""
mock_request = RequestFactory().get('/')
mock_course = Mock(id=self.course_key, user_partitions={})
mock_block = Mock(scope_ids=Mock(usage_id=Mock(course_key=mock_course.id)))
mock_course_masquerade = Mock(
role='student',
user_partition_id=ENROLLMENT_TRACK_PARTITION_ID,
group_id=settings.COURSE_ENROLLMENT_MODES['audit']['id'],
user_name=None
)
CourseModeFactory.create(course_id=mock_course.id, mode_slug='verified')
global_staff = GlobalStaffFactory.create()
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=True)
partition = create_content_gating_partition(mock_course)
with patch(
'courseware.masquerade.get_course_masquerade',
return_value=mock_course_masquerade
), patch(
'openedx.features.content_type_gating.partitions.get_course_masquerade',
return_value=mock_course_masquerade
), patch(
'crum.get_current_request',
return_value=mock_request
):
fragment = partition.access_denied_fragment(mock_block, global_staff, GroupFactory(), 'test_allowed_group')
self.assertIsNotNone(fragment)
def test_access_denied_fragment_for_masquerading(self):
"""
Test that a global staff sees gated content flag when viewing course as `Learner in Limited Access`
Note: Global staff doesn't require to be enrolled in course.
"""
mock_request = RequestFactory().get('/')
mock_course = Mock(id=self.course_key, user_partitions={})
mock_block = Mock(scope_ids=Mock(usage_id=Mock(course_key=mock_course.id)))
mock_course_masquerade = Mock(
role='student',
user_partition_id=CONTENT_GATING_PARTITION_ID,
group_id=LIMITED_ACCESS.id,
user_name=None
)
CourseModeFactory.create(course_id=mock_course.id, mode_slug='verified')
global_staff = GlobalStaffFactory.create()
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=True)
partition = create_content_gating_partition(mock_course)
with patch(
'crum.get_current_request',
return_value=mock_request
):
fragment = partition.access_denied_fragment(mock_block, global_staff, LIMITED_ACCESS, [FULL_ACCESS])
self.assertIsNotNone(fragment)
def test_create_content_gating_partition_partition_id_used(self):
mock_course = Mock(id=self.course_key, user_partitions={Mock(name='partition', id=CONTENT_GATING_PARTITION_ID): object()})
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime(2018, 1, 1))
with patch('openedx.features.content_type_gating.partitions.LOG') as mock_log:
partition = create_content_gating_partition(mock_course)
mock_log.warning.assert_called()
self.assertIsNone(partition)
def test_create_content_gating_partition_no_scheme_installed(self):
mock_course = Mock(id=self.course_key, user_partitions={})
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime(2018, 1, 1))
with patch('openedx.features.content_type_gating.partitions.UserPartition.get_scheme', side_effect=UserPartitionError):
partition = create_content_gating_partition(mock_course)
self.assertIsNone(partition)
def test_create_content_gating_partition_happy_path(self):
mock_course = Mock(id=self.course_key, user_partitions={})
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime(2018, 1, 1))
with patch('openedx.features.content_type_gating.partitions.ContentTypeGatingPartitionScheme.create_user_partition') as mock_create:
partition = create_content_gating_partition(mock_course)
self.assertEqual(partition, mock_create.return_value)
def _get_dynamic_partitions(course):
"""
Return the dynamic user partitions for this course.
If none exists, returns an empty array.
"""
return [
partition
for partition in [
_create_enrollment_track_partition(course),
create_content_gating_partition(course),
]
if partition
]
def test_create_content_gating_partition_happy_path(self):
mock_course = Mock(id=self.course_key, user_partitions={})
CourseModeFactory.create(course_id=mock_course.id, mode_slug='audit')
CourseModeFactory.create(course_id=mock_course.id,
mode_slug='verified')
ContentTypeGatingConfig.objects.create(enabled=True,
enabled_as_of=datetime(
2018, 1, 1))
with patch(
'openedx.features.content_type_gating.partitions.ContentTypeGatingPartitionScheme.create_user_partition'
) as mock_create:
partition = create_content_gating_partition(mock_course)
assert partition == mock_create.return_value
def test_create_content_gating_partition_partition_id_used(self):
mock_course = Mock(id=self.course_key,
user_partitions={
Mock(name='partition',
id=CONTENT_GATING_PARTITION_ID):
object()
})
ContentTypeGatingConfig.objects.create(enabled=True,
enabled_as_of=datetime(
2018, 1, 1))
with patch('openedx.features.content_type_gating.partitions.LOG'
) as mock_log:
partition = create_content_gating_partition(mock_course)
mock_log.warning.assert_called()
self.assertIsNone(partition)
def test_access_denied_fragment_for_full_access_users(self):
"""
Test that Full Access users do not see the access_denied_fragment or access_denied_message
"""
mock_request = RequestFactory().get('/')
mock_course = Mock(id=self.course_key, user_partitions={})
mock_block = Mock(scope_ids=Mock(usage_id=Mock(course_key=mock_course.id)))
CourseModeFactory.create(course_id=mock_course.id, mode_slug='verified')
global_staff = GlobalStaffFactory.create()
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=True)
partition = create_content_gating_partition(mock_course)
with patch(
'crum.get_current_request',
return_value=mock_request
):
fragment = partition.access_denied_fragment(mock_block, global_staff, FULL_ACCESS, 'test_allowed_group')
self.assertIsNone(fragment)
message = partition.access_denied_message(mock_block.scope_ids.usage_id, global_staff, FULL_ACCESS, 'test_allowed_group')
self.assertIsNone(message)
def test_access_denied_fragment_for_full_access_users(self):
"""
Test that Full Access users do not see the access_denied_fragment or access_denied_message
"""
mock_request = RequestFactory().get('/')
mock_course = Mock(id=self.course_key, user_partitions={})
mock_block = Mock(scope_ids=Mock(usage_id=Mock(course_key=mock_course.id)))
CourseModeFactory.create(course_id=mock_course.id, mode_slug='verified')
global_staff = GlobalStaffFactory.create()
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=True)
partition = create_content_gating_partition(mock_course)
with patch(
'crum.get_current_request',
return_value=mock_request
):
fragment = partition.access_denied_fragment(mock_block, global_staff, FULL_ACCESS, 'test_allowed_group')
self.assertIsNone(fragment)
message = partition.access_denied_message(mock_block, global_staff, FULL_ACCESS, 'test_allowed_group')
self.assertIsNone(message)
def test_acess_denied_fragment_for_null_request(self):
"""
Verifies the access denied fragment is visible when HTTP request is not available.
Given the HTTP request instance is None
Then set the mobile_app context variable to False
And the fragment should be created successfully
"""
mock_request = None
mock_course = Mock(id=self.course_key, user_partitions={})
mock_block = Mock(scope_ids=Mock(usage_id=Mock(course_key=mock_course.id)))
CourseModeFactory.create(course_id=mock_course.id, mode_slug='audit')
CourseModeFactory.create(course_id=mock_course.id, mode_slug='verified')
global_staff = GlobalStaffFactory.create()
ContentTypeGatingConfig.objects.create(enabled=True, enabled_as_of=datetime(2018, 1, 1))
partition = create_content_gating_partition(mock_course)
with patch(
'crum.get_current_request',
return_value=mock_request
):
fragment = partition.access_denied_fragment(mock_block, global_staff, LIMITED_ACCESS, [FULL_ACCESS])
self.assertIsNotNone(fragment)
def test_create_content_gating_partition_disabled(self):
mock_course = Mock(id=self.course_key, user_partitions={})
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=False)
partition = create_content_gating_partition(mock_course)
self.assertIsNone(partition)
def test_create_content_gating_partition_disabled(self):
mock_course = Mock(id=self.course_key, user_partitions={})
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=False)
partition = create_content_gating_partition(mock_course)
self.assertIsNone(partition)
def test_create_content_gating_partition_override_only(self):
mock_course = Mock(id=self.course_key, user_partitions={})
ContentTypeGatingConfig.objects.create(enabled=False, studio_override_enabled=True)
partition = create_content_gating_partition(mock_course)
assert partition is not None
