LMS-11016 Studio server-side for course_listing and course_rerun.

Conflicts:
	cms/djangoapps/contentstore/tests/test_course_listing.py

cms/djangoapps/contentstore/tests/test_contentstore.py

@@ -29,7 +29,7 @@ from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.inheritance import own_metadata
 from opaque_keys.edx.keys import UsageKey
-from opaque_keys.edx.locations import SlashSeparatedCourseKey, AssetLocation
+from opaque_keys.edx.locations import SlashSeparatedCourseKey, AssetLocation, CourseLocator
 from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
 from xmodule.modulestore.xml_exporter import export_to_xml
 from xmodule.modulestore.xml_importer import import_from_xml, perform_xlint
@@ -46,6 +46,7 @@ from student.models import CourseEnrollment
 from student.roles import CourseCreatorRole, CourseInstructorRole
 from opaque_keys import InvalidKeyError
 from contentstore.tests.utils import get_url
+from course_action_state.models import CourseRerunState, CourseRerunUIStateManager
 
 
 TEST_DATA_CONTENTSTORE = copy.deepcopy(settings.CONTENTSTORE)
@@ -1561,6 +1562,107 @@ class MetadataSaveTestCase(ContentStoreTestCase):
         pass
 
 
+class RerunCourseTest(ContentStoreTestCase):
+    """
+    Tests for Rerunning a course via the view handler
+    """
+    def setUp(self):
+        super(RerunCourseTest, self).setUp()
+        self.destination_course_data = {
+            'org': 'MITx',
+            'number': '111',
+            'display_name': 'Robot Super Course',
+            'run': '2013_Spring'
+        }
+        self.destination_course_key = _get_course_id(self.destination_course_data)
+
+    def post_rerun_request(self, source_course_key, response_code=200):
+        """Create and send an ajax post for the rerun request"""
+
+        # create data to post
+        rerun_course_data = {'source_course_key': unicode(source_course_key)}
+        rerun_course_data.update(self.destination_course_data)
+
+        # post the request
+        course_url = get_url('course_handler', self.destination_course_key, 'course_key_string')
+        response = self.client.ajax_post(course_url, rerun_course_data)
+
+        # verify response
+        self.assertEqual(response.status_code, response_code)
+        if response_code == 200:
+            self.assertNotIn('ErrMsg', parse_json(response))
+
+    def create_course_listing_html(self, course_key):
+        """Creates html fragment that is created for the given course_key in the course listing section"""
+        return '<a class="course-link" href="/course/{}"'.format(course_key)
+
+    def create_unsucceeded_course_action_html(self, course_key):
+        """Creates html fragment that is created for the given course_key in the unsucceeded course action section"""
+        # TODO LMS-11011 Update this once the Rerun UI is implemented.
+        return '<div class="unsucceeded-course-action" href="/course/{}"'.format(course_key)
+
+    def assertInCourseListing(self, course_key):
+        """
+        Asserts that the given course key is in the accessible course listing section of the html
+        and NOT in the unsucceeded course action section of the html.
+        """
+        course_listing_html = self.client.get_html('/course/')
+        self.assertIn(self.create_course_listing_html(course_key), course_listing_html.content)
+        self.assertNotIn(self.create_unsucceeded_course_action_html(course_key), course_listing_html.content)
+
+    def assertInUnsucceededCourseActions(self, course_key):
+        """
+        Asserts that the given course key is in the unsucceeded course action section of the html
+        and NOT in the accessible course listing section of the html.
+        """
+        course_listing_html = self.client.get_html('/course/')
+        self.assertNotIn(self.create_course_listing_html(course_key), course_listing_html.content)
+        # TODO Uncomment this once LMS-11011 is implemented.
+        # self.assertIn(self.create_unsucceeded_course_action_html(course_key), course_listing_html.content)
+
+    def test_rerun_course_success(self):
+        source_course = CourseFactory.create()
+        self.post_rerun_request(source_course.id)
+
+        # Verify that the course rerun action is marked succeeded
+        rerun_state = CourseRerunState.objects.find_first(course_key=self.destination_course_key)
+        self.assertEquals(rerun_state.state, CourseRerunUIStateManager.State.SUCCEEDED)
+
+        # Verify that the creator is now enrolled in the course.
+        self.assertTrue(CourseEnrollment.is_enrolled(self.user, self.destination_course_key))
+
+        # Verify both courses are in the course listing section
+        self.assertInCourseListing(source_course.id)
+        self.assertInCourseListing(self.destination_course_key)
+
+    def test_rerun_course_fail(self):
+        existent_course_key = CourseFactory.create().id
+        non_existent_course_key = CourseLocator("org", "non_existent_course", "run")
+        self.post_rerun_request(non_existent_course_key)
+
+        # Verify that the course rerun action is marked failed
+        rerun_state = CourseRerunState.objects.find_first(course_key=self.destination_course_key)
+        self.assertEquals(rerun_state.state, CourseRerunUIStateManager.State.FAILED)
+        self.assertIn("Cannot find a course at", rerun_state.message)
+
+        # Verify that the creator is not enrolled in the course.
+        self.assertFalse(CourseEnrollment.is_enrolled(self.user, non_existent_course_key))
+
+        # Verify that the existing course continues to be in the course listings
+        self.assertInCourseListing(existent_course_key)
+
+        # Verify that the failed course is NOT in the course listings
+        self.assertInUnsucceededCourseActions(non_existent_course_key)
+
+    def test_rerun_with_permission_denied(self):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+            source_course = CourseFactory.create()
+            auth.add_users(self.user, CourseCreatorRole(), self.user)
+            self.user.is_staff = False
+            self.user.save()
+            self.post_rerun_request(source_course.id, 403)
+
+
 class EntryPageTestCase(TestCase):
     """
     Tests entry pages that aren't specific to a course.

cms/djangoapps/contentstore/tests/utils.py

@@ -95,6 +95,7 @@ class CourseTestCase(ModuleStoreTestCase):
         client = Client()
         if authenticate:
             client.login(username=nonstaff.username, password=password)
+            nonstaff.is_authenticated = True
         return client, nonstaff
 
     def populate_course(self):

cms/djangoapps/contentstore/utils.py

@@ -9,6 +9,8 @@ from pytz import UTC
 from django.conf import settings
 from django.utils.translation import ugettext as _
 from django.core.urlresolvers import reverse
+from django_comment_common.models import assign_default_role
+from django_comment_common.utils import seed_permissions_roles
 
 from xmodule.contentstore.content import StaticContent
 from xmodule.modulestore import ModuleStoreEnum
@@ -16,6 +18,8 @@ from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from opaque_keys.edx.keys import UsageKey, CourseKey
 from student.roles import CourseInstructorRole, CourseStaffRole
+from student.models import CourseEnrollment
+from student import auth
 
 
 log = logging.getLogger(__name__)
@@ -26,25 +30,58 @@ NOTES_PANEL = {"name": _("My Notes"), "type": "notes"}
 EXTRA_TAB_PANELS = dict([(p['type'], p) for p in [OPEN_ENDED_PANEL, NOTES_PANEL]])
 
 
-def delete_course_and_groups(course_id, user_id):
+def add_instructor(course_key, requesting_user, new_instructor):
     """
