Factory refactor working for lms lettuce tests.

cms/djangoapps/contentstore/features/common.py

@@ -7,8 +7,6 @@ from selenium.common.exceptions import WebDriverException, StaleElementReference
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.common.by import By
 
-from terrain.factories import UserFactory, RegistrationFactory, UserProfileFactory
-from terrain.factories import CourseFactory, GroupFactory
 from xmodule.modulestore.django import _MODULESTORES, modulestore
 from xmodule.templates import update_templates
 from auth.authz import get_user_by_email
@@ -61,7 +59,7 @@ def create_studio_user(
         email='robot+studio@edx.org',
         password='test',
         is_staff=False):
-    studio_user = UserFactory.build(
+    studio_user = world.UserFactory.build(
         username=uname,
         email=email,
         password=password,
@@ -69,11 +67,11 @@ def create_studio_user(
     studio_user.set_password(password)
     studio_user.save()
 
-    registration = RegistrationFactory(user=studio_user)
+    registration = world.RegistrationFactory(user=studio_user)
     registration.register(studio_user)
     registration.activate()
 
-    user_profile = UserProfileFactory(user=studio_user)
+    user_profile = world.UserProfileFactory(user=studio_user)
 
 
 def flush_xmodule_store():
@@ -175,11 +173,11 @@ def log_into_studio(
 
 
 def create_a_course():
-    c = CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
+    c = world.CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
 
     # Add the user to the instructor group of the course
     # so they will have the permissions to see it in studio
-    g = GroupFactory.create(name='instructor_MITx/999/Robot_Super_Course')
+    g = world.GroupFactory.create(name='instructor_MITx/999/Robot_Super_Course')
     u = get_user_by_email('robot+studio@edx.org')
     u.groups.add(g)
     u.save()

cms/djangoapps/contentstore/features/factories.py

-import factory
-from student.models import User, UserProfile, Registration
-from datetime import datetime
-import uuid
-
-
-class UserProfileFactory(factory.Factory):
-    FACTORY_FOR = UserProfile
-
-    user = None
-    name = 'Robot Studio'
-    courseware = 'course.xml'
-
-
-class RegistrationFactory(factory.Factory):
-    FACTORY_FOR = Registration
-
-    user = None
-    activation_key = uuid.uuid4().hex
-
-
-class UserFactory(factory.Factory):
-    FACTORY_FOR = User
-
-    username = 'robot-studio'
-    email = 'robot+studio@edx.org'
-    password = 'test'
-    first_name = 'Robot'
-    last_name = 'Studio'
-    is_staff = False
-    is_active = True
-    is_superuser = False
-    last_login = datetime.now()
-    date_joined = datetime.now()

common/djangoapps/student/tests/factories.py

+from student.models import (User, UserProfile, Registration, 
+                            CourseEnrollmentAllowed)
+from django.contrib.auth.models import Group
+from datetime import datetime
+from factory import Factory
+from xmodule.modulestore import Location
+from xmodule.modulestore.django import modulestore
+from time import gmtime
+from uuid import uuid4
+from xmodule.timeparse import stringify_time
+from xmodule.modulestore.inheritance import own_metadata
+
+
+class GroupFactory(Factory):
+    FACTORY_FOR = Group
+
+    name = 'staff_MITx/999/Robot_Super_Course'
+
+
+class UserProfileFactory(Factory):
+    FACTORY_FOR = UserProfile
+
+    user = None
+    name = 'Robot Test'
+    level_of_education = None
+    gender = 'm'
+    mailing_address = None
+    goals = 'World domination'
+
+
+class RegistrationFactory(Factory):
+    FACTORY_FOR = Registration
+
+    user = None
+    activation_key = uuid4().hex
+
+
+class UserFactory(Factory):
+    FACTORY_FOR = User
+
+    username = 'robot'
+    email = 'robot+test@edx.org'
+    password = 'test'
+    first_name = 'Robot'
+    last_name = 'Test'
+    is_staff = False
+    is_active = True
+    is_superuser = False
+    last_login = datetime(2012, 1, 1)
+    date_joined = datetime(2011, 1, 1)
+
+
+class CourseEnrollmentAllowedFactory(Factory):
+    FACTORY_FOR = CourseEnrollmentAllowed
+
+    email = 'test@edx.org'
+    course_id = 'edX/test/2012_Fall'
+
+
+def XMODULE_COURSE_CREATION(class_to_create, **kwargs):
+    return XModuleCourseFactory._create(class_to_create, **kwargs)
+
+
+def XMODULE_ITEM_CREATION(class_to_create, **kwargs):
+    return XModuleItemFactory._create(class_to_create, **kwargs)
+
+
+class XModuleCourseFactory(Factory):
+    """
+    Factory for XModule courses.
+    """
+
+    ABSTRACT_FACTORY = True
+    _creation_function = (XMODULE_COURSE_CREATION,)
+
+    @classmethod
+    def _create(cls, target_class, *args, **kwargs):
+
+        template = Location('i4x', 'edx', 'templates', 'course', 'Empty')
+        org = kwargs.get('org')
+        number = kwargs.get('number')
+        display_name = kwargs.get('display_name')
+        location = Location('i4x', org, number,
+                            'course', Location.clean(display_name))
+
+        store = modulestore('direct')
+
+        # Write the data to the mongo datastore
+        new_course = store.clone_item(template, location)
+
+        # This metadata code was copied from cms/djangoapps/contentstore/views.py
+        if display_name is not None:
+            new_course.display_name = display_name
+
+        new_course.lms.start = gmtime()
+        new_course.tabs = [{"type": "courseware"},
+            {"type": "course_info", "name": "Course Info"},
+            {"type": "discussion", "name": "Discussion"},
+            {"type": "wiki", "name": "Wiki"},
+            {"type": "progress", "name": "Progress"}]
+
+        # Update the data in the mongo datastore
+        store.update_metadata(new_course.location.url(), own_metadata(new_course))
+
+        return new_course
+
+
+class Course:
+    pass
+
+
+class CourseFactory(XModuleCourseFactory):
+    FACTORY_FOR = Course
+
+    template = 'i4x://edx/templates/course/Empty'
+    org = 'MITx'
+    number = '999'
+    display_name = 'Robot Super Course'
+
+
+class XModuleItemFactory(Factory):
+    """
+    Factory for XModule items.
+    """
+
+    ABSTRACT_FACTORY = True
+    _creation_function = (XMODULE_ITEM_CREATION,)
+
+    @classmethod
+    def _create(cls, target_class, *args, **kwargs):
+        """
+        Uses *kwargs*:
+
+        *parent_location* (required): the location of the parent module
+            (e.g. the parent course or section)
+
+        *template* (required): the template to create the item from
+            (e.g. i4x://templates/section/Empty)
+
+        *data* (optional): the data for the item
+            (e.g. XML problem definition for a problem item)
+
+        *display_name* (optional): the display name of the item
+
+        *metadata* (optional): dictionary of metadata attributes
+
+        *target_class* is ignored
+        """
+
+        DETACHED_CATEGORIES = ['about', 'static_tab', 'course_info']
+
+        parent_location = Location(kwargs.get('parent_location'))
+        template = Location(kwargs.get('template'))
+        data = kwargs.get('data')
+        display_name = kwargs.get('display_name')
+        metadata = kwargs.get('metadata', {})
+
+        store = modulestore('direct')
+
+        # This code was based off that in cms/djangoapps/contentstore/views.py
+        parent = store.get_item(parent_location)
+
+        # If a display name is set, use that
+        dest_name = display_name.replace(" ", "_") if display_name is not None else uuid4().hex
+        dest_location = parent_location._replace(category=template.category,
+                                                name=dest_name)
+
+        new_item = store.clone_item(template, dest_location)
+
+        # replace the display name with an optional parameter passed in from the caller
+        if display_name is not None:
+            new_item.display_name = display_name
+
+        # Add additional metadata or override current metadata
+        item_metadata = own_metadata(new_item)
+        item_metadata.update(metadata)
+        store.update_metadata(new_item.location.url(), item_metadata)
+
+        # replace the data with the optional *data* parameter
+        if data is not None:
+            store.update_item(new_item.location, data)
+
+        if new_item.location.category not in DETACHED_CATEGORIES:
+            store.update_children(parent_location, parent.children + [new_item.location.url()])
+
+        return new_item
+
+
+class Item:
+    pass
+
+
+class ItemFactory(XModuleItemFactory):
+    FACTORY_FOR = Item
+
+    parent_location = 'i4x://MITx/999/course/Robot_Super_Course'
+    template = 'i4x://edx/templates/chapter/Empty'
+    display_name = 'Section One'

common/djangoapps/student/tests/tests.py

+"""
+This file demonstrates writing tests using the unittest module. These will pass
+when you run "manage.py test".
+
+Replace this with more appropriate tests for your application.
+"""
+import logging
+
+from django.test import TestCase
+from mock import Mock
+
+from .models import unique_id_for_user
+from .views import process_survey_link, _cert_info
+
+COURSE_1 = 'edX/toy/2012_Fall'
+COURSE_2 = 'edx/full/6.002_Spring_2012'
+
+log = logging.getLogger(__name__)
+
+
+class CourseEndingTest(TestCase):
+    """Test things related to course endings: certificates, surveys, etc"""
+
+    def test_process_survey_link(self):
+        username = "fred"
+        user = Mock(username=username)
+        id = unique_id_for_user(user)
+        link1 = "http://www.mysurvey.com"
+        self.assertEqual(process_survey_link(link1, user), link1)
+
+        link2 = "http://www.mysurvey.com?unique={UNIQUE_ID}"
+        link2_expected = "http://www.mysurvey.com?unique={UNIQUE_ID}".format(UNIQUE_ID=id)
+        self.assertEqual(process_survey_link(link2, user), link2_expected)
+
+    def test_cert_info(self):
+        user = Mock(username="fred")
+        survey_url = "http://a_survey.com"
+        course = Mock(end_of_course_survey_url=survey_url)
+
+        self.assertEqual(_cert_info(user, course, None),
+                         {'status': 'processing',
+                          'show_disabled_download_button': False,
+                          'show_download_url': False,
+                          'show_survey_button': False, })
+
+        cert_status = {'status': 'unavailable'}
+        self.assertEqual(_cert_info(user, course, cert_status),
+                         {'status': 'processing',
+                          'show_disabled_download_button': False,
+                          'show_download_url': False,
+                          'show_survey_button': False})
+
+        cert_status = {'status': 'generating', 'grade': '67'}
+        self.assertEqual(_cert_info(user, course, cert_status),
+                         {'status': 'generating',
+                          'show_disabled_download_button': True,
+                          'show_download_url': False,
+                          'show_survey_button': True,
+                          'survey_url': survey_url,
+                          'grade': '67'
+                          })
+
+        cert_status = {'status': 'regenerating', 'grade': '67'}
+        self.assertEqual(_cert_info(user, course, cert_status),
+                         {'status': 'generating',
+                          'show_disabled_download_button': True,
+                          'show_download_url': False,
+                          'show_survey_button': True,
+                          'survey_url': survey_url,
+                          'grade': '67'
+                          })
+
+        download_url = 'http://s3.edx/cert'
+        cert_status = {'status': 'downloadable', 'grade': '67',
+                       'download_url': download_url}
+        self.assertEqual(_cert_info(user, course, cert_status),
+                         {'status': 'ready',
+                          'show_disabled_download_button': False,
+                          'show_download_url': True,
+                          'download_url': download_url,
+                          'show_survey_button': True,
+                          'survey_url': survey_url,
+                          'grade': '67'
+                          })
+
+        cert_status = {'status': 'notpassing', 'grade': '67',
+                       'download_url': download_url}
+        self.assertEqual(_cert_info(user, course, cert_status),
+                         {'status': 'notpassing',
+                          'show_disabled_download_button': False,
+                          'show_download_url': False,
+                          'show_survey_button': True,
+                          'survey_url': survey_url,
+                          'grade': '67'
+                          })
+
+        # Test a course that doesn't have a survey specified
+        course2 = Mock(end_of_course_survey_url=None)
+        cert_status = {'status': 'notpassing', 'grade': '67',
+                       'download_url': download_url}
+        self.assertEqual(_cert_info(user, course2, cert_status),
+                         {'status': 'notpassing',
+                          'show_disabled_download_button': False,
+                          'show_download_url': False,
+                          'show_survey_button': False,
+                          'grade': '67'
+                          })

common/djangoapps/terrain/factories.py

-from student.models import User, UserProfile, Registration
-from django.contrib.auth.models import Group
-from datetime import datetime
-from factory import Factory
-from xmodule.modulestore import Location
-from xmodule.modulestore.django import modulestore
-from time import gmtime
-from uuid import uuid4
-from xmodule.timeparse import stringify_time
-from xmodule.modulestore.inheritance import own_metadata
+from student.tests.factories import (UserFactory, UserProfileFactory,
+                                    RegistrationFactory, GroupFactory, 
+                                    CourseEnrollmentAllowed,
+                                    CourseFactory, ItemFactory)
+from lettuce import world
 
 
-class GroupFactory(Factory):
-    FACTORY_FOR = Group
-
-    name = 'staff_MITx/999/Robot_Super_Course'
-
-
-class UserProfileFactory(Factory):
-    FACTORY_FOR = UserProfile
-
-    user = None
-    name = 'Robot Test'
-    level_of_education = None
-    gender = 'm'
-    mailing_address = None
-    goals = 'World domination'
-
-
-class RegistrationFactory(Factory):
-    FACTORY_FOR = Registration
-
-    user = None
-    activation_key = uuid4().hex
-
-
-class UserFactory(Factory):
-    FACTORY_FOR = User
-
-    username = 'robot'
-    email = 'robot+test@edx.org'
-    password = 'test'
-    first_name = 'Robot'
-    last_name = 'Test'
-    is_staff = False
-    is_active = True
-    is_superuser = False
-    last_login = datetime(2012, 1, 1)
-    date_joined = datetime(2011, 1, 1)
-
-
-def XMODULE_COURSE_CREATION(class_to_create, **kwargs):
-    return XModuleCourseFactory._create(class_to_create, **kwargs)
-
-
-def XMODULE_ITEM_CREATION(class_to_create, **kwargs):
-    return XModuleItemFactory._create(class_to_create, **kwargs)
-
-
-class XModuleCourseFactory(Factory):
-    """
-    Factory for XModule courses.
+@world.absorb
+class UserFactory(UserFactory):
     """
-
-    ABSTRACT_FACTORY = True
-    _creation_function = (XMODULE_COURSE_CREATION,)
-
-    @classmethod
-    def _create(cls, target_class, *args, **kwargs):
-
-        template = Location('i4x', 'edx', 'templates', 'course', 'Empty')
-        org = kwargs.get('org')
-        number = kwargs.get('number')
-        display_name = kwargs.get('display_name')
-        location = Location('i4x', org, number,
-                            'course', Location.clean(display_name))
-
-        store = modulestore('direct')
-
-        # Write the data to the mongo datastore
-        new_course = store.clone_item(template, location)
-
-        # This metadata code was copied from cms/djangoapps/contentstore/views.py
-        if display_name is not None:
-            new_course.display_name = display_name
-
-        new_course.lms.start = gmtime()
-        new_course.tabs = [{"type": "courseware"},
-            {"type": "course_info", "name": "Course Info"},
-            {"type": "discussion", "name": "Discussion"},
-            {"type": "wiki", "name": "Wiki"},
-            {"type": "progress", "name": "Progress"}]
-
-        # Update the data in the mongo datastore
-        store.update_metadata(new_course.location.url(), own_metadata(new_course))
-
-        return new_course
-
-
-class Course:
+    User account for lms / cms
+    """ 
     pass
 
 
-class CourseFactory(XModuleCourseFactory):
-    FACTORY_FOR = Course
-
-    template = 'i4x://edx/templates/course/Empty'
-    org = 'MITx'
-    number = '999'
-    display_name = 'Robot Super Course'
-
-
-class XModuleItemFactory(Factory):
+@world.absorb
+class UserProfileFactory(UserProfileFactory):
     """
-    Factory for XModule items.
-    """
-
-    ABSTRACT_FACTORY = True
-    _creation_function = (XMODULE_ITEM_CREATION,)
-
-    @classmethod
-    def _create(cls, target_class, *args, **kwargs):
-        """
-        Uses *kwargs*:
-
-        *parent_location* (required): the location of the parent module
-            (e.g. the parent course or section)
-
-        *template* (required): the template to create the item from
-            (e.g. i4x://templates/section/Empty)
-
-        *data* (optional): the data for the item
-            (e.g. XML problem definition for a problem item)
-
-        *display_name* (optional): the display name of the item
-
-        *metadata* (optional): dictionary of metadata attributes
-
-        *target_class* is ignored
-        """
-
-        DETACHED_CATEGORIES = ['about', 'static_tab', 'course_info']
-
-        parent_location = Location(kwargs.get('parent_location'))
-        template = Location(kwargs.get('template'))
-        data = kwargs.get('data')
-        display_name = kwargs.get('display_name')
-        metadata = kwargs.get('metadata', {})
-
-        store = modulestore('direct')
-
-        # This code was based off that in cms/djangoapps/contentstore/views.py
-        parent = store.get_item(parent_location)
-
-        # If a display name is set, use that
-        dest_name = display_name.replace(" ", "_") if display_name is not None else uuid4().hex
-        dest_location = parent_location._replace(category=template.category,
-                                                name=dest_name)
-
-        new_item = store.clone_item(template, dest_location)
-
-        # replace the display name with an optional parameter passed in from the caller
-        if display_name is not None:
-            new_item.display_name = display_name
+    Demographics etc for the User
+    """ 
+    pass
 
-        # Add additional metadata or override current metadata
-        item_metadata = own_metadata(new_item)
-        item_metadata.update(metadata)
-        store.update_metadata(new_item.location.url(), item_metadata)
 
-        # replace the data with the optional *data* parameter
-        if data is not None:
-            store.update_item(new_item.location, data)
+@world.absorb
+class RegistrationFactory(RegistrationFactory):
+    """
+    Activation key for registering the user account
+    """ 
+    pass
 
-        if new_item.location.category not in DETACHED_CATEGORIES:
-            store.update_children(parent_location, parent.children + [new_item.location.url()])
 
-        return new_item
+@world.absorb
+class GroupFactory(GroupFactory):
+    """
+    Groups for user permissions for courses
+    """ 
+    pass
 
 
-class Item:
+@world.absorb
+class CourseEnrollmentAllowed(CourseEnrollmentAllowed):
+    """
+    Users allowed to enroll in the course outside of the usual window
+    """ 
     pass
 
 
-class ItemFactory(XModuleItemFactory):
-    FACTORY_FOR = Item
+@world.absorb
+class CourseFactory(CourseFactory):
+    """
+    Courseware courses
+    """ 
+    pass
+    
 
-    parent_location = 'i4x://MITx/999/course/Robot_Super_Course'
-    template = 'i4x://edx/templates/chapter/Empty'
-    display_name = 'Section One'
+@world.absorb
+class ItemFactory(ItemFactory):
+    """
+    Everything included inside a course
+    """ 
+    pass

common/djangoapps/terrain/steps.py

@@ -119,11 +119,11 @@ def create_user(uname):
     portal_user.set_password('test')
     portal_user.save()
 
-    registration = RegistrationFactory(user=portal_user)
+    registration = world.RegistrationFactory(user=portal_user)
     registration.register(portal_user)
     registration.activate()
 
-    user_profile = UserProfileFactory(user=portal_user)
+    user_profile = world.UserProfileFactory(user=portal_user)
 
 
 @world.absorb