% if user.is_authenticated():
- % if staff_access and masquerade is not UNDEFINED and studio_url is not None:
- % if masquerade == 'staff':
-
- % endif
+ % if studio_url is not None and masquerade and masquerade.role == 'staff':
+
% endif
${_("Course Updates & News")}
diff --git a/lms/urls.py b/lms/urls.py
index 4af2de7571..aeac3f6ed2 100644
--- a/lms/urls.py
+++ b/lms/urls.py
@@ -389,7 +389,8 @@ if settings.COURSEWARE_ENABLED:
# allow course staff to change to student view of courseware
if settings.FEATURES.get('ENABLE_MASQUERADE'):
urlpatterns += (
- url(r'^masquerade/(?P.*)$', 'courseware.masquerade.handle_ajax', name="masquerade-switch"),
+ url(r'^courses/{}/masquerade$'.format(settings.COURSE_KEY_PATTERN),
+ 'courseware.masquerade.handle_ajax', name="masquerade_update"),
)
# discussion forums live within courseware, so courseware must be enabled first
diff --git a/openedx/core/djangoapps/course_groups/cohorts.py b/openedx/core/djangoapps/course_groups/cohorts.py
index 7fba71cafa..8d0b096271 100644
--- a/openedx/core/djangoapps/course_groups/cohorts.py
+++ b/openedx/core/djangoapps/course_groups/cohorts.py
@@ -16,6 +16,7 @@ from eventtracking import tracker
from student.models import get_user_by_username_or_email
from .models import CourseUserGroup, CourseUserGroupPartitionGroup
+
log = logging.getLogger(__name__)
@@ -381,15 +382,15 @@ def add_user_to_cohort(cohort, username_or_email):
return (user, previous_cohort_name)
-def get_partition_group_id_for_cohort(cohort):
+def get_group_info_for_cohort(cohort):
"""
- Get the ids of the partition and group to which this cohort has been linked
+ Get the ids of the group and partition to which this cohort has been linked
as a tuple of (int, int).
- If the cohort has not been linked to any partition/group, both values in the
+ If the cohort has not been linked to any group/partition, both values in the
tuple will be None.
"""
res = CourseUserGroupPartitionGroup.objects.filter(course_user_group=cohort)
if len(res):
- return res[0].partition_id, res[0].group_id
+ return res[0].group_id, res[0].partition_id
return None, None
diff --git a/openedx/core/djangoapps/course_groups/partition_scheme.py b/openedx/core/djangoapps/course_groups/partition_scheme.py
index 5ab30fc5d1..bb1530ac38 100644
--- a/openedx/core/djangoapps/course_groups/partition_scheme.py
+++ b/openedx/core/djangoapps/course_groups/partition_scheme.py
@@ -3,9 +3,12 @@ Provides a UserPartition driver for cohorts.
"""
import logging
+from courseware import courses
+from courseware.masquerade import get_masquerading_group_info
from xmodule.partitions.partitions import NoSuchUserPartitionGroupError
-from .cohorts import get_cohort, get_partition_group_id_for_cohort
+from .cohorts import get_cohort, get_group_info_for_cohort
+
log = logging.getLogger(__name__)
@@ -17,8 +20,9 @@ class CohortPartitionScheme(object):
Groups.
"""
+ # pylint: disable=unused-argument
@classmethod
- def get_group_for_user(cls, course_id, user, user_partition, track_function=None):
+ def get_group_for_user(cls, course_key, user, user_partition, track_function=None):
"""
Returns the Group from the specified user partition to which the user
is assigned, via their cohort membership and any mappings from cohorts
@@ -32,12 +36,22 @@ class CohortPartitionScheme(object):
If the user has no cohort mapping, or there is no (valid) cohort ->
partition group mapping found, the function returns None.
"""
- cohort = get_cohort(user, course_id)
+ # If the current user is masquerading as being in a group belonging to the
+ # specified user partition then return the masquerading group.
+ group_id, user_partition_id = get_masquerading_group_info(user, course_key)
+ if group_id is not None and user_partition_id == user_partition.id:
+ try:
+ return user_partition.get_group(group_id)
+ except NoSuchUserPartitionGroupError:
+ # If the group no longer exists then the masquerade is not in effect
+ pass
+
+ cohort = get_cohort(user, course_key)
if cohort is None:
# student doesn't have a cohort
return None
- partition_id, group_id = get_partition_group_id_for_cohort(cohort)
+ group_id, partition_id = get_group_info_for_cohort(cohort)
if partition_id is None:
# cohort isn't mapped to any partition group.
return None
@@ -75,3 +89,17 @@ class CohortPartitionScheme(object):
)
# fail silently
return None
+
+
+def get_cohorted_user_partition(course_key):
+ """
+ Returns the first user partition from the specified course which uses the CohortPartitionScheme,
+ or None if one is not found. Note that it is currently recommended that each course have only
+ one cohorted user partition.
+ """
+ course = courses.get_course_by_id(course_key)
+ for user_partition in course.user_partitions:
+ if user_partition.scheme == CohortPartitionScheme:
+ return user_partition
+
+ return None
diff --git a/openedx/core/djangoapps/course_groups/tests/test_cohorts.py b/openedx/core/djangoapps/course_groups/tests/test_cohorts.py
index 1707dd0530..aed51f7a23 100644
--- a/openedx/core/djangoapps/course_groups/tests/test_cohorts.py
+++ b/openedx/core/djangoapps/course_groups/tests/test_cohorts.py
@@ -623,13 +623,13 @@ class TestCohortsAndPartitionGroups(TestCase):
link.save()
return link
- def test_get_partition_group_id_for_cohort(self):
+ def test_get_group_info_for_cohort(self):
"""
- Basic test of the partition_group_id accessor function
+ Basic test of the partition_group_info accessor function
"""
# api should return nothing for an unmapped cohort
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
+ cohorts.get_group_info_for_cohort(self.first_cohort),
(None, None),
)
# create a link for the cohort in the db
@@ -640,14 +640,14 @@ class TestCohortsAndPartitionGroups(TestCase):
)
# api should return the specified partition and group
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
- (self.partition_id, self.group1_id)
+ cohorts.get_group_info_for_cohort(self.first_cohort),
+ (self.group1_id, self.partition_id)
)
# delete the link in the db
link.delete()
# api should return nothing again
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
+ cohorts.get_group_info_for_cohort(self.first_cohort),
(None, None),
)
@@ -666,12 +666,12 @@ class TestCohortsAndPartitionGroups(TestCase):
self.group1_id,
)
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
- (self.partition_id, self.group1_id),
+ cohorts.get_group_info_for_cohort(self.first_cohort),
+ (self.group1_id, self.partition_id),
)
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.second_cohort),
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
+ cohorts.get_group_info_for_cohort(self.second_cohort),
+ cohorts.get_group_info_for_cohort(self.first_cohort),
)
def test_multiple_partition_groups(self):
@@ -701,14 +701,14 @@ class TestCohortsAndPartitionGroups(TestCase):
self.group1_id
)
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
- (self.partition_id, self.group1_id)
+ cohorts.get_group_info_for_cohort(self.first_cohort),
+ (self.group1_id, self.partition_id)
)
# delete the link
self.first_cohort.delete()
# api should return nothing at that point
self.assertEqual(
- cohorts.get_partition_group_id_for_cohort(self.first_cohort),
+ cohorts.get_group_info_for_cohort(self.first_cohort),
(None, None),
)
# link should no longer exist because of delete cascade
diff --git a/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py b/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
index 43817268d7..7891be1844 100644
--- a/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
+++ b/openedx/core/djangoapps/course_groups/tests/test_partition_scheme.py
@@ -3,18 +3,23 @@ Test the partitions and partitions service
"""
+import json
from django.conf import settings
import django.test
from django.test.utils import override_settings
from mock import patch
+from unittest import skipUnless
+from courseware.masquerade import handle_ajax, setup_masquerade
+from courseware.tests.test_masquerade import StaffMasqueradeTestCase
from student.tests.factories import UserFactory
from xmodule.partitions.partitions import Group, UserPartition, UserPartitionError
from xmodule.modulestore.django import modulestore, clear_existing_modulestores
from xmodule.modulestore.tests.django_utils import mixed_store_config
from opaque_keys.edx.locations import SlashSeparatedCourseKey
-from ..partition_scheme import CohortPartitionScheme
+from openedx.core.djangoapps.user_api.partition_schemes import RandomUserPartitionScheme
+from ..partition_scheme import CohortPartitionScheme, get_cohorted_user_partition
from ..models import CourseUserGroupPartitionGroup
from ..cohorts import add_user_to_cohort, get_course_cohorts
from .helpers import CohortFactory, config_course_cohorts
@@ -280,3 +285,111 @@ class TestExtension(django.test.TestCase):
self.assertEqual(UserPartition.get_scheme('cohort'), CohortPartitionScheme)
with self.assertRaisesRegexp(UserPartitionError, 'Unrecognized scheme'):
UserPartition.get_scheme('other')
+
+
+@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
+class TestGetCohortedUserPartition(django.test.TestCase):
+ """
+ Test that `get_cohorted_user_partition` returns the first user_partition with scheme `CohortPartitionScheme`.
+ """
+ def setUp(self):
+ """
+ Regenerate a course with cohort configuration, partition and groups,
+ and a student for each test.
+ """
+ self.course_key = SlashSeparatedCourseKey("edX", "toy", "2012_Fall")
+ self.course = modulestore().get_course(self.course_key)
+ self.student = UserFactory.create()
+
+ self.random_user_partition = UserPartition(
+ 1,
+ 'Random Partition',
+ 'Should not be returned',
+ [Group(0, 'Group 0'), Group(1, 'Group 1')],
+ scheme=RandomUserPartitionScheme
+ )
+
+ self.cohort_user_partition = UserPartition(
+ 0,
+ 'Cohort Partition 1',
+ 'Should be returned',
+ [Group(10, 'Group 10'), Group(20, 'Group 20')],
+ scheme=CohortPartitionScheme
+ )
+
+ self.second_cohort_user_partition = UserPartition(
+ 2,
+ 'Cohort Partition 2',
+ 'Should not be returned',
+ [Group(10, 'Group 10'), Group(1, 'Group 1')],
+ scheme=CohortPartitionScheme
+ )
+
+ def test_returns_first_cohort_user_partition(self):
+ """
+ Test get_cohorted_user_partition returns first user_partition with scheme `CohortPartitionScheme`.
+ """
+ self.course.user_partitions.append(self.random_user_partition)
+ self.course.user_partitions.append(self.cohort_user_partition)
+ self.course.user_partitions.append(self.second_cohort_user_partition)
+ self.assertEqual(self.cohort_user_partition, get_cohorted_user_partition(self.course_key))
+
+ def test_no_cohort_user_partitions(self):
+ """
+ Test get_cohorted_user_partition returns None when there are no cohorted user partitions.
+ """
+ self.course.user_partitions.append(self.random_user_partition)
+ self.assertIsNone(get_cohorted_user_partition(self.course_key))
+
+
+class TestMasqueradedGroup(StaffMasqueradeTestCase):
+ """
+ Check for staff being able to masquerade as belonging to a group.
+ """
+ def setUp(self):
+ super(TestMasqueradedGroup, self).setUp()
+ self.user_partition = UserPartition(
+ 0, 'Test User Partition', '',
+ [Group(0, 'Group 1'), Group(1, 'Group 2')],
+ scheme_id='cohort'
+ )
+ self.course.user_partitions.append(self.user_partition)
+ self.session = {}
+ modulestore().update_item(self.course, self.test_user.id)
+
+ def _verify_masquerade_for_group(self, group):
+ """
+ Verify that the masquerade works for the specified group id.
+ """
+ # Send the request to set the masquerade
+ request_json = {
+ "role": "student",
+ }
+ if group and self.user_partition:
+ request_json['user_partition_id'] = self.user_partition.id
+ request_json['group_id'] = group.id
+ request = self._create_mock_json_request(
+ self.test_user,
+ body=json.dumps(request_json),
+ session=self.session
+ )
+ handle_ajax(request, unicode(self.course.id))
+
+ # Now setup the masquerade for the test user
+ setup_masquerade(request, self.test_user, True)
+ scheme = self.user_partition.scheme # pylint: disable=no-member
+ self.assertEqual(
+ scheme.get_group_for_user(self.course.id, self.test_user, self.user_partition),
+ group
+ )
+
+ @skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in LMS')
+ @patch.dict('django.conf.settings.FEATURES', {'DISABLE_START_DATES': False})
+ def test_group_masquerade(self):
+ """
+ Tests that a staff member can masquerade as being in a particular group.
+ """
+ self._verify_masquerade_for_group(self.user_partition.groups[0])
+ self._verify_masquerade_for_group(self.user_partition.groups[1])
+ self._verify_masquerade_for_group(None)
+
diff --git a/openedx/core/djangoapps/user_api/partition_schemes.py b/openedx/core/djangoapps/user_api/partition_schemes.py
index 0e30f195bd..756adc4049 100644
--- a/openedx/core/djangoapps/user_api/partition_schemes.py
+++ b/openedx/core/djangoapps/user_api/partition_schemes.py
@@ -17,13 +17,13 @@ class RandomUserPartitionScheme(object):
RANDOM = random.Random()
@classmethod
- def get_group_for_user(cls, course_id, user, user_partition, assign=True, track_function=None):
+ def get_group_for_user(cls, course_key, user, user_partition, assign=True, track_function=None):
"""
Returns the group from the specified user position to which the user is assigned.
If the user has not yet been assigned, a group will be randomly chosen for them if assign flag is True.
"""
partition_key = cls._key_for_partition(user_partition)
- group_id = course_tag_api.get_course_tag(user, course_id, partition_key)
+ group_id = course_tag_api.get_course_tag(user, course_key, partition_key)
group = None
if group_id is not None:
@@ -52,7 +52,7 @@ class RandomUserPartitionScheme(object):
group = cls.RANDOM.choice(user_partition.groups)
# persist the value as a course tag
- course_tag_api.set_course_tag(user, course_id, partition_key, group.id)
+ course_tag_api.set_course_tag(user, course_key, partition_key, group.id)
if track_function:
# emit event for analytics