-    This deletes the courseware associated with a course_id as well as cleaning update_item
+    Adds given user as instructor and staff to the given course,
+    after verifying that the requesting_user has permission to do so.
+    """
+    # can't use auth.add_users here b/c it requires user to already have Instructor perms in this course
+    CourseInstructorRole(course_key).add_users(new_instructor)
+    auth.add_users(requesting_user, CourseStaffRole(course_key), new_instructor)
+
+
+def initialize_permissions(course_key, user_who_created_course):
+    """
+    Initializes a new course by enrolling the course creator as a student,
+    and initializing Forum by seeding its permissions and assigning default roles.
+    """
+    # seed the forums
+    seed_permissions_roles(course_key)
+
+    # auto-enroll the course creator in the course so that "View Live" will work.
+    CourseEnrollment.enroll(user_who_created_course, course_key)
+
+    # set default forum roles (assign 'Student' role)
+    assign_default_role(course_key, user_who_created_course)
+
+
+def remove_all_instructors(course_key):
+    """
+    Removes given user as instructor and staff to the given course,
+    after verifying that the requesting_user has permission to do so.
+    """
+    staff_role = CourseStaffRole(course_key)
+    staff_role.remove_users(*staff_role.users_with_role())
+    instructor_role = CourseInstructorRole(course_key)
+    instructor_role.remove_users(*instructor_role.users_with_role())
+
+
+def delete_course_and_groups(course_key, user_id):
+    """
+    This deletes the courseware associated with a course_key as well as cleaning update_item
     the various user table stuff (groups, permissions, etc.)
     """
     module_store = modulestore()
 
-    with module_store.bulk_write_operations(course_id):
-        module_store.delete_course(course_id, user_id)
+    with module_store.bulk_write_operations(course_key):
+        module_store.delete_course(course_key, user_id)
 
         print 'removing User permissions from course....'
         # in the django layer, we need to remove all the user permissions groups associated with this course
         try:
-            staff_role = CourseStaffRole(course_id)
-            staff_role.remove_users(*staff_role.users_with_role())
-            instructor_role = CourseInstructorRole(course_id)
-            instructor_role.remove_users(*instructor_role.users_with_role())
+            remove_all_instructors(course_key)
         except Exception as err:
-            log.error("Error in deleting course groups for {0}: {1}".format(course_id, err))
+            log.error("Error in deleting course groups for {0}: {1}".format(course_key, err))
 
 
 def get_lms_link_for_item(location, preview=False):
@@ -64,19 +101,19 @@ def get_lms_link_for_item(location, preview=False):
     else:
         lms_base = settings.LMS_BASE
 
-    return u"//{lms_base}/courses/{course_id}/jump_to/{location}".format(
+    return u"//{lms_base}/courses/{course_key}/jump_to/{location}".format(
         lms_base=lms_base,
-        course_id=location.course_key.to_deprecated_string(),
+        course_key=location.course_key.to_deprecated_string(),
         location=location.to_deprecated_string(),
     )
 
 
-def get_lms_link_for_about_page(course_id):
+def get_lms_link_for_about_page(course_key):
     """
     Returns the url to the course about page from the location tuple.
     """
 
-    assert(isinstance(course_id, CourseKey))
+    assert(isinstance(course_key, CourseKey))
 
     if settings.FEATURES.get('ENABLE_MKTG_SITE', False):
         if not hasattr(settings, 'MKTG_URLS'):
@@ -101,9 +138,9 @@ def get_lms_link_for_about_page(course_id):
     else:
         return None
 
-    return u"//{about_base_url}/courses/{course_id}/about".format(
+    return u"//{about_base_url}/courses/{course_key}/about".format(
         about_base_url=about_base,
-        course_id=course_id.to_deprecated_string()
+        course_key=course_key.to_deprecated_string()
     )
 
 

cms/djangoapps/contentstore/views/tasks.py

+"""
+This file contains celery tasks for contentstore views
+"""
+
+from celery.task import task
+from django.contrib.auth.models import User
+from xmodule.modulestore.django import modulestore
+from course_action_state.models import CourseRerunState
+from contentstore.utils import initialize_permissions
+
+
+@task()
+def rerun_course(source_course_key, destination_course_key, user_id, fields=None):
+    """
+    Reruns a course in a new celery task.
+    """
+    try:
+        modulestore().clone_course(source_course_key, destination_course_key, user_id, fields=fields)
+
+        # set initial permissions for the user to access the course.
+        initialize_permissions(destination_course_key, User.objects.get(id=user_id))
+
+        # update state: Succeeded
+        CourseRerunState.objects.succeeded(course_key=destination_course_key)
+
+    # catch all exceptions so we can update the state and properly cleanup the course.
+    except Exception as exc:  # pylint: disable=broad-except
+        # update state: Failed
+        CourseRerunState.objects.failed(course_key=destination_course_key, exception=exc)
+
+        # cleanup any remnants of the course
+        modulestore().delete_course(destination_course_key, user_id)