diff --git a/cms/djangoapps/contentstore/features/advanced-settings.feature b/cms/djangoapps/contentstore/features/advanced-settings.feature
index af97709ad0..db7294c14c 100644
--- a/cms/djangoapps/contentstore/features/advanced-settings.feature
+++ b/cms/djangoapps/contentstore/features/advanced-settings.feature
@@ -1,6 +1,6 @@
 Feature: Advanced (manual) course policy
   In order to specify course policy settings for which no custom user interface exists
-  I want to be able to manually enter JSON key/value pairs
+  I want to be able to manually enter JSON key /value pairs
 
   Scenario: A course author sees default advanced settings
     Given I have opened a new course in Studio
diff --git a/cms/djangoapps/contentstore/features/advanced-settings.py b/cms/djangoapps/contentstore/features/advanced-settings.py
index 7e86e94a31..16562b6b15 100644
--- a/cms/djangoapps/contentstore/features/advanced-settings.py
+++ b/cms/djangoapps/contentstore/features/advanced-settings.py
@@ -1,9 +1,10 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from common import *
 import time
 from terrain.steps import reload_the_page
-from selenium.common.exceptions import WebDriverException
-from selenium.webdriver.support import expected_conditions as EC
 
 from nose.tools import assert_true, assert_false, assert_equal
 
@@ -18,13 +19,14 @@ DISPLAY_NAME_KEY = "display_name"
 DISPLAY_NAME_VALUE = '"Robot Super Course"'
 
 ############### ACTIONS ####################
+
 @step('I select the Advanced Settings$')
 def i_select_advanced_settings(step):
     expand_icon_css = 'li.nav-course-settings i.icon-expand'
     if world.browser.is_element_present_by_css(expand_icon_css):
-        css_click(expand_icon_css)
+        world.css_click(expand_icon_css)
     link_css = 'li.nav-course-settings-advanced a'
-    css_click(link_css)
+    world.css_click(link_css)
 
 
 @step('I am on the Advanced Course Settings page in Studio$')
@@ -35,24 +37,8 @@ def i_am_on_advanced_course_settings(step):
 
 @step(u'I press the "([^"]*)" notification button$')
 def press_the_notification_button(step, name):
-    def is_visible(driver):
-        return EC.visibility_of_element_located((By.CSS_SELECTOR, css,))
-
-    #    def is_invisible(driver):
-    #        return EC.invisibility_of_element_located((By.CSS_SELECTOR,css,))
-
     css = 'a.%s-button' % name.lower()
-    wait_for(is_visible)
-    time.sleep(float(1))
-    css_click_at(css)
-
-#   is_invisible is not returning a boolean, not working
-#    try:
-#        css_click_at(css)
-#        wait_for(is_invisible)
-#    except WebDriverException, e:
-#        css_click_at(css)
-#        wait_for(is_invisible)
+    world.css_click_at(css)
 
 
 @step(u'I edit the value of a policy key$')
@@ -61,7 +47,7 @@ def edit_the_value_of_a_policy_key(step):
     It is hard to figure out how to get into the CodeMirror
     area, so cheat and do it from the policy key field :)
     """
-    e = css_find(KEY_CSS)[get_index_of(DISPLAY_NAME_KEY)]
+    e = world.css_find(KEY_CSS)[get_index_of(DISPLAY_NAME_KEY)]
     e._element.send_keys(Keys.TAB, Keys.END, Keys.ARROW_LEFT, ' ', 'X')
 
 
@@ -85,7 +71,7 @@ def i_see_default_advanced_settings(step):
 
 @step('the settings are alphabetized$')
 def they_are_alphabetized(step):
-    key_elements = css_find(KEY_CSS)
+    key_elements = world.css_find(KEY_CSS)
     all_keys = []
     for key in key_elements:
         all_keys.append(key.value)
@@ -118,13 +104,13 @@ def assert_policy_entries(expected_keys, expected_values):
     for counter in range(len(expected_keys)):
         index = get_index_of(expected_keys[counter])
         assert_false(index == -1, "Could not find key: " + expected_keys[counter])
-        assert_equal(expected_values[counter], css_find(VALUE_CSS)[index].value, "value is incorrect")
+        assert_equal(expected_values[counter], world.css_find(VALUE_CSS)[index].value, "value is incorrect")
 
 
 def get_index_of(expected_key):
-    for counter in range(len(css_find(KEY_CSS))):
+    for counter in range(len(world.css_find(KEY_CSS))):
         #   Sometimes get stale reference if I hold on to the array of elements
-        key = css_find(KEY_CSS)[counter].value
+        key = world.css_find(KEY_CSS)[counter].value
         if key == expected_key:
             return counter
 
@@ -133,14 +119,14 @@ def get_index_of(expected_key):
 
 def get_display_name_value():
     index = get_index_of(DISPLAY_NAME_KEY)
-    return css_find(VALUE_CSS)[index].value
+    return world.css_find(VALUE_CSS)[index].value
 
 
 def change_display_name_value(step, new_value):
-    e = css_find(KEY_CSS)[get_index_of(DISPLAY_NAME_KEY)]
+    e = world.css_find(KEY_CSS)[get_index_of(DISPLAY_NAME_KEY)]
     display_name = get_display_name_value()
     for count in range(len(display_name)):
         e._element.send_keys(Keys.TAB, Keys.END, Keys.BACK_SPACE)
         # Must delete "" before typing the JSON value
     e._element.send_keys(Keys.TAB, Keys.END, Keys.BACK_SPACE, Keys.BACK_SPACE, new_value)
-    press_the_notification_button(step, "Save")
\ No newline at end of file
+    press_the_notification_button(step, "Save")
diff --git a/cms/djangoapps/contentstore/features/checklists.py b/cms/djangoapps/contentstore/features/checklists.py
index 9ef66c8096..dc399f5fac 100644
--- a/cms/djangoapps/contentstore/features/checklists.py
+++ b/cms/djangoapps/contentstore/features/checklists.py
@@ -1,15 +1,19 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
-from common import *
+from nose.tools import assert_true, assert_equal
 from terrain.steps import reload_the_page
+from selenium.common.exceptions import StaleElementReferenceException
 
 ############### ACTIONS ####################
 @step('I select Checklists from the Tools menu$')
 def i_select_checklists(step):
     expand_icon_css = 'li.nav-course-tools i.icon-expand'
     if world.browser.is_element_present_by_css(expand_icon_css):
-        css_click(expand_icon_css)
+        world.css_click(expand_icon_css)
     link_css = 'li.nav-course-tools-checklists a'
-    css_click(link_css)
+    world.css_click(link_css)
 
 
 @step('I have opened Checklists$')
@@ -20,7 +24,7 @@ def i_have_opened_checklists(step):
 
 @step('I see the four default edX checklists$')
 def i_see_default_checklists(step):
-    checklists = css_find('.checklist-title')
+    checklists = world.css_find('.checklist-title')
     assert_equal(4, len(checklists))
     assert_true(checklists[0].text.endswith('Getting Started With Studio'))
     assert_true(checklists[1].text.endswith('Draft a Rough Course Outline'))
@@ -58,7 +62,7 @@ def i_select_a_link_to_the_course_outline(step):
 
 @step('I am brought to the course outline page$')
 def i_am_brought_to_course_outline(step):
-    assert_equal('Course Outline', css_find('.outline .title-1')[0].text)
+    assert_equal('Course Outline', world.css_find('.outline .title-1')[0].text)
     assert_equal(1, len(world.browser.windows))
 
 
@@ -90,30 +94,30 @@ def i_am_brought_to_help_page_in_new_window(step):
 def verifyChecklist2Status(completed, total, percentage):
     def verify_count(driver):
         try:
-            statusCount = css_find('#course-checklist1 .status-count').first
+            statusCount = world.css_find('#course-checklist1 .status-count').first
             return statusCount.text == str(completed)
         except StaleElementReferenceException:
             return False
 
-    wait_for(verify_count)
-    assert_equal(str(total), css_find('#course-checklist1 .status-amount').first.text)
+    world.wait_for(verify_count)
+    assert_equal(str(total), world.css_find('#course-checklist1 .status-amount').first.text)
     # Would like to check the CSS width, but not sure how to do that.
-    assert_equal(str(percentage), css_find('#course-checklist1 .viz-checklist-status-value .int').first.text)
+    assert_equal(str(percentage), world.css_find('#course-checklist1 .viz-checklist-status-value .int').first.text)
 
 
 def toggleTask(checklist, task):
-    css_click('#course-checklist' + str(checklist) +'-task' + str(task))
+    world.css_click('#course-checklist' + str(checklist) +'-task' + str(task))
 
 
 def clickActionLink(checklist, task, actionText):
     # toggle checklist item to make sure that the link button is showing
     toggleTask(checklist, task)
-    action_link = css_find('#course-checklist' + str(checklist) + ' a')[task]
+    action_link = world.css_find('#course-checklist' + str(checklist) + ' a')[task]
 
     # text will be empty initially, wait for it to populate
     def verify_action_link_text(driver):
         return action_link.text == actionText
 
-    wait_for(verify_action_link_text)
+    world.wait_for(verify_action_link_text)
     action_link.click()
 
diff --git a/cms/djangoapps/contentstore/features/common.py b/cms/djangoapps/contentstore/features/common.py
index 820b60123b..3878340af3 100644
--- a/cms/djangoapps/contentstore/features/common.py
+++ b/cms/djangoapps/contentstore/features/common.py
@@ -1,11 +1,9 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
-from lettuce.django import django_url
 from nose.tools import assert_true
 from nose.tools import assert_equal
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.common.exceptions import WebDriverException, StaleElementReferenceException
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.common.by import By
 
 from xmodule.modulestore.django import _MODULESTORES, modulestore
 from xmodule.templates import update_templates
@@ -15,14 +13,15 @@ from logging import getLogger
 logger = getLogger(__name__)
 
 ###########  STEP HELPERS ##############
+
 @step('I (?:visit|access|open) the Studio homepage$')
 def i_visit_the_studio_homepage(step):
     # To make this go to port 8001, put
     # LETTUCE_SERVER_PORT = 8001
     # in your settings.py file.
-    world.browser.visit(django_url('/'))
+    world.visit('/')
     signin_css = 'a.action-signin'
-    assert world.browser.is_element_present_by_css(signin_css, 10)
+    assert world.is_css_present(signin_css)
 
 
 @step('I am logged into Studio$')
@@ -43,12 +42,12 @@ def i_press_the_category_delete_icon(step, category):
         css = 'a.delete-button.delete-subsection-button  span.delete-icon'
     else:
         assert False, 'Invalid category: %s' % category
-    css_click(css)
+    world.css_click(css)
 
 
 @step('I have opened a new course in Studio$')
 def i_have_opened_a_new_course(step):
-    clear_courses()
+    world.clear_courses()
     log_into_studio()
     create_a_course()
 
@@ -74,80 +73,13 @@ def create_studio_user(
     user_profile = world.UserProfileFactory(user=studio_user)
 
 
-def flush_xmodule_store():
-    # Flush and initialize the module store
-    # It needs the templates because it creates new records
-    # by cloning from the template.
-    # Note that if your test module gets in some weird state
-    # (though it shouldn't), do this manually
-    # from the bash shell to drop it:
-    # $ mongo test_xmodule --eval "db.dropDatabase()"
-    _MODULESTORES = {}
-    modulestore().collection.drop()
-    update_templates()
-
-
-def assert_css_with_text(css, text):
-    assert_true(world.browser.is_element_present_by_css(css, 5))
-    assert_equal(world.browser.find_by_css(css).text, text)
-
-
-def css_click(css):
-    '''
-    First try to use the regular click method, 
-    but if clicking in the middle of an element
-    doesn't work it might be that it thinks some other
-    element is on top of it there so click in the upper left
-    '''
-    try:
-        css_find(css).first.click()
-    except WebDriverException, e:
-        css_click_at(css)
-
-
-def css_click_at(css, x=10, y=10):
-    '''
-    A method to click at x,y coordinates of the element
-    rather than in the center of the element
-    '''
-    e = css_find(css).first
-    e.action_chains.move_to_element_with_offset(e._element, x, y)
-    e.action_chains.click()
-    e.action_chains.perform()
-
-
-def css_fill(css, value):
-    world.browser.find_by_css(css).first.fill(value)
-
-
-def css_find(css):
-    def is_visible(driver):
-        return EC.visibility_of_element_located((By.CSS_SELECTOR,css,))
-
-    world.browser.is_element_present_by_css(css, 5)
-    wait_for(is_visible)
-    return world.browser.find_by_css(css)
-
-
-def wait_for(func):
-    WebDriverWait(world.browser.driver, 5).until(func)
-
-
-def id_find(id):
-    return world.browser.find_by_id(id)
-
-
-def clear_courses():
-    flush_xmodule_store()
-
-
 def fill_in_course_info(
         name='Robot Super Course',
         org='MITx',
         num='101'):
-    css_fill('.new-course-name', name)
-    css_fill('.new-course-org', org)
-    css_fill('.new-course-number', num)
+    world.css_fill('.new-course-name', name)
+    world.css_fill('.new-course-org', org)
+    world.css_fill('.new-course-number', num)
 
 
 def log_into_studio(
@@ -155,21 +87,22 @@ def log_into_studio(
         email='robot+studio@edx.org',
         password='test',
         is_staff=False):
-    create_studio_user(uname=uname, email=email, is_staff=is_staff)
-    world.browser.cookies.delete()
-    world.browser.visit(django_url('/'))
-    signin_css = 'a.action-signin'
-    world.browser.is_element_present_by_css(signin_css, 10)
 
-    # click the signin button
-    css_click(signin_css)
+    create_studio_user(uname=uname, email=email, is_staff=is_staff)
+
+    world.browser.cookies.delete()
+    world.visit('/')
+
+    signin_css = 'a.action-signin'
+    world.is_css_present(signin_css)
+    world.css_click(signin_css)
 
     login_form = world.browser.find_by_css('form#login_form')
     login_form.find_by_name('email').fill(email)
     login_form.find_by_name('password').fill(password)
     login_form.find_by_name('submit').click()
 
-    assert_true(world.browser.is_element_present_by_css('.new-course-button', 5))
+    assert_true(world.is_css_present('.new-course-button'))
 
 
 def create_a_course():
@@ -184,26 +117,26 @@ def create_a_course():
     world.browser.reload()
 
     course_link_css = 'span.class-name'
-    css_click(course_link_css)
+    world.css_click(course_link_css)
     course_title_css = 'span.course-title'
-    assert_true(world.browser.is_element_present_by_css(course_title_css, 5))
+    assert_true(world.is_css_present(course_title_css))
 
 
 def add_section(name='My Section'):
     link_css = 'a.new-courseware-section-button'
-    css_click(link_css)
+    world.css_click(link_css)
     name_css = 'input.new-section-name'
     save_css = 'input.new-section-name-save'
-    css_fill(name_css, name)
-    css_click(save_css)
+    world.css_fill(name_css, name)
+    world.css_click(save_css)
     span_css = 'span.section-name-span'
-    assert_true(world.browser.is_element_present_by_css(span_css, 5))
+    assert_true(world.is_css_present(span_css))
 
 
 def add_subsection(name='Subsection One'):
     css = 'a.new-subsection-item'
-    css_click(css)
+    world.css_click(css)
     name_css = 'input.new-subsection-name-input'
     save_css = 'input.new-subsection-name-save'
-    css_fill(name_css, name)
-    css_click(save_css)
+    world.css_fill(name_css, name)
+    world.css_click(save_css)
diff --git a/cms/djangoapps/contentstore/features/course-settings.py b/cms/djangoapps/contentstore/features/course-settings.py
index a0c25045f2..9eb5b0951d 100644
--- a/cms/djangoapps/contentstore/features/course-settings.py
+++ b/cms/djangoapps/contentstore/features/course-settings.py
@@ -1,5 +1,7 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
-from common import *
 from terrain.steps import reload_the_page
 from selenium.webdriver.common.keys import Keys
 import time
@@ -25,9 +27,9 @@ DEFAULT_TIME = "12:00am"
 def test_i_select_schedule_and_details(step):
     expand_icon_css = 'li.nav-course-settings i.icon-expand'
     if world.browser.is_element_present_by_css(expand_icon_css):
-        css_click(expand_icon_css)
+        world.css_click(expand_icon_css)
     link_css = 'li.nav-course-settings-schedule a'
-    css_click(link_css)
+    world.css_click(link_css)
 
 
 @step('I have set course dates$')
@@ -97,9 +99,9 @@ def test_i_clear_the_course_start_date(step):
 
 @step('I receive a warning about course start date$')
 def test_i_receive_a_warning_about_course_start_date(step):
-    assert_css_with_text('.message-error', 'The course must have an assigned start date.')
-    assert_true('error' in css_find(COURSE_START_DATE_CSS).first._element.get_attribute('class'))
-    assert_true('error' in css_find(COURSE_START_TIME_CSS).first._element.get_attribute('class'))
+    assert_true(world.css_has_text('.message-error', 'The course must have an assigned start date.'))
+    assert_true('error' in world.css_find(COURSE_START_DATE_CSS).first._element.get_attribute('class'))
+    assert_true('error' in world.css_find(COURSE_START_TIME_CSS).first._element.get_attribute('class'))
 
 
 @step('The previously set start date is shown on refresh$')
@@ -124,9 +126,9 @@ def test_i_have_entered_a_new_course_start_date(step):
 
 @step('The warning about course start date goes away$')
 def test_the_warning_about_course_start_date_goes_away(step):
-    assert_equal(0, len(css_find('.message-error')))
-    assert_false('error' in css_find(COURSE_START_DATE_CSS).first._element.get_attribute('class'))
-    assert_false('error' in css_find(COURSE_START_TIME_CSS).first._element.get_attribute('class'))
+    assert_equal(0, len(world.css_find('.message-error')))
+    assert_false('error' in world.css_find(COURSE_START_DATE_CSS).first._element.get_attribute('class'))
+    assert_false('error' in world.css_find(COURSE_START_TIME_CSS).first._element.get_attribute('class'))
 
 
 @step('My new course start date is shown on refresh$')
@@ -142,8 +144,8 @@ def set_date_or_time(css, date_or_time):
     """
     Sets date or time field.
     """
-    css_fill(css, date_or_time)
-    e = css_find(css).first
+    world.css_fill(css, date_or_time)
+    e = world.css_find(css).first
     # hit Enter to apply the changes
     e._element.send_keys(Keys.ENTER)
 
@@ -152,7 +154,7 @@ def verify_date_or_time(css, date_or_time):
     """
     Verifies date or time field.
     """
-    assert_equal(date_or_time, css_find(css).first.value)
+    assert_equal(date_or_time, world.css_find(css).first.value)
 
 
 def pause():
diff --git a/cms/djangoapps/contentstore/features/courses.feature b/cms/djangoapps/contentstore/features/courses.feature
index 39d39b50aa..455313b0e2 100644
--- a/cms/djangoapps/contentstore/features/courses.feature
+++ b/cms/djangoapps/contentstore/features/courses.feature
@@ -10,4 +10,4 @@ Feature: Create Course
     And I fill in the new course information
     And I press the "Save" button
     Then the Courseware page has loaded in Studio
-    And I see a link for adding a new section
\ No newline at end of file
+    And I see a link for adding a new section
diff --git a/cms/djangoapps/contentstore/features/courses.py b/cms/djangoapps/contentstore/features/courses.py
index e394165f08..5da7720945 100644
--- a/cms/djangoapps/contentstore/features/courses.py
+++ b/cms/djangoapps/contentstore/features/courses.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from common import *
 
@@ -6,12 +9,12 @@ from common import *
 
 @step('There are no courses$')
 def no_courses(step):
-    clear_courses()
+    world.clear_courses()
 
 
 @step('I click the New Course button$')
 def i_click_new_course(step):
-    css_click('.new-course-button')
+    world.css_click('.new-course-button')
 
 
 @step('I fill in the new course information$')
@@ -27,7 +30,7 @@ def i_create_a_course(step):
 @step('I click the course link in My Courses$')
 def i_click_the_course_link_in_my_courses(step):
     course_css = 'span.class-name'
-    css_click(course_css)
+    world.css_click(course_css)
 
 ############ ASSERTIONS ###################
 
@@ -35,28 +38,28 @@ def i_click_the_course_link_in_my_courses(step):
 @step('the Courseware page has loaded in Studio$')
 def courseware_page_has_loaded_in_studio(step):
     course_title_css = 'span.course-title'
-    assert world.browser.is_element_present_by_css(course_title_css)
+    assert world.is_css_present(course_title_css)
 
 
 @step('I see the course listed in My Courses$')
 def i_see_the_course_in_my_courses(step):
     course_css = 'span.class-name'
-    assert_css_with_text(course_css, 'Robot Super Course')
+    assert world.css_has_text(course_css, 'Robot Super Course')
 
 
 @step('the course is loaded$')
 def course_is_loaded(step):
     class_css = 'a.class-name'
-    assert_css_with_text(class_css, 'Robot Super Course')
+    assert world.css_has_text(course_css, 'Robot Super Cousre')
 
 
 @step('I am on the "([^"]*)" tab$')
 def i_am_on_tab(step, tab_name):
     header_css = 'div.inner-wrapper h1'
-    assert_css_with_text(header_css, tab_name)
+    assert world.css_has_text(header_css, tab_name)
 
 
 @step('I see a link for adding a new section$')
 def i_see_new_section_link(step):
     link_css = 'a.new-courseware-section-button'
-    assert_css_with_text(link_css, '+ New Section')
+    assert world.css_has_text(link_css, '+ New Section')
diff --git a/cms/djangoapps/contentstore/features/section.py b/cms/djangoapps/contentstore/features/section.py
index b5ddb48a09..0c0f5536a0 100644
--- a/cms/djangoapps/contentstore/features/section.py
+++ b/cms/djangoapps/contentstore/features/section.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from common import *
 from nose.tools import assert_equal
@@ -10,7 +13,7 @@ import time
 @step('I click the new section link$')
 def i_click_new_section_link(step):
     link_css = 'a.new-courseware-section-button'
-    css_click(link_css)
+    world.css_click(link_css)
 
 
 @step('I enter the section name and click save$')
@@ -31,19 +34,19 @@ def i_have_added_new_section(step):
 @step('I click the Edit link for the release date$')
 def i_click_the_edit_link_for_the_release_date(step):
     button_css = 'div.section-published-date a.edit-button'
-    css_click(button_css)
+    world.css_click(button_css)
 
 
 @step('I save a new section release date$')
 def i_save_a_new_section_release_date(step):
     date_css = 'input.start-date.date.hasDatepicker'
     time_css = 'input.start-time.time.ui-timepicker-input'
-    css_fill(date_css, '12/25/2013')
+    world.css_fill(date_css, '12/25/2013')
     # hit TAB to get to the time field
-    e = css_find(date_css).first
+    e = world.css_find(date_css).first
     e._element.send_keys(Keys.TAB)
-    css_fill(time_css, '12:00am')
-    e = css_find(time_css).first
+    world.css_fill(time_css, '12:00am')
+    e = world.css_find(time_css).first
     e._element.send_keys(Keys.TAB)
     time.sleep(float(1))
     world.browser.click_link_by_text('Save')
@@ -64,13 +67,13 @@ def i_see_my_section_name_with_quote_on_the_courseware_page(step):
 
 @step('I click to edit the section name$')
 def i_click_to_edit_section_name(step):
-    css_click('span.section-name-span')
+    world.css_click('span.section-name-span')
 
 
 @step('I see the complete section name with a quote in the editor$')
 def i_see_complete_section_name_with_quote_in_editor(step):
     css = '.edit-section-name'
-    assert world.browser.is_element_present_by_css(css, 5)
+    assert world.is_css_present(css)
     assert_equal(world.browser.find_by_css(css).value, 'Section with "Quote"')
 
 
@@ -85,7 +88,7 @@ def i_see_a_release_date_for_my_section(step):
     import re
 
     css = 'span.published-status'
-    assert world.browser.is_element_present_by_css(css)
+    assert world.is_css_present(css)
     status_text = world.browser.find_by_css(css).text
 
     # e.g. 11/06/2012 at 16:25
@@ -99,20 +102,20 @@ def i_see_a_release_date_for_my_section(step):
 @step('I see a link to create a new subsection$')
 def i_see_a_link_to_create_a_new_subsection(step):
     css = 'a.new-subsection-item'
-    assert world.browser.is_element_present_by_css(css)
+    assert world.is_css_present(css)
 
 
 @step('the section release date picker is not visible$')
 def the_section_release_date_picker_not_visible(step):
     css = 'div.edit-subsection-publish-settings'
-    assert False, world.browser.find_by_css(css).visible
+    assert not world.css_visible(css)
 
 
 @step('the section release date is updated$')
 def the_section_release_date_is_updated(step):
     css = 'span.published-status'
-    status_text = world.browser.find_by_css(css).text
-    assert_equal(status_text,'Will Release: 12/25/2013 at 12:00am')
+    status_text = world.css_text(css)
+    assert_equal(status_text, 'Will Release: 12/25/2013 at 12:00am')
 
 
 ############ HELPER METHODS ###################
@@ -120,10 +123,10 @@ def the_section_release_date_is_updated(step):
 def save_section_name(name):
     name_css = '.new-section-name'
     save_css = '.new-section-name-save'
-    css_fill(name_css, name)
-    css_click(save_css)
+    world.css_fill(name_css, name)
+    world.css_click(save_css)
 
 
 def see_my_section_on_the_courseware_page(name):
     section_css = 'span.section-name-span'
-    assert_css_with_text(section_css, name)
+    assert world.css_has_text(section_css, name)
diff --git a/cms/djangoapps/contentstore/features/signup.py b/cms/djangoapps/contentstore/features/signup.py
index e8d0dd8229..6ca358183b 100644
--- a/cms/djangoapps/contentstore/features/signup.py
+++ b/cms/djangoapps/contentstore/features/signup.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from common import *
 
@@ -17,9 +20,10 @@ def i_press_the_button_on_the_registration_form(step):
     submit_css = 'form#register_form button#submit'
     # Workaround for click not working on ubuntu
     # for some unknown reason.
-    e = css_find(submit_css)
+    e = world.css_find(submit_css)
     e.type(' ')
 
+
 @step('I should see be on the studio home page$')
 def i_should_see_be_on_the_studio_home_page(step):
     assert world.browser.find_by_css('div.inner-wrapper')
diff --git a/cms/djangoapps/contentstore/features/studio-overview-togglesection.feature b/cms/djangoapps/contentstore/features/studio-overview-togglesection.feature
index 52c10e41a8..762dea6838 100644
--- a/cms/djangoapps/contentstore/features/studio-overview-togglesection.feature
+++ b/cms/djangoapps/contentstore/features/studio-overview-togglesection.feature
@@ -1,30 +1,30 @@
 Feature: Overview Toggle Section
 	In order to quickly view the details of a course's section or to scan the inventory of sections
-	As a course author
-	I want to toggle the visibility of each section's  subsection details in the overview listing
+        As a course author
+        I want to toggle the visibility of each section's  subsection details in the overview listing
 
 	Scenario: The default layout for the overview page is to show sections in expanded view
 		Given I have a course with multiple sections
-		When I navigate to the course overview page
-		Then I see the "Collapse All Sections" link
-		And all sections are expanded
+                When I navigate to the course overview page
+                Then I see the "Collapse All Sections" link
+                And all sections are expanded
 
-	Scenario: Expand/collapse for a course with no sections
+	Scenario: Expand /collapse for a course with no sections
 		Given I have a course with no sections
-		When I navigate to the course overview page
-		Then I do not see the "Collapse All Sections" link
+                When I navigate to the course overview page
+                Then I do not see the "Collapse All Sections" link
 
 	Scenario: Collapse link appears after creating first section of a course
 		Given I have a course with no sections
-		When I navigate to the course overview page
-		And I add a section
-		Then I see the "Collapse All Sections" link
-		And all sections are expanded
+                When I navigate to the course overview page
+                And I add a section
+                Then I see the "Collapse All Sections" link
+                And all sections are expanded
 
 	@skip-phantom
 	Scenario: Collapse link is not removed after last section of a course is deleted
 		Given I have a course with 1 section
-		And I navigate to the course overview page
+                And I navigate to the course overview page
 	    When I press the "section" delete icon
 	    And I confirm the alert
 		Then I see the "Collapse All Sections" link
diff --git a/cms/djangoapps/contentstore/features/studio-overview-togglesection.py b/cms/djangoapps/contentstore/features/studio-overview-togglesection.py
index 060d592cfd..7f717b731c 100644
--- a/cms/djangoapps/contentstore/features/studio-overview-togglesection.py
+++ b/cms/djangoapps/contentstore/features/studio-overview-togglesection.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from common import *
 from nose.tools import assert_true, assert_false, assert_equal
@@ -8,13 +11,13 @@ logger = getLogger(__name__)
 
 @step(u'I have a course with no sections$')
 def have_a_course(step):
-    clear_courses()
+    world.clear_courses()
     course = world.CourseFactory.create()
 
 
 @step(u'I have a course with 1 section$')
 def have_a_course_with_1_section(step):
-    clear_courses()
+    world.clear_courses()
     course = world.CourseFactory.create()
     section = world.ItemFactory.create(parent_location=course.location)
     subsection1 = world.ItemFactory.create(
@@ -25,7 +28,7 @@ def have_a_course_with_1_section(step):
 
 @step(u'I have a course with multiple sections$')
 def have_a_course_with_two_sections(step):
-    clear_courses()
+    world.clear_courses()
     course = world.CourseFactory.create()
     section = world.ItemFactory.create(parent_location=course.location)
     subsection1 = world.ItemFactory.create(
@@ -49,7 +52,7 @@ def have_a_course_with_two_sections(step):
 def navigate_to_the_course_overview_page(step):
     log_into_studio(is_staff=True)
     course_locator = '.class-name'
-    css_click(course_locator)
+    world.css_click(course_locator)
 
 
 @step(u'I navigate to the courseware page of a course with multiple sections')
@@ -66,44 +69,44 @@ def i_add_a_section(step):
 @step(u'I click the "([^"]*)" link$')
 def i_click_the_text_span(step, text):
     span_locator = '.toggle-button-sections span'
-    assert_true(world.browser.is_element_present_by_css(span_locator, 5))
+    assert_true(world.browser.is_element_present_by_css(span_locator))
     # first make sure that the expand/collapse text is the one you expected
     assert_equal(world.browser.find_by_css(span_locator).value, text)
-    css_click(span_locator)
+    world.css_click(span_locator)
 
 
 @step(u'I collapse the first section$')
 def i_collapse_a_section(step):
     collapse_locator = 'section.courseware-section a.collapse'
-    css_click(collapse_locator)
+    world.css_click(collapse_locator)
 
 
 @step(u'I expand the first section$')
 def i_expand_a_section(step):
     expand_locator = 'section.courseware-section a.expand'
-    css_click(expand_locator)
+    world.css_click(expand_locator)
 
 
 @step(u'I see the "([^"]*)" link$')
 def i_see_the_span_with_text(step, text):
     span_locator = '.toggle-button-sections span'
-    assert_true(world.browser.is_element_present_by_css(span_locator, 5))
-    assert_equal(world.browser.find_by_css(span_locator).value, text)
-    assert_true(world.browser.find_by_css(span_locator).visible)
+    assert_true(world.is_css_present(span_locator))
+    assert_equal(world.css_find(span_locator).value, text)
+    assert_true(world.css_visible(span_locator))
 
 
 @step(u'I do not see the "([^"]*)" link$')
 def i_do_not_see_the_span_with_text(step, text):
     # Note that the span will exist on the page but not be visible
     span_locator = '.toggle-button-sections span'
-    assert_true(world.browser.is_element_present_by_css(span_locator))
-    assert_false(world.browser.find_by_css(span_locator).visible)
+    assert_true(world.is_css_present(span_locator))
+    assert_false(world.css_visible(span_locator))
 
 
 @step(u'all sections are expanded$')
 def all_sections_are_expanded(step):
     subsection_locator = 'div.subsection-list'
-    subsections = world.browser.find_by_css(subsection_locator)
+    subsections = world.css_find(subsection_locator)
     for s in subsections:
         assert_true(s.visible)
 
@@ -111,6 +114,6 @@ def all_sections_are_expanded(step):
 @step(u'all sections are collapsed$')
 def all_sections_are_expanded(step):
     subsection_locator = 'div.subsection-list'
-    subsections = world.browser.find_by_css(subsection_locator)
+    subsections = world.css_find(subsection_locator)
     for s in subsections:
         assert_false(s.visible)
diff --git a/cms/djangoapps/contentstore/features/subsection.feature b/cms/djangoapps/contentstore/features/subsection.feature
index 1be5f4aeb9..e913c6a4bf 100644
--- a/cms/djangoapps/contentstore/features/subsection.feature
+++ b/cms/djangoapps/contentstore/features/subsection.feature
@@ -17,6 +17,14 @@ Feature: Create Subsection
     And I click to edit the subsection name
     Then I see the complete subsection name with a quote in the editor
 
+    Scenario: Assign grading type to a subsection and verify it is still shown after refresh (bug #258)
+    Given I have opened a new course section in Studio
+    And I have added a new subsection
+    And I mark it as Homework
+    Then I see it marked as Homework
+    And I reload the page
+    Then I see it marked as Homework
+
     @skip-phantom
     Scenario: Delete a subsection
     Given I have opened a new course section in Studio
diff --git a/cms/djangoapps/contentstore/features/subsection.py b/cms/djangoapps/contentstore/features/subsection.py
index 88e1424898..4ab27fcb49 100644
--- a/cms/djangoapps/contentstore/features/subsection.py
+++ b/cms/djangoapps/contentstore/features/subsection.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from common import *
 from nose.tools import assert_equal
@@ -7,7 +10,7 @@ from nose.tools import assert_equal
 
 @step('I have opened a new course section in Studio$')
 def i_have_opened_a_new_course_section(step):
-    clear_courses()
+    world.clear_courses()
     log_into_studio()
     create_a_course()
     add_section()
@@ -15,8 +18,7 @@ def i_have_opened_a_new_course_section(step):
 
 @step('I click the New Subsection link')
 def i_click_the_new_subsection_link(step):
-    css = 'a.new-subsection-item'
-    css_click(css)
+    world.css_click('a.new-subsection-item')
 
 
 @step('I enter the subsection name and click save$')
@@ -31,14 +33,14 @@ def i_save_subsection_name_with_quote(step):
 
 @step('I click to edit the subsection name$')
 def i_click_to_edit_subsection_name(step):
-    css_click('span.subsection-name-value')
+    world.css_click('span.subsection-name-value')
 
 
 @step('I see the complete subsection name with a quote in the editor$')
 def i_see_complete_subsection_name_with_quote_in_editor(step):
     css = '.subsection-display-name-input'
-    assert world.browser.is_element_present_by_css(css, 5)
-    assert_equal(world.browser.find_by_css(css).value, 'Subsection With "Quote"')
+    assert world.is_css_present(css)
+    assert_equal(world.css_find(css).value, 'Subsection With "Quote"')
 
 
 @step('I have added a new subsection$')
@@ -46,6 +48,17 @@ def i_have_added_a_new_subsection(step):
     add_subsection()
 
 
+@step('I mark it as Homework$')
+def i_mark_it_as_homework(step):
+    world.css_click('a.menu-toggle')
+    world.browser.click_link_by_text('Homework')
+
+
+@step('I see it marked as Homework$')
+def i_see_it_marked__as_homework(step):
+    assert_equal(world.css_find(".status-label").value, 'Homework')
+
+
 ############ ASSERTIONS ###################
 
 
@@ -70,11 +83,12 @@ def the_subsection_does_not_exist(step):
 def save_subsection_name(name):
     name_css = 'input.new-subsection-name-input'
     save_css = 'input.new-subsection-name-save'
-    css_fill(name_css, name)
-    css_click(save_css)
+    world.css_fill(name_css, name)
+    world.css_click(save_css)
+
 
 def see_subsection_name(name):
     css = 'span.subsection-name'
-    assert world.browser.is_element_present_by_css(css)
+    assert world.is_css_present(css)
     css = 'span.subsection-name-value'
-    assert_css_with_text(css, name)
+    assert world.css_has_text(css, name)
diff --git a/cms/djangoapps/contentstore/tests/test_contentstore.py b/cms/djangoapps/contentstore/tests/test_contentstore.py
index edb20561bc..49a609a879 100644
--- a/cms/djangoapps/contentstore/tests/test_contentstore.py
+++ b/cms/djangoapps/contentstore/tests/test_contentstore.py
@@ -25,7 +25,7 @@ from xmodule.modulestore.django import modulestore
 from xmodule.contentstore.django import contentstore
 from xmodule.templates import update_templates
 from xmodule.modulestore.xml_exporter import export_to_xml
-from xmodule.modulestore.xml_importer import import_from_xml
+from xmodule.modulestore.xml_importer import import_from_xml, perform_xlint
 from xmodule.modulestore.inheritance import own_metadata
 
 from xmodule.capa_module import CapaDescriptor
@@ -85,6 +85,43 @@ class ContentStoreToyCourseTest(ModuleStoreTestCase):
     def test_edit_unit_full(self):
         self.check_edit_unit('full')
 
+    def _get_draft_counts(self, item):
+        cnt = 1 if getattr(item, 'is_draft', False) else 0
+        for child in item.get_children():
+            cnt = cnt + self._get_draft_counts(child)
+
+        return cnt
+
+    def test_get_depth_with_drafts(self):
+        import_from_xml(modulestore(), 'common/test/data/', ['simple'])
+
+        course = modulestore('draft').get_item(Location(['i4x', 'edX', 'simple', 
+            'course', '2012_Fall', None]), depth=None)
+
+        # make sure no draft items have been returned
+        num_drafts = self._get_draft_counts(course)
+        self.assertEqual(num_drafts, 0)
+
+        problem = modulestore('draft').get_item(Location(['i4x', 'edX', 'simple', 
+            'problem', 'ps01-simple', None]))
+
+        # put into draft
+        modulestore('draft').clone_item(problem.location, problem.location)
+
+        # make sure we can query that item and verify that it is a draft
+        draft_problem = modulestore('draft').get_item(Location(['i4x', 'edX', 'simple', 
+            'problem', 'ps01-simple', None]))
+        self.assertTrue(getattr(draft_problem,'is_draft', False))
+
+        #now requery with depth
+        course = modulestore('draft').get_item(Location(['i4x', 'edX', 'simple', 
+            'course', '2012_Fall', None]), depth=None)
+
+        # make sure just one draft item have been returned
+        num_drafts = self._get_draft_counts(course)
+        self.assertEqual(num_drafts, 1)       
+
+
     def test_static_tab_reordering(self):
         import_from_xml(modulestore(), 'common/test/data/', ['full'])
 
@@ -123,6 +160,10 @@ class ContentStoreToyCourseTest(ModuleStoreTestCase):
         # check that there's actually content in the 'question' field
         self.assertGreater(len(items[0].question),0)
 
+    def test_xlint_fails(self):
+        err_cnt = perform_xlint('common/test/data', ['full'])
+        self.assertGreater(err_cnt, 0)
+
     def test_delete(self):
         import_from_xml(modulestore(), 'common/test/data/', ['full'])
 
@@ -211,7 +252,11 @@ class ContentStoreToyCourseTest(ModuleStoreTestCase):
             new_loc = descriptor.location._replace(org='MITx', course='999')
             print "Checking {0} should now also be at {1}".format(descriptor.location.url(), new_loc.url())
             resp = self.client.get(reverse('edit_unit', kwargs={'location': new_loc.url()}))
-            self.assertEqual(resp.status_code, 200)    
+            self.assertEqual(resp.status_code, 200)
+
+    def test_bad_contentstore_request(self):
+        resp = self.client.get('http://localhost:8001/c4x/CDX/123123/asset/&images_circuits_Lab7Solution2.png')
+        self.assertEqual(resp.status_code, 400)
 
     def test_delete_course(self):
         import_from_xml(modulestore(), 'common/test/data/', ['full'])
@@ -328,11 +373,11 @@ class ContentStoreToyCourseTest(ModuleStoreTestCase):
         self.assertEqual(wrapper.counter, 4)
 
         # make sure we pre-fetched a known sequential which should be at depth=2
-        self.assertTrue(Location(['i4x', 'edX', 'full', 'sequential', 
+        self.assertTrue(Location(['i4x', 'edX', 'full', 'sequential',
             'Administrivia_and_Circuit_Elements', None]) in course.system.module_data)
 
         # make sure we don't have a specific vertical which should be at depth=3
-        self.assertFalse(Location(['i4x', 'edX', 'full', 'vertical', 'vertical_58', 
+        self.assertFalse(Location(['i4x', 'edX', 'full', 'vertical', 'vertical_58',
             None]) in course.system.module_data)
 
     def test_export_course_with_unknown_metadata(self):
@@ -556,7 +601,7 @@ class ContentStoreTest(ModuleStoreTestCase):
         module_store.update_children(parent.location, parent.children + [new_component_location.url()])
 
         # flush the cache
-        module_store.get_cached_metadata_inheritance_tree(new_component_location, -1)
+        module_store.refresh_cached_metadata_inheritance_tree(new_component_location)
         new_module = module_store.get_item(new_component_location)
 
         # check for grace period definition which should be defined at the course level
@@ -571,7 +616,7 @@ class ContentStoreTest(ModuleStoreTestCase):
         module_store.update_metadata(new_module.location, own_metadata(new_module))
 
         # flush the cache and refetch
-        module_store.get_cached_metadata_inheritance_tree(new_component_location, -1)
+        module_store.refresh_cached_metadata_inheritance_tree(new_component_location)
         new_module = module_store.get_item(new_component_location)
 
         self.assertEqual(timedelta(1), new_module.lms.graceperiod)
diff --git a/cms/djangoapps/contentstore/tests/test_course_settings.py b/cms/djangoapps/contentstore/tests/test_course_settings.py
index 2e7bc5db83..fe90ad18aa 100644
--- a/cms/djangoapps/contentstore/tests/test_course_settings.py
+++ b/cms/djangoapps/contentstore/tests/test_course_settings.py
@@ -1,8 +1,6 @@
 import datetime
 import json
 import copy
-from util import converters
-from util.converters import jsdate_to_time
 
 from django.contrib.auth.models import User
 from django.test.client import Client
@@ -15,69 +13,13 @@ from models.settings.course_details import (CourseDetails,
 from models.settings.course_grading import CourseGradingModel
 from contentstore.utils import get_modulestore
 
-from django.test import TestCase
 from .utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
 from models.settings.course_metadata import CourseMetadata
 from xmodule.modulestore.xml_importer import import_from_xml
 from xmodule.modulestore.django import modulestore
-import time
-
-
-# YYYY-MM-DDThh:mm:ss.s+/-HH:MM
-class ConvertersTestCase(TestCase):
-    @staticmethod
-    def struct_to_datetime(struct_time):
-        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
-            struct_time.tm_mday, struct_time.tm_hour,
-            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
-
-    def compare_dates(self, date1, date2, expected_delta):
-        dt1 = ConvertersTestCase.struct_to_datetime(date1)
-        dt2 = ConvertersTestCase.struct_to_datetime(date2)
-        self.assertEqual(dt1 - dt2, expected_delta, str(date1) + "-"
-            + str(date2) + "!=" + str(expected_delta))
-
-    def test_iso_to_struct(self):
-        '''Test conversion from iso compatible date strings to struct_time'''
-        self.compare_dates(converters.jsdate_to_time("2013-01-01"),
-            converters.jsdate_to_time("2012-12-31"),
-            datetime.timedelta(days=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00"),
-            converters.jsdate_to_time("2012-12-31T23"),
-            datetime.timedelta(hours=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00:00"),
-            converters.jsdate_to_time("2012-12-31T23:59"),
-            datetime.timedelta(minutes=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00:00:00"),
-            converters.jsdate_to_time("2012-12-31T23:59:59"),
-            datetime.timedelta(seconds=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00:00:00Z"),
-            converters.jsdate_to_time("2012-12-31T23:59:59Z"),
-            datetime.timedelta(seconds=1))
-        self.compare_dates(
-            converters.jsdate_to_time("2012-12-31T23:00:01-01:00"),
-            converters.jsdate_to_time("2013-01-01T00:00:00+01:00"),
-            datetime.timedelta(hours=1, seconds=1))
-
-    def test_struct_to_iso(self):
-        '''
-        Test converting time reprs to iso dates
-        '''
-        self.assertEqual(
-            converters.time_to_isodate(
-                time.strptime("2012-12-31T23:59:59Z", "%Y-%m-%dT%H:%M:%SZ")),
-            "2012-12-31T23:59:59Z")
-        self.assertEqual(
-            converters.time_to_isodate(
-                jsdate_to_time("2012-12-31T23:59:59Z")),
-            "2012-12-31T23:59:59Z")
-        self.assertEqual(
-            converters.time_to_isodate(
-                jsdate_to_time("2012-12-31T23:00:01-01:00")),
-            "2013-01-01T00:00:01Z")
-
+from xmodule.fields import Date
 
 class CourseTestCase(ModuleStoreTestCase):
     def setUp(self):
@@ -206,17 +148,24 @@ class CourseDetailsViewTest(CourseTestCase):
         self.assertEqual(details['intro_video'], encoded.get('intro_video', None), context + " intro_video not ==")
         self.assertEqual(details['effort'], encoded['effort'], context + " efforts not ==")
 
+    @staticmethod
+    def struct_to_datetime(struct_time):
+        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
+            struct_time.tm_mday, struct_time.tm_hour,
+            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
+
     def compare_date_fields(self, details, encoded, context, field):
         if details[field] is not None:
+            date = Date()
             if field in encoded and encoded[field] is not None:
-                encoded_encoded = jsdate_to_time(encoded[field])
-                dt1 = ConvertersTestCase.struct_to_datetime(encoded_encoded)
+                encoded_encoded = date.from_json(encoded[field])
+                dt1 = CourseDetailsViewTest.struct_to_datetime(encoded_encoded)
 
                 if isinstance(details[field], datetime.datetime):
                     dt2 = details[field]
                 else:
-                    details_encoded = jsdate_to_time(details[field])
-                    dt2 = ConvertersTestCase.struct_to_datetime(details_encoded)
+                    details_encoded = date.from_json(details[field])
+                    dt2 = CourseDetailsViewTest.struct_to_datetime(details_encoded)
 
                 expected_delta = datetime.timedelta(0)
                 self.assertEqual(dt1 - dt2, expected_delta, str(dt1) + "!=" + str(dt2) + " at " + context)
diff --git a/cms/djangoapps/contentstore/tests/utils.py b/cms/djangoapps/contentstore/tests/utils.py
index b6b8cd5023..bb7ac2bf06 100644
--- a/cms/djangoapps/contentstore/tests/utils.py
+++ b/cms/djangoapps/contentstore/tests/utils.py
@@ -1,3 +1,9 @@
+'''
+Utilities for contentstore tests
+'''
+
+#pylint: disable=W0603
+
 import json
 import copy
 from uuid import uuid4
@@ -17,36 +23,89 @@ class ModuleStoreTestCase(TestCase):
     collection with templates before running the TestCase
     and drops it they are finished. """
 
-    def _pre_setup(self):
-        super(ModuleStoreTestCase, self)._pre_setup()
+    @staticmethod
+    def flush_mongo_except_templates():
+        '''
+        Delete everything in the module store except templates
+        '''
+        modulestore = xmodule.modulestore.django.modulestore()
+
+        # This query means: every item in the collection
+        # that is not a template
+        query = {"_id.course": {"$ne": "templates"}}
+
+        # Remove everything except templates
+        modulestore.collection.remove(query)
+
+    @staticmethod
+    def load_templates_if_necessary():
+        '''
+        Load templates into the modulestore only if they do not already exist.
+        We need the templates, because they are copied to create
+        XModules such as sections and problems
+        '''
+        modulestore = xmodule.modulestore.django.modulestore()
+
+        # Count the number of templates
+        query = {"_id.course": "templates"}
+        num_templates = modulestore.collection.find(query).count()
+
+        if num_templates < 1:
+            update_templates()
+
+    @classmethod
+    def setUpClass(cls):
+        '''
+        Flush the mongo store and set up templates
+        '''
 
         # Use a uuid to differentiate
         # the mongo collections on jenkins.
-        self.orig_MODULESTORE = copy.deepcopy(settings.MODULESTORE)
-        self.test_MODULESTORE = self.orig_MODULESTORE
-        self.test_MODULESTORE['default']['OPTIONS']['collection'] = 'modulestore_%s' % uuid4().hex
-        self.test_MODULESTORE['direct']['OPTIONS']['collection'] = 'modulestore_%s' % uuid4().hex
-        settings.MODULESTORE = self.test_MODULESTORE
-
-        # Flush and initialize the module store
-        # It needs the templates because it creates new records
-        # by cloning from the template.
-        # Note that if your test module gets in some weird state
-        # (though it shouldn't), do this manually
-        # from the bash shell to drop it:
-        # $ mongo test_xmodule --eval "db.dropDatabase()"
+        cls.orig_modulestore = copy.deepcopy(settings.MODULESTORE)
+        test_modulestore = cls.orig_modulestore
+        test_modulestore['default']['OPTIONS']['collection'] = 'modulestore_%s' % uuid4().hex
+        test_modulestore['direct']['OPTIONS']['collection'] = 'modulestore_%s' % uuid4().hex
         xmodule.modulestore.django._MODULESTORES = {}
-        update_templates()
+
+        settings.MODULESTORE = test_modulestore
+
+        TestCase.setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        '''
+        Revert to the old modulestore settings
+        '''
+
+        # Clean up by dropping the collection
+        modulestore = xmodule.modulestore.django.modulestore()
+        modulestore.collection.drop()
+
+        # Restore the original modulestore settings
+        settings.MODULESTORE = cls.orig_modulestore
+
+    def _pre_setup(self):
+        '''
+        Remove everything but the templates before each test
+        '''
+
+        # Flush anything that is not a template
+        ModuleStoreTestCase.flush_mongo_except_templates()
+
+        # Check that we have templates loaded; if not, load them
+        ModuleStoreTestCase.load_templates_if_necessary()
+
+        # Call superclass implementation
+        super(ModuleStoreTestCase, self)._pre_setup()
 
     def _post_teardown(self):
-        # Make sure you flush out the modulestore.
-        # Drop the collection at the end of the test,
-        # otherwise there will be lingering collections leftover
-        # from executing the tests.
-        xmodule.modulestore.django._MODULESTORES = {}
-        xmodule.modulestore.django.modulestore().collection.drop()
-        settings.MODULESTORE = self.orig_MODULESTORE
+        '''
+        Flush everything we created except the templates
+        '''
+        # Flush anything that is not a template
+        ModuleStoreTestCase.flush_mongo_except_templates()
 
+        # Call superclass implementation
         super(ModuleStoreTestCase, self)._post_teardown()
 
 
diff --git a/cms/djangoapps/contentstore/utils.py b/cms/djangoapps/contentstore/utils.py
index 63dfe5bf5f..d38918d6b0 100644
--- a/cms/djangoapps/contentstore/utils.py
+++ b/cms/djangoapps/contentstore/utils.py
@@ -1,11 +1,15 @@
+import logging
 from django.conf import settings
 from xmodule.modulestore import Location
 from xmodule.modulestore.django import modulestore
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from django.core.urlresolvers import reverse
+import copy
 
 DIRECT_ONLY_CATEGORIES = ['course', 'chapter', 'sequential', 'about', 'static_tab', 'course_info']
 
+#In order to instantiate an open ended tab automatically, need to have this data
+OPEN_ENDED_PANEL = {"name" : "Open Ended Panel", "type" : "open_ended"}
 
 def get_modulestore(location):
     """
@@ -137,7 +141,7 @@ def compute_unit_state(unit):
     'private' content is editabled and not visible in the LMS
     """
 
-    if unit.cms.is_draft:
+    if getattr(unit, 'is_draft', False):
         try:
             modulestore('direct').get_item(unit.location)
             return UnitState.draft
@@ -191,3 +195,35 @@ class CoursePageNames:
     SettingsGrading = "settings_grading"
     CourseOutline = "course_index"
     Checklists = "checklists"
+
+def add_open_ended_panel_tab(course):
+    """
+    Used to add the open ended panel tab to a course if it does not exist.
+    @param course: A course object from the modulestore.
+    @return: Boolean indicating whether or not a tab was added and a list of tabs for the course.
+    """
+    #Copy course tabs
+    course_tabs = copy.copy(course.tabs)
+    changed = False
+    #Check to see if open ended panel is defined in the course
+    if OPEN_ENDED_PANEL not in course_tabs:
+        #Add panel to the tabs if it is not defined
+        course_tabs.append(OPEN_ENDED_PANEL)
+        changed = True
+    return changed, course_tabs
+
+def remove_open_ended_panel_tab(course):
+    """
+    Used to remove the open ended panel tab from a course if it exists.
+    @param course: A course object from the modulestore.
+    @return: Boolean indicating whether or not a tab was added and a list of tabs for the course.
+    """
+    #Copy course tabs
+    course_tabs = copy.copy(course.tabs)
+    changed = False
+    #Check to see if open ended panel is defined in the course
+    if OPEN_ENDED_PANEL in course_tabs:
+        #Add panel to the tabs if it is not defined
+        course_tabs = [ct for ct in course_tabs if ct!=OPEN_ENDED_PANEL]
+        changed = True
+    return changed, course_tabs
diff --git a/cms/djangoapps/contentstore/views.py b/cms/djangoapps/contentstore/views.py
index 561708c833..9681f54350 100644
--- a/cms/djangoapps/contentstore/views.py
+++ b/cms/djangoapps/contentstore/views.py
@@ -42,7 +42,7 @@ from xmodule.modulestore.mongo import MongoUsage
 from mitxmako.shortcuts import render_to_response, render_to_string
 from xmodule.modulestore.django import modulestore
 from xmodule_modifiers import replace_static_urls, wrap_xmodule
-from xmodule.exceptions import NotFoundError
+from xmodule.exceptions import NotFoundError, ProcessingError
 from functools import partial
 
 from xmodule.contentstore.django import contentstore
@@ -52,7 +52,8 @@ from auth.authz import is_user_in_course_group_role, get_users_in_course_group_b
 from auth.authz import get_user_by_email, add_user_to_course_group, remove_user_from_course_group
 from auth.authz import INSTRUCTOR_ROLE_NAME, STAFF_ROLE_NAME, create_all_course_groups
 from .utils import get_course_location_for_item, get_lms_link_for_item, compute_unit_state, \
-    get_date_display, UnitState, get_course_for_item, get_url_reverse
+    get_date_display, UnitState, get_course_for_item, get_url_reverse, add_open_ended_panel_tab, \
+    remove_open_ended_panel_tab
 
 from xmodule.modulestore.xml_importer import import_from_xml
 from contentstore.course_info_model import get_course_updates, \
@@ -73,7 +74,8 @@ log = logging.getLogger(__name__)
 
 COMPONENT_TYPES = ['customtag', 'discussion', 'html', 'problem', 'video']
 
-ADVANCED_COMPONENT_TYPES = ['annotatable', 'combinedopenended', 'peergrading']
+OPEN_ENDED_COMPONENT_TYPES = ["combinedopenended", "peergrading"]
+ADVANCED_COMPONENT_TYPES = ['annotatable'] + OPEN_ENDED_COMPONENT_TYPES
 ADVANCED_COMPONENT_CATEGORY = 'advanced'
 ADVANCED_COMPONENT_POLICY_KEY = 'advanced_modules'
 
@@ -188,7 +190,7 @@ def course_index(request, org, course, name):
         'coursename': name
     })
 
-    course = modulestore().get_item(location)
+    course = modulestore().get_item(location, depth=3)
     sections = course.get_children()
 
     return render_to_response('overview.html', {
@@ -208,19 +210,14 @@ def course_index(request, org, course, name):
 @login_required
 def edit_subsection(request, location):
     # check that we have permissions to edit this item
-    if not has_access(request.user, location):
+    course = get_course_for_item(location)
+    if not has_access(request.user, course.location):
         raise PermissionDenied()
 
-    item = modulestore().get_item(location)
+    item = modulestore().get_item(location, depth=1)
 
-    # TODO: we need a smarter way to figure out what course an item is in
-    for course in modulestore().get_courses():
-        if (course.location.org == item.location.org and
-            course.location.course == item.location.course):
-            break
-
-    lms_link = get_lms_link_for_item(location)
-    preview_link = get_lms_link_for_item(location, preview=True)
+    lms_link = get_lms_link_for_item(location, course_id=course.location.course_id)
+    preview_link = get_lms_link_for_item(location, course_id=course.location.course_id, preview=True)
 
     # make sure that location references a 'sequential', otherwise return BadRequest
     if item.location.category != 'sequential':
@@ -277,19 +274,13 @@ def edit_unit(request, location):
 
     id: A Location URL
     """
-    # check that we have permissions to edit this item
-    if not has_access(request.user, location):
+    course = get_course_for_item(location)
+    if not has_access(request.user, course.location):
         raise PermissionDenied()
 
-    item = modulestore().get_item(location)
+    item = modulestore().get_item(location, depth=1)
 
-    # TODO: we need a smarter way to figure out what course an item is in
-    for course in modulestore().get_courses():
-        if (course.location.org == item.location.org and
-            course.location.course == item.location.course):
-            break
-
-    lms_link = get_lms_link_for_item(item.location)
+    lms_link = get_lms_link_for_item(item.location, course_id=course.location.course_id)
 
     component_templates = defaultdict(list)
 
@@ -448,9 +439,16 @@ def preview_dispatch(request, preview_id, location, dispatch=None):
     # Let the module handle the AJAX
     try:
         ajax_return = instance.handle_ajax(dispatch, request.POST)
+
     except NotFoundError:
         log.exception("Module indicating to user that request doesn't exist")
         raise Http404
+
+    except ProcessingError:
+        log.warning("Module raised an error while processing AJAX request",
+                    exc_info=True)
+        return HttpResponseBadRequest()
+
     except:
         log.exception("error processing ajax call")
         raise
@@ -1273,15 +1271,48 @@ def course_advanced_updates(request, org, course, name):
     location = get_location_and_verify_access(request, org, course, name)
 
     real_method = get_request_method(request)
-        
+
     if real_method == 'GET':
         return HttpResponse(json.dumps(CourseMetadata.fetch(location)), mimetype="application/json")
     elif real_method == 'DELETE':
-        return HttpResponse(json.dumps(CourseMetadata.delete_key(location, json.loads(request.body))), mimetype="application/json")
+        return HttpResponse(json.dumps(CourseMetadata.delete_key(location, json.loads(request.body))),
+                            mimetype="application/json")
     elif real_method == 'POST' or real_method == 'PUT':
         # NOTE: request.POST is messed up because expect_json cloned_request.POST.copy() is creating a defective entry w/ the whole payload as the key
-        return HttpResponse(json.dumps(CourseMetadata.update_from_json(location, json.loads(request.body))), mimetype="application/json")
-
+        request_body = json.loads(request.body)
+        #Whether or not to filter the tabs key out of the settings metadata
+        filter_tabs = True
+        #Check to see if the user instantiated any advanced components.  This is a hack to add the open ended panel tab
+        #to a course automatically if the user has indicated that they want to edit the combinedopenended or peergrading
+        #module, and to remove it if they have removed the open ended elements.
+        if ADVANCED_COMPONENT_POLICY_KEY in request_body:
+            #Check to see if the user instantiated any open ended components
+            found_oe_type = False
+            #Get the course so that we can scrape current tabs
+            course_module = modulestore().get_item(location)
+            for oe_type in OPEN_ENDED_COMPONENT_TYPES:
+                if oe_type in request_body[ADVANCED_COMPONENT_POLICY_KEY]:
+                    #Add an open ended tab to the course if needed
+                    changed, new_tabs = add_open_ended_panel_tab(course_module)
+                    #If a tab has been added to the course, then send the metadata along to CourseMetadata.update_from_json
+                    if changed:
+                        request_body.update({'tabs': new_tabs})
+                        #Indicate that tabs should not be filtered out of the metadata
+                        filter_tabs = False
+                    #Set this flag to avoid the open ended tab removal code below.
+                    found_oe_type = True
+                    break
+            #If we did not find an open ended module type in the advanced settings,
+            # we may need to remove the open ended tab from the course.
+            if not found_oe_type:
+                #Remove open ended tab to the course if needed
+                changed, new_tabs = remove_open_ended_panel_tab(course_module)
+                if changed:
+                    request_body.update({'tabs': new_tabs})
+                    #Indicate that tabs should not be filtered out of the metadata
+                    filter_tabs = False
+        response_json = json.dumps(CourseMetadata.update_from_json(location, request_body, filter_tabs=filter_tabs))
+        return HttpResponse(response_json, mimetype="application/json")
 
 @ensure_csrf_cookie
 @login_required
diff --git a/cms/djangoapps/models/settings/course_details.py b/cms/djangoapps/models/settings/course_details.py
index d3cd5fe164..876000c7fe 100644
--- a/cms/djangoapps/models/settings/course_details.py
+++ b/cms/djangoapps/models/settings/course_details.py
@@ -1,4 +1,3 @@
-from xmodule.modulestore.django import modulestore
 from xmodule.modulestore import Location
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.inheritance import own_metadata
@@ -6,9 +5,9 @@ import json
 from json.encoder import JSONEncoder
 import time
 from contentstore.utils import get_modulestore
-from util.converters import jsdate_to_time, time_to_date
 from models.settings import course_grading
 from contentstore.utils import update_item
+from xmodule.fields import Date
 import re
 import logging
 
@@ -81,8 +80,14 @@ class CourseDetails(object):
 
         dirty = False
 
+        # In the descriptor's setter, the date is converted to JSON using Date's to_json method.
+        # Calling to_json on something that is already JSON doesn't work. Since reaching directly
+        # into the model is nasty, convert the JSON Date to a Python date, which is what the
+        # setter expects as input.
+        date = Date()
+
         if 'start_date' in jsondict:
-            converted = jsdate_to_time(jsondict['start_date'])
+            converted = date.from_json(jsondict['start_date'])
         else:
             converted = None
         if converted != descriptor.start:
@@ -90,7 +95,7 @@ class CourseDetails(object):
             descriptor.start = converted
 
         if 'end_date' in jsondict:
-            converted = jsdate_to_time(jsondict['end_date'])
+            converted = date.from_json(jsondict['end_date'])
         else:
             converted = None
 
@@ -99,7 +104,7 @@ class CourseDetails(object):
             descriptor.end = converted
 
         if 'enrollment_start' in jsondict:
-            converted = jsdate_to_time(jsondict['enrollment_start'])
+            converted = date.from_json(jsondict['enrollment_start'])
         else:
             converted = None
 
@@ -108,7 +113,7 @@ class CourseDetails(object):
             descriptor.enrollment_start = converted
 
         if 'enrollment_end' in jsondict:
-            converted = jsdate_to_time(jsondict['enrollment_end'])
+            converted = date.from_json(jsondict['enrollment_end'])
         else:
             converted = None
 
@@ -178,6 +183,6 @@ class CourseSettingsEncoder(json.JSONEncoder):
         elif isinstance(obj, Location):
             return obj.dict()
         elif isinstance(obj, time.struct_time):
-            return time_to_date(obj)
+            return Date().to_json(obj)
         else:
             return JSONEncoder.default(self, obj)
diff --git a/cms/djangoapps/models/settings/course_grading.py b/cms/djangoapps/models/settings/course_grading.py
index b20fb71f66..ee9b4ac0eb 100644
--- a/cms/djangoapps/models/settings/course_grading.py
+++ b/cms/djangoapps/models/settings/course_grading.py
@@ -1,7 +1,5 @@
 from xmodule.modulestore import Location
 from contentstore.utils import get_modulestore
-import re
-from util import converters
 from datetime import timedelta
 
 
diff --git a/cms/djangoapps/models/settings/course_metadata.py b/cms/djangoapps/models/settings/course_metadata.py
index 563dd16524..70f69315ff 100644
--- a/cms/djangoapps/models/settings/course_metadata.py
+++ b/cms/djangoapps/models/settings/course_metadata.py
@@ -4,7 +4,7 @@ from xmodule.x_module import XModuleDescriptor
 from xmodule.modulestore.inheritance import own_metadata
 from xblock.core import Scope
 from xmodule.course_module import CourseDescriptor
-
+import copy
 
 class CourseMetadata(object):
     '''
@@ -39,7 +39,7 @@ class CourseMetadata(object):
         return course
 
     @classmethod
-    def update_from_json(cls, course_location, jsondict):
+    def update_from_json(cls, course_location, jsondict, filter_tabs=True):
         """
         Decode the json into CourseMetadata and save any changed attrs to the db.
 
@@ -48,10 +48,16 @@ class CourseMetadata(object):
         descriptor = get_modulestore(course_location).get_item(course_location)
 
         dirty = False
+		
+        #Copy the filtered list to avoid permanently changing the class attribute
+        filtered_list = copy.copy(cls.FILTERED_LIST)
+        #Don't filter on the tab attribute if filter_tabs is False
+        if not filter_tabs:
+            filtered_list.remove("tabs")
 
         for k, v in jsondict.iteritems():
             # should it be an error if one of the filtered list items is in the payload?
-            if k in cls.FILTERED_LIST:
+            if k in filtered_list:
                 continue
 
             if hasattr(descriptor, k) and getattr(descriptor, k) != v:
diff --git a/cms/envs/common.py b/cms/envs/common.py
index a83f61d8f9..12fa09947a 100644
--- a/cms/envs/common.py
+++ b/cms/envs/common.py
@@ -113,6 +113,7 @@ TEMPLATE_LOADERS = (
 
 MIDDLEWARE_CLASSES = (
     'contentserver.middleware.StaticContentServer',
+    'request_cache.middleware.RequestCache',
     'django.middleware.cache.UpdateCacheMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
diff --git a/cms/envs/dev.py b/cms/envs/dev.py
index 5612db1396..c4465a0e06 100644
--- a/cms/envs/dev.py
+++ b/cms/envs/dev.py
@@ -112,6 +112,10 @@ CACHE_TIMEOUT = 0
 # Dummy secret key for dev
 SECRET_KEY = '85920908f28904ed733fe576320db18cabd7b6cd'
 
+################################ PIPELINE #################################
+
+PIPELINE_SASS_ARGUMENTS = '--debug-info --require {proj_dir}/static/sass/bourbon/lib/bourbon.rb'.format(proj_dir=PROJECT_ROOT)
+
 ################################ DEBUG TOOLBAR #################################
 INSTALLED_APPS += ('debug_toolbar', 'debug_toolbar_mongo')
 MIDDLEWARE_CLASSES += ('django_comment_client.utils.QueryCountDebugMiddleware',
@@ -142,4 +146,4 @@ DEBUG_TOOLBAR_CONFIG = {
 
 # To see stacktraces for MongoDB queries, set this to True.
 # Stacktraces slow down page loads drastically (for pages with lots of queries).
-DEBUG_TOOLBAR_MONGO_STACKTRACES = False
+DEBUG_TOOLBAR_MONGO_STACKTRACES = True
diff --git a/cms/envs/test.py b/cms/envs/test.py
index d7992cb471..59664bfd40 100644
--- a/cms/envs/test.py
+++ b/cms/envs/test.py
@@ -58,6 +58,10 @@ MODULESTORE = {
     'direct': {
         'ENGINE': 'xmodule.modulestore.mongo.MongoModuleStore',
         'OPTIONS': modulestore_options
+    },
+    'draft': {
+        'ENGINE': 'xmodule.modulestore.mongo.DraftMongoModuleStore',
+        'OPTIONS': modulestore_options
     }
 }
 
diff --git a/cms/one_time_startup.py b/cms/one_time_startup.py
index 38a2fef847..6e88fed439 100644
--- a/cms/one_time_startup.py
+++ b/cms/one_time_startup.py
@@ -1,13 +1,15 @@
 from dogapi import dog_http_api, dog_stats_api
 from django.conf import settings
 from xmodule.modulestore.django import modulestore
+from request_cache.middleware import RequestCache
 
 from django.core.cache import get_cache, InvalidCacheBackendError
 
 cache = get_cache('mongo_metadata_inheritance')
 for store_name in settings.MODULESTORE:
     store = modulestore(store_name)
-    store.metadata_inheritance_cache = cache
+    store.metadata_inheritance_cache_subsystem = cache
+    store.request_cache = RequestCache.get_request_cache()
 
 if hasattr(settings, 'DATADOG_API'):
     dog_http_api.api_key = settings.DATADOG_API
diff --git a/cms/static/sass/_base.scss b/cms/static/sass/_base.scss
index 10c046d22a..28415b8e8a 100644
--- a/cms/static/sass/_base.scss
+++ b/cms/static/sass/_base.scss
@@ -660,7 +660,7 @@ hr.divide {
   position: absolute;
   top: 0;
   left: 0;
-  z-index: 99999;
+  z-index: 10000;
   padding: 0 10px;
   border-radius: 3px;
   background: rgba(0, 0, 0, 0.85);
diff --git a/cms/static/sass/elements/_jquery-ui-calendar.scss b/cms/static/sass/elements/_jquery-ui-calendar.scss
index 3d20bde642..d7d7f093e5 100644
--- a/cms/static/sass/elements/_jquery-ui-calendar.scss
+++ b/cms/static/sass/elements/_jquery-ui-calendar.scss
@@ -8,6 +8,7 @@
   font-family: $sans-serif;
   font-size: 12px;
   @include box-shadow(0 5px 10px rgba(0, 0, 0, 0.1));
+  z-index: 100000 !important;
 
   .ui-widget-header {
     background: $darkGrey;
diff --git a/cms/templates/overview.html b/cms/templates/overview.html
index 904f654717..d45a90093e 100644
--- a/cms/templates/overview.html
+++ b/cms/templates/overview.html
@@ -200,7 +200,7 @@
                     </a>
                   </div>
 
-                  <div class="gradable-status" data-initial-status="${subsection.lms.format if section.lms.format is not None else 'Not Graded'}">
+                  <div class="gradable-status" data-initial-status="${subsection.lms.format if subsection.lms.format is not None else 'Not Graded'}">
                   </div>
 
                   <div class="item-actions">
diff --git a/cms/xmodule_namespace.py b/cms/xmodule_namespace.py
index cad3110574..c9bb8f4c6e 100644
--- a/cms/xmodule_namespace.py
+++ b/cms/xmodule_namespace.py
@@ -40,7 +40,6 @@ class CmsNamespace(Namespace):
     """
     Namespace with fields common to all blocks in Studio
     """
-    is_draft = Boolean(help="Whether this module is a draft", default=False, scope=Scope.settings)
     published_date = DateTuple(help="Date when the module was published", scope=Scope.settings)
     published_by = String(help="Id of the user who published this module", scope=Scope.settings)
     empty = StringyBoolean(help="Whether this is an empty template", scope=Scope.settings, default=False)
diff --git a/common/djangoapps/contentserver/middleware.py b/common/djangoapps/contentserver/middleware.py
index c5e887801e..8e9e70046d 100644
--- a/common/djangoapps/contentserver/middleware.py
+++ b/common/djangoapps/contentserver/middleware.py
@@ -5,6 +5,7 @@ from django.http import HttpResponse, Http404, HttpResponseNotModified
 
 from xmodule.contentstore.django import contentstore
 from xmodule.contentstore.content import StaticContent, XASSET_LOCATION_TAG
+from xmodule.modulestore import InvalidLocationError
 from cache_toolbox.core import get_cached_content, set_cached_content
 from xmodule.exceptions import NotFoundError
 
@@ -13,7 +14,14 @@ class StaticContentServer(object):
     def process_request(self, request):
         # look to see if the request is prefixed with 'c4x' tag
         if request.path.startswith('/' + XASSET_LOCATION_TAG + '/'):
-            loc = StaticContent.get_location_from_path(request.path)
+            try:
+                loc = StaticContent.get_location_from_path(request.path)
+            except InvalidLocationError:
+                # return a 'Bad Request' to browser as we have a malformed Location
+                response = HttpResponse()
+                response.status_code = 400
+                return response     
+
             # first look in our cache so we don't have to round-trip to the DB
             content = get_cached_content(loc)
             if content is None:
diff --git a/common/djangoapps/request_cache/__init__.py b/common/djangoapps/request_cache/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/common/djangoapps/request_cache/middleware.py b/common/djangoapps/request_cache/middleware.py
new file mode 100644
index 0000000000..9d3dffdf27
--- /dev/null
+++ b/common/djangoapps/request_cache/middleware.py
@@ -0,0 +1,20 @@
+import threading
+
+_request_cache_threadlocal = threading.local()
+_request_cache_threadlocal.data = {}
+
+class RequestCache(object):
+    @classmethod
+    def get_request_cache(cls):
+        return _request_cache_threadlocal
+            
+    def clear_request_cache(self):
+        _request_cache_threadlocal.data = {}
+
+    def process_request(self, request):
+        self.clear_request_cache()
+        return None
+
+    def process_response(self, request, response):
+        self.clear_request_cache()
+        return response
\ No newline at end of file
diff --git a/common/djangoapps/student/views.py b/common/djangoapps/student/views.py
index 5dbaf5d2c2..8267816e2c 100644
--- a/common/djangoapps/student/views.py
+++ b/common/djangoapps/student/views.py
@@ -325,7 +325,12 @@ def change_enrollment(request):
                               "course:{0}".format(course_num),
                               "run:{0}".format(run)])
 
-        enrollment, created = CourseEnrollment.objects.get_or_create(user=user, course_id=course.id)
+        try:
+            enrollment, created = CourseEnrollment.objects.get_or_create(user=user, course_id=course.id)
+        except IntegrityError:
+            # If we've already created this enrollment in a separate transaction,
+            # then just continue
+            pass
         return {'success': True}
 
     elif action == "unenroll":
@@ -369,14 +374,14 @@ def login_user(request, error=""):
     try:
         user = User.objects.get(email=email)
     except User.DoesNotExist:
-        log.warning("Login failed - Unknown user email: {0}".format(email))
+        log.warning(u"Login failed - Unknown user email: {0}".format(email))
         return HttpResponse(json.dumps({'success': False,
                                         'value': 'Email or password is incorrect.'}))  # TODO: User error message
 
     username = user.username
     user = authenticate(username=username, password=password)
     if user is None:
-        log.warning("Login failed - password for {0} is invalid".format(email))
+        log.warning(u"Login failed - password for {0} is invalid".format(email))
         return HttpResponse(json.dumps({'success': False,
                                         'value': 'Email or password is incorrect.'}))
 
@@ -392,7 +397,7 @@ def login_user(request, error=""):
             log.critical("Login failed - Could not create session. Is memcached running?")
             log.exception(e)
 
-        log.info("Login success - {0} ({1})".format(username, email))
+        log.info(u"Login success - {0} ({1})".format(username, email))
 
         try_change_enrollment(request)
 
@@ -400,7 +405,7 @@ def login_user(request, error=""):
 
         return HttpResponse(json.dumps({'success': True}))
 
-    log.warning("Login failed - Account not active for user {0}, resending activation".format(username))
+    log.warning(u"Login failed - Account not active for user {0}, resending activation".format(username))
 
     reactivation_email_for_user(user)
     not_activated_msg = "This account has not been activated. We have " + \
diff --git a/common/djangoapps/terrain/course_helpers.py b/common/djangoapps/terrain/course_helpers.py
new file mode 100644
index 0000000000..f0df456c80
--- /dev/null
+++ b/common/djangoapps/terrain/course_helpers.py
@@ -0,0 +1,140 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
+from lettuce import world, step
+from .factories import *
+from django.conf import settings
+from django.http import HttpRequest
+from django.contrib.auth.models import User
+from django.contrib.auth import authenticate, login
+from django.contrib.auth.middleware import AuthenticationMiddleware
+from django.contrib.sessions.middleware import SessionMiddleware
+from student.models import CourseEnrollment
+from xmodule.modulestore.django import _MODULESTORES, modulestore
+from xmodule.templates import update_templates
+from bs4 import BeautifulSoup
+import os.path
+from urllib import quote_plus
+from lettuce.django import django_url
+
+
+@world.absorb
+def create_user(uname):
+
+    # If the user already exists, don't try to create it again
+    if len(User.objects.filter(username=uname)) > 0:
+        return
+
+    portal_user = UserFactory.build(username=uname, email=uname + '@edx.org')
+    portal_user.set_password('test')
+    portal_user.save()
+
+    registration = world.RegistrationFactory(user=portal_user)
+    registration.register(portal_user)
+    registration.activate()
+
+    user_profile = world.UserProfileFactory(user=portal_user)
+
+
+@world.absorb
+def log_in(username, password):
+    '''
+    Log the user in programatically
+    '''
+
+    # Authenticate the user
+    user = authenticate(username=username, password=password)
+    assert(user is not None and user.is_active)
+
+    # Send a fake HttpRequest to log the user in
+    # We need to process the request using
+    # Session middleware and Authentication middleware
+    # to ensure that session state can be stored
+    request = HttpRequest()
+    SessionMiddleware().process_request(request)
+    AuthenticationMiddleware().process_request(request)
+    login(request, user)
+
+    # Save the session
+    request.session.save()
+
+    # Retrieve the sessionid and add it to the browser's cookies
+    cookie_dict = {settings.SESSION_COOKIE_NAME: request.session.session_key}
+    try:
+        world.browser.cookies.add(cookie_dict)
+
+    # WebDriver has an issue where we cannot set cookies
+    # before we make a GET request, so if we get an error,
+    # we load the '/' page and try again
+    except:
+        world.browser.visit(django_url('/'))
+        world.browser.cookies.add(cookie_dict)
+
+
+@world.absorb
+def register_by_course_id(course_id, is_staff=False):
+    create_user('robot')
+    u = User.objects.get(username='robot')
+    if is_staff:
+        u.is_staff = True
+        u.save()
+    CourseEnrollment.objects.get_or_create(user=u, course_id=course_id)
+
+
+
+@world.absorb
+def save_the_course_content(path='/tmp'):
+    html = world.browser.html.encode('ascii', 'ignore')
+    soup = BeautifulSoup(html)
+
+    # get rid of the header, we only want to compare the body
+    soup.head.decompose()
+
+    # for now, remove the data-id attributes, because they are
+    # causing mismatches between cms-master and master
+    for item in soup.find_all(attrs={'data-id': re.compile('.*')}):
+        del item['data-id']
+
+    # we also need to remove them from unrendered problems,
+    # where they are contained in the text of divs instead of
+    # in attributes of tags
+    # Be careful of whether or not it was the last attribute
+    # and needs a trailing space
+    for item in soup.find_all(text=re.compile(' data-id=".*?" ')):
+        s = unicode(item.string)
+        item.string.replace_with(re.sub(' data-id=".*?" ', ' ', s))
+
+    for item in soup.find_all(text=re.compile(' data-id=".*?"')):
+        s = unicode(item.string)
+        item.string.replace_with(re.sub(' data-id=".*?"', ' ', s))
+
+    # prettify the html so it will compare better, with
+    # each HTML tag on its own line
+    output = soup.prettify()
+
+    # use string slicing to grab everything after 'courseware/' in the URL
+    u = world.browser.url
+    section_url = u[u.find('courseware/') + 11:]
+
+
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+    filename = '%s.html' % (quote_plus(section_url))
+    f = open('%s/%s' % (path, filename), 'w')
+    f.write(output)
+    f.close
+
+
+@world.absorb
+def clear_courses():
+    # Flush and initialize the module store
+    # It needs the templates because it creates new records
+    # by cloning from the template.
+    # Note that if your test module gets in some weird state
+    # (though it shouldn't), do this manually
+    # from the bash shell to drop it:
+    # $ mongo test_xmodule --eval "db.dropDatabase()"
+    _MODULESTORES = {}
+    modulestore().collection.drop()
+    update_templates()
diff --git a/common/djangoapps/terrain/steps.py b/common/djangoapps/terrain/steps.py
index 3bc838a6af..a8a32db173 100644
--- a/common/djangoapps/terrain/steps.py
+++ b/common/djangoapps/terrain/steps.py
@@ -1,20 +1,12 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
-from .factories import *
+from .course_helpers import *
+from .ui_helpers import *
 from lettuce.django import django_url
-from django.conf import settings
-from django.http import HttpRequest
-from django.contrib.auth.models import User
-from django.contrib.auth import authenticate, login
-from django.contrib.auth.middleware import AuthenticationMiddleware
-from django.contrib.sessions.middleware import SessionMiddleware
-from student.models import CourseEnrollment
-from urllib import quote_plus
-from nose.tools import assert_equals
-from bs4 import BeautifulSoup
+from nose.tools import assert_equals, assert_in
 import time
-import re
-import os.path
-from selenium.common.exceptions import WebDriverException
 
 from logging import getLogger
 logger = getLogger(__name__)
@@ -22,7 +14,7 @@ logger = getLogger(__name__)
 
 @step(u'I wait (?:for )?"(\d+)" seconds?$')
 def wait(step, seconds):
-    time.sleep(float(seconds))
+    world.wait(seconds)
 
 
 @step('I reload the page$')
@@ -37,42 +29,42 @@ def browser_back(step):
 
 @step('I (?:visit|access|open) the homepage$')
 def i_visit_the_homepage(step):
-    world.browser.visit(django_url('/'))
-    assert world.browser.is_element_present_by_css('header.global', 10)
+    world.visit('/')
+    assert world.is_css_present('header.global')
 
 
 @step(u'I (?:visit|access|open) the dashboard$')
 def i_visit_the_dashboard(step):
-    world.browser.visit(django_url('/dashboard'))
-    assert world.browser.is_element_present_by_css('section.container.dashboard', 5)
+    world.visit('/dashboard')
+    assert world.is_css_present('section.container.dashboard')
 
 
 @step('I should be on the dashboard page$')
 def i_should_be_on_the_dashboard(step):
-    assert world.browser.is_element_present_by_css('section.container.dashboard', 5)
+    assert world.is_css_present('section.container.dashboard')
     assert world.browser.title == 'Dashboard'
 
 
 @step(u'I (?:visit|access|open) the courses page$')
 def i_am_on_the_courses_page(step):
-    world.browser.visit(django_url('/courses'))
-    assert world.browser.is_element_present_by_css('section.courses')
+    world.visit('/courses')
+    assert world.is_css_present('section.courses')
 
 
 @step(u'I press the "([^"]*)" button$')
 def and_i_press_the_button(step, value):
     button_css = 'input[value="%s"]' % value
-    world.browser.find_by_css(button_css).first.click()
+    world.css_click(button_css)
 
 
 @step(u'I click the link with the text "([^"]*)"$')
 def click_the_link_with_the_text_group1(step, linktext):
-    world.browser.find_link_by_text(linktext).first.click()
+    world.click_link(linktext)
 
 
 @step('I should see that the path is "([^"]*)"$')
 def i_should_see_that_the_path_is(step, path):
-    assert world.browser.url == django_url(path)
+    assert world.url_equals(path)
 
 
 @step(u'the page title should be "([^"]*)"$')
@@ -85,10 +77,15 @@ def the_page_title_should_contain(step, title):
     assert(title in world.browser.title)
 
 
+@step('I log in$')
+def i_log_in(step):
+    world.log_in('robot', 'test')
+
+
 @step('I am a logged in user$')
 def i_am_logged_in_user(step):
-    create_user('robot')
-    log_in('robot', 'test')
+    world.create_user('robot')
+    world.log_in('robot', 'test')
 
 
 @step('I am not logged in$')
@@ -98,151 +95,46 @@ def i_am_not_logged_in(step):
 
 @step('I am staff for course "([^"]*)"$')
 def i_am_staff_for_course_by_id(step, course_id):
-    register_by_course_id(course_id, True)
+    world.register_by_course_id(course_id, True)
 
 
-@step('I log in$')
-def i_log_in(step):
-    log_in('robot', 'test')
+@step(r'click (?:the|a) link (?:called|with the text) "([^"]*)"$')
+def click_the_link_called(step, text):
+    world.click_link(text)
+
+
+@step(r'should see that the url is "([^"]*)"$')
+def should_have_the_url(step, url):
+    assert_equals(world.browser.url, url)
+
+
+@step(r'should see (?:the|a) link (?:called|with the text) "([^"]*)"$')
+def should_see_a_link_called(step, text):
+    assert len(world.browser.find_link_by_text(text)) > 0
+
+
+@step(r'should see "(.*)" (?:somewhere|anywhere) in (?:the|this) page')
+def should_see_in_the_page(step, text):
+    assert_in(text, world.css_text('body'))
+
+
+@step('I am logged in$')
+def i_am_logged_in(step):
+    world.create_user('robot')
+    world.log_in('robot', 'test')
+    world.browser.visit(django_url('/'))
+
+
+@step('I am not logged in$')
+def i_am_not_logged_in(step):
+    world.browser.cookies.delete()
 
 
 @step(u'I am an edX user$')
 def i_am_an_edx_user(step):
-    create_user('robot')
-
-#### helper functions
+    world.create_user('robot')
 
 
-@world.absorb
-def scroll_to_bottom():
-    # Maximize the browser
-    world.browser.execute_script("window.scrollTo(0, screen.height);")
-
-
-@world.absorb
-def create_user(uname):
-
-    # If the user already exists, don't try to create it again
-    if len(User.objects.filter(username=uname)) > 0:
-        return
-
-    portal_user = UserFactory.build(username=uname, email=uname + '@edx.org')
-    portal_user.set_password('test')
-    portal_user.save()
-
-    registration = world.RegistrationFactory(user=portal_user)
-    registration.register(portal_user)
-    registration.activate()
-
-    user_profile = world.UserProfileFactory(user=portal_user)
-
-
-@world.absorb
-def log_in(username, password):
-    '''
-    Log the user in programatically
-    '''
-
-    # Authenticate the user
-    user = authenticate(username=username, password=password)
-    assert(user is not None and user.is_active)
-
-    # Send a fake HttpRequest to log the user in
-    # We need to process the request using
-    # Session middleware and Authentication middleware
-    # to ensure that session state can be stored
-    request = HttpRequest()
-    SessionMiddleware().process_request(request)
-    AuthenticationMiddleware().process_request(request)
-    login(request, user)
-
-    # Save the session
-    request.session.save()
-
-    # Retrieve the sessionid and add it to the browser's cookies
-    cookie_dict = {settings.SESSION_COOKIE_NAME: request.session.session_key}
-    try:
-        world.browser.cookies.add(cookie_dict)
-
-    # WebDriver has an issue where we cannot set cookies
-    # before we make a GET request, so if we get an error,
-    # we load the '/' page and try again
-    except:
-        world.browser.visit(django_url('/'))
-        world.browser.cookies.add(cookie_dict)
-
-
-@world.absorb
-def register_by_course_id(course_id, is_staff=False):
-    create_user('robot')
-    u = User.objects.get(username='robot')
-    if is_staff:
-        u.is_staff = True
-        u.save()
-    CourseEnrollment.objects.get_or_create(user=u, course_id=course_id)
-
-
-@world.absorb
-def save_the_html(path='/tmp'):
-    u = world.browser.url
-    html = world.browser.html.encode('ascii', 'ignore')
-    filename = '%s.html' % quote_plus(u)
-    f = open('%s/%s' % (path, filename), 'w')
-    f.write(html)
-    f.close
-
-
-@world.absorb
-def save_the_course_content(path='/tmp'):
-    html = world.browser.html.encode('ascii', 'ignore')
-    soup = BeautifulSoup(html)
-
-    # get rid of the header, we only want to compare the body
-    soup.head.decompose()
-
-    # for now, remove the data-id attributes, because they are
-    # causing mismatches between cms-master and master
-    for item in soup.find_all(attrs={'data-id': re.compile('.*')}):
-        del item['data-id']
-
-    # we also need to remove them from unrendered problems,
-    # where they are contained in the text of divs instead of
-    # in attributes of tags
-    # Be careful of whether or not it was the last attribute
-    # and needs a trailing space
-    for item in soup.find_all(text=re.compile(' data-id=".*?" ')):
-        s = unicode(item.string)
-        item.string.replace_with(re.sub(' data-id=".*?" ', ' ', s))
-
-    for item in soup.find_all(text=re.compile(' data-id=".*?"')):
-        s = unicode(item.string)
-        item.string.replace_with(re.sub(' data-id=".*?"', ' ', s))
-
-    # prettify the html so it will compare better, with
-    # each HTML tag on its own line
-    output = soup.prettify()
-
-    # use string slicing to grab everything after 'courseware/' in the URL
-    u = world.browser.url
-    section_url = u[u.find('courseware/') + 11:]
-
-
-    if not os.path.exists(path):
-        os.makedirs(path)
-
-    filename = '%s.html' % (quote_plus(section_url))
-    f = open('%s/%s' % (path, filename), 'w')
-    f.write(output)
-    f.close
-
-@world.absorb
-def css_click(css_selector):
-    try:
-        world.browser.find_by_css(css_selector).click()
-
-    except WebDriverException:
-        # Occassionally, MathJax or other JavaScript can cover up
-        # an element  temporarily.
-        # If this happens, wait a second, then try again
-        time.sleep(1)
-        world.browser.find_by_css(css_selector).click()
+@step(u'User "([^"]*)" is an edX user$')
+def registered_edx_user(step, uname):
+    world.create_user(uname)
diff --git a/common/djangoapps/terrain/ui_helpers.py b/common/djangoapps/terrain/ui_helpers.py
new file mode 100644
index 0000000000..d4d99e17b5
--- /dev/null
+++ b/common/djangoapps/terrain/ui_helpers.py
@@ -0,0 +1,117 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
+from lettuce import world, step
+import time
+from urllib import quote_plus
+from selenium.common.exceptions import WebDriverException
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from lettuce.django import django_url
+
+
+@world.absorb
+def wait(seconds):
+    time.sleep(float(seconds))
+
+
+@world.absorb
+def wait_for(func):
+    WebDriverWait(world.browser.driver, 5).until(func)
+
+
+@world.absorb
+def visit(url):
+    world.browser.visit(django_url(url))
+
+
+@world.absorb
+def url_equals(url):
+    return world.browser.url == django_url(url)
+
+
+@world.absorb
+def is_css_present(css_selector):
+    return world.browser.is_element_present_by_css(css_selector, wait_time=4)
+
+
+@world.absorb
+def css_has_text(css_selector, text):
+    return world.css_text(css_selector) == text
+
+
+@world.absorb
+def css_find(css):
+    def is_visible(driver):
+        return EC.visibility_of_element_located((By.CSS_SELECTOR, css,))
+
+    world.browser.is_element_present_by_css(css, 5)
+    wait_for(is_visible)
+    return world.browser.find_by_css(css)
+
+
+@world.absorb
+def css_click(css_selector):
+    '''
+    First try to use the regular click method,
+    but if clicking in the middle of an element
+    doesn't work it might be that it thinks some other
+    element is on top of it there so click in the upper left
+    '''
+    try:
+        world.browser.find_by_css(css_selector).click()
+
+    except WebDriverException:
+        # Occassionally, MathJax or other JavaScript can cover up
+        # an element  temporarily.
+        # If this happens, wait a second, then try again
+        time.sleep(1)
+        world.browser.find_by_css(css_selector).click()
+
+
+@world.absorb
+def css_click_at(css, x=10, y=10):
+    '''
+    A method to click at x,y coordinates of the element
+    rather than in the center of the element
+    '''
+    e = css_find(css).first
+    e.action_chains.move_to_element_with_offset(e._element, x, y)
+    e.action_chains.click()
+    e.action_chains.perform()
+
+
+@world.absorb
+def css_fill(css_selector, text):
+    world.browser.find_by_css(css_selector).first.fill(text)
+
+
+@world.absorb
+def click_link(partial_text):
+    world.browser.find_link_by_partial_text(partial_text).first.click()
+
+
+@world.absorb
+def css_text(css_selector):
+
+    # Wait for the css selector to appear
+    if world.is_css_present(css_selector):
+        return world.browser.find_by_css(css_selector).first.text
+    else:
+        return ""
+
+
+@world.absorb
+def css_visible(css_selector):
+    return world.browser.find_by_css(css_selector).visible
+
+
+@world.absorb
+def save_the_html(path='/tmp'):
+    u = world.browser.url
+    html = world.browser.html.encode('ascii', 'ignore')
+    filename = '%s.html' % quote_plus(u)
+    f = open('%s/%s' % (path, filename), 'w')
+    f.write(html)
+    f.close
diff --git a/common/djangoapps/util/converters.py b/common/djangoapps/util/converters.py
deleted file mode 100644
index 212cceb77d..0000000000
--- a/common/djangoapps/util/converters.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import time
-import datetime
-import calendar
-import dateutil.parser
-
-
-def time_to_date(time_obj):
-    """
-    Convert a time.time_struct to a true universal time (can pass to js Date
-    constructor)
-    """
-    return calendar.timegm(time_obj) * 1000
-
-
-def time_to_isodate(source):
-    '''Convert to an iso date'''
-    if isinstance(source, time.struct_time):
-        return time.strftime('%Y-%m-%dT%H:%M:%SZ', source)
-    elif isinstance(source, datetime):
-        return source.isoformat() + 'Z'
-
-
-def jsdate_to_time(field):
-    """
-    Convert a universal time (iso format) or msec since epoch to a time obj
-    """
-    if field is None:
-        return field
-    elif isinstance(field, basestring):
-        d = dateutil.parser.parse(field)
-        return d.utctimetuple()
-    elif isinstance(field, (int, long, float)):
-        return time.gmtime(field / 1000)
-    elif isinstance(field, time.struct_time):
-        return field
-    else:
-        raise ValueError("Couldn't convert %r to time" % field)
diff --git a/common/lib/capa/capa/capa_problem.py b/common/lib/capa/capa/capa_problem.py
index 68f80006f6..6580114bcc 100644
--- a/common/lib/capa/capa/capa_problem.py
+++ b/common/lib/capa/capa/capa_problem.py
@@ -32,6 +32,8 @@ from copy import deepcopy
 
 import chem
 import chem.miller
+import chem.chemcalc
+import chem.chemtools
 import verifiers
 import verifiers.draganddrop
 
@@ -67,6 +69,9 @@ global_context = {'random': random,
                   'scipy': scipy,
                   'calc': calc,
                   'eia': eia,
+                  'chemcalc': chem.chemcalc,
+                  'chemtools': chem.chemtools,
+                  'miller': chem.miller,
                   'draganddrop': verifiers.draganddrop}
 
 # These should be removed from HTML output, including all subelements
@@ -118,7 +123,7 @@ class LoncapaProblem(object):
         #       3. Assign from the OS's random number generator
         self.seed = state.get('seed', seed)
         if self.seed is None:
-            self.seed = struct.unpack('i', os.urandom(4))
+            self.seed = struct.unpack('i', os.urandom(4))[0]
         self.student_answers = state.get('student_answers', {})
         if 'correct_map' in state:
             self.correct_map.set_dict(state['correct_map'])
diff --git a/common/lib/capa/capa/correctmap.py b/common/lib/capa/capa/correctmap.py
index b726f765d8..950cd199fc 100644
--- a/common/lib/capa/capa/correctmap.py
+++ b/common/lib/capa/capa/correctmap.py
@@ -80,16 +80,17 @@ class CorrectMap(object):
 
         Special migration case:
             If correct_map is a one-level dict, then convert it to the new dict of dicts format.
-        '''
-        if correct_map and not (type(correct_map[correct_map.keys()[0]]) == dict):
-            # empty current dict
-            self.__init__()
 
-            # create new dict entries
+        '''
+        # empty current dict
+        self.__init__()
+
+        # create new dict entries
+        if correct_map and not isinstance(correct_map.values()[0], dict):
+            # special migration
             for k in correct_map:
-                self.set(k, correct_map[k])
+                self.set(k, correctness=correct_map[k])
         else:
-            self.__init__()
             for k in correct_map:
                 self.set(k, **correct_map[k])
 
diff --git a/common/lib/capa/capa/responsetypes.py b/common/lib/capa/capa/responsetypes.py
index 8ab716735c..5b1b46d858 100644
--- a/common/lib/capa/capa/responsetypes.py
+++ b/common/lib/capa/capa/responsetypes.py
@@ -17,6 +17,7 @@ import logging
 import numbers
 import numpy
 import os
+import sys
 import random
 import re
 import requests
@@ -52,12 +53,17 @@ class LoncapaProblemError(Exception):
 
 class ResponseError(Exception):
     '''
-    Error for failure in processing a response
+    Error for failure in processing a response, including
+    exceptions that occur when executing a custom script.
     '''
     pass
 
 
 class StudentInputError(Exception):
+    '''
+    Error for an invalid student input.
+    For example, submitting a string when the problem expects a number
+    '''
     pass
 
 #-----------------------------------------------------------------------------
@@ -833,7 +839,7 @@ class NumericalResponse(LoncapaResponse):
             import sys
             type, value, traceback = sys.exc_info()
 
-            raise StudentInputError, ("Invalid input: could not interpret '%s' as a number" %
+            raise StudentInputError, ("Could not interpret '%s' as a number" %
                                       cgi.escape(student_answer)), traceback
 
         if correct:
@@ -1072,13 +1078,10 @@ def sympy_check2():
                 correct = self.context['correct']
                 messages = self.context['messages']
                 overall_message = self.context['overall_message']
+
             except Exception as err:
-                print "oops in customresponse (code) error %s" % err
-                print "context = ", self.context
-                print traceback.format_exc()
-                # Notify student
-                raise StudentInputError(
-                    "Error: Problem could not be evaluated with your input")
+                self._handle_exec_exception(err)
+
         else:
             # self.code is not a string; assume its a function
 
@@ -1105,13 +1108,9 @@ def sympy_check2():
                     nargs, args, kwargs))
 
                 ret = fn(*args[:nargs], **kwargs)
+
             except Exception as err:
-                log.error("oops in customresponse (cfn) error %s" % err)
-                # print "context = ",self.context
-                log.error(traceback.format_exc())
-                raise Exception("oops in customresponse (cfn) error %s" % err)
-            log.debug(
-                "[courseware.capa.responsetypes.customresponse.get_score] ret = %s" % ret)
+                self._handle_exec_exception(err)
 
             if type(ret) == dict:
 
@@ -1147,9 +1146,9 @@ def sympy_check2():
                     correct = []
                     messages = []
                     for input_dict in input_list:
-                        correct.append('correct' 
+                        correct.append('correct'
                                 if input_dict['ok'] else 'incorrect')
-                        msg = (self.clean_message_html(input_dict['msg']) 
+                        msg = (self.clean_message_html(input_dict['msg'])
                                 if 'msg' in input_dict else None)
                         messages.append(msg)
 
@@ -1157,7 +1156,7 @@ def sympy_check2():
                 # Raise an exception
                 else:
                     log.error(traceback.format_exc())
-                    raise Exception(
+                    raise ResponseError(
                         "CustomResponse: check function returned an invalid dict")
 
             # The check function can return a boolean value,
@@ -1174,7 +1173,7 @@ def sympy_check2():
         correct_map.set_overall_message(overall_message)
 
         for k in range(len(idset)):
-            npoints = (self.maxpoints[idset[k]] 
+            npoints = (self.maxpoints[idset[k]]
                     if correct[k] == 'correct' else 0)
             correct_map.set(idset[k], correct[k], msg=messages[k],
                             npoints=npoints)
@@ -1227,6 +1226,22 @@ def sympy_check2():
             return {self.answer_ids[0]: self.expect}
         return self.default_answer_map
 
+    def _handle_exec_exception(self, err):
+        '''
+        Handle an exception raised during the execution of
+        custom Python code.
+
+        Raises a ResponseError
+        '''
+
+        # Log the error if we are debugging
+        msg = 'Error occurred while evaluating CustomResponse'
+        log.warning(msg, exc_info=True)
+
+        # Notify student with a student input error
+        _, _, traceback_obj = sys.exc_info()
+        raise ResponseError, err.message, traceback_obj
+
 #-----------------------------------------------------------------------------
 
 
@@ -1901,7 +1916,14 @@ class SchematicResponse(LoncapaResponse):
         submission = [json.loads(student_answers[
                                  k]) for k in sorted(self.answer_ids)]
         self.context.update({'submission': submission})
-        exec self.code in global_context, self.context
+
+        try:
+            exec self.code in global_context, self.context
+
+        except Exception as err:
+            _, _, traceback_obj = sys.exc_info()
+            raise ResponseError, ResponseError(err.message), traceback_obj
+
         cmap = CorrectMap()
         cmap.set_dict(dict(zip(sorted(
             self.answer_ids), self.context['correct'])))
@@ -1961,9 +1983,10 @@ class ImageResponse(LoncapaResponse):
         self.ielements = self.inputfields
         self.answer_ids = [ie.get('id') for ie in self.ielements]
 
+
     def get_score(self, student_answers):
         correct_map = CorrectMap()
-        expectedset = self.get_answers()
+        expectedset = self.get_mapped_answers()
         for aid in self.answer_ids:  # loop through IDs of <imageinput>
         #  fields in our stanza
             given = student_answers[
@@ -2018,11 +2041,42 @@ class ImageResponse(LoncapaResponse):
                             break
         return correct_map
 
-    def get_answers(self):
-        return (
+    def get_mapped_answers(self):
+        '''
+        Returns the internal representation of the answers
+
+        Input:
+            None
+        Returns:
+            tuple (dict, dict) -
+                rectangles (dict) - a map of inputs to the defined rectangle for that input
+                regions (dict) - a map of inputs to the defined region for that input
+        '''
+        answers =  (
             dict([(ie.get('id'), ie.get(
                 'rectangle')) for ie in self.ielements]),
             dict([(ie.get('id'), ie.get('regions')) for ie in self.ielements]))
+        return answers
+
+    def get_answers(self):
+        '''
+        Returns the external representation of the answers
+
+        Input:
+            None
+        Returns:
+            dict (str, (str, str)) - a map of inputs to a tuple of their rectange
+                and their regions
+        '''
+        answers = {}
+        for ie in self.ielements:
+            ie_id = ie.get('id')
+            answers[ie_id] = (ie.get('rectangle'), ie.get('regions'))
+
+        return answers
+            
+
+
 #-----------------------------------------------------------------------------
 
 
@@ -2074,7 +2128,7 @@ class AnnotationResponse(LoncapaResponse):
             option_scoring = dict([(option['id'], {
                     'correctness': choices.get(option['choice']),
                     'points': scoring.get(option['choice'])
-                }) for option in self._find_options(inputfield) ])
+                }) for option in self._find_options(inputfield)])
 
             scoring_map[inputfield.get('id')] = option_scoring
 
@@ -2087,8 +2141,8 @@ class AnnotationResponse(LoncapaResponse):
             correct_option = self._find_option_with_choice(
                 inputfield, 'correct')
             if correct_option is not None:
-                answer_map[inputfield.get(
-                    'id')] = correct_option.get('description')
+                input_id = inputfield.get('id')
+                answer_map[input_id] = correct_option.get('description')
         return answer_map
 
     def _get_max_points(self):
diff --git a/common/lib/capa/capa/templates/choicegroup.html b/common/lib/capa/capa/templates/choicegroup.html
index 758e2ffba1..c9cc3fd28d 100644
--- a/common/lib/capa/capa/templates/choicegroup.html
+++ b/common/lib/capa/capa/templates/choicegroup.html
@@ -17,7 +17,7 @@
 
         % for choice_id, choice_description in choices:
         <label for="input_${id}_${choice_id}"
-            % if input_type == 'radio' and choice_id == value:
+            % if input_type == 'radio' and ( (isinstance(value, basestring) and (choice_id == value))  or  (not isinstance(value, basestring) and choice_id in value) ):
             <% 
                 if status == 'correct':
                     correctness = 'correct'
@@ -30,9 +30,9 @@
             class="choicegroup_${correctness}"
             % endif
             % endif
-            >  
+            >
             <input type="${input_type}" name="input_${id}${name_array_suffix}" id="input_${id}_${choice_id}" value="${choice_id}"
-            % if input_type == 'radio' and choice_id == value:
+            % if input_type == 'radio' and ( (isinstance(value, basestring) and (choice_id == value))  or  (not isinstance(value, basestring) and choice_id in value) ):
             checked="true" 
             % elif input_type != 'radio' and choice_id in value:
             checked="true"
diff --git a/common/lib/capa/capa/tests/test_responsetypes.py b/common/lib/capa/capa/tests/test_responsetypes.py
index 0c007f83b2..bf64d3cc69 100644
--- a/common/lib/capa/capa/tests/test_responsetypes.py
+++ b/common/lib/capa/capa/tests/test_responsetypes.py
@@ -13,6 +13,8 @@ import textwrap
 from . import test_system
 
 import capa.capa_problem as lcp
+from capa.responsetypes import LoncapaProblemError, \
+                            StudentInputError, ResponseError
 from capa.correctmap import CorrectMap
 from capa.util import convert_files_to_filenames
 from capa.xqueue_interface import dateformat
@@ -36,6 +38,10 @@ class ResponseTest(unittest.TestCase):
         correct_map = problem.grade_answers(input_dict)
         self.assertEquals(correct_map.get_correctness('1_2_1'), expected_correctness)
 
+    def assert_answer_format(self, problem):
+        answers = problem.get_question_answers()
+        self.assertTrue(answers['1_2_1'] is not None)
+
     def assert_multiple_grade(self, problem, correct_answers, incorrect_answers):
         for input_str in correct_answers:
             result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
@@ -166,6 +172,13 @@ class ImageResponseTest(ResponseTest):
         incorrect_inputs = ["[0,0]", "[600,300]"]
         self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
 
+    def test_show_answer(self):
+        rectangle_str = "(100,100)-(200,200)"
+        region_str = "[[10,10], [20,10], [20, 30]]"
+
+        problem = self.build_problem(regions=region_str, rectangle=rectangle_str)
+        self.assert_answer_format(problem)
+
 
 class SymbolicResponseTest(unittest.TestCase):
     def test_sr_grade(self):
@@ -853,7 +866,7 @@ class CustomResponseTest(ResponseTest):
         # Message is interpreted as an "overall message"
         self.assertEqual(correct_map.get_overall_message(), 'Message text')
 
-    def test_script_exception(self):
+    def test_script_exception_function(self):
 
         # Construct a script that will raise an exception
         script = textwrap.dedent("""
@@ -864,7 +877,17 @@ class CustomResponseTest(ResponseTest):
         problem = self.build_problem(script=script, cfn="check_func")
 
         # Expect that an exception gets raised when we check the answer
-        with self.assertRaises(Exception):
+        with self.assertRaises(ResponseError):
+            problem.grade_answers({'1_2_1': '42'})
+
+    def test_script_exception_inline(self):
+
+        # Construct a script that will raise an exception
+        script = 'raise Exception("Test")'
+        problem = self.build_problem(answer=script)
+
+        # Expect that an exception gets raised when we check the answer
+        with self.assertRaises(ResponseError):
             problem.grade_answers({'1_2_1': '42'})
 
     def test_invalid_dict_exception(self):
@@ -878,10 +901,70 @@ class CustomResponseTest(ResponseTest):
         problem = self.build_problem(script=script, cfn="check_func")
 
         # Expect that an exception gets raised when we check the answer
-        with self.assertRaises(Exception):
+        with self.assertRaises(ResponseError):
             problem.grade_answers({'1_2_1': '42'})
 
 
+    def test_module_imports_inline(self):
+        '''
+        Check that the correct modules are available to custom
+        response scripts
+        '''
+
+        for module_name in ['random', 'numpy', 'math', 'scipy', 
+                            'calc', 'eia', 'chemcalc', 'chemtools',
+                            'miller', 'draganddrop']:
+
+            # Create a script that checks that the name is defined
+            # If the name is not defined, then the script
+            # will raise an exception
+            script = textwrap.dedent('''
+            correct[0] = 'correct'
+            assert('%s' in globals())''' % module_name)
+             
+            # Create the problem
+            problem = self.build_problem(answer=script)
+
+            # Expect that we can grade an answer without 
+            # getting an exception
+            try:
+                problem.grade_answers({'1_2_1': '42'})
+
+            except ResponseError:
+                self.fail("Could not use name '%s' in custom response" 
+                            % module_name)
+        
+    def test_module_imports_function(self):
+        '''
+        Check that the correct modules are available to custom
+        response scripts
+        '''
+
+        for module_name in ['random', 'numpy', 'math', 'scipy', 
+                            'calc', 'eia', 'chemcalc', 'chemtools',
+                            'miller', 'draganddrop']:
+
+            # Create a script that checks that the name is defined
+            # If the name is not defined, then the script
+            # will raise an exception
+            script = textwrap.dedent('''
+            def check_func(expect, answer_given):
+                assert('%s' in globals())
+                return True''' % module_name)
+             
+            # Create the problem
+            problem = self.build_problem(script=script, cfn="check_func")
+
+            # Expect that we can grade an answer without 
+            # getting an exception
+            try:
+                problem.grade_answers({'1_2_1': '42'})
+
+            except ResponseError:
+                self.fail("Could not use name '%s' in custom response" 
+                            % module_name)
+
+
 class SchematicResponseTest(ResponseTest):
     from response_xml_factory import SchematicResponseXMLFactory
     xml_factory_class = SchematicResponseXMLFactory
@@ -911,6 +994,18 @@ class SchematicResponseTest(ResponseTest):
         # is what we expect)
         self.assertEqual(correct_map.get_correctness('1_2_1'), 'correct')
 
+    def test_script_exception(self):
+
+        # Construct a script that will raise an exception
+        script = "raise Exception('test')"
+        problem = self.build_problem(answer=script)
+
+        # Expect that an exception gets raised when we check the answer
+        with self.assertRaises(ResponseError):
+            submission_dict = {'test': 'test'}
+            input_dict = {'1_2_1': json.dumps(submission_dict)}
+            problem.grade_answers(input_dict)
+
 
 class AnnotationResponseTest(ResponseTest):
     from response_xml_factory import AnnotationResponseXMLFactory
diff --git a/common/lib/xmodule/xmodule/capa_module.py b/common/lib/xmodule/xmodule/capa_module.py
index da8b5b4f96..7ca38ea30a 100644
--- a/common/lib/xmodule/xmodule/capa_module.py
+++ b/common/lib/xmodule/xmodule/capa_module.py
@@ -12,12 +12,13 @@ from lxml import etree
 from pkg_resources import resource_string
 
 from capa.capa_problem import LoncapaProblem
-from capa.responsetypes import StudentInputError
+from capa.responsetypes import StudentInputError, \
+                                ResponseError, LoncapaProblemError
 from capa.util import convert_files_to_filenames
 from .progress import Progress
 from xmodule.x_module import XModule
 from xmodule.raw_module import RawDescriptor
-from xmodule.exceptions import NotFoundError
+from xmodule.exceptions import NotFoundError, ProcessingError
 from xblock.core import Integer, Scope, BlockScope, ModelType, String, Boolean, Object, Float
 from .fields import Timedelta
 
@@ -93,7 +94,7 @@ class CapaFields(object):
     rerandomize = Randomization(help="When to rerandomize the problem", default="always", scope=Scope.settings)
     data = String(help="XML data for the problem", scope=Scope.content)
     correct_map = Object(help="Dictionary with the correctness of current student answers", scope=Scope.student_state, default={})
-    input_state = Object(help="Dictionary for maintaining the state of inputtypes", scope=Scope.student_state, default={})
+    input_state = Object(help="Dictionary for maintaining the state of inputtypes", scope=Scope.student_state)
     student_answers = Object(help="Dictionary with the current student responses", scope=Scope.student_state)
     done = Boolean(help="Whether the student has answered the problem", scope=Scope.student_state)
     display_name = String(help="Display name for this module", scope=Scope.settings)
@@ -150,6 +151,16 @@ class CapaModule(CapaFields, XModule):
             # TODO (vshnayder): move as much as possible of this work and error
             # checking to descriptor load time
             self.lcp = self.new_lcp(self.get_state_for_lcp())
+
+            # At this point, we need to persist the randomization seed
+            # so that when the problem is re-loaded (to check/view/save)
+            # it stays the same.
+            # However, we do not want to write to the database
+            # every time the module is loaded.
+            # So we set the seed ONLY when there is not one set already
+            if self.seed is None:
+                self.seed = self.lcp.seed
+
         except Exception as err:
             msg = 'cannot create LoncapaProblem {loc}: {err}'.format(
                 loc=self.location.url(), err=err)
@@ -454,7 +465,14 @@ class CapaModule(CapaFields, XModule):
             return 'Error'
 
         before = self.get_progress()
-        d = handlers[dispatch](get)
+
+        try:
+            d = handlers[dispatch](get)
+
+        except Exception as err:
+            _, _, traceback_obj = sys.exc_info()
+            raise ProcessingError, err.message, traceback_obj
+
         after = self.get_progress()
         d.update({
             'progress_changed': after != before,
@@ -576,7 +594,7 @@ class CapaModule(CapaFields, XModule):
         # save any state changes that may occur
         self.set_state_from_lcp()
         return response
-        
+
 
     def get_answer(self, get):
         '''
@@ -725,9 +743,24 @@ class CapaModule(CapaFields, XModule):
         try:
             correct_map = self.lcp.grade_answers(answers)
             self.set_state_from_lcp()
-        except StudentInputError as inst:
-            log.exception("StudentInputError in capa_module:problem_check")
-            return {'success': inst.message}
+
+        except (StudentInputError, ResponseError, LoncapaProblemError) as inst:
+            log.warning("StudentInputError in capa_module:problem_check",
+                        exc_info=True)
+
+            # If the user is a staff member, include
+            # the full exception, including traceback,
+            # in the response
+            if self.system.user_is_staff:
+                msg = "Staff debug info: %s" % traceback.format_exc()
+
+            # Otherwise, display just an error message,
+            # without a stack trace
+            else:
+                msg = "Error: %s" % str(inst.message)
+
+            return {'success': msg}
+
         except Exception, err:
             if self.system.DEBUG:
                 msg = "Error checking problem: " + str(err)
@@ -778,7 +811,7 @@ class CapaModule(CapaFields, XModule):
         event_info['answers'] = answers
 
         # Too late. Cannot submit
-        if self.closed() and not self.max_attempts ==0:
+        if self.closed() and not self.max_attempts == 0:
             event_info['failure'] = 'closed'
             self.system.track_function('save_problem_fail', event_info)
             return {'success': False,
@@ -798,7 +831,7 @@ class CapaModule(CapaFields, XModule):
 
         self.system.track_function('save_problem_success', event_info)
         msg = "Your answers have been saved"
-        if not self.max_attempts ==0:
+        if not self.max_attempts == 0:
             msg += " but not graded. Hit 'Check' to grade them."
         return {'success': True,
                 'msg': msg}
diff --git a/common/lib/xmodule/xmodule/combined_open_ended_module.py b/common/lib/xmodule/xmodule/combined_open_ended_module.py
index 48fbfcced1..f45ad39e35 100644
--- a/common/lib/xmodule/xmodule/combined_open_ended_module.py
+++ b/common/lib/xmodule/xmodule/combined_open_ended_module.py
@@ -6,14 +6,15 @@ from pkg_resources import resource_string
 
 from xmodule.raw_module import RawDescriptor
 from .x_module import XModule
-from xblock.core import Integer, Scope, BlockScope, ModelType, String, Boolean, Object, Float, List
+from xblock.core import Integer, Scope, BlockScope, ModelType, String, Boolean, Object, List
 from xmodule.open_ended_grading_classes.combined_open_ended_modulev1 import CombinedOpenEndedV1Module, CombinedOpenEndedV1Descriptor
 from collections import namedtuple
+from xmodule.open_ended_grading_classes.xblock_field_types import StringyFloat
 
 log = logging.getLogger("mitx.courseware")
 
 V1_SETTINGS_ATTRIBUTES = ["display_name", "attempts", "is_graded", "accept_file_upload",
-                          "skip_spelling_checks", "due", "graceperiod", "max_score"]
+                          "skip_spelling_checks", "due", "graceperiod"]
 
 V1_STUDENT_ATTRIBUTES = ["current_task_number", "task_states", "state",
                          "student_attempts", "ready_to_reset"]
@@ -66,9 +67,9 @@ class CombinedOpenEndedFields(object):
     due = String(help="Date that this problem is due by", default=None, scope=Scope.settings)
     graceperiod = String(help="Amount of time after the due date that submissions will be accepted", default=None,
                          scope=Scope.settings)
-    max_score = Integer(help="Maximum score for the problem.", default=1, scope=Scope.settings)
     version = VersionInteger(help="Current version number", default=DEFAULT_VERSION, scope=Scope.settings)
     data = String(help="XML data for the problem", scope=Scope.content)
+    weight = StringyFloat(help="How much to weight this problem by", scope=Scope.settings)
 
 
 class CombinedOpenEndedModule(CombinedOpenEndedFields, XModule):
@@ -118,7 +119,7 @@ class CombinedOpenEndedModule(CombinedOpenEndedFields, XModule):
         Definition file should have one or many task blocks, a rubric block, and a prompt block:
 
         Sample file:
-        <combinedopenended attempts="10000" max_score="1">
+        <combinedopenended attempts="10000">
             <rubric>
                 Blah blah rubric.
             </rubric>
@@ -190,8 +191,8 @@ class CombinedOpenEndedModule(CombinedOpenEndedFields, XModule):
     def get_score(self):
         return self.child_module.get_score()
 
-    #def max_score(self):
-    #    return self.child_module.max_score()
+    def max_score(self):
+        return self.child_module.max_score()
 
     def get_progress(self):
         return self.child_module.get_progress()
diff --git a/common/lib/xmodule/xmodule/course_module.py b/common/lib/xmodule/xmodule/course_module.py
index 7999f8d6da..6f3b8e94c9 100644
--- a/common/lib/xmodule/xmodule/course_module.py
+++ b/common/lib/xmodule/xmodule/course_module.py
@@ -635,8 +635,17 @@ class CourseDescriptor(CourseFields, SequenceDescriptor):
 
     @property
     def start_date_text(self):
+        def try_parse_iso_8601(text):
+            try:
+                result = datetime.strptime(text, "%Y-%m-%dT%H:%M")
+                result = result.strftime("%b %d, %Y")
+            except ValueError:
+                result = text.title()
+
+            return result
+
         if isinstance(self.advertised_start, basestring):
-            return self.advertised_start
+            return try_parse_iso_8601(self.advertised_start)
         elif self.advertised_start is None and self.start is None:
             return 'TBD'
         else:
diff --git a/common/lib/xmodule/xmodule/exceptions.py b/common/lib/xmodule/xmodule/exceptions.py
index 3db5ceccde..d38fbb12bb 100644
--- a/common/lib/xmodule/xmodule/exceptions.py
+++ b/common/lib/xmodule/xmodule/exceptions.py
@@ -1,6 +1,12 @@
 class InvalidDefinitionError(Exception):
     pass
 
-
 class NotFoundError(Exception):
     pass
+
+class ProcessingError(Exception):
+    '''
+    An error occurred while processing a request to the XModule.
+    For example: if an exception occurs while checking a capa problem.
+    '''
+    pass
diff --git a/common/lib/xmodule/xmodule/fields.py b/common/lib/xmodule/xmodule/fields.py
index 0abe850d68..ea857933fc 100644
--- a/common/lib/xmodule/xmodule/fields.py
+++ b/common/lib/xmodule/xmodule/fields.py
@@ -14,7 +14,6 @@ class Date(ModelType):
     '''
     Date fields know how to parse and produce json (iso) compatible formats.
     '''
-    # NB: these are copies of util.converters.*
     def from_json(self, field):
         """
         Parse an optional metadata key containing a time: if present, complain
diff --git a/common/lib/xmodule/xmodule/graders.py b/common/lib/xmodule/xmodule/graders.py
index 35318f4f1e..862da791c0 100644
--- a/common/lib/xmodule/xmodule/graders.py
+++ b/common/lib/xmodule/xmodule/graders.py
@@ -45,8 +45,9 @@ def invalid_args(func, argdict):
     Given a function and a dictionary of arguments, returns a set of arguments
     from argdict that aren't accepted by func
     """
-    args, varargs, keywords, defaults = inspect.getargspec(func)
-    if keywords: return set()  # All accepted
+    args, _, keywords, _ = inspect.getargspec(func)
+    if keywords:
+        return set()  # All accepted
     return set(argdict) - set(args)
 
 
@@ -119,7 +120,7 @@ class CourseGrader(object):
     that has the matching section format.
 
     The grader outputs a dictionary with the following keys:
-    - percent: Contaisn a float value, which is the final percentage score for the student.
+    - percent: Contains a float value, which is the final percentage score for the student.
     - section_breakdown: This is a list of dictionaries which provide details on sections
     that were graded. These are used for display in a graph or chart. The format for a
     section_breakdown dictionary is explained below.
@@ -150,6 +151,7 @@ class CourseGrader(object):
 
     @abc.abstractmethod
     def grade(self, grade_sheet, generate_random_scores=False):
+        '''Given a grade sheet, return a dict containing grading information'''
         raise NotImplementedError
 
 
@@ -158,7 +160,10 @@ class WeightedSubsectionsGrader(CourseGrader):
     This grader takes a list of tuples containing (grader, category_name, weight) and computes
     a final grade by totalling the contribution of each sub grader and multiplying it by the
     given weight. For example, the sections may be
-    [ (homeworkGrader, "Homework", 0.15), (labGrader, "Labs", 0.15), (midtermGrader, "Midterm", 0.30), (finalGrader, "Final", 0.40) ]
+
+    [ (homeworkGrader, "Homework", 0.15), (labGrader, "Labs", 0.15), (midtermGrader, "Midterm", 0.30),
+      (finalGrader, "Final", 0.40) ]
+
     All items in section_breakdown for each subgrader will be combined. A grade_breakdown will be
     composed using the score from each grader.
 
@@ -177,12 +182,12 @@ class WeightedSubsectionsGrader(CourseGrader):
         for subgrader, category, weight in self.sections:
             subgrade_result = subgrader.grade(grade_sheet, generate_random_scores)
 
-            weightedPercent = subgrade_result['percent'] * weight
-            section_detail = "{0} = {1:.1%} of a possible {2:.0%}".format(category, weightedPercent, weight)
+            weighted_percent = subgrade_result['percent'] * weight
+            section_detail = "{0} = {1:.1%} of a possible {2:.0%}".format(category, weighted_percent, weight)
 
-            total_percent += weightedPercent
+            total_percent += weighted_percent
             section_breakdown += subgrade_result['section_breakdown']
-            grade_breakdown.append({'percent': weightedPercent, 'detail': section_detail, 'category': category})
+            grade_breakdown.append({'percent': weighted_percent, 'detail': section_detail, 'category': category})
 
         return {'percent': total_percent,
                 'section_breakdown': section_breakdown,
@@ -203,32 +208,33 @@ class SingleSectionGrader(CourseGrader):
         self.category = category or name
 
     def grade(self, grade_sheet, generate_random_scores=False):
-        foundScore = None
+        found_score = None
         if self.type in grade_sheet:
             for score in grade_sheet[self.type]:
                 if score.section == self.name:
-                    foundScore = score
+                    found_score = score
                     break
 
-        if foundScore or generate_random_scores:
+        if found_score or generate_random_scores:
             if generate_random_scores:  	# for debugging!
                 earned = random.randint(2, 15)
                 possible = random.randint(earned, 15)
             else:   # We found the score
-                earned = foundScore.earned
-                possible = foundScore.possible
+                earned = found_score.earned
+                possible = found_score.possible
 
             percent = earned / float(possible)
             detail = "{name} - {percent:.0%} ({earned:.3n}/{possible:.3n})".format(name=self.name,
-                                                                        percent=percent,
-                                                                        earned=float(earned),
-                                                                        possible=float(possible))
+                                                                                   percent=percent,
+                                                                                   earned=float(earned),
+                                                                                   possible=float(possible))
 
         else:
             percent = 0.0
             detail = "{name} - 0% (?/?)".format(name=self.name)
 
-        breakdown = [{'percent': percent, 'label': self.short_label, 'detail': detail, 'category': self.category, 'prominent': True}]
+        breakdown = [{'percent': percent, 'label': self.short_label,
+                      'detail': detail, 'category': self.category, 'prominent': True}]
 
         return {'percent': percent,
                 'section_breakdown': breakdown,
@@ -250,6 +256,13 @@ class AssignmentFormatGrader(CourseGrader):
     show_only_average is to suppress the display of each assignment in this grader and instead
     only show the total score of this grader in the breakdown.
 
+    hide_average is to suppress the display of the total score in this grader and instead
+    only show each assignment in this grader in the breakdown.
+
+    If there is only a single assignment in this grader, then it acts like a SingleSectionGrader
+    and returns only one entry for the grader.  Since the assignment and the total are the same,
+    the total is returned but is not labeled as an average.
+
     category should be presentable to the user, but may not appear. When the grade breakdown is
     displayed, scores from the same category will be similar (for example, by color).
 
@@ -263,7 +276,8 @@ class AssignmentFormatGrader(CourseGrader):
     min_count = 2 would produce the labels "Assignment 3", "Assignment 4"
 
     """
-    def __init__(self, type, min_count, drop_count, category=None, section_type=None, short_label=None, show_only_average=False, hide_average=False, starting_index=1):
+    def __init__(self, type, min_count, drop_count, category=None, section_type=None, short_label=None,
+                 show_only_average=False, hide_average=False, starting_index=1):
         self.type = type
         self.min_count = min_count
         self.drop_count = drop_count
@@ -275,7 +289,8 @@ class AssignmentFormatGrader(CourseGrader):
         self.hide_average = hide_average
 
     def grade(self, grade_sheet, generate_random_scores=False):
-        def totalWithDrops(breakdown, drop_count):
+        def total_with_drops(breakdown, drop_count):
+            '''calculates total score for a section while dropping lowest scores'''
             #create an array of tuples with (index, mark), sorted by mark['percent'] descending
             sorted_breakdown = sorted(enumerate(breakdown), key=lambda x: -x[1]['percent'])
             # A list of the indices of the dropped scores
@@ -308,33 +323,50 @@ class AssignmentFormatGrader(CourseGrader):
                     section_name = scores[i].section
 
                 percentage = earned / float(possible)
-                summary = "{section_type} {index} - {name} - {percent:.0%} ({earned:.3n}/{possible:.3n})".format(index=i + self.starting_index,
-                                                                section_type=self.section_type,
-                                                                name=section_name,
-                                                                percent=percentage,
-                                                                earned=float(earned),
-                                                                possible=float(possible))
+                summary_format = "{section_type} {index} - {name} - {percent:.0%} ({earned:.3n}/{possible:.3n})"
+                summary = summary_format.format(index=i + self.starting_index,
+                                                section_type=self.section_type,
+                                                name=section_name,
+                                                percent=percentage,
+                                                earned=float(earned),
+                                                possible=float(possible))
             else:
                 percentage = 0
-                summary = "{section_type} {index} Unreleased - 0% (?/?)".format(index=i + self.starting_index, section_type=self.section_type)
+                summary = "{section_type} {index} Unreleased - 0% (?/?)".format(index=i + self.starting_index,
+                                                                                section_type=self.section_type)
 
-            short_label = "{short_label} {index:02d}".format(index=i + self.starting_index, short_label=self.short_label)
+            short_label = "{short_label} {index:02d}".format(index=i + self.starting_index,
+                                                             short_label=self.short_label)
 
-            breakdown.append({'percent': percentage, 'label': short_label, 'detail': summary, 'category': self.category})
+            breakdown.append({'percent': percentage, 'label': short_label,
+                              'detail': summary, 'category': self.category})
 
-        total_percent, dropped_indices = totalWithDrops(breakdown, self.drop_count)
+        total_percent, dropped_indices = total_with_drops(breakdown, self.drop_count)
 
         for dropped_index in dropped_indices:
-            breakdown[dropped_index]['mark'] = {'detail': "The lowest {drop_count} {section_type} scores are dropped.".format(drop_count=self.drop_count, section_type=self.section_type)}
+            breakdown[dropped_index]['mark'] = {'detail': "The lowest {drop_count} {section_type} scores are dropped."
+                                                .format(drop_count=self.drop_count, section_type=self.section_type)}
 
-        total_detail = "{section_type} Average = {percent:.0%}".format(percent=total_percent, section_type=self.section_type)
-        total_label = "{short_label} Avg".format(short_label=self.short_label)
+        if len(breakdown) == 1:
+            # if there is only one entry in a section, suppress the existing individual entry and the average,
+            # and just display a single entry for the section.  That way it acts automatically like a
+            # SingleSectionGrader.
+            total_detail = "{section_type} = {percent:.0%}".format(percent=total_percent,
+                                                                   section_type=self.section_type)
+            total_label = "{short_label}".format(short_label=self.short_label)
+            breakdown = [{'percent': total_percent, 'label': total_label,
+                          'detail': total_detail, 'category': self.category, 'prominent': True}, ]
+        else:
+            total_detail = "{section_type} Average = {percent:.0%}".format(percent=total_percent,
+                                                                           section_type=self.section_type)
+            total_label = "{short_label} Avg".format(short_label=self.short_label)
 
-        if self.show_only_average:
-            breakdown = []
+            if self.show_only_average:
+                breakdown = []
 
-        if not self.hide_average:
-            breakdown.append({'percent': total_percent, 'label': total_label, 'detail': total_detail, 'category': self.category, 'prominent': True})
+            if not self.hide_average:
+                breakdown.append({'percent': total_percent, 'label': total_label,
+                                  'detail': total_detail, 'category': self.category, 'prominent': True})
 
         return {'percent': total_percent,
                 'section_breakdown': breakdown,
diff --git a/common/lib/xmodule/xmodule/modulestore/__init__.py b/common/lib/xmodule/xmodule/modulestore/__init__.py
index 022e016a58..2593b04472 100644
--- a/common/lib/xmodule/xmodule/modulestore/__init__.py
+++ b/common/lib/xmodule/xmodule/modulestore/__init__.py
@@ -10,6 +10,7 @@ from collections import namedtuple
 
 from .exceptions import InvalidLocationError, InsufficientSpecificationError
 from xmodule.errortracker import ErrorLog, make_error_tracker
+from bson.son import SON
 
 log = logging.getLogger('mitx.' + 'modulestore')
 
@@ -457,3 +458,13 @@ class ModuleStoreBase(ModuleStore):
             if c.id == course_id:
                 return c
         return None
+
+
+def namedtuple_to_son(namedtuple, prefix=''):
+    """
+    Converts a namedtuple into a SON object with the same key order
+    """
+    son = SON()
+    for idx, field_name in enumerate(namedtuple._fields):
+        son[prefix + field_name] = namedtuple[idx]
+    return son
diff --git a/common/lib/xmodule/xmodule/modulestore/draft.py b/common/lib/xmodule/xmodule/modulestore/draft.py
index 71922c08df..cfce5eb7db 100644
--- a/common/lib/xmodule/xmodule/modulestore/draft.py
+++ b/common/lib/xmodule/xmodule/modulestore/draft.py
@@ -1,7 +1,8 @@
 from datetime import datetime
 
-from . import ModuleStoreBase, Location
+from . import ModuleStoreBase, Location, namedtuple_to_son
 from .exceptions import ItemNotFoundError
+import logging
 
 DRAFT = 'draft'
 
@@ -15,11 +16,11 @@ def as_draft(location):
 
 def wrap_draft(item):
     """
-    Sets `item.cms.is_draft` to `True` if the item is a
+    Sets `item.is_draft` to `True` if the item is a
     draft, and `False` otherwise. Sets the item's location to the
     non-draft location in either case
     """
-    item.cms.is_draft = item.location.revision == DRAFT
+    setattr(item, 'is_draft', item.location.revision == DRAFT)
     item.location = item.location._replace(revision=None)
     return item
 
@@ -55,11 +56,10 @@ class DraftModuleStore(ModuleStoreBase):
             get_children() to cache. None indicates to cache all descendents
         """
 
-        # cdodge: we're forcing depth=0 here as the Draft store is not handling caching well
         try:
-            return wrap_draft(super(DraftModuleStore, self).get_item(as_draft(location), depth=0))
+            return wrap_draft(super(DraftModuleStore, self).get_item(as_draft(location), depth=depth))
         except ItemNotFoundError:
-            return wrap_draft(super(DraftModuleStore, self).get_item(location, depth=0))
+            return wrap_draft(super(DraftModuleStore, self).get_item(location, depth=depth))
 
     def get_instance(self, course_id, location, depth=0):
         """
@@ -67,11 +67,10 @@ class DraftModuleStore(ModuleStoreBase):
         TODO (vshnayder): this may want to live outside the modulestore eventually
         """
 
-        # cdodge: we're forcing depth=0 here as the Draft store is not handling caching well
         try:
-            return wrap_draft(super(DraftModuleStore, self).get_instance(course_id, as_draft(location), depth=0))
+            return wrap_draft(super(DraftModuleStore, self).get_instance(course_id, as_draft(location), depth=depth))
         except ItemNotFoundError:
-            return wrap_draft(super(DraftModuleStore, self).get_instance(course_id, location, depth=0))
+            return wrap_draft(super(DraftModuleStore, self).get_instance(course_id, location, depth=depth))
 
     def get_items(self, location, course_id=None, depth=0):
         """
@@ -88,9 +87,8 @@ class DraftModuleStore(ModuleStoreBase):
         """
         draft_loc = as_draft(location)
 
-        # cdodge: we're forcing depth=0 here as the Draft store is not handling caching well
-        draft_items = super(DraftModuleStore, self).get_items(draft_loc, course_id=course_id, depth=0)
-        items = super(DraftModuleStore, self).get_items(location, course_id=course_id, depth=0)
+        draft_items = super(DraftModuleStore, self).get_items(draft_loc, course_id=course_id, depth=depth)
+        items = super(DraftModuleStore, self).get_items(location, course_id=course_id, depth=depth)
 
         draft_locs_found = set(item.location._replace(revision=None) for item in draft_items)
         non_draft_items = [
@@ -118,7 +116,7 @@ class DraftModuleStore(ModuleStoreBase):
         """
         draft_loc = as_draft(location)
         draft_item = self.get_item(location)
-        if not draft_item.cms.is_draft:
+        if not getattr(draft_item, 'is_draft', False):
             self.clone_item(location, draft_loc)
 
         return super(DraftModuleStore, self).update_item(draft_loc, data)
@@ -133,7 +131,7 @@ class DraftModuleStore(ModuleStoreBase):
         """
         draft_loc = as_draft(location)
         draft_item = self.get_item(location)
-        if not draft_item.cms.is_draft:
+        if not getattr(draft_item, 'is_draft', False):
             self.clone_item(location, draft_loc)
 
         return super(DraftModuleStore, self).update_children(draft_loc, children)
@@ -149,7 +147,7 @@ class DraftModuleStore(ModuleStoreBase):
         draft_loc = as_draft(location)
         draft_item = self.get_item(location)
 
-        if not draft_item.cms.is_draft:
+        if not getattr(draft_item, 'is_draft', False):
             self.clone_item(location, draft_loc)
 
         if 'is_draft' in metadata:
@@ -192,3 +190,36 @@ class DraftModuleStore(ModuleStoreBase):
         """
         super(DraftModuleStore, self).clone_item(location, as_draft(location))
         super(DraftModuleStore, self).delete_item(location)
+
+    def _query_children_for_cache_children(self, items):
+        # first get non-draft in a round-trip
+        queried_children = []
+        to_process_non_drafts = super(DraftModuleStore, self)._query_children_for_cache_children(items)
+
+        to_process_dict = {}
+        for non_draft in to_process_non_drafts:
+            to_process_dict[Location(non_draft["_id"])] = non_draft
+
+        # now query all draft content in another round-trip
+        query = {
+            '_id': {'$in': [namedtuple_to_son(as_draft(Location(item))) for item in items]}
+        }
+        to_process_drafts = list(self.collection.find(query))
+
+        # now we have to go through all drafts and replace the non-draft
+        # with the draft. This is because the semantics of the DraftStore is to
+        # always return the draft - if available
+        for draft in to_process_drafts:
+            draft_loc = Location(draft["_id"])
+            draft_as_non_draft_loc = draft_loc._replace(revision=None)
+
+            # does non-draft exist in the collection
+            # if so, replace it
+            if draft_as_non_draft_loc in to_process_dict:
+                to_process_dict[draft_as_non_draft_loc] = draft
+
+        # convert the dict - which is used for look ups - back into a list
+        for key, value in to_process_dict.iteritems():
+            queried_children.append(value)  
+
+        return queried_children
diff --git a/common/lib/xmodule/xmodule/modulestore/mongo.py b/common/lib/xmodule/xmodule/modulestore/mongo.py
index b76251bb99..f1e09b024a 100644
--- a/common/lib/xmodule/xmodule/modulestore/mongo.py
+++ b/common/lib/xmodule/xmodule/modulestore/mongo.py
@@ -3,12 +3,12 @@ import sys
 import logging
 import copy
 
-from bson.son import SON
 from collections import namedtuple
 from fs.osfs import OSFS
 from itertools import repeat
 from path import path
 from datetime import datetime
+from operator import attrgetter
 
 from importlib import import_module
 from xmodule.errortracker import null_error_tracker, exc_info_to_str
@@ -18,7 +18,7 @@ from xmodule.error_module import ErrorDescriptor
 from xblock.runtime import DbModel, KeyValueStore, InvalidScopeError
 from xblock.core import Scope
 
-from . import ModuleStoreBase, Location
+from . import ModuleStoreBase, Location, namedtuple_to_son
 from .draft import DraftModuleStore
 from .exceptions import (ItemNotFoundError,
                          DuplicateItemError)
@@ -96,6 +96,7 @@ class MongoKeyValueStore(KeyValueStore):
         else:
             return False
 
+
 MongoUsage = namedtuple('MongoUsage', 'id, def_id')
 
 
@@ -107,7 +108,7 @@ class CachingDescriptorSystem(MakoDescriptorSystem):
     references to metadata_inheritance_tree
     """
     def __init__(self, modulestore, module_data, default_class, resources_fs,
-                 error_tracker, render_template, metadata_inheritance_tree = None):
+                 error_tracker, render_template, cached_metadata=None):
         """
         modulestore: the module store that can be used to retrieve additional modules
 
@@ -132,9 +133,13 @@ class CachingDescriptorSystem(MakoDescriptorSystem):
         # cdodge: other Systems have a course_id attribute defined. To keep things consistent, let's
         # define an attribute here as well, even though it's None
         self.course_id = None
-        self.metadata_inheritance_tree = metadata_inheritance_tree
+        self.cached_metadata = cached_metadata
+
 
     def load_item(self, location):
+        """
+        Return an XModule instance for the specified location
+        """
         location = Location(location)
         json_data = self.module_data.get(location)
         if json_data is None:
@@ -165,8 +170,8 @@ class CachingDescriptorSystem(MakoDescriptorSystem):
 
                 model_data = DbModel(kvs, class_, None, MongoUsage(self.course_id, location))
                 module = class_(self, location, model_data)
-                if self.metadata_inheritance_tree is not None:
-                    metadata_to_inherit = self.metadata_inheritance_tree.get('parent_metadata', {}).get(location.url(), {})
+                if self.cached_metadata is not None:
+                    metadata_to_inherit = self.cached_metadata.get(location.url(), {})
                     inherit_metadata(module, metadata_to_inherit)
                 return module
             except:
@@ -196,14 +201,7 @@ def location_to_query(location, wildcard=True):
     return query
 
 
-def namedtuple_to_son(namedtuple, prefix=''):
-    """
-    Converts a namedtuple into a SON object with the same key order
-    """
-    son = SON()
-    for idx, field_name in enumerate(namedtuple._fields):
-        son[prefix + field_name] = namedtuple[idx]
-    return son
+metadata_cache_key = attrgetter('org', 'course')
 
 
 class MongoModuleStore(ModuleStoreBase):
@@ -215,7 +213,8 @@ class MongoModuleStore(ModuleStoreBase):
     def __init__(self, host, db, collection, fs_root, render_template,
                  port=27017, default_class=None,
                  error_tracker=null_error_tracker,
-                 user=None, password=None, **kwargs):
+                 user=None, password=None, request_cache=None, 
+                 metadata_inheritance_cache_subsystem=None, **kwargs):
 
         ModuleStoreBase.__init__(self)
 
@@ -228,7 +227,6 @@ class MongoModuleStore(ModuleStoreBase):
         if user is not None and password is not None:
             self.collection.database.authenticate(user, password)
 
-
         # Force mongo to report errors, at the expense of performance
         self.collection.safe = True
 
@@ -247,8 +245,10 @@ class MongoModuleStore(ModuleStoreBase):
         self.error_tracker = error_tracker
         self.render_template = render_template
         self.ignore_write_events_on_courses = []
+        self.request_cache = request_cache
+        self.metadata_inheritance_cache_subsystem = metadata_inheritance_cache_subsystem
 
-    def get_metadata_inheritance_tree(self, location):
+    def compute_metadata_inheritance_tree(self, location):
         '''
         TODO (cdodge) This method can be deleted when the 'split module store' work has been completed
         '''
@@ -258,10 +258,15 @@ class MongoModuleStore(ModuleStoreBase):
         query = {
                     '_id.org': location.org,
                     '_id.course': location.course,
-                    '_id.category': {'$in': [ 'course', 'chapter', 'sequential', 'vertical']}
+                    '_id.category': {'$in': ['course', 'chapter', 'sequential', 'vertical']}
                 }
-        # we just want the Location, children, and metadata
-        record_filter = {'_id': 1, 'definition.children': 1, 'metadata': 1}
+        # we just want the Location, children, and inheritable metadata
+        record_filter = {'_id': 1, 'definition.children': 1}
+
+        # just get the inheritable metadata since that is all we need for the computation
+        # this minimizes both data pushed over the wire
+        for attr in INHERITABLE_METADATA:
+            record_filter['metadata.{0}'.format(attr)] = 1
 
         # call out to the DB
         resultset = self.collection.find(query, record_filter)
@@ -278,7 +283,11 @@ class MongoModuleStore(ModuleStoreBase):
 
         # now traverse the tree and compute down the inherited metadata
         metadata_to_inherit = {}
+
         def _compute_inherited_metadata(url):
+            """
+            Helper method for computing inherited metadata for a specific location url
+            """
             my_metadata = {}
             # check for presence of metadata key. Note that a given module may not yet be fully formed.
             # example: update_item -> update_children -> update_metadata sequence on new item create
@@ -293,7 +302,7 @@ class MongoModuleStore(ModuleStoreBase):
 
             # go through all the children and recurse, but only if we have
             # in the result set. Remember results will not contain leaf nodes
-            for child in results_by_url[url].get('definition',{}).get('children',[]):
+            for child in results_by_url[url].get('definition', {}).get('children', []):
                 if child in results_by_url:
                     new_child_metadata = copy.deepcopy(my_metadata)
                     new_child_metadata.update(results_by_url[child].get('metadata', {}))
@@ -304,42 +313,57 @@ class MongoModuleStore(ModuleStoreBase):
                     # this is likely a leaf node, so let's record what metadata we need to inherit
                     metadata_to_inherit[child] = my_metadata
 
-
         if root is not None:
             _compute_inherited_metadata(root)
 
-        return {'parent_metadata': metadata_to_inherit,
-            'timestamp' : datetime.now()}
+        return metadata_to_inherit
 
     def get_cached_metadata_inheritance_tree(self, location, force_refresh=False):
         '''
         TODO (cdodge) This method can be deleted when the 'split module store' work has been completed
         '''
-        key_name = '{0}/{1}'.format(location.org, location.course)
+        key = metadata_cache_key(location)
+        tree = {}
+        
+        if not force_refresh:
+            # see if we are first in the request cache (if present)
+            if self.request_cache is not None and key in self.request_cache.data.get('metadata_inheritance', {}):
+                return self.request_cache.data['metadata_inheritance'][key]
 
-        tree = None
-        if self.metadata_inheritance_cache is not None:
-            tree = self.metadata_inheritance_cache.get(key_name)
-        else:
-            # This is to help guard against an accident prod runtime without a cache
-            logging.warning('Running MongoModuleStore without metadata_inheritance_cache. This should not happen in production!')
+            # then look in any caching subsystem (e.g. memcached)
+            if self.metadata_inheritance_cache_subsystem is not None:
+                tree = self.metadata_inheritance_cache_subsystem.get(key, {})
+            else:
+                logging.warning('Running MongoModuleStore without a metadata_inheritance_cache_subsystem. This is OK in localdev and testing environment. Not OK in production.')
 
-        if tree is None or force_refresh:
-            tree = self.get_metadata_inheritance_tree(location)
-            if self.metadata_inheritance_cache is not None:
-                self.metadata_inheritance_cache.set(key_name, tree)
+        if not tree:
+            # if not in subsystem, or we are on force refresh, then we have to compute
+            tree = self.compute_metadata_inheritance_tree(location)
+            
+            # now write out computed tree to caching subsystem (e.g. memcached), if available
+            if self.metadata_inheritance_cache_subsystem is not None:
+                self.metadata_inheritance_cache_subsystem.set(key, tree)
+
+        # now populate a request_cache, if available. NOTE, we are outside of the
+        # scope of the above if: statement so that after a memcache hit, it'll get
+        # put into the request_cache
+        if self.request_cache is not None:
+            # we can't assume the 'metadatat_inheritance' part of the request cache dict has been
+            # defined
+            if 'metadata_inheritance' not in self.request_cache.data:
+                self.request_cache.data['metadata_inheritance'] = {}
+            self.request_cache.data['metadata_inheritance'][key] = tree
 
         return tree
 
     def refresh_cached_metadata_inheritance_tree(self, location):
+        """
+        Refresh the cached metadata inheritance tree for the org/course combination
+        for location
+        """
         pseudo_course_id = '/'.join([location.org, location.course])
         if pseudo_course_id not in self.ignore_write_events_on_courses:
-           self.get_cached_metadata_inheritance_tree(location, force_refresh = True)
-
-    def clear_cached_metadata_inheritance_tree(self, location):
-        key_name = '{0}/{1}'.format(location.org, location.course)
-        if self.metadata_inheritance_cache is not None:
-            self.metadata_inheritance_cache.delete(key_name)
+            self.get_cached_metadata_inheritance_tree(location, force_refresh=True)
 
     def _clean_item_data(self, item):
         """
@@ -348,6 +372,13 @@ class MongoModuleStore(ModuleStoreBase):
         item['location'] = item['_id']
         del item['_id']
 
+    def _query_children_for_cache_children(self, items):
+        # first get non-draft in a round-trip
+        query = {
+            '_id': {'$in': [namedtuple_to_son(Location(item)) for item in items]}
+        }
+        return list(self.collection.find(query))
+
     def _cache_children(self, items, depth=0):
         """
         Returns a dictionary mapping Location -> item data, populated with json data
@@ -367,25 +398,22 @@ class MongoModuleStore(ModuleStoreBase):
                 data[Location(item['location'])] = item
 
             if depth == 0:
-                break;
+                break
 
             # Load all children by id. See
             # http://www.mongodb.org/display/DOCS/Advanced+Queries#AdvancedQueries-%24or
             # for or-query syntax
+            to_process = []
             if children:
-                query = {
-                    '_id': {'$in': [namedtuple_to_son(Location(child)) for child in children]}
-                }
-                to_process = self.collection.find(query)
-            else:
-                to_process = []
+                to_process = self._query_children_for_cache_children(children)
+
             # If depth is None, then we just recurse until we hit all the descendents
             if depth is not None:
                 depth -= 1
 
         return data
 
-    def _load_item(self, item, data_cache, should_apply_metadata_inheritence=True):
+    def _load_item(self, item, data_cache, apply_cached_metadata=True):
         """
         Load an XModuleDescriptor from item, using the children stored in data_cache
         """
@@ -397,10 +425,9 @@ class MongoModuleStore(ModuleStoreBase):
 
         resource_fs = OSFS(root)
 
-        metadata_inheritance_tree = None
-
-        if should_apply_metadata_inheritence:
-            metadata_inheritance_tree = self.get_cached_metadata_inheritance_tree(Location(item['location']))
+        cached_metadata = {}
+        if apply_cached_metadata:
+            cached_metadata = self.get_cached_metadata_inheritance_tree(Location(item['location']))
 
         # TODO (cdodge): When the 'split module store' work has been completed, we should remove
         # the 'metadata_inheritance_tree' parameter
@@ -411,7 +438,7 @@ class MongoModuleStore(ModuleStoreBase):
             resource_fs,
             self.error_tracker,
             self.render_template,
-            metadata_inheritance_tree = metadata_inheritance_tree
+            cached_metadata,
         )
         return system.load_item(item['location'])
 
@@ -423,9 +450,9 @@ class MongoModuleStore(ModuleStoreBase):
         data_cache = self._cache_children(items, depth)
 
         # if we are loading a course object, if we're not prefetching children (depth != 0) then don't
-        # bother with the metadata inheritence 
-        return [self._load_item(item, data_cache, 
-            should_apply_metadata_inheritence=(item['location']['category'] != 'course' or depth != 0)) for item in items]
+        # bother with the metadata inheritance
+        return [self._load_item(item, data_cache,
+            apply_cached_metadata=(item['location']['category']!='course' or depth !=0)) for item in items]
 
     def get_courses(self):
         '''
@@ -559,7 +586,8 @@ class MongoModuleStore(ModuleStoreBase):
             raise Exception('Could not find course at {0}'.format(course_search_location))
 
         if found_cnt > 1:
-            raise Exception('Found more than one course at {0}. There should only be one!!! Dump = {1}'.format(course_search_location, courses))
+            raise Exception('Found more than one course at {0}. There should only be one!!! '
+                            'Dump = {1}'.format(course_search_location, courses))
 
         return courses[0]
 
@@ -631,7 +659,7 @@ class MongoModuleStore(ModuleStoreBase):
 
         self._update_single_item(location, {'metadata': metadata})
         # recompute (and update) the metadata inheritance tree which is cached
-        self.refresh_cached_metadata_inheritance_tree(loc)      
+        self.refresh_cached_metadata_inheritance_tree(loc)
 
     def delete_item(self, location):
         """
@@ -654,7 +682,7 @@ class MongoModuleStore(ModuleStoreBase):
             # from overriding our default value set in the init method.
             safe=self.collection.safe)
         # recompute (and update) the metadata inheritance tree which is cached
-        self.refresh_cached_metadata_inheritance_tree(Location(location))  
+        self.refresh_cached_metadata_inheritance_tree(Location(location))
 
     def get_parent_locations(self, location, course_id):
         '''Find all locations that are the parents of this location in this
@@ -675,4 +703,10 @@ class MongoModuleStore(ModuleStoreBase):
 
 # DraftModuleStore is first, because it needs to intercept calls to MongoModuleStore
 class DraftMongoModuleStore(DraftModuleStore, MongoModuleStore):
+    """
+    Version of MongoModuleStore with draft capability mixed in
+    """
+    """
+    Version of MongoModuleStore with draft capability mixed in
+    """
     pass
diff --git a/common/lib/xmodule/xmodule/modulestore/store_utilities.py b/common/lib/xmodule/xmodule/modulestore/store_utilities.py
index cb3cd375a7..2935069090 100644
--- a/common/lib/xmodule/xmodule/modulestore/store_utilities.py
+++ b/common/lib/xmodule/xmodule/modulestore/store_utilities.py
@@ -136,3 +136,4 @@ def delete_course(modulestore, contentstore, source_location, commit = False):
         modulestore.delete_item(source_location)
 
     return True
+
diff --git a/common/lib/xmodule/xmodule/modulestore/tests/test_mongo.py b/common/lib/xmodule/xmodule/modulestore/tests/test_mongo.py
index 6f6f47ba85..061d70d09f 100644
--- a/common/lib/xmodule/xmodule/modulestore/tests/test_mongo.py
+++ b/common/lib/xmodule/xmodule/modulestore/tests/test_mongo.py
@@ -1,6 +1,7 @@
 import pymongo
 
-from nose.tools import assert_equals, assert_raises, assert_not_equals, with_setup
+from mock import Mock
+from nose.tools import assert_equals, assert_raises, assert_not_equals, with_setup, assert_false
 from pprint import pprint
 
 from xmodule.modulestore import Location
diff --git a/common/lib/xmodule/xmodule/modulestore/xml_importer.py b/common/lib/xmodule/xmodule/modulestore/xml_importer.py
index 6a4ce5131b..023e7bc9e0 100644
--- a/common/lib/xmodule/xmodule/modulestore/xml_importer.py
+++ b/common/lib/xmodule/xmodule/modulestore/xml_importer.py
@@ -356,6 +356,26 @@ def remap_namespace(module, target_location_namespace):
 
     return module
 
+def validate_no_non_editable_metadata(module_store, course_id, category, allowed=[]):
+    '''
+    Assert that there is no metadata within a particular category that we can't support editing
+    However we always allow display_name and 'xml_attribtues'
+    '''
+    allowed = allowed + ['xml_attributes', 'display_name']
+
+    err_cnt = 0
+    for module_loc in module_store.modules[course_id]:
+        module = module_store.modules[course_id][module_loc]
+        if module.location.category == category:
+            my_metadata = dict(own_metadata(module))
+            for key in my_metadata.keys():
+                if key not in allowed:
+                    err_cnt = err_cnt + 1
+                    print ': found metadata on {0}. Studio will not support editing this piece of metadata, so it is not allowed. Metadata: {1} = {2}'. format(module.location.url(), key, my_metadata[key])
+
+    return err_cnt
+
+
 def validate_category_hierarchy(module_store, course_id, parent_category, expected_child_category):
     err_cnt = 0
 
@@ -440,6 +460,13 @@ def perform_xlint(data_dir, course_dirs,
         err_cnt += validate_category_hierarchy(module_store, course_id, "chapter", "sequential")
         # constrain that sequentials only have 'verticals'
         err_cnt += validate_category_hierarchy(module_store, course_id, "sequential", "vertical")
+        # don't allow metadata on verticals, since we can't edit them in studio
+        err_cnt += validate_no_non_editable_metadata(module_store, course_id, "vertical")
+        # don't allow metadata on chapters, since we can't edit them in studio
+        err_cnt += validate_no_non_editable_metadata(module_store, course_id, "chapter",['start'])
+        # don't allow metadata on sequences that we can't edit
+        err_cnt += validate_no_non_editable_metadata(module_store, course_id, "sequential",
+            ['due','format','start','graded'])
 
         # check for a presence of a course marketing video
         location_elements = course_id.split('/')
@@ -456,3 +483,5 @@ def perform_xlint(data_dir, course_dirs,
         print "This course can be imported, but some errors may occur during the run of the course. It is recommend that you fix your courseware before importing"
     else:
         print "This course can be imported successfully."
+
+    return err_cnt
diff --git a/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_modulev1.py b/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_modulev1.py
index 98a54601de..eaa43c0d86 100644
--- a/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_modulev1.py
+++ b/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_modulev1.py
@@ -19,12 +19,8 @@ log = logging.getLogger("mitx.courseware")
 # attempts specified in xml definition overrides this.
 MAX_ATTEMPTS = 1
 
-# Set maximum available number of points.
-# Overriden by max_score specified in xml.
-MAX_SCORE = 1
-
 #The highest score allowed for the overall xmodule and for each rubric point
-MAX_SCORE_ALLOWED = 3
+MAX_SCORE_ALLOWED = 50
 
 #If true, default behavior is to score module as a practice problem.  Otherwise, no grade at all is shown in progress
 #Metadata overrides this.
@@ -88,7 +84,7 @@ class CombinedOpenEndedV1Module():
         Definition file should have one or many task blocks, a rubric block, and a prompt block:
 
         Sample file:
-        <combinedopenended attempts="10000" max_score="1">
+        <combinedopenended attempts="10000">
             <rubric>
                 Blah blah rubric.
             </rubric>
@@ -153,13 +149,9 @@ class CombinedOpenEndedV1Module():
             raise
         self.display_due_date = self.timeinfo.display_due_date
 
-        # Used for progress / grading.  Currently get credit just for
-        # completion (doesn't matter if you self-assessed correct/incorrect).
-        self._max_score = self.instance_state.get('max_score', MAX_SCORE)
-
         self.rubric_renderer = CombinedOpenEndedRubric(system, True)
         rubric_string = stringify_children(definition['rubric'])
-        self.rubric_renderer.check_if_rubric_is_parseable(rubric_string, location, MAX_SCORE_ALLOWED, self._max_score)
+        self._max_score = self.rubric_renderer.check_if_rubric_is_parseable(rubric_string, location, MAX_SCORE_ALLOWED)
 
         #Static data is passed to the child modules to render
         self.static_data = {
@@ -363,7 +355,15 @@ class CombinedOpenEndedV1Module():
         """
         self.update_task_states()
         html = self.current_task.get_html(self.system)
-        return_html = rewrite_links(html, self.rewrite_content_links)
+        return_html = html
+        try:
+            #Without try except block, get this error:
+            # File "/home/vik/mitx_all/mitx/common/lib/xmodule/xmodule/x_module.py", line 263, in rewrite_content_links
+            # if link.startswith(XASSET_SRCREF_PREFIX):
+            # Placing try except so that if the error is fixed, this code will start working again.
+            return_html = rewrite_links(html, self.rewrite_content_links)
+        except:
+            pass
         return return_html
 
     def get_current_attributes(self, task_number):
@@ -782,7 +782,7 @@ class CombinedOpenEndedV1Descriptor():
     template_dir_name = "combinedopenended"
 
     def __init__(self, system):
-        self.system =system
+        self.system = system
 
     @classmethod
     def definition_from_xml(cls, xml_object, system):
diff --git a/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_rubric.py b/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_rubric.py
index bceb12e444..6245d4d31c 100644
--- a/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_rubric.py
+++ b/common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_rubric.py
@@ -79,7 +79,7 @@ class CombinedOpenEndedRubric(object):
             raise RubricParsingError(error_message)
         return {'success': success, 'html': html, 'rubric_scores': rubric_scores}
 
-    def check_if_rubric_is_parseable(self, rubric_string, location, max_score_allowed, max_score):
+    def check_if_rubric_is_parseable(self, rubric_string, location, max_score_allowed):
         rubric_dict = self.render_rubric(rubric_string)
         success = rubric_dict['success']
         rubric_feedback = rubric_dict['html']
@@ -101,12 +101,7 @@ class CombinedOpenEndedRubric(object):
                 log.error(error_message)
                 raise RubricParsingError(error_message)
 
-        if int(total) != int(max_score):
-            #This is a staff_facing_error
-            error_msg = "The max score {0} for problem {1} does not match the total number of points in the rubric {2}. Contact the learning sciences group for assistance.".format(
-                max_score, location, total)
-            log.error(error_msg)
-            raise RubricParsingError(error_msg)
+        return int(total)
 
     def extract_categories(self, element):
         '''
diff --git a/common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_image_submission.py b/common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_image_submission.py
index 6956f336a5..2eb9502269 100644
--- a/common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_image_submission.py
+++ b/common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_image_submission.py
@@ -36,7 +36,7 @@ ALLOWABLE_IMAGE_SUFFIXES = [
 ]
 
 #Maximum allowed dimensions (x and y) for an uploaded image
-MAX_ALLOWED_IMAGE_DIM = 1500
+MAX_ALLOWED_IMAGE_DIM = 2000
 
 #Dimensions to which image is resized before it is evaluated for color count, etc
 MAX_IMAGE_DIM = 150
@@ -178,7 +178,7 @@ class URLProperties(object):
         Runs all available url tests
         @return: True if URL passes tests, false if not.
         """
-        url_is_okay = self.check_suffix() and self.check_if_parses() and self.check_domain()
+        url_is_okay = self.check_suffix() and self.check_if_parses()
         return url_is_okay
 
     def check_domain(self):
diff --git a/common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py b/common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py
index 2e49565bec..b9341f0cbe 100644
--- a/common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py
+++ b/common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py
@@ -357,10 +357,6 @@ class OpenEndedChild(object):
             if get_data['can_upload_files'] in ['true', '1']:
                 has_file_to_upload = True
                 file = get_data['student_file'][0]
-                if self.system.track_fuction:
-                    self.system.track_function('open_ended_image_upload', {'filename': file.name})
-                else:
-                    log.info("No tracking function found when uploading image.")
                 uploaded_to_s3, image_ok, s3_public_url = self.upload_image_to_s3(file)
                 if uploaded_to_s3:
                     image_tag = self.generate_image_tag_from_url(s3_public_url, file.name)
diff --git a/common/lib/xmodule/xmodule/open_ended_grading_classes/xblock_field_types.py b/common/lib/xmodule/xmodule/open_ended_grading_classes/xblock_field_types.py
new file mode 100644
index 0000000000..2dcb7a4cda
--- /dev/null
+++ b/common/lib/xmodule/xmodule/open_ended_grading_classes/xblock_field_types.py
@@ -0,0 +1,14 @@
+from xblock.core import Integer, Float
+
+
+class StringyFloat(Float):
+    """
+    A model type that converts from string to floats when reading from json
+    """
+
+    def from_json(self, value):
+        try:
+            return float(value)
+        except:
+            return None
+
diff --git a/common/lib/xmodule/xmodule/peer_grading_module.py b/common/lib/xmodule/xmodule/peer_grading_module.py
index e18f2ceca3..564356fcc3 100644
--- a/common/lib/xmodule/xmodule/peer_grading_module.py
+++ b/common/lib/xmodule/xmodule/peer_grading_module.py
@@ -13,6 +13,7 @@ from xmodule.modulestore import Location
 from xmodule.modulestore.django import modulestore
 from .timeinfo import TimeInfo
 from xblock.core import Object, Integer, Boolean, String, Scope
+from xmodule.open_ended_grading_classes.xblock_field_types import StringyFloat
 
 from xmodule.open_ended_grading_classes.peer_grading_service import PeerGradingService, GradingServiceError, MockPeerGradingService
 
@@ -28,13 +29,18 @@ EXTERNAL_GRADER_NO_CONTACT_ERROR = "Failed to contact external graders.  Please
 
 
 class PeerGradingFields(object):
-    use_for_single_location = Boolean(help="Whether to use this for a single location or as a panel.", default=USE_FOR_SINGLE_LOCATION, scope=Scope.settings)
-    link_to_location = String(help="The location this problem is linked to.", default=LINK_TO_LOCATION, scope=Scope.settings)
-    is_graded = Boolean(help="Whether or not this module is scored.",default=IS_GRADED, scope=Scope.settings)
+    use_for_single_location = Boolean(help="Whether to use this for a single location or as a panel.",
+                                      default=USE_FOR_SINGLE_LOCATION, scope=Scope.settings)
+    link_to_location = String(help="The location this problem is linked to.", default=LINK_TO_LOCATION,
+                              scope=Scope.settings)
+    is_graded = Boolean(help="Whether or not this module is scored.", default=IS_GRADED, scope=Scope.settings)
     display_due_date_string = String(help="Due date that should be displayed.", default=None, scope=Scope.settings)
     grace_period_string = String(help="Amount of grace to give on the due date.", default=None, scope=Scope.settings)
-    max_grade = Integer(help="The maximum grade that a student can receieve for this problem.", default=MAX_SCORE, scope=Scope.settings)
-    student_data_for_location = Object(help="Student data for a given peer grading problem.", default=json.dumps({}),scope=Scope.student_state)
+    max_grade = Integer(help="The maximum grade that a student can receieve for this problem.", default=MAX_SCORE,
+                        scope=Scope.settings)
+    student_data_for_location = Object(help="Student data for a given peer grading problem.", default=json.dumps({}),
+                                       scope=Scope.student_state)
+    weight = StringyFloat(help="How much to weight this problem by", scope=Scope.settings)
 
 
 class PeerGradingModule(PeerGradingFields, XModule):
diff --git a/common/lib/xmodule/xmodule/templates/combinedopenended/default.yaml b/common/lib/xmodule/xmodule/templates/combinedopenended/default.yaml
index f2aba0e18b..515d9071b1 100644
--- a/common/lib/xmodule/xmodule/templates/combinedopenended/default.yaml
+++ b/common/lib/xmodule/xmodule/templates/combinedopenended/default.yaml
@@ -2,12 +2,12 @@
 metadata:
     display_name: Open Ended Response
     max_attempts: 1
-    max_score: 1
     is_graded: False
     version: 1
     display_name: Open Ended Response
     skip_spelling_checks: False
     accept_file_upload: False
+    weight: ""
 data: |
   <combinedopenended>
   	<rubric>
diff --git a/common/lib/xmodule/xmodule/templates/peer_grading/default.yaml b/common/lib/xmodule/xmodule/templates/peer_grading/default.yaml
index cb8e29dfa2..1ba8f978d6 100644
--- a/common/lib/xmodule/xmodule/templates/peer_grading/default.yaml
+++ b/common/lib/xmodule/xmodule/templates/peer_grading/default.yaml
@@ -6,6 +6,7 @@ metadata:
     link_to_location: None
     is_graded: False
     max_grade: 1
+    weight: ""
 data: |
   <peergrading>
   </peergrading>
diff --git a/common/lib/xmodule/xmodule/tests/test_capa_module.py b/common/lib/xmodule/xmodule/tests/test_capa_module.py
index d2458cb3d0..1fefbb64cd 100644
--- a/common/lib/xmodule/xmodule/tests/test_capa_module.py
+++ b/common/lib/xmodule/xmodule/tests/test_capa_module.py
@@ -7,6 +7,8 @@ import random
 
 import xmodule
 import capa
+from capa.responsetypes import StudentInputError, \
+                                LoncapaProblemError, ResponseError
 from xmodule.capa_module import CapaModule
 from xmodule.modulestore import Location
 from lxml import etree
@@ -407,7 +409,7 @@ class CapaModuleTest(unittest.TestCase):
             mock_html.return_value = "Test HTML"
 
             # Check the problem
-            get_request_dict = { CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): '3.14'}
             result = module.check_problem(get_request_dict)
 
         # Expect that the problem is marked correct
@@ -428,7 +430,7 @@ class CapaModuleTest(unittest.TestCase):
             mock_is_correct.return_value = False
 
             # Check the problem
-            get_request_dict = { CapaFactory.input_key(): '0'}
+            get_request_dict = {CapaFactory.input_key(): '0'}
             result = module.check_problem(get_request_dict)
 
         # Expect that the problem is marked correct
@@ -446,7 +448,7 @@ class CapaModuleTest(unittest.TestCase):
         with patch('xmodule.capa_module.CapaModule.closed') as mock_closed:
             mock_closed.return_value = True
             with self.assertRaises(xmodule.exceptions.NotFoundError):
-                get_request_dict = { CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): '3.14'}
                 module.check_problem(get_request_dict)
 
         # Expect that number of attempts NOT incremented
@@ -492,7 +494,7 @@ class CapaModuleTest(unittest.TestCase):
             mock_is_queued.return_value = True
             mock_get_queuetime.return_value = datetime.datetime.now()
 
-            get_request_dict = { CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): '3.14'}
             result = module.check_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success'
@@ -502,21 +504,61 @@ class CapaModuleTest(unittest.TestCase):
         self.assertEqual(module.attempts, 1)
 
 
-    def test_check_problem_student_input_error(self):
-        module = CapaFactory.create(attempts=1)
+    def test_check_problem_error(self):
 
-        # Simulate a student input exception
-        with patch('capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
-            mock_grade.side_effect = capa.responsetypes.StudentInputError('test error')
+        # Try each exception that capa_module should handle
+        for exception_class in [StudentInputError, 
+                                LoncapaProblemError, 
+                                ResponseError]:
 
-            get_request_dict = { CapaFactory.input_key(): '3.14'}
-            result = module.check_problem(get_request_dict)
+            # Create the module
+            module = CapaFactory.create(attempts=1)
+
+            # Ensure that the user is NOT staff
+            module.system.user_is_staff = False
+
+            # Simulate answering a problem that raises the exception
+            with patch('capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
+                mock_grade.side_effect = exception_class('test error')
+
+                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                result = module.check_problem(get_request_dict)
+
+            # Expect an AJAX alert message in 'success'
+            expected_msg = 'Error: test error'
+            self.assertEqual(expected_msg, result['success'])
+
+            # Expect that the number of attempts is NOT incremented
+            self.assertEqual(module.attempts, 1)
+
+    def test_check_problem_error_with_staff_user(self):
+        
+        # Try each exception that capa module should handle
+        for exception_class in [StudentInputError, 
+                                LoncapaProblemError,
+                                ResponseError]:
+
+            # Create the module
+            module = CapaFactory.create(attempts=1)
+
+            # Ensure that the user IS staff
+            module.system.user_is_staff = True
+
+            # Simulate answering a problem that raises an exception
+            with patch('capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
+                mock_grade.side_effect = exception_class('test error')
+
+                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                result = module.check_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success'
             self.assertTrue('test error' in result['success'])
 
-        # Expect that the number of attempts is NOT incremented
-        self.assertEqual(module.attempts, 1)
+            # We DO include traceback information for staff users
+            self.assertTrue('Traceback' in result['success'])
+
+            # Expect that the number of attempts is NOT incremented
+            self.assertEqual(module.attempts, 1)
 
 
     def test_reset_problem(self):
@@ -573,11 +615,11 @@ class CapaModuleTest(unittest.TestCase):
         module = CapaFactory.create(done=False)
 
         # Save the problem
-        get_request_dict = { CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): '3.14'}
         result = module.save_problem(get_request_dict)
 
         # Expect that answers are saved to the problem
-        expected_answers = { CapaFactory.answer_key(): '3.14'}
+        expected_answers = {CapaFactory.answer_key(): '3.14'}
         self.assertEqual(module.lcp.student_answers, expected_answers)
 
         # Expect that the result is success
@@ -592,7 +634,7 @@ class CapaModuleTest(unittest.TestCase):
             mock_closed.return_value = True
 
             # Try to save the problem
-            get_request_dict = { CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): '3.14'}
             result = module.save_problem(get_request_dict)
 
         # Expect that the result is failure
@@ -603,7 +645,7 @@ class CapaModuleTest(unittest.TestCase):
         module = CapaFactory.create(rerandomize='always', done=True)
 
         # Try to save
-        get_request_dict = { CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): '3.14'}
         result = module.save_problem(get_request_dict)
 
         # Expect that we cannot save
@@ -614,7 +656,7 @@ class CapaModuleTest(unittest.TestCase):
         module = CapaFactory.create(rerandomize='never', done=True)
 
         # Try to save
-        get_request_dict = { CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): '3.14'}
         result = module.save_problem(get_request_dict)
 
         # Expect that we succeed
@@ -626,7 +668,7 @@ class CapaModuleTest(unittest.TestCase):
         # Just in case, we also check what happens if we have
         # more attempts than allowed.
         attempts = random.randint(1, 10)
-        module = CapaFactory.create(attempts=attempts -1, max_attempts=attempts)
+        module = CapaFactory.create(attempts=attempts - 1, max_attempts=attempts)
         self.assertEqual(module.check_button_name(), "Final Check")
 
         module = CapaFactory.create(attempts=attempts, max_attempts=attempts)
@@ -636,14 +678,14 @@ class CapaModuleTest(unittest.TestCase):
         self.assertEqual(module.check_button_name(), "Final Check")
 
         # Otherwise, button name is "Check"
-        module = CapaFactory.create(attempts=attempts -2, max_attempts=attempts)
+        module = CapaFactory.create(attempts=attempts - 2, max_attempts=attempts)
         self.assertEqual(module.check_button_name(), "Check")
 
-        module = CapaFactory.create(attempts=attempts -3, max_attempts=attempts)
+        module = CapaFactory.create(attempts=attempts - 3, max_attempts=attempts)
         self.assertEqual(module.check_button_name(), "Check")
 
         # If no limit on attempts, then always show "Check"
-        module = CapaFactory.create(attempts=attempts -3)
+        module = CapaFactory.create(attempts=attempts - 3)
         self.assertEqual(module.check_button_name(), "Check")
 
         module = CapaFactory.create(attempts=0)
@@ -859,3 +901,97 @@ class CapaModuleTest(unittest.TestCase):
 
         # Expect that the module has created a new dummy problem with the error
         self.assertNotEqual(original_problem, module.lcp)
+
+
+    def test_random_seed_no_change(self):
+
+        # Run the test for each possible rerandomize value
+        for rerandomize in ['never', 'per_student', 'always', 'onreset']:
+            module = CapaFactory.create(rerandomize=rerandomize)
+
+            # Get the seed
+            # By this point, the module should have persisted the seed
+            seed = module.seed
+            self.assertTrue(seed is not None)
+
+            # If we're not rerandomizing, the seed is always set
+            # to the same value (1)
+            if rerandomize == 'never':
+                self.assertEqual(seed, 1)
+
+            # Check the problem
+            get_request_dict = { CapaFactory.input_key(): '3.14'}
+            module.check_problem(get_request_dict)
+
+            # Expect that the seed is the same 
+            self.assertEqual(seed, module.seed)
+
+            # Save the problem
+            module.save_problem(get_request_dict)
+
+            # Expect that the seed is the same
+            self.assertEqual(seed, module.seed)
+
+    def test_random_seed_with_reset(self):
+        
+        def _reset_and_get_seed(module):
+            '''
+            Reset the XModule and return the module's seed
+            '''
+
+            # Simulate submitting an attempt
+            # We need to do this, or reset_problem() will
+            # fail with a complaint that we haven't submitted
+            # the problem yet.
+            module.done = True
+
+            # Reset the problem
+            module.reset_problem({})
+
+            # Return the seed
+            return module.seed
+
+        def _retry_and_check(num_tries, test_func):
+            '''
+            Returns True if *test_func* was successful
+            (returned True) within *num_tries* attempts
+
+            *test_func* must be a function 
+            of the form test_func() -> bool
+            '''
+            success = False
+            for i in range(num_tries):
+                if test_func() is True:
+                    success = True
+                    break
+            return success
+
+        # Run the test for each possible rerandomize value
+        for rerandomize in ['never', 'per_student', 'always', 'onreset']:
+            module = CapaFactory.create(rerandomize=rerandomize)
+
+            # Get the seed
+            # By this point, the module should have persisted the seed
+            seed = module.seed
+            self.assertTrue(seed is not None)
+
+            # We do NOT want the seed to reset if rerandomize
+            # is set to 'never' -- it should still be 1
+            # The seed also stays the same if we're randomizing
+            # 'per_student': the same student should see the same problem
+            if rerandomize in ['never', 'per_student']:
+                self.assertEqual(seed, _reset_and_get_seed(module))
+
+            # Otherwise, we expect the seed to change
+            # to another valid seed
+            else:
+
+                # Since there's a small chance we might get the
+                # same seed again, give it 5 chances
+                # to generate a different seed
+                success = _retry_and_check(5, 
+                                lambda: _reset_and_get_seed(module) != seed)
+                
+                self.assertTrue(module.seed != None)
+                msg = 'Could not get a new seed from reset after 5 tries'
+                self.assertTrue(success, msg)
diff --git a/common/lib/xmodule/xmodule/tests/test_combined_open_ended.py b/common/lib/xmodule/xmodule/tests/test_combined_open_ended.py
index 55c31ded58..1950389399 100644
--- a/common/lib/xmodule/xmodule/tests/test_combined_open_ended.py
+++ b/common/lib/xmodule/xmodule/tests/test_combined_open_ended.py
@@ -5,11 +5,15 @@ import unittest
 from xmodule.open_ended_grading_classes.openendedchild import OpenEndedChild
 from xmodule.open_ended_grading_classes.open_ended_module import OpenEndedModule
 from xmodule.open_ended_grading_classes.combined_open_ended_modulev1 import CombinedOpenEndedV1Module
+from xmodule.combined_open_ended_module import CombinedOpenEndedModule
 
 from xmodule.modulestore import Location
 from lxml import etree
 import capa.xqueue_interface as xqueue_interface
 from datetime import datetime
+import logging
+
+log = logging.getLogger(__name__)
 
 from . import test_system
 
@@ -57,7 +61,7 @@ class OpenEndedChildTest(unittest.TestCase):
     def setUp(self):
         self.test_system = test_system()
         self.openendedchild = OpenEndedChild(self.test_system, self.location,
-                                            self.definition, self.descriptor, self.static_data, self.metadata)
+                                             self.definition, self.descriptor, self.static_data, self.metadata)
 
 
     def test_latest_answer_empty(self):
@@ -183,10 +187,12 @@ class OpenEndedModuleTest(unittest.TestCase):
         self.test_system.location = self.location
         self.mock_xqueue = MagicMock()
         self.mock_xqueue.send_to_queue.return_value = (None, "Message")
+
         def constructed_callback(dispatch="score_update"):
             return dispatch
-        
-        self.test_system.xqueue = {'interface': self.mock_xqueue, 'construct_callback': constructed_callback, 'default_queuename': 'testqueue',
+
+        self.test_system.xqueue = {'interface': self.mock_xqueue, 'construct_callback': constructed_callback,
+                                   'default_queuename': 'testqueue',
                                    'waittime': 1}
         self.openendedmodule = OpenEndedModule(self.test_system, self.location,
                                                self.definition, self.descriptor, self.static_data, self.metadata)
@@ -281,7 +287,18 @@ class OpenEndedModuleTest(unittest.TestCase):
 class CombinedOpenEndedModuleTest(unittest.TestCase):
     location = Location(["i4x", "edX", "open_ended", "combinedopenended",
                          "SampleQuestion"])
-
+    definition_template = """
+                    <combinedopenended attempts="10000">
+                    {rubric}
+                    {prompt}
+                    <task>
+                    {task1}
+                    </task>
+                    <task>
+                    {task2}
+                    </task>
+                    </combinedopenended>
+                    """
     prompt = "<prompt>This is a question prompt</prompt>"
     rubric = '''<rubric><rubric>
         <category>
@@ -335,10 +352,15 @@ class CombinedOpenEndedModuleTest(unittest.TestCase):
            </openendedparam>
     </openended>'''
     definition = {'prompt': etree.XML(prompt), 'rubric': etree.XML(rubric), 'task_xml': [task_xml1, task_xml2]}
-    descriptor = Mock()
+    full_definition = definition_template.format(prompt=prompt, rubric=rubric, task1=task_xml1, task2=task_xml2)
+    descriptor = Mock(data=full_definition)
+    test_system = test_system()
+    combinedoe_container = CombinedOpenEndedModule(test_system,
+                                                   location,
+                                                   descriptor,
+                                                   model_data={'data': full_definition, 'weight' : '1'})
 
     def setUp(self):
-        self.test_system = test_system()
         # TODO: this constructor call is definitely wrong, but neither branch
         # of the merge matches the module constructor.  Someone (Vik?) should fix this.
         self.combinedoe = CombinedOpenEndedV1Module(self.test_system,
@@ -368,3 +390,19 @@ class CombinedOpenEndedModuleTest(unittest.TestCase):
         changed = self.combinedoe.update_task_states()
 
         self.assertTrue(changed)
+
+    def test_get_max_score(self):
+        changed = self.combinedoe.update_task_states()
+        self.combinedoe.state = "done"
+        self.combinedoe.is_scored = True
+        max_score = self.combinedoe.max_score()
+        self.assertEqual(max_score, 1)
+
+    def test_container_get_max_score(self):
+        #The progress view requires that this function be exposed
+        max_score = self.combinedoe_container.max_score()
+        self.assertEqual(max_score, None)
+
+    def test_container_weight(self):
+        weight = self.combinedoe_container.weight
+        self.assertEqual(weight,1)
diff --git a/common/lib/xmodule/xmodule/tests/test_course_module.py b/common/lib/xmodule/xmodule/tests/test_course_module.py
index e1de8a1ed0..eda9cf386c 100644
--- a/common/lib/xmodule/xmodule/tests/test_course_module.py
+++ b/common/lib/xmodule/xmodule/tests/test_course_module.py
@@ -1,5 +1,6 @@
 import unittest
 from time import strptime
+
 from fs.memoryfs import MemoryFS
 
 from mock import Mock, patch
@@ -108,7 +109,22 @@ class IsNewCourseTestCase(unittest.TestCase):
             print "Comparing %s to %s" % (a, b)
             assertion(a_score, b_score)
 
+    @patch('xmodule.course_module.time.gmtime')
+    def test_start_date_text(self, gmtime_mock):
+        gmtime_mock.return_value = NOW
 
+        settings = [
+            # start, advertized, result
+            ('2012-12-02T12:00', None, 'Dec 02, 2012'),
+            ('2012-12-02T12:00', '2011-11-01T12:00', 'Nov 01, 2011'),
+            ('2012-12-02T12:00', 'Spring 2012', 'Spring 2012'),
+            ('2012-12-02T12:00', 'November, 2011', 'November, 2011'),
+        ]
+
+        for s in settings:
+            d = self.get_dummy_course(start=s[0], advertised_start=s[1])
+            print "Checking start=%s advertised=%s" % (s[0], s[1])
+            self.assertEqual(d.start_date_text, s[2])
 
     @patch('xmodule.course_module.time.gmtime')
     def test_is_newish(self, gmtime_mock):
diff --git a/common/lib/xmodule/xmodule/tests/test_fields.py b/common/lib/xmodule/xmodule/tests/test_fields.py
new file mode 100644
index 0000000000..7c8872efc1
--- /dev/null
+++ b/common/lib/xmodule/xmodule/tests/test_fields.py
@@ -0,0 +1,80 @@
+"""Tests for Date class defined in fields.py."""
+import datetime
+import unittest
+from django.utils.timezone import UTC
+from xmodule.fields import Date
+import time
+
+class DateTest(unittest.TestCase):
+    date = Date()
+
+    @staticmethod
+    def struct_to_datetime(struct_time):
+        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
+            struct_time.tm_mday, struct_time.tm_hour,
+            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
+
+    def compare_dates(self, date1, date2, expected_delta):
+        dt1 = DateTest.struct_to_datetime(date1)
+        dt2 = DateTest.struct_to_datetime(date2)
+        self.assertEqual(dt1 - dt2, expected_delta, str(date1) + "-"
+                                                    + str(date2) + "!=" + str(expected_delta))
+
+    def test_from_json(self):
+        '''Test conversion from iso compatible date strings to struct_time'''
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01"),
+            DateTest.date.from_json("2012-12-31"),
+            datetime.timedelta(days=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00"),
+            DateTest.date.from_json("2012-12-31T23"),
+            datetime.timedelta(hours=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00:00"),
+            DateTest.date.from_json("2012-12-31T23:59"),
+            datetime.timedelta(minutes=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00:00:00"),
+            DateTest.date.from_json("2012-12-31T23:59:59"),
+            datetime.timedelta(seconds=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00:00:00Z"),
+            DateTest.date.from_json("2012-12-31T23:59:59Z"),
+            datetime.timedelta(seconds=1))
+        self.compare_dates(
+            DateTest.date.from_json("2012-12-31T23:00:01-01:00"),
+            DateTest.date.from_json("2013-01-01T00:00:00+01:00"),
+            datetime.timedelta(hours=1, seconds=1))
+
+    def test_return_None(self):
+        self.assertIsNone(DateTest.date.from_json(""))
+        self.assertIsNone(DateTest.date.from_json(None))
+        self.assertIsNone(DateTest.date.from_json(['unknown value']))
+
+    def test_old_due_date_format(self):
+        current = datetime.datetime.today()
+        self.assertEqual(
+            time.struct_time((current.year, 3, 12, 12, 0, 0, 1, 71, 0)),
+            DateTest.date.from_json("March 12 12:00"))
+        self.assertEqual(
+            time.struct_time((current.year, 12, 4, 16, 30, 0, 2, 338, 0)),
+            DateTest.date.from_json("December 4 16:30"))
+
+    def test_to_json(self):
+        '''
+        Test converting time reprs to iso dates
+        '''
+        self.assertEqual(
+            DateTest.date.to_json(
+                time.strptime("2012-12-31T23:59:59Z", "%Y-%m-%dT%H:%M:%SZ")),
+            "2012-12-31T23:59:59Z")
+        self.assertEqual(
+            DateTest.date.to_json(
+                DateTest.date.from_json("2012-12-31T23:59:59Z")),
+            "2012-12-31T23:59:59Z")
+        self.assertEqual(
+            DateTest.date.to_json(
+                DateTest.date.from_json("2012-12-31T23:00:01-01:00")),
+            "2013-01-01T00:00:01Z")
+
diff --git a/common/lib/xmodule/xmodule/tests/test_graders.py b/common/lib/xmodule/xmodule/tests/test_graders.py
index 27416b1d5c..1a9ba50dc4 100644
--- a/common/lib/xmodule/xmodule/tests/test_graders.py
+++ b/common/lib/xmodule/xmodule/tests/test_graders.py
@@ -6,32 +6,34 @@ from xmodule.graders import Score, aggregate_scores
 
 
 class GradesheetTest(unittest.TestCase):
+    '''Tests the aggregate_scores method'''
 
     def test_weighted_grading(self):
         scores = []
         Score.__sub__ = lambda me, other: (me.earned - other.earned) + (me.possible - other.possible)
 
-        all, graded = aggregate_scores(scores)
-        self.assertEqual(all, Score(earned=0, possible=0, graded=False, section="summary"))
-        self.assertEqual(graded, Score(earned=0, possible=0, graded=True, section="summary"))
+        all_total, graded_total = aggregate_scores(scores)
+        self.assertEqual(all_total, Score(earned=0, possible=0, graded=False, section="summary"))
+        self.assertEqual(graded_total, Score(earned=0, possible=0, graded=True, section="summary"))
 
         scores.append(Score(earned=0, possible=5, graded=False, section="summary"))
-        all, graded = aggregate_scores(scores)
-        self.assertEqual(all, Score(earned=0, possible=5, graded=False, section="summary"))
-        self.assertEqual(graded, Score(earned=0, possible=0, graded=True, section="summary"))
+        all_total, graded_total = aggregate_scores(scores)
+        self.assertEqual(all_total, Score(earned=0, possible=5, graded=False, section="summary"))
+        self.assertEqual(graded_total, Score(earned=0, possible=0, graded=True, section="summary"))
 
         scores.append(Score(earned=3, possible=5, graded=True, section="summary"))
-        all, graded = aggregate_scores(scores)
-        self.assertAlmostEqual(all, Score(earned=3, possible=10, graded=False, section="summary"))
-        self.assertAlmostEqual(graded, Score(earned=3, possible=5, graded=True, section="summary"))
+        all_total, graded_total = aggregate_scores(scores)
+        self.assertAlmostEqual(all_total, Score(earned=3, possible=10, graded=False, section="summary"))
+        self.assertAlmostEqual(graded_total, Score(earned=3, possible=5, graded=True, section="summary"))
 
         scores.append(Score(earned=2, possible=5, graded=True, section="summary"))
-        all, graded = aggregate_scores(scores)
-        self.assertAlmostEqual(all, Score(earned=5, possible=15, graded=False, section="summary"))
-        self.assertAlmostEqual(graded, Score(earned=5, possible=10, graded=True, section="summary"))
+        all_total, graded_total = aggregate_scores(scores)
+        self.assertAlmostEqual(all_total, Score(earned=5, possible=15, graded=False, section="summary"))
+        self.assertAlmostEqual(graded_total, Score(earned=5, possible=10, graded=True, section="summary"))
 
 
 class GraderTest(unittest.TestCase):
+    '''Tests grader implementations'''
 
     empty_gradesheet = {
     }
@@ -44,136 +46,152 @@ class GraderTest(unittest.TestCase):
 
     test_gradesheet = {
         'Homework': [Score(earned=2, possible=20.0, graded=True, section='hw1'),
-              Score(earned=16, possible=16.0, graded=True, section='hw2')],
-              #The dropped scores should be from the assignments that don't exist yet
+                     Score(earned=16, possible=16.0, graded=True, section='hw2')],
+        # The dropped scores should be from the assignments that don't exist yet
 
         'Lab': [Score(earned=1, possible=2.0, graded=True, section='lab1'),  # Dropped
-             Score(earned=1, possible=1.0, graded=True, section='lab2'),
-             Score(earned=1, possible=1.0, graded=True, section='lab3'),
-             Score(earned=5, possible=25.0, graded=True, section='lab4'),  # Dropped
-             Score(earned=3, possible=4.0, graded=True, section='lab5'),  # Dropped
-             Score(earned=6, possible=7.0, graded=True, section='lab6'),
-             Score(earned=5, possible=6.0, graded=True, section='lab7')],
+                Score(earned=1, possible=1.0, graded=True, section='lab2'),
+                Score(earned=1, possible=1.0, graded=True, section='lab3'),
+                Score(earned=5, possible=25.0, graded=True, section='lab4'),  # Dropped
+                Score(earned=3, possible=4.0, graded=True, section='lab5'),  # Dropped
+                Score(earned=6, possible=7.0, graded=True, section='lab6'),
+                Score(earned=5, possible=6.0, graded=True, section='lab7')],
 
         'Midterm': [Score(earned=50.5, possible=100, graded=True, section="Midterm Exam"), ],
     }
 
-    def test_SingleSectionGrader(self):
-        midtermGrader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
-        lab4Grader = graders.SingleSectionGrader("Lab", "lab4")
-        badLabGrader = graders.SingleSectionGrader("Lab", "lab42")
+    def test_single_section_grader(self):
+        midterm_grader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
+        lab4_grader = graders.SingleSectionGrader("Lab", "lab4")
+        bad_lab_grader = graders.SingleSectionGrader("Lab", "lab42")
 
-        for graded in [midtermGrader.grade(self.empty_gradesheet),
-                        midtermGrader.grade(self.incomplete_gradesheet),
-                        badLabGrader.grade(self.test_gradesheet)]:
+        for graded in [midterm_grader.grade(self.empty_gradesheet),
+                       midterm_grader.grade(self.incomplete_gradesheet),
+                       bad_lab_grader.grade(self.test_gradesheet)]:
             self.assertEqual(len(graded['section_breakdown']), 1)
             self.assertEqual(graded['percent'], 0.0)
 
-        graded = midtermGrader.grade(self.test_gradesheet)
+        graded = midterm_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.505)
         self.assertEqual(len(graded['section_breakdown']), 1)
 
-        graded = lab4Grader.grade(self.test_gradesheet)
+        graded = lab4_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.2)
         self.assertEqual(len(graded['section_breakdown']), 1)
 
-    def test_AssignmentFormatGrader(self):
-        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
-        noDropGrader = graders.AssignmentFormatGrader("Homework", 12, 0)
-        #Even though the minimum number is 3, this should grade correctly when 7 assignments are found
-        overflowGrader = graders.AssignmentFormatGrader("Lab", 3, 2)
-        labGrader = graders.AssignmentFormatGrader("Lab", 7, 3)
+    def test_assignment_format_grader(self):
+        homework_grader = graders.AssignmentFormatGrader("Homework", 12, 2)
+        no_drop_grader = graders.AssignmentFormatGrader("Homework", 12, 0)
+        # Even though the minimum number is 3, this should grade correctly when 7 assignments are found
+        overflow_grader = graders.AssignmentFormatGrader("Lab", 3, 2)
+        lab_grader = graders.AssignmentFormatGrader("Lab", 7, 3)
 
-        #Test the grading of an empty gradesheet
-        for graded in [homeworkGrader.grade(self.empty_gradesheet),
-                        noDropGrader.grade(self.empty_gradesheet),
-                        homeworkGrader.grade(self.incomplete_gradesheet),
-                        noDropGrader.grade(self.incomplete_gradesheet)]:
+        # Test the grading of an empty gradesheet
+        for graded in [homework_grader.grade(self.empty_gradesheet),
+                       no_drop_grader.grade(self.empty_gradesheet),
+                       homework_grader.grade(self.incomplete_gradesheet),
+                       no_drop_grader.grade(self.incomplete_gradesheet)]:
             self.assertAlmostEqual(graded['percent'], 0.0)
-            #Make sure the breakdown includes 12 sections, plus one summary
+            # Make sure the breakdown includes 12 sections, plus one summary
             self.assertEqual(len(graded['section_breakdown']), 12 + 1)
 
-        graded = homeworkGrader.grade(self.test_gradesheet)
+        graded = homework_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.11)  # 100% + 10% / 10 assignments
         self.assertEqual(len(graded['section_breakdown']), 12 + 1)
 
-        graded = noDropGrader.grade(self.test_gradesheet)
+        graded = no_drop_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.0916666666666666)  # 100% + 10% / 12 assignments
         self.assertEqual(len(graded['section_breakdown']), 12 + 1)
 
-        graded = overflowGrader.grade(self.test_gradesheet)
+        graded = overflow_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.8880952380952382)  # 100% + 10% / 5 assignments
         self.assertEqual(len(graded['section_breakdown']), 7 + 1)
 
-        graded = labGrader.grade(self.test_gradesheet)
+        graded = lab_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.9226190476190477)
         self.assertEqual(len(graded['section_breakdown']), 7 + 1)
 
-    def test_WeightedSubsectionsGrader(self):
-        #First, a few sub graders
-        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
-        labGrader = graders.AssignmentFormatGrader("Lab", 7, 3)
-        midtermGrader = graders.SingleSectionGrader("Midterm", "Midterm Exam")
+    def test_assignment_format_grader_on_single_section_entry(self):
+        midterm_grader = graders.AssignmentFormatGrader("Midterm", 1, 0)
+        # Test the grading on a section with one item:
+        for graded in [midterm_grader.grade(self.empty_gradesheet),
+                       midterm_grader.grade(self.incomplete_gradesheet)]:
+            self.assertAlmostEqual(graded['percent'], 0.0)
+            # Make sure the breakdown includes just the one summary
+            self.assertEqual(len(graded['section_breakdown']), 0 + 1)
+            self.assertEqual(graded['section_breakdown'][0]['label'], 'Midterm')
 
-        weightedGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.25),
-                                                            (labGrader, labGrader.category, 0.25),
-        (midtermGrader, midtermGrader.category, 0.5)])
+        graded = midterm_grader.grade(self.test_gradesheet)
+        self.assertAlmostEqual(graded['percent'], 0.505)
+        self.assertEqual(len(graded['section_breakdown']), 0 + 1)
 
-        overOneWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.5),
-                                                                  (labGrader, labGrader.category, 0.5),
-        (midtermGrader, midtermGrader.category, 0.5)])
+    def test_weighted_subsections_grader(self):
+        # First, a few sub graders
+        homework_grader = graders.AssignmentFormatGrader("Homework", 12, 2)
+        lab_grader = graders.AssignmentFormatGrader("Lab", 7, 3)
+        # phasing out the use of SingleSectionGraders, and instead using AssignmentFormatGraders that
+        # will act like SingleSectionGraders on single sections.
+        midterm_grader = graders.AssignmentFormatGrader("Midterm", 1, 0)
 
-        #The midterm should have all weight on this one
-        zeroWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.0),
-                                                               (labGrader, labGrader.category, 0.0),
-        (midtermGrader, midtermGrader.category, 0.5)])
+        weighted_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.25),
+                                                             (lab_grader, lab_grader.category, 0.25),
+                                                             (midterm_grader, midterm_grader.category, 0.5)])
 
-        #This should always have a final percent of zero
-        allZeroWeightsGrader = graders.WeightedSubsectionsGrader([(homeworkGrader, homeworkGrader.category, 0.0),
-                                                                  (labGrader, labGrader.category, 0.0),
-        (midtermGrader, midtermGrader.category, 0.0)])
+        over_one_weights_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.5),
+                                                                     (lab_grader, lab_grader.category, 0.5),
+                                                                     (midterm_grader, midterm_grader.category, 0.5)])
 
-        emptyGrader = graders.WeightedSubsectionsGrader([])
+        # The midterm should have all weight on this one
+        zero_weights_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.0),
+                                                                 (lab_grader, lab_grader.category, 0.0),
+                                                                 (midterm_grader, midterm_grader.category, 0.5)])
 
-        graded = weightedGrader.grade(self.test_gradesheet)
+        # This should always have a final percent of zero
+        all_zero_weights_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.0),
+                                                                     (lab_grader, lab_grader.category, 0.0),
+                                                                     (midterm_grader, midterm_grader.category, 0.0)])
+
+        empty_grader = graders.WeightedSubsectionsGrader([])
+
+        graded = weighted_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.5106547619047619)
         self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
         self.assertEqual(len(graded['grade_breakdown']), 3)
 
-        graded = overOneWeightsGrader.grade(self.test_gradesheet)
+        graded = over_one_weights_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.7688095238095238)
         self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
         self.assertEqual(len(graded['grade_breakdown']), 3)
 
-        graded = zeroWeightsGrader.grade(self.test_gradesheet)
+        graded = zero_weights_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.2525)
         self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
         self.assertEqual(len(graded['grade_breakdown']), 3)
 
-        graded = allZeroWeightsGrader.grade(self.test_gradesheet)
+        graded = all_zero_weights_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.0)
         self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
         self.assertEqual(len(graded['grade_breakdown']), 3)
 
-        for graded in [weightedGrader.grade(self.empty_gradesheet),
-                        weightedGrader.grade(self.incomplete_gradesheet),
-                        zeroWeightsGrader.grade(self.empty_gradesheet),
-                        allZeroWeightsGrader.grade(self.empty_gradesheet)]:
+        for graded in [weighted_grader.grade(self.empty_gradesheet),
+                       weighted_grader.grade(self.incomplete_gradesheet),
+                       zero_weights_grader.grade(self.empty_gradesheet),
+                       all_zero_weights_grader.grade(self.empty_gradesheet)]:
             self.assertAlmostEqual(graded['percent'], 0.0)
             self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
             self.assertEqual(len(graded['grade_breakdown']), 3)
 
-        graded = emptyGrader.grade(self.test_gradesheet)
+        graded = empty_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.0)
         self.assertEqual(len(graded['section_breakdown']), 0)
         self.assertEqual(len(graded['grade_breakdown']), 0)
 
-    def test_graderFromConf(self):
+    def test_grader_from_conf(self):
 
-        #Confs always produce a graders.WeightedSubsectionsGrader, so we test this by repeating the test
-        #in test_graders.WeightedSubsectionsGrader, but generate the graders with confs.
+        # Confs always produce a graders.WeightedSubsectionsGrader, so we test this by repeating the test
+        # in test_graders.WeightedSubsectionsGrader, but generate the graders with confs.
 
-        weightedGrader = graders.grader_from_conf([
+        weighted_grader = graders.grader_from_conf([
             {
                 'type': "Homework",
                 'min_count': 12,
@@ -196,25 +214,25 @@ class GraderTest(unittest.TestCase):
             },
         ])
 
-        emptyGrader = graders.grader_from_conf([])
+        empty_grader = graders.grader_from_conf([])
 
-        graded = weightedGrader.grade(self.test_gradesheet)
+        graded = weighted_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.5106547619047619)
         self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
         self.assertEqual(len(graded['grade_breakdown']), 3)
 
-        graded = emptyGrader.grade(self.test_gradesheet)
+        graded = empty_grader.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.0)
         self.assertEqual(len(graded['section_breakdown']), 0)
         self.assertEqual(len(graded['grade_breakdown']), 0)
 
-        #Test that graders can also be used instead of lists of dictionaries
-        homeworkGrader = graders.AssignmentFormatGrader("Homework", 12, 2)
-        homeworkGrader2 = graders.grader_from_conf(homeworkGrader)
+        # Test that graders can also be used instead of lists of dictionaries
+        homework_grader = graders.AssignmentFormatGrader("Homework", 12, 2)
+        homework_grader2 = graders.grader_from_conf(homework_grader)
 
-        graded = homeworkGrader2.grade(self.test_gradesheet)
+        graded = homework_grader2.grade(self.test_gradesheet)
         self.assertAlmostEqual(graded['percent'], 0.11)
         self.assertEqual(len(graded['section_breakdown']), 12 + 1)
 
-        #TODO: How do we test failure cases? The parser only logs an error when
-        #it can't parse something. Maybe it should throw exceptions?
+        # TODO: How do we test failure cases? The parser only logs an error when
+        # it can't parse something. Maybe it should throw exceptions?
diff --git a/common/lib/xmodule/xmodule/x_module.py b/common/lib/xmodule/xmodule/x_module.py
index 02835e0d5d..bd331ec7d2 100644
--- a/common/lib/xmodule/xmodule/x_module.py
+++ b/common/lib/xmodule/xmodule/x_module.py
@@ -340,7 +340,7 @@ class XModuleDescriptor(XModuleFields, HTMLSnippet, ResourceTemplates, XBlock):
 
     # cdodge: this is a list of metadata names which are 'system' metadata
     # and should not be edited by an end-user
-    system_metadata_fields = ['data_dir', 'published_date', 'published_by', 'is_draft']
+    system_metadata_fields = ['data_dir', 'published_date', 'published_by', 'is_draft', 'xml_attributes']
 
     # A list of descriptor attributes that must be equal for the descriptors to
     # be equal
diff --git a/common/static/js/capa/symbolic_mathjax_preprocessor.js b/common/static/js/capa/symbolic_mathjax_preprocessor.js
new file mode 100644
index 0000000000..766e5efc03
--- /dev/null
+++ b/common/static/js/capa/symbolic_mathjax_preprocessor.js
@@ -0,0 +1,35 @@
+/* This file defines a processor in between the student's math input
+   (AsciiMath) and what is read by MathJax. It allows for our own
+   customizations, such as use of the syntax "a_b__x" in superscripts, or
+   possibly coloring certain variables, etc&.
+
+   It is used in the <textline> definition like the following:
+
+     <symbolicresponse expect="a_b^c + b_x__d" size="30">
+       <textline math="1"
+         preprocessorClassName="SymbolicMathjaxPreprocessor"
+	 preprocessorSrc="/static/js/capa/symbolic_mathjax_preprocessor.js"/>
+     </symbolicresponse>
+*/
+window.SymbolicMathjaxPreprocessor = function () {
+  this.fn = function (eqn) {
+    // flags and config
+    var superscriptsOn = true;
+
+    if (superscriptsOn) {
+      // find instances of "__" and make them superscripts ("^") and tag them
+      // as such. Specifcally replace instances of "__X" or "__{XYZ}" with
+      // "^{CHAR$1}", marking superscripts as different from powers
+
+      // a zero width space--this is an invisible character that no one would
+      // use, that gets passed through MathJax and to the server
+      var c = "\u200b";
+      eqn = eqn.replace(/__(?:([^\{])|\{([^\}]+)\})/g, '^{' + c + '$1$2}');
+
+      // NOTE: MathJax supports '\class{name}{mathcode}' but not for asciimath
+      // input, which is too bad. This would be preferable to this char tag
+    }
+
+    return eqn;
+  };
+};
diff --git a/doc/public/course_data_formats/symbolic_response.rst b/doc/public/course_data_formats/symbolic_response.rst
new file mode 100644
index 0000000000..8463faab3c
--- /dev/null
+++ b/doc/public/course_data_formats/symbolic_response.rst
@@ -0,0 +1,40 @@
+#################
+Symbolic Response
+#################
+
+This document plans to document features that the current symbolic response
+supports. In general it allows the input and validation of math expressions,
+up to commutativity and some identities.
+
+
+********
+Features
+********
+
+This is a partial list of features, to be revised as we go along:
+    * sub and superscripts: an expression following the ``^`` character
+      indicates exponentiation. To use superscripts in variables, the syntax
+      is ``b_x__d`` for the variable ``b`` with subscript ``x`` and super
+      ``d``. 
+
+      An example of a problem::
+
+      <symbolicresponse expect="a_b^c + b_x__d" size="30">
+        <textline math="1"
+           preprocessorClassName="SymbolicMathjaxPreprocessor"
+           preprocessorSrc="/static/js/capa/symbolic_mathjax_preprocessor.js"/>
+      </symbolicresponse>
+
+      It's a bit of a pain to enter that.
+
+    * The script-style math variant. What would be outputted in latex if you
+      entered ``\mathcal{N}``. This is used in some variables.
+
+      An example::
+
+          <symbolicresponse expect="scriptN_B + x" size="30">
+            <textline math="1"/>
+          </symbolicresponse>
+
+      There is no fancy preprocessing needed, but if you had superscripts or
+      something, you would need to include that part.
diff --git a/jenkins/test.sh b/jenkins/test.sh
index 1f5ce70b1b..edcca840c8 100755
--- a/jenkins/test.sh
+++ b/jenkins/test.sh
@@ -43,13 +43,15 @@ rake pep8 > pep8.log || cat pep8.log
 rake pylint > pylint.log || cat pylint.log
 
 TESTS_FAILED=0
+
+# Run the python unit tests
 rake test_cms[false] || TESTS_FAILED=1
 rake test_lms[false] || TESTS_FAILED=1
 rake test_common/lib/capa || TESTS_FAILED=1
 rake test_common/lib/xmodule || TESTS_FAILED=1
-# Don't run the lms jasmine tests for now because
-# they mostly all fail anyhow
-# rake phantomjs_jasmine_lms || true
+
+# Run the jaavascript unit tests
+rake phantomjs_jasmine_lms || TESTS_FAILED=1
 rake phantomjs_jasmine_cms || TESTS_FAILED=1
 rake phantomjs_jasmine_common/lib/xmodule || TESTS_FAILED=1
 
diff --git a/lms/djangoapps/certificates/management/commands/ungenerated_certs.py b/lms/djangoapps/certificates/management/commands/ungenerated_certs.py
index 071b2c261b..ab1459766a 100644
--- a/lms/djangoapps/certificates/management/commands/ungenerated_certs.py
+++ b/lms/djangoapps/certificates/management/commands/ungenerated_certs.py
@@ -73,6 +73,9 @@ class Command(BaseCommand):
                     ended_courses.append(course_id)
 
         for course_id in ended_courses:
+            # prefetch all chapters/sequentials by saying depth=2
+            course = modulestore().get_instance(course_id, CourseDescriptor.id_to_location(course_id), depth=2)
+
             print "Fetching enrolled students for {0}".format(course_id)
             enrolled_students = User.objects.filter(
                 courseenrollment__course_id=course_id).prefetch_related(
@@ -99,6 +102,6 @@ class Command(BaseCommand):
                         student, course_id)['status'] in valid_statuses:
                     if not options['noop']:
                         # Add the certificate request to the queue
-                        ret = xq.add_cert(student, course_id)
+                        ret = xq.add_cert(student, course_id, course=course)
                         if ret == 'generating':
                             print '{0} - {1}'.format(student, ret)
diff --git a/lms/djangoapps/certificates/queue.py b/lms/djangoapps/certificates/queue.py
index a7eb4e3c81..b4632ce9ab 100644
--- a/lms/djangoapps/certificates/queue.py
+++ b/lms/djangoapps/certificates/queue.py
@@ -115,7 +115,7 @@ class XQueueCertInterface(object):
 
         raise NotImplementedError
 
-    def add_cert(self, student, course_id):
+    def add_cert(self, student, course_id, course=None):
         """
 
         Arguments:
@@ -151,9 +151,12 @@ class XQueueCertInterface(object):
 
         if cert_status in VALID_STATUSES:
             # grade the student
-            course = courses.get_course_by_id(course_id)
-            profile = UserProfile.objects.get(user=student)
 
+            # re-use the course passed in optionally so we don't have to re-fetch everything
+            # for every student
+            if course is None:
+                course = courses.get_course_by_id(course_id)
+            profile = UserProfile.objects.get(user=student)
 
             cert, created = GeneratedCertificate.objects.get_or_create(
                    user=student, course_id=course_id)
diff --git a/lms/djangoapps/course_wiki/tests/tests.py b/lms/djangoapps/course_wiki/tests/tests.py
index cecc4f9cf9..620cf104d7 100644
--- a/lms/djangoapps/course_wiki/tests/tests.py
+++ b/lms/djangoapps/course_wiki/tests/tests.py
@@ -3,13 +3,11 @@ from django.test.utils import override_settings
 
 import xmodule.modulestore.django
 
-from courseware.tests.tests import PageLoader, TEST_DATA_XML_MODULESTORE
+from courseware.tests.tests import LoginEnrollmentTestCase, TEST_DATA_XML_MODULESTORE
 from xmodule.modulestore.django import modulestore
-from xmodule.modulestore.xml_importer import import_from_xml
-
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-class WikiRedirectTestCase(PageLoader):
+class WikiRedirectTestCase(LoginEnrollmentTestCase):
     def setUp(self):
         xmodule.modulestore.django._MODULESTORES = {}
         courses = modulestore().get_courses()
@@ -30,8 +28,6 @@ class WikiRedirectTestCase(PageLoader):
         self.activate_user(self.student)
         self.activate_user(self.instructor)
 
-
-
     def test_wiki_redirect(self):
         """
         Test that requesting wiki URLs redirect properly to or out of classes.
@@ -69,7 +65,6 @@ class WikiRedirectTestCase(PageLoader):
         self.assertEqual(resp.status_code, 302)
         self.assertEqual(resp['Location'], 'http://testserver' + destination)
 
-
     def create_course_page(self, course):
         """
         Test that loading the course wiki page creates the wiki page.
@@ -98,7 +93,6 @@ class WikiRedirectTestCase(PageLoader):
         self.assertTrue("course info" in resp.content.lower())
         self.assertTrue("courseware" in resp.content.lower())
 
-
     def test_course_navigator(self):
         """"
         Test that going from a course page to a wiki page contains the course navigator.
@@ -108,7 +102,6 @@ class WikiRedirectTestCase(PageLoader):
         self.enroll(self.toy)
         self.create_course_page(self.toy)
 
-
         course_wiki_page = reverse('wiki:get', kwargs={'path': self.toy.wiki_slug + '/'})
         referer = reverse("courseware", kwargs={'course_id': self.toy.id})
 
diff --git a/lms/djangoapps/courseware/features/common.py b/lms/djangoapps/courseware/features/common.py
index 7d41637c8e..f6256adfa1 100644
--- a/lms/djangoapps/courseware/features/common.py
+++ b/lms/djangoapps/courseware/features/common.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from nose.tools import assert_equals, assert_in
 from lettuce.django import django_url
@@ -6,83 +9,13 @@ from student.models import CourseEnrollment
 from xmodule.modulestore import Location
 from xmodule.modulestore.django import _MODULESTORES, modulestore
 from xmodule.templates import update_templates
-import time
+from xmodule.course_module import CourseDescriptor
+from courseware.courses import get_course_by_id
+from xmodule import seq_module, vertical_module
 
 from logging import getLogger
 logger = getLogger(__name__)
 
-
-@step(u'I wait (?:for )?"(\d+)" seconds?$')
-def wait(step, seconds):
-    time.sleep(float(seconds))
-
-
-@step('I (?:visit|access|open) the homepage$')
-def i_visit_the_homepage(step):
-    world.browser.visit(django_url('/'))
-    assert world.browser.is_element_present_by_css('header.global', 10)
-
-
-@step(u'I (?:visit|access|open) the dashboard$')
-def i_visit_the_dashboard(step):
-    world.browser.visit(django_url('/dashboard'))
-    assert world.browser.is_element_present_by_css('section.container.dashboard', 5)
-
-
-@step(r'click (?:the|a) link (?:called|with the text) "([^"]*)"$')
-def click_the_link_called(step, text):
-    world.browser.find_link_by_text(text).click()
-
-
-@step('I should be on the dashboard page$')
-def i_should_be_on_the_dashboard(step):
-    assert world.browser.is_element_present_by_css('section.container.dashboard', 5)
-    assert world.browser.title == 'Dashboard'
-
-
-@step(u'I (?:visit|access|open) the courses page$')
-def i_am_on_the_courses_page(step):
-    world.browser.visit(django_url('/courses'))
-    assert world.browser.is_element_present_by_css('section.courses')
-
-
-@step('I should see that the path is "([^"]*)"$')
-def i_should_see_that_the_path_is(step, path):
-    assert world.browser.url == django_url(path)
-
-
-@step(u'the page title should be "([^"]*)"$')
-def the_page_title_should_be(step, title):
-    assert world.browser.title == title
-
-
-@step(r'should see that the url is "([^"]*)"$')
-def should_have_the_url(step, url):
-    assert_equals(world.browser.url, url)
-
-
-@step(r'should see (?:the|a) link (?:called|with the text) "([^"]*)"$')
-def should_see_a_link_called(step, text):
-    assert len(world.browser.find_link_by_text(text)) > 0
-
-
-@step(r'should see "(.*)" (?:somewhere|anywhere) in (?:the|this) page')
-def should_see_in_the_page(step, text):
-    assert_in(text, world.browser.html)
-
-
-@step('I am logged in$')
-def i_am_logged_in(step):
-    world.create_user('robot')
-    world.log_in('robot', 'test')
-    world.browser.visit(django_url('/'))
-
-
-@step('I am not logged in$')
-def i_am_not_logged_in(step):
-    world.browser.cookies.delete()
-
-
 TEST_COURSE_ORG = 'edx'
 TEST_COURSE_NAME = 'Test Course'
 TEST_SECTION_NAME = "Problem"
@@ -94,7 +27,7 @@ def create_course(step, course):
     # First clear the modulestore so we don't try to recreate
     # the same course twice
     # This also ensures that the necessary templates are loaded
-    flush_xmodule_store()
+    world.clear_courses()
 
     # Create the course
     # We always use the same org and display name,
@@ -135,29 +68,6 @@ def add_tab_to_course(step, course, extra_tab_name):
                                             display_name=str(extra_tab_name))
 
 
-@step(u'I am an edX user$')
-def i_am_an_edx_user(step):
-    world.create_user('robot')
-
-
-@step(u'User "([^"]*)" is an edX user$')
-def registered_edx_user(step, uname):
-    world.create_user(uname)
-
-
-def flush_xmodule_store():
-    # Flush and initialize the module store
-    # It needs the templates because it creates new records
-    # by cloning from the template.
-    # Note that if your test module gets in some weird state
-    # (though it shouldn't), do this manually
-    # from the bash shell to drop it:
-    # $ mongo test_xmodule --eval "db.dropDatabase()"
-    _MODULESTORES = {}
-    modulestore().collection.drop()
-    update_templates()
-
-
 def course_id(course_num):
     return "%s/%s/%s" % (TEST_COURSE_ORG, course_num,
                          TEST_COURSE_NAME.replace(" ", "_"))
@@ -177,3 +87,87 @@ def section_location(course_num):
                     course=course_num,
                     category='sequential',
                     name=TEST_SECTION_NAME.replace(" ", "_"))
+
+
+def get_courses():
+    '''
+    Returns dict of lists of courses available, keyed by course.org (ie university).
+    Courses are sorted by course.number.
+    '''
+    courses = [c for c in modulestore().get_courses()
+               if isinstance(c, CourseDescriptor)]
+    courses = sorted(courses, key=lambda course: course.number)
+    return courses
+
+
+def get_courseware_with_tabs(course_id):
+    """
+    Given a course_id (string), return a courseware array of dictionaries for the
+    top three levels of navigation. Same as get_courseware() except include
+    the tabs on the right hand main navigation page.
+
+    This hides the appropriate courseware as defined by the hide_from_toc field:
+    chapter.lms.hide_from_toc
+
+    Example:
+
+    [{
+        'chapter_name': 'Overview',
+        'sections': [{
+            'clickable_tab_count': 0,
+            'section_name': 'Welcome',
+            'tab_classes': []
+        }, {
+            'clickable_tab_count': 1,
+            'section_name': 'System Usage Sequence',
+            'tab_classes': ['VerticalDescriptor']
+        }, {
+            'clickable_tab_count': 0,
+            'section_name': 'Lab0: Using the tools',
+            'tab_classes': ['HtmlDescriptor', 'HtmlDescriptor', 'CapaDescriptor']
+        }, {
+            'clickable_tab_count': 0,
+            'section_name': 'Circuit Sandbox',
+            'tab_classes': []
+        }]
+    }, {
+        'chapter_name': 'Week 1',
+        'sections': [{
+            'clickable_tab_count': 4,
+            'section_name': 'Administrivia and Circuit Elements',
+            'tab_classes': ['VerticalDescriptor', 'VerticalDescriptor', 'VerticalDescriptor', 'VerticalDescriptor']
+        }, {
+            'clickable_tab_count': 0,
+            'section_name': 'Basic Circuit Analysis',
+            'tab_classes': ['CapaDescriptor', 'CapaDescriptor', 'CapaDescriptor']
+        }, {
+            'clickable_tab_count': 0,
+            'section_name': 'Resistor Divider',
+            'tab_classes': []
+        }, {
+            'clickable_tab_count': 0,
+            'section_name': 'Week 1 Tutorials',
+            'tab_classes': []
+        }]
+    }, {
+        'chapter_name': 'Midterm Exam',
+        'sections': [{
+            'clickable_tab_count': 2,
+            'section_name': 'Midterm Exam',
+            'tab_classes': ['VerticalDescriptor', 'VerticalDescriptor']
+        }]
+    }]
+    """
+
+    course = get_course_by_id(course_id)
+    chapters = [chapter for chapter in course.get_children() if not chapter.lms.hide_from_toc]
+    courseware = [{'chapter_name': c.display_name_with_default,
+                   'sections': [{'section_name': s.display_name_with_default,
+                                'clickable_tab_count': len(s.get_children()) if (type(s) == seq_module.SequenceDescriptor) else 0,
+                                'tabs': [{'children_count': len(t.get_children()) if (type(t) == vertical_module.VerticalDescriptor) else 0,
+                                         'class': t.__class__.__name__}
+                                         for t in s.get_children()]}
+                                for s in c.get_children() if not s.lms.hide_from_toc]}
+                  for c in chapters]
+
+    return courseware
diff --git a/lms/djangoapps/courseware/features/courses.py b/lms/djangoapps/courseware/features/courses.py
deleted file mode 100644
index c99fb58b85..0000000000
--- a/lms/djangoapps/courseware/features/courses.py
+++ /dev/null
@@ -1,234 +0,0 @@
-from lettuce import world
-from xmodule.course_module import CourseDescriptor
-from xmodule.modulestore.django import modulestore
-from courseware.courses import get_course_by_id
-from xmodule import seq_module, vertical_module
-
-from logging import getLogger
-logger = getLogger(__name__)
-
-## support functions
-
-
-def get_courses():
-    '''
-    Returns dict of lists of courses available, keyed by course.org (ie university).
-    Courses are sorted by course.number.
-    '''
-    courses = [c for c in modulestore().get_courses()
-               if isinstance(c, CourseDescriptor)]
-    courses = sorted(courses, key=lambda course: course.number)
-    return courses
-
-
-def get_courseware_with_tabs(course_id):
-    """
-    Given a course_id (string), return a courseware array of dictionaries for the
-    top three levels of navigation. Same as get_courseware() except include
-    the tabs on the right hand main navigation page.
-
-    This hides the appropriate courseware as defined by the hide_from_toc field:
-    chapter.lms.hide_from_toc
-
-    Example:
-
-    [{
-        'chapter_name': 'Overview',
-        'sections': [{
-            'clickable_tab_count': 0,
-            'section_name': 'Welcome',
-            'tab_classes': []
-        }, {
-            'clickable_tab_count': 1,
-            'section_name': 'System Usage Sequence',
-            'tab_classes': ['VerticalDescriptor']
-        }, {
-            'clickable_tab_count': 0,
-            'section_name': 'Lab0: Using the tools',
-            'tab_classes': ['HtmlDescriptor', 'HtmlDescriptor', 'CapaDescriptor']
-        }, {
-            'clickable_tab_count': 0,
-            'section_name': 'Circuit Sandbox',
-            'tab_classes': []
-        }]
-    }, {
-        'chapter_name': 'Week 1',
-        'sections': [{
-            'clickable_tab_count': 4,
-            'section_name': 'Administrivia and Circuit Elements',
-            'tab_classes': ['VerticalDescriptor', 'VerticalDescriptor', 'VerticalDescriptor', 'VerticalDescriptor']
-        }, {
-            'clickable_tab_count': 0,
-            'section_name': 'Basic Circuit Analysis',
-            'tab_classes': ['CapaDescriptor', 'CapaDescriptor', 'CapaDescriptor']
-        }, {
-            'clickable_tab_count': 0,
-            'section_name': 'Resistor Divider',
-            'tab_classes': []
-        }, {
-            'clickable_tab_count': 0,
-            'section_name': 'Week 1 Tutorials',
-            'tab_classes': []
-        }]
-    }, {
-        'chapter_name': 'Midterm Exam',
-        'sections': [{
-            'clickable_tab_count': 2,
-            'section_name': 'Midterm Exam',
-            'tab_classes': ['VerticalDescriptor', 'VerticalDescriptor']
-        }]
-    }]
-    """
-
-    course = get_course_by_id(course_id)
-    chapters = [chapter for chapter in course.get_children() if not chapter.lms.hide_from_toc]
-    courseware = [{'chapter_name': c.display_name_with_default,
-                   'sections': [{'section_name': s.display_name_with_default,
-                                'clickable_tab_count': len(s.get_children()) if (type(s) == seq_module.SequenceDescriptor) else 0,
-                                'tabs': [{'children_count': len(t.get_children()) if (type(t) == vertical_module.VerticalDescriptor) else 0,
-                                         'class': t.__class__.__name__}
-                                         for t in s.get_children()]}
-                                for s in c.get_children() if not s.lms.hide_from_toc]}
-                  for c in chapters]
-
-    return courseware
-
-
-def process_section(element, num_tabs=0):
-    '''
-    Process section reads through whatever is in 'course-content' and classifies it according to sequence module type.
-
-    This function is recursive
-
-    There are 6 types, with 6 actions.
-
-    Sequence Module
-    -contains one child module
-
-    Vertical Module
-    -contains other modules
-    -process it and get its children, then process them
-
-    Capa Module
-    -problem type, contains only one problem
-    -for this, the most complex type, we created a separate method, process_problem
-
-    Video Module
-    -video type, contains only one video
-    -we only check to ensure that a section with class of video exists
-
-    HTML Module
-    -html text
-    -we do not check anything about it
-
-    Custom Tag Module
-    -a custom 'hack' module type
-    -there is a large variety of content that could go in a custom tag module, so we just pass if it is of this unusual type
-
-    can be used like this:
-    e = world.browser.find_by_css('section.course-content section')
-    process_section(e)
-
-    '''
-    if element.has_class('xmodule_display xmodule_SequenceModule'):
-        logger.debug('####### Processing xmodule_SequenceModule')
-        child_modules = element.find_by_css("div>div>section[class^='xmodule']")
-        for mod in child_modules:
-            process_section(mod)
-
-    elif element.has_class('xmodule_display xmodule_VerticalModule'):
-        logger.debug('####### Processing xmodule_VerticalModule')
-        vert_list = element.find_by_css("li section[class^='xmodule']")
-        for item in vert_list:
-            process_section(item)
-
-    elif element.has_class('xmodule_display xmodule_CapaModule'):
-        logger.debug('####### Processing xmodule_CapaModule')
-        assert element.find_by_css("section[id^='problem']"), "No problems found in Capa Module"
-        p = element.find_by_css("section[id^='problem']").first
-        p_id = p['id']
-        logger.debug('####################')
-        logger.debug('id is "%s"' % p_id)
-        logger.debug('####################')
-        process_problem(p, p_id)
-
-    elif element.has_class('xmodule_display xmodule_VideoModule'):
-        logger.debug('####### Processing xmodule_VideoModule')
-        assert element.find_by_css("section[class^='video']"), "No video found in Video Module"
-
-    elif element.has_class('xmodule_display xmodule_HtmlModule'):
-        logger.debug('####### Processing xmodule_HtmlModule')
-        pass
-
-    elif element.has_class('xmodule_display xmodule_CustomTagModule'):
-        logger.debug('####### Processing xmodule_CustomTagModule')
-        pass
-
-    else:
-        assert False, "Class for element not recognized!!"
-
-
-def process_problem(element, problem_id):
-    '''
-    Process problem attempts to
-    1) scan all the input fields and reset them
-    2) click the 'check' button and look for an incorrect response (p.status text should be 'incorrect')
-    3) click the 'show answer' button IF it exists and IF the answer is not already displayed
-    4) enter the correct answer in each input box
-    5) click the 'check' button and verify that answers are correct
-
-    Because of all the ajax calls happening, sometimes the test fails because objects disconnect from the DOM.
-    The basic functionality does exist, though, and I'm hoping that someone can take it over and make it super effective.
-    '''
-
-    prob_xmod = element.find_by_css("section.problem").first
-    input_fields = prob_xmod.find_by_css("section[id^='input']")
-
-    ## clear out all input to ensure an incorrect result
-    for field in input_fields:
-        field.find_by_css("input").first.fill('')
-
-    ## because of cookies or the application, only click the 'check' button if the status is not already 'incorrect'
-    # This would need to be reworked because multiple choice problems don't have this status
-    # if prob_xmod.find_by_css("p.status").first.text.strip().lower() != 'incorrect':
-    prob_xmod.find_by_css("section.action input.check").first.click()
-
-    ## all elements become disconnected after the click
-    ## grab element and prob_xmod because the dom has changed (some classes/elements became hidden and changed the hierarchy)
-    # Wait for the ajax reload
-    assert world.browser.is_element_present_by_css("section[id='%s']" % problem_id, wait_time=5)
-    element = world.browser.find_by_css("section[id='%s']" % problem_id).first
-    prob_xmod = element.find_by_css("section.problem").first
-    input_fields = prob_xmod.find_by_css("section[id^='input']")
-    for field in input_fields:
-        assert field.find_by_css("div.incorrect"), "The 'check' button did not work for %s" % (problem_id)
-
-    show_button = element.find_by_css("section.action input.show").first
-    ## this logic is to ensure we do not accidentally hide the answers
-    if show_button.value.lower() == 'show answer':
-        show_button.click()
-    else:
-        pass
-
-    ## grab element and prob_xmod because the dom has changed (some classes/elements became hidden and changed the hierarchy)
-    assert world.browser.is_element_present_by_css("section[id='%s']" % problem_id, wait_time=5)
-    element = world.browser.find_by_css("section[id='%s']" % problem_id).first
-    prob_xmod = element.find_by_css("section.problem").first
-    input_fields = prob_xmod.find_by_css("section[id^='input']")
-
-    ## in each field, find the answer, and send it to the field.
-    ## Note that this does not work if the answer type is a strange format, e.g. "either a or b"
-    for field in input_fields:
-        field.find_by_css("input").first.fill(field.find_by_css("p[id^='answer']").first.text)
-
-    prob_xmod.find_by_css("section.action input.check").first.click()
-
-    ## assert that we entered the correct answers
-    ## grab element and prob_xmod because the dom has changed (some classes/elements became hidden and changed the hierarchy)
-    assert world.browser.is_element_present_by_css("section[id='%s']" % problem_id, wait_time=5)
-    element = world.browser.find_by_css("section[id='%s']" % problem_id).first
-    prob_xmod = element.find_by_css("section.problem").first
-    input_fields = prob_xmod.find_by_css("section[id^='input']")
-    for field in input_fields:
-        ## if you don't use 'starts with ^=' the test will fail because the actual class is 'correct ' (with a space)
-        assert field.find_by_css("div[class^='correct']"), "The check answer values were not correct for %s" % problem_id
diff --git a/lms/djangoapps/courseware/features/courseware.py b/lms/djangoapps/courseware/features/courseware.py
index 7e99cc9f55..234f3a84d2 100644
--- a/lms/djangoapps/courseware/features/courseware.py
+++ b/lms/djangoapps/courseware/features/courseware.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from lettuce.django import django_url
 
diff --git a/lms/djangoapps/courseware/features/courseware_common.py b/lms/djangoapps/courseware/features/courseware_common.py
index 96304e016f..4e9aa3fb7b 100644
--- a/lms/djangoapps/courseware/features/courseware_common.py
+++ b/lms/djangoapps/courseware/features/courseware_common.py
@@ -1,23 +1,23 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
-from lettuce.django import django_url
 
 
 @step('I click on View Courseware')
 def i_click_on_view_courseware(step):
-    css = 'a.enter-course'
-    world.browser.find_by_css(css).first.click()
+    world.css_click('a.enter-course')
 
 
 @step('I click on the "([^"]*)" tab$')
-def i_click_on_the_tab(step, tab):
-    world.browser.find_link_by_partial_text(tab).first.click()
+def i_click_on_the_tab(step, tab_text):
+    world.click_link(tab_text)
     world.save_the_html()
 
 
 @step('I visit the courseware URL$')
 def i_visit_the_course_info_url(step):
-    url = django_url('/courses/MITx/6.002x/2012_Fall/courseware')
-    world.browser.visit(url)
+    world.visit('/courses/MITx/6.002x/2012_Fall/courseware')
 
 
 @step(u'I do not see "([^"]*)" anywhere on the page')
@@ -27,18 +27,15 @@ def i_do_not_see_text_anywhere_on_the_page(step, text):
 
 @step(u'I am on the dashboard page$')
 def i_am_on_the_dashboard_page(step):
-    assert world.browser.is_element_present_by_css('section.courses')
-    assert world.browser.url == django_url('/dashboard')
+    assert world.is_css_present('section.courses')
+    assert world.url_equals('/dashboard')
 
 
 @step('the "([^"]*)" tab is active$')
-def the_tab_is_active(step, tab):
-    css = '.course-tabs a.active'
-    active_tab = world.browser.find_by_css(css)
-    assert (active_tab.text == tab)
+def the_tab_is_active(step, tab_text):
+    assert world.css_text('.course-tabs a.active') == tab_text
 
 
 @step('the login dialog is visible$')
 def login_dialog_visible(step):
-    css = 'form#login_form.login_form'
-    assert world.browser.find_by_css(css).visible
+    assert world.css_visible('form#login_form.login_form')
diff --git a/lms/djangoapps/courseware/features/high-level-tabs.feature b/lms/djangoapps/courseware/features/high-level-tabs.feature
index 473f3f1572..c60ec7b374 100644
--- a/lms/djangoapps/courseware/features/high-level-tabs.feature
+++ b/lms/djangoapps/courseware/features/high-level-tabs.feature
@@ -3,7 +3,7 @@ Feature: All the high level tabs should work
   As a student
   I want to navigate through the high level tabs
 
-Scenario: I can navigate to all high -level tabs in a course
+Scenario: I can navigate to all high - level tabs in a course
         Given: I am registered for the course "6.002x"
         And The course "6.002x" has extra tab "Custom Tab"
         And I am logged in
diff --git a/lms/djangoapps/courseware/features/homepage.py b/lms/djangoapps/courseware/features/homepage.py
index 442098c161..62e9096e70 100644
--- a/lms/djangoapps/courseware/features/homepage.py
+++ b/lms/djangoapps/courseware/features/homepage.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from nose.tools import assert_in
 
diff --git a/lms/djangoapps/courseware/features/login.py b/lms/djangoapps/courseware/features/login.py
index 094db078ca..bc90ea301c 100644
--- a/lms/djangoapps/courseware/features/login.py
+++ b/lms/djangoapps/courseware/features/login.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import step, world
 from django.contrib.auth.models import User
 
@@ -28,9 +31,7 @@ def i_should_see_the_login_error_message(step, msg):
 
 @step(u'click the dropdown arrow$')
 def click_the_dropdown(step):
-    css = ".dropdown"
-    e = world.browser.find_by_css(css)
-    e.click()
+    world.css_click('.dropdown')
 
 #### helper functions
 
diff --git a/lms/djangoapps/courseware/features/openended.py b/lms/djangoapps/courseware/features/openended.py
index 0725a051ff..d848eb55d7 100644
--- a/lms/djangoapps/courseware/features/openended.py
+++ b/lms/djangoapps/courseware/features/openended.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from lettuce.django import django_url
 from nose.tools import assert_equals, assert_in
@@ -12,7 +15,7 @@ def navigate_to_an_openended_question(step):
     problem = '/courses/MITx/3.091x/2012_Fall/courseware/Week_10/Polymer_Synthesis/'
     world.browser.visit(django_url(problem))
     tab_css = 'ol#sequence-list > li > a[data-element="5"]'
-    world.browser.find_by_css(tab_css).click()
+    world.css_click(tab_css)
 
 
 @step('I navigate to an openended question as staff$')
@@ -22,81 +25,69 @@ def navigate_to_an_openended_question_as_staff(step):
     problem = '/courses/MITx/3.091x/2012_Fall/courseware/Week_10/Polymer_Synthesis/'
     world.browser.visit(django_url(problem))
     tab_css = 'ol#sequence-list > li > a[data-element="5"]'
-    world.browser.find_by_css(tab_css).click()
+    world.css_click(tab_css)
 
 
 @step(u'I enter the answer "([^"]*)"$')
 def enter_the_answer_text(step, text):
-    textarea_css = 'textarea'
-    world.browser.find_by_css(textarea_css).first.fill(text)
+    world.css_fill('textarea', text)
 
 
 @step(u'I submit the answer "([^"]*)"$')
 def i_submit_the_answer_text(step, text):
-    textarea_css = 'textarea'
-    world.browser.find_by_css(textarea_css).first.fill(text)
-    check_css = 'input.check'
-    world.browser.find_by_css(check_css).click()
+    world.css_fill('textarea', text)
+    world.css_click('input.check')
 
 
 @step('I click the link for full output$')
 def click_full_output_link(step):
-    link_css = 'a.full'
-    world.browser.find_by_css(link_css).first.click()
+    world.css_click('a.full')
 
 
 @step(u'I visit the staff grading page$')
 def i_visit_the_staff_grading_page(step):
-    # course_u = '/courses/MITx/3.091x/2012_Fall'
-    # sg_url = '%s/staff_grading' % course_u
-    world.browser.click_link_by_text('Instructor')
-    world.browser.click_link_by_text('Staff grading')
-    # world.browser.visit(django_url(sg_url))
+    world.click_link('Instructor')
+    world.click_link('Staff grading')
 
 
 @step(u'I see the grader message "([^"]*)"$')
 def see_grader_message(step, msg):
     message_css = 'div.external-grader-message'
-    grader_msg = world.browser.find_by_css(message_css).text
-    assert_in(msg, grader_msg)
+    assert_in(msg, world.css_text(message_css))
 
 
 @step(u'I see the grader status "([^"]*)"$')
 def see_the_grader_status(step, status):
     status_css = 'div.grader-status'
-    grader_status = world.browser.find_by_css(status_css).text
-    assert_equals(status, grader_status)
+    assert_equals(status, world.css_text(status_css))
 
 
 @step('I see the red X$')
 def see_the_red_x(step):
-    x_css = 'div.grader-status > span.incorrect'
-    assert world.browser.find_by_css(x_css)
+    assert world.is_css_present('div.grader-status > span.incorrect')
 
 
 @step(u'I see the grader score "([^"]*)"$')
 def see_the_grader_score(step, score):
     score_css = 'div.result-output > p'
-    score_text = world.browser.find_by_css(score_css).text
+    score_text = world.css_text(score_css)
     assert_equals(score_text, 'Score: %s' % score)
 
 
 @step('I see the link for full output$')
 def see_full_output_link(step):
-    link_css = 'a.full'
-    assert world.browser.find_by_css(link_css)
+    assert world.is_css_present('a.full')
 
 
 @step('I see the spelling grading message "([^"]*)"$')
 def see_spelling_msg(step, msg):
-    spelling_css = 'div.spelling'
-    spelling_msg = world.browser.find_by_css(spelling_css).text
+    spelling_msg = world.css_text('div.spelling')
     assert_equals('Spelling: %s' % msg, spelling_msg)
 
 
 @step(u'my answer is queued for instructor grading$')
 def answer_is_queued_for_instructor_grading(step):
     list_css = 'ul.problem-list > li > a'
-    actual_msg = world.browser.find_by_css(list_css).text
+    actual_msg = world.css_text(list_css)
     expected_msg = "(0 graded, 1 pending)"
     assert_in(expected_msg, actual_msg)
diff --git a/lms/djangoapps/courseware/features/problems.py b/lms/djangoapps/courseware/features/problems.py
index d2d379a212..b25d606c4e 100644
--- a/lms/djangoapps/courseware/features/problems.py
+++ b/lms/djangoapps/courseware/features/problems.py
@@ -2,6 +2,8 @@
 Steps for problem.feature lettuce tests
 '''
 
+#pylint: disable=C0111
+#pylint: disable=W0621
 
 from lettuce import world, step
 from lettuce.django import django_url
@@ -339,7 +341,7 @@ def assert_answer_mark(step, problem_type, correctness):
 
     # At least one of the correct selectors should be present
     for sel in selector_dict[problem_type]:
-        has_expected = world.browser.is_element_present_by_css(sel, wait_time=4)
+        has_expected = world.is_css_present(sel)
 
         # As soon as we find the selector, break out of the loop
         if has_expected:
@@ -366,7 +368,7 @@ def inputfield(problem_type, choice=None, input_num=1):
 
 
     # If the input element doesn't exist, fail immediately
-    assert(world.browser.is_element_present_by_css(sel, wait_time=4))
+    assert world.is_css_present(sel)
 
     # Retrieve the input element
     return world.browser.find_by_css(sel)
diff --git a/lms/djangoapps/courseware/features/registration.py b/lms/djangoapps/courseware/features/registration.py
index 94b9b50f6c..72bde65f99 100644
--- a/lms/djangoapps/courseware/features/registration.py
+++ b/lms/djangoapps/courseware/features/registration.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from lettuce.django import django_url
 from common import TEST_COURSE_ORG, TEST_COURSE_NAME
@@ -13,17 +16,17 @@ def i_register_for_the_course(step, course):
     register_link = intro_section.find_by_css('a.register')
     register_link.click()
 
-    assert world.browser.is_element_present_by_css('section.container.dashboard')
+    assert world.is_css_present('section.container.dashboard')
 
 
 @step(u'I should see the course numbered "([^"]*)" in my dashboard$')
 def i_should_see_that_course_in_my_dashboard(step, course):
     course_link_css = 'section.my-courses a[href*="%s"]' % course
-    assert world.browser.is_element_present_by_css(course_link_css)
+    assert world.is_css_present(course_link_css)
 
 
 @step(u'I press the "([^"]*)" button in the Unenroll dialog')
 def i_press_the_button_in_the_unenroll_dialog(step, value):
     button_css = 'section#unenroll-modal input[value="%s"]' % value
-    world.browser.find_by_css(button_css).click()
-    assert world.browser.is_element_present_by_css('section.container.dashboard')
+    world.css_click(button_css)
+    assert world.is_css_present('section.container.dashboard')
diff --git a/lms/djangoapps/courseware/features/signup.py b/lms/djangoapps/courseware/features/signup.py
index 3a697a6102..5ba385ef54 100644
--- a/lms/djangoapps/courseware/features/signup.py
+++ b/lms/djangoapps/courseware/features/signup.py
@@ -1,5 +1,7 @@
-from lettuce import world, step
+#pylint: disable=C0111
+#pylint: disable=W0621
 
+from lettuce import world, step
 
 @step('I fill in "([^"]*)" on the registration form with "([^"]*)"$')
 def when_i_fill_in_field_on_the_registration_form_with_value(step, field, value):
@@ -22,4 +24,4 @@ def i_check_checkbox(step, checkbox):
 @step('I should see "([^"]*)" in the dashboard banner$')
 def i_should_see_text_in_the_dashboard_banner_section(step, text):
     css_selector = "section.dashboard-banner h2"
-    assert (text in world.browser.find_by_css(css_selector).text)
+    assert (text in world.css_text(css_selector))
diff --git a/lms/djangoapps/courseware/features/smart-accordion.py b/lms/djangoapps/courseware/features/smart-accordion.py
index a7eb782722..63408d7683 100644
--- a/lms/djangoapps/courseware/features/smart-accordion.py
+++ b/lms/djangoapps/courseware/features/smart-accordion.py
@@ -1,8 +1,11 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from lettuce import world, step
 from re import sub
 from nose.tools import assert_equals
 from xmodule.modulestore.django import modulestore
-from courses import *
+from common import *
 
 from logging import getLogger
 logger = getLogger(__name__)
@@ -32,20 +35,20 @@ def i_verify_all_the_content_of_each_course(step):
         pass
 
     for test_course in registered_courses:
-        test_course.find_by_css('a').click()
+        test_course.css_click('a')
         check_for_errors()
 
         # Get the course. E.g. 'MITx/6.002x/2012_Fall'
         current_course = sub('/info', '', sub('.*/courses/', '', world.browser.url))
         validate_course(current_course, ids)
 
-        world.browser.find_link_by_text('Courseware').click()
-        assert world.browser.is_element_present_by_id('accordion', wait_time=2)
+        world.click_link('Courseware')
+        assert world.is_css_present('accordion')
         check_for_errors()
         browse_course(current_course)
 
         # clicking the user link gets you back to the user's home page
-        world.browser.find_by_css('.user-link').click()
+        world.css_click('.user-link')
         check_for_errors()
 
 
@@ -94,7 +97,7 @@ def browse_course(course_id):
             world.browser.find_by_css('#accordion > nav > div')[chapter_it].find_by_tag('li')[section_it].find_by_tag('a').click()
 
             ## sometimes the course-content takes a long time to load
-            assert world.browser.is_element_present_by_css('.course-content', wait_time=5)
+            assert world.is_css_present('.course-content')
 
             ## look for server error div
             check_for_errors()
diff --git a/lms/djangoapps/courseware/features/xqueue_setup.py b/lms/djangoapps/courseware/features/xqueue_setup.py
index 23706941a9..90a68961ee 100644
--- a/lms/djangoapps/courseware/features/xqueue_setup.py
+++ b/lms/djangoapps/courseware/features/xqueue_setup.py
@@ -1,3 +1,6 @@
+#pylint: disable=C0111
+#pylint: disable=W0621
+
 from courseware.mock_xqueue_server.mock_xqueue_server import MockXQueueServer
 from lettuce import before, after, world
 from django.conf import settings
diff --git a/lms/djangoapps/courseware/grades.py b/lms/djangoapps/courseware/grades.py
index ba29b25d40..51c0b21799 100644
--- a/lms/djangoapps/courseware/grades.py
+++ b/lms/djangoapps/courseware/grades.py
@@ -13,7 +13,6 @@ from xblock.core import Scope
 from .module_render import get_module, get_module_for_descriptor
 from xmodule import graders
 from xmodule.capa_module import CapaModule
-from xmodule.course_module import CourseDescriptor
 from xmodule.graders import Score
 from .models import StudentModule
 
@@ -43,7 +42,6 @@ def yield_dynamic_descriptor_descendents(descriptor, module_creator):
         else:
             return descriptor.get_children()
 
-
     stack = [descriptor]
 
     while len(stack) > 0:
@@ -66,7 +64,7 @@ def yield_problems(request, course, student):
     ).values_list('module_state_key', flat=True))
 
     sections_to_list = []
-    for section_format, sections in grading_context['graded_sections'].iteritems():
+    for _, sections in grading_context['graded_sections'].iteritems():
         for section in sections:
 
             section_descriptor = section['section_descriptor']
@@ -123,7 +121,7 @@ def answer_distributions(request, course):
 
 def grade(student, request, course, model_data_cache=None, keep_raw_scores=False):
     """
-    This grades a student as quickly as possible. It retuns the
+    This grades a student as quickly as possible. It returns the
     output from the course grader, augmented with the final letter
     grade. The keys in the output are:
 
@@ -158,6 +156,12 @@ def grade(student, request, course, model_data_cache=None, keep_raw_scores=False
             should_grade_section = False
             # If we haven't seen a single problem in the section, we don't have to grade it at all! We can assume 0%
             for moduledescriptor in section['xmoduledescriptors']:
+                # some problems have state that is updated independently of interaction
+                # with the LMS, so they need to always be scored. (E.g. foldit.)
+                if moduledescriptor.always_recalculate_grades:
+                    should_grade_section = True
+                    break
+
                 # Create a fake key to pull out a StudentModule object from the ModelDataCache
 
                 key = LmsKeyValueStore.Key(
@@ -174,7 +178,8 @@ def grade(student, request, course, model_data_cache=None, keep_raw_scores=False
                 scores = []
 
                 def create_module(descriptor):
-                    # TODO: We need the request to pass into here. If we could forgo that, our arguments
+                    '''creates an XModule instance given a descriptor'''
+                    # TODO: We need the request to pass into here. If we could forego that, our arguments
                     # would be simpler
                     return get_module_for_descriptor(student, request, descriptor, model_data_cache, course.id)
 
@@ -197,18 +202,18 @@ def grade(student, request, course, model_data_cache=None, keep_raw_scores=False
 
                     scores.append(Score(correct, total, graded, module_descriptor.display_name_with_default))
 
-                section_total, graded_total = graders.aggregate_scores(scores, section_name)
+                _, graded_total = graders.aggregate_scores(scores, section_name)
                 if keep_raw_scores:
                     raw_scores += scores
             else:
-                section_total = Score(0.0, 1.0, False, section_name)
                 graded_total = Score(0.0, 1.0, True, section_name)
 
             #Add the graded total to totaled_scores
             if graded_total.possible > 0:
                 format_scores.append(graded_total)
             else:
-                log.exception("Unable to grade a section with a total possible score of zero. " + str(section_descriptor.location))
+                log.exception("Unable to grade a section with a total possible score of zero. " +
+                              str(section_descriptor.location))
 
         totaled_scores[section_format] = format_scores
 
@@ -274,12 +279,9 @@ def progress_summary(student, request, course, model_data_cache):
 
     """
 
-
-    # TODO: We need the request to pass into here. If we could forgo that, our arguments
+    # TODO: We need the request to pass into here. If we could forego that, our arguments
     # would be simpler
-    course_module = get_module(student, request,
-                                course.location, model_data_cache,
-                                course.id, depth=None)
+    course_module = get_module(student, request, course.location, model_data_cache, course.id, depth=None)
     if not course_module:
         # This student must not have access to the course.
         return None
@@ -310,20 +312,19 @@ def progress_summary(student, request, course, model_data_cache):
                 if correct is None and total is None:
                     continue
 
-                scores.append(Score(correct, total, graded,
-                    module_descriptor.display_name_with_default))
+                scores.append(Score(correct, total, graded, module_descriptor.display_name_with_default))
 
             scores.reverse()
-            section_total, graded_total = graders.aggregate_scores(
+            section_total, _ = graders.aggregate_scores(
                 scores, section_module.display_name_with_default)
 
-            format = section_module.lms.format if section_module.lms.format is not None else ''
+            module_format = section_module.lms.format if section_module.lms.format is not None else ''
             sections.append({
                 'display_name': section_module.display_name_with_default,
                 'url_name': section_module.url_name,
                 'scores': scores,
                 'section_total': section_total,
-                'format': format,
+                'format': module_format,
                 'due': section_module.lms.due,
                 'graded': graded,
             })
@@ -353,11 +354,13 @@ def get_score(course_id, user, problem_descriptor, module_creator, model_data_ca
     if not user.is_authenticated():
         return (None, None)
 
+    # some problems have state that is updated independently of interaction
+    # with the LMS, so they need to always be scored. (E.g. foldit.)
     if problem_descriptor.always_recalculate_grades:
         problem = module_creator(problem_descriptor)
-        d = problem.get_score()
-        if d is not None:
-            return (d['score'], d['total'])
+        score = problem.get_score()
+        if score is not None:
+            return (score['score'], score['total'])
         else:
             return (None, None)
 
@@ -394,7 +397,7 @@ def get_score(course_id, user, problem_descriptor, module_creator, model_data_ca
         if total is None:
             return (None, None)
 
-    #Now we re-weight the problem, if specified
+    # Now we re-weight the problem, if specified
     weight = problem_descriptor.weight
     if weight is not None:
         if total == 0:
diff --git a/lms/djangoapps/courseware/mock_xqueue_server/test_mock_xqueue_server.py b/lms/djangoapps/courseware/mock_xqueue_server/test_mock_xqueue_server.py
index 4e4d95f23b..3f9a8e5b42 100644
--- a/lms/djangoapps/courseware/mock_xqueue_server/test_mock_xqueue_server.py
+++ b/lms/djangoapps/courseware/mock_xqueue_server/test_mock_xqueue_server.py
@@ -3,10 +3,11 @@ import unittest
 import threading
 import json
 import urllib
-import urlparse
 import time
 from mock_xqueue_server import MockXQueueServer, MockXQueueRequestHandler
 
+from nose.plugins.skip import SkipTest
+
 
 class MockXQueueServerTest(unittest.TestCase):
     '''
@@ -22,11 +23,16 @@ class MockXQueueServerTest(unittest.TestCase):
 
     def setUp(self):
 
+        # This is a test of the test setup,
+        # so it does not need to run as part of the unit test suite
+        # You can re-enable it by commenting out the line below
+        raise SkipTest
+
         # Create the server
         server_port = 8034
         self.server_url = 'http://127.0.0.1:%d' % server_port
         self.server = MockXQueueServer(server_port,
-                                {'correct': True, 'score': 1, 'msg': ''})
+                                       {'correct': True, 'score': 1, 'msg': ''})
 
         # Start the server in a separate daemon thread
         server_thread = threading.Thread(target=self.server.serve_forever)
@@ -48,18 +54,18 @@ class MockXQueueServerTest(unittest.TestCase):
         callback_url = 'http://127.0.0.1:8000/test_callback'
 
         grade_header = json.dumps({'lms_callback_url': callback_url,
-                                    'lms_key': 'test_queuekey',
-                                    'queue_name': 'test_queue'})
+                                   'lms_key': 'test_queuekey',
+                                   'queue_name': 'test_queue'})
 
         grade_body = json.dumps({'student_info': 'test',
                                 'grader_payload': 'test',
                                 'student_response': 'test'})
 
         grade_request = {'xqueue_header': grade_header,
-                        'xqueue_body': grade_body}
+                         'xqueue_body': grade_body}
 
         response_handle = urllib.urlopen(self.server_url + '/xqueue/submit',
-                                urllib.urlencode(grade_request))
+                                         urllib.urlencode(grade_request))
 
         response_dict = json.loads(response_handle.read())
 
@@ -71,8 +77,8 @@ class MockXQueueServerTest(unittest.TestCase):
 
         # Expect that the server tries to post back the grading info
         xqueue_body = json.dumps({'correct': True, 'score': 1,
-                                    'msg': '<div></div>'})
+                                  'msg': '<div></div>'})
         expected_callback_dict = {'xqueue_header': grade_header,
-                                'xqueue_body': xqueue_body}
+                                  'xqueue_body': xqueue_body}
         MockXQueueRequestHandler.post_to_url.assert_called_with(callback_url,
-                                                        expected_callback_dict)
+                                                                expected_callback_dict)
diff --git a/lms/djangoapps/courseware/module_render.py b/lms/djangoapps/courseware/module_render.py
index 973940d784..4e7b5dd35c 100644
--- a/lms/djangoapps/courseware/module_render.py
+++ b/lms/djangoapps/courseware/module_render.py
@@ -8,9 +8,10 @@ from functools import partial
 
 from django.conf import settings
 from django.contrib.auth.models import User
+from django.core.exceptions import PermissionDenied
 from django.core.urlresolvers import reverse
 from django.http import Http404
-from django.http import HttpResponse
+from django.http import HttpResponse, HttpResponseBadRequest
 from django.views.decorators.csrf import csrf_exempt
 
 from requests.auth import HTTPBasicAuth
@@ -22,7 +23,7 @@ from .models import StudentModule
 from psychometrics.psychoanalyze import make_psychometrics_data_update_handler
 from student.models import unique_id_for_user
 from xmodule.errortracker import exc_info_to_str
-from xmodule.exceptions import NotFoundError
+from xmodule.exceptions import NotFoundError, ProcessingError
 from xmodule.modulestore import Location
 from xmodule.modulestore.django import modulestore
 from xmodule.x_module import ModuleSystem
@@ -208,9 +209,6 @@ def get_module_for_descriptor(user, request, descriptor, model_data_cache, cours
               'waittime': settings.XQUEUE_WAITTIME_BETWEEN_REQUESTS
              }
 
-    def get_or_default(key, default):
-        getattr(settings, key, default)
-
     #This is a hacky way to pass settings to the combined open ended xmodule
     #It needs an S3 interface to upload images to S3
     #It needs the open ended grading interface in order to get peer grading to be done
@@ -226,12 +224,11 @@ def get_module_for_descriptor(user, request, descriptor, model_data_cache, cours
         open_ended_grading_interface['mock_staff_grading'] = settings.MOCK_STAFF_GRADING
         if is_descriptor_combined_open_ended:
             s3_interface = {
-                'access_key' : get_or_default('AWS_ACCESS_KEY_ID',''),
-                'secret_access_key' : get_or_default('AWS_SECRET_ACCESS_KEY',''),
-                'storage_bucket_name' : get_or_default('AWS_STORAGE_BUCKET_NAME','')
+                'access_key' : getattr(settings,'AWS_ACCESS_KEY_ID',''),
+                'secret_access_key' : getattr(settings,'AWS_SECRET_ACCESS_KEY',''),
+                'storage_bucket_name' : getattr(settings,'AWS_STORAGE_BUCKET_NAME','openended')
             }
 
-
     def inner_get_module(descriptor):
         """
         Delegate to get_module.  It does an access check, so may return None
@@ -412,6 +409,9 @@ def modx_dispatch(request, dispatch, location, course_id):
     if not Location.is_valid(location):
         raise Http404("Invalid location")
 
+    if not request.user.is_authenticated():
+        raise PermissionDenied
+
     # Check for submitted files and basic file size checks
     p = request.POST.copy()
     if request.FILES:
@@ -443,9 +443,19 @@ def modx_dispatch(request, dispatch, location, course_id):
     # Let the module handle the AJAX
     try:
         ajax_return = instance.handle_ajax(dispatch, p)
+
+    # If we can't find the module, respond with a 404
     except NotFoundError:
         log.exception("Module indicating to user that request doesn't exist")
         raise Http404
+
+    # For XModule-specific errors, we respond with 400
+    except ProcessingError:
+        log.warning("Module encountered an error while prcessing AJAX call",
+                    exc_info=True)
+        return HttpResponseBadRequest()
+
+    # If any other error occurred, re-raise it to trigger a 500 response
     except:
         log.exception("error processing ajax call")
         raise
diff --git a/lms/djangoapps/courseware/tests/test_login.py b/lms/djangoapps/courseware/tests/test_login.py
new file mode 100644
index 0000000000..dda58a4462
--- /dev/null
+++ b/lms/djangoapps/courseware/tests/test_login.py
@@ -0,0 +1,107 @@
+from django.test import TestCase
+from django.test.client import Client
+from django.core.urlresolvers import reverse
+from django.contrib.auth.models import User
+from student.models import Registration, UserProfile
+import json
+
+class LoginTest(TestCase):
+    '''
+    Test student.views.login_user() view
+    '''
+
+    def setUp(self):
+
+        # Create one user and save it to the database
+        self.user = User.objects.create_user('test', 'test@edx.org', 'test_password')
+        self.user.is_active = True
+        self.user.save()
+
+        # Create a registration for the user
+        Registration().register(self.user)
+
+        # Create a profile for the user
+        UserProfile(user=self.user).save()
+
+        # Create the test client
+        self.client = Client()
+
+        # Store the login url
+        self.url = reverse('login')
+
+    def test_login_success(self):
+        response = self._login_response('test@edx.org', 'test_password')
+        self._assert_response(response, success=True)
+
+    def test_login_success_unicode_email(self):
+        unicode_email = u'test@edx.org' + unichr(40960)
+
+        self.user.email = unicode_email
+        self.user.save()
+
+        response = self._login_response(unicode_email, 'test_password')
+        self._assert_response(response, success=True)
+
+
+    def test_login_fail_no_user_exists(self):
+        response = self._login_response('not_a_user@edx.org', 'test_password')
+        self._assert_response(response, success=False, 
+                                value='Email or password is incorrect')
+
+    def test_login_fail_wrong_password(self):
+        response = self._login_response('test@edx.org', 'wrong_password')
+        self._assert_response(response, success=False, 
+                                        value='Email or password is incorrect')
+
+    def test_login_not_activated(self):
+
+        # De-activate the user
+        self.user.is_active = False
+        self.user.save()
+
+        # Should now be unable to login
+        response = self._login_response('test@edx.org', 'test_password')
+        self._assert_response(response, success=False,
+                            value="This account has not been activated")
+
+
+    def test_login_unicode_email(self):
+        unicode_email = u'test@edx.org' + unichr(40960)
+        response = self._login_response(unicode_email, 'test_password')
+        self._assert_response(response, success=False)
+
+    def test_login_unicode_password(self):
+        unicode_password = u'test_password' + unichr(1972)
+        response = self._login_response('test@edx.org', unicode_password)
+        self._assert_response(response, success=False)
+
+    def _login_response(self, email, password):
+        post_params = {'email': email, 'password': password}
+        return self.client.post(self.url, post_params)
+
+    def _assert_response(self, response, success=None, value=None):
+        '''
+        Assert that the response had status 200 and returned a valid
+        JSON-parseable dict.
+
+        If success is provided, assert that the response had that
+        value for 'success' in the JSON dict.
+
+        If value is provided, assert that the response contained that
+        value for 'value' in the JSON dict.
+        '''
+        self.assertEqual(response.status_code, 200)
+
+        try:
+            response_dict = json.loads(response.content)
+        except ValueError:
+            self.fail("Could not parse response content as JSON: %s" 
+                        % str(response.content))
+
+        if success is not None:
+            self.assertEqual(response_dict['success'], success)
+
+        if value is not None:
+            msg = ("'%s' did not contain '%s'" % 
+                    (str(response_dict['value']), str(value)))
+            self.assertTrue(value in response_dict['value'], msg)
diff --git a/lms/djangoapps/courseware/tests/test_module_render.py b/lms/djangoapps/courseware/tests/test_module_render.py
index 3a3a7ac5ea..85a65b7772 100644
--- a/lms/djangoapps/courseware/tests/test_module_render.py
+++ b/lms/djangoapps/courseware/tests/test_module_render.py
@@ -1,28 +1,17 @@
-import logging
-from mock import MagicMock, patch
+from mock import MagicMock
 import json
-import factory
-import unittest
-from nose.tools import set_trace
 
-from django.http import Http404, HttpResponse, HttpRequest
-from django.conf import settings
-from django.contrib.auth.models import User
-from django.test.client import Client
+from django.http import Http404, HttpResponse
+from django.core.urlresolvers import reverse
 from django.conf import settings
 from django.test import TestCase
 from django.test.client import RequestFactory
-from django.core.urlresolvers import reverse
 from django.test.utils import override_settings
 
 from xmodule.modulestore.exceptions import ItemNotFoundError
-from xmodule.exceptions import NotFoundError
-from xmodule.modulestore import Location
+from xmodule.modulestore.django import modulestore
 import courseware.module_render as render
-from xmodule.modulestore.django import modulestore, _MODULESTORES
-from xmodule.seq_module import SequenceModule
-from courseware.tests.tests import PageLoader
-from student.models import Registration
+from courseware.tests.tests import LoginEnrollmentTestCase
 from courseware.model_data import ModelDataCache
 
 from .factories import UserFactory
@@ -49,10 +38,9 @@ TEST_DATA_XML_MODULESTORE = xml_store_config(TEST_DATA_DIR)
 
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-class ModuleRenderTestCase(PageLoader):
+class ModuleRenderTestCase(LoginEnrollmentTestCase):
     def setUp(self):
         self.location = ['i4x', 'edX', 'toy', 'chapter', 'Overview']
-        self._MODULESTORES = {}
         self.course_id = 'edX/toy/2012_Fall'
         self.toy_course = modulestore().get_course(self.course_id)
 
@@ -66,10 +54,9 @@ class ModuleRenderTestCase(PageLoader):
         mock_request = MagicMock()
         mock_request.FILES.keys.return_value = ['file_id']
         mock_request.FILES.getlist.return_value = ['file'] * (settings.MAX_FILEUPLOADS_PER_INPUT + 1)
-        self.assertEquals(render.modx_dispatch(mock_request, 'dummy', self.location,
-                                          'dummy').content,
-                         json.dumps({'success': 'Submission aborted! Maximum %d files may be submitted at once' %
-                                     settings.MAX_FILEUPLOADS_PER_INPUT}))
+        self.assertEquals(render.modx_dispatch(mock_request, 'dummy', self.location, 'dummy').content,
+                          json.dumps({'success': 'Submission aborted! Maximum %d files may be submitted at once' %
+                                      settings.MAX_FILEUPLOADS_PER_INPUT}))
         mock_request_2 = MagicMock()
         mock_request_2.FILES.keys.return_value = ['file_id']
         inputfile = Stub()
@@ -80,7 +67,7 @@ class ModuleRenderTestCase(PageLoader):
         self.assertEquals(render.modx_dispatch(mock_request_2, 'dummy', self.location,
                                                'dummy').content,
                           json.dumps({'success': 'Submission aborted! Your file "%s" is too large (max size: %d MB)' %
-                                        (inputfile.name, settings.STUDENT_FILEUPLOAD_MAX_SIZE / (1000 ** 2))}))
+                                      (inputfile.name, settings.STUDENT_FILEUPLOAD_MAX_SIZE / (1000 ** 2))}))
         mock_request_3 = MagicMock()
         mock_request_3.POST.copy.return_value = {}
         mock_request_3.FILES = False
@@ -91,10 +78,10 @@ class ModuleRenderTestCase(PageLoader):
         self.assertRaises(ItemNotFoundError, render.modx_dispatch,
                           mock_request_3, 'dummy', self.location, 'toy')
         self.assertRaises(Http404, render.modx_dispatch, mock_request_3, 'dummy',
-                            self.location, self.course_id)
+                          self.location, self.course_id)
         mock_request_3.POST.copy.return_value = {'position': 1}
         self.assertIsInstance(render.modx_dispatch(mock_request_3, 'goto_position',
-                            self.location, self.course_id), HttpResponse)
+                                                   self.location, self.course_id), HttpResponse)
 
     def test_get_score_bucket(self):
         self.assertEquals(render.get_score_bucket(0, 10), 'incorrect')
@@ -104,12 +91,23 @@ class ModuleRenderTestCase(PageLoader):
         self.assertEquals(render.get_score_bucket(11, 10), 'incorrect')
         self.assertEquals(render.get_score_bucket(-1, 10), 'incorrect')
 
+    def test_anonymous_modx_dispatch(self):
+        dispatch_url = reverse(
+            'modx_dispatch',
+            args=[
+                'edX/toy/2012_Fall',
+                'i4x://edX/toy/videosequence/Toy_Videos',
+                'goto_position'
+            ]
+        )
+        response = self.client.post(dispatch_url, {'position': 2})
+        self.assertEquals(403, response.status_code)
+
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
 class TestTOC(TestCase):
     """Check the Table of Contents for a course"""
     def setUp(self):
-        self._MODULESTORES = {}
 
         # Toy courses should be loaded
         self.course_name = 'edX/toy/2012_Fall'
@@ -125,19 +123,19 @@ class TestTOC(TestCase):
             self.toy_course.id, self.portal_user, self.toy_course, depth=2)
 
         expected = ([{'active': True, 'sections':
-                    [{'url_name': 'Toy_Videos', 'display_name': u'Toy Videos', 'graded': True,
-                    'format': u'Lecture Sequence', 'due': '', 'active': False},
-                    {'url_name': 'Welcome', 'display_name': u'Welcome', 'graded': True,
-                    'format': '', 'due': '', 'active': False},
-                    {'url_name': 'video_123456789012', 'display_name': 'video 123456789012', 'graded': True,
-                    'format': '', 'due': '', 'active': False},
-                    {'url_name': 'video_4f66f493ac8f', 'display_name': 'video 4f66f493ac8f', 'graded': True,
-                    'format': '', 'due': '', 'active': False}],
-                    'url_name': 'Overview', 'display_name': u'Overview'},
-                    {'active': False, 'sections':
-                    [{'url_name': 'toyvideo', 'display_name': 'toyvideo', 'graded': True,
-                    'format': '', 'due': '', 'active': False}],
-                    'url_name': 'secret:magic', 'display_name': 'secret:magic'}])
+                      [{'url_name': 'Toy_Videos', 'display_name': u'Toy Videos', 'graded': True,
+                        'format': u'Lecture Sequence', 'due': '', 'active': False},
+                       {'url_name': 'Welcome', 'display_name': u'Welcome', 'graded': True,
+                        'format': '', 'due': '', 'active': False},
+                       {'url_name': 'video_123456789012', 'display_name': 'video 123456789012', 'graded': True,
+                        'format': '', 'due': '', 'active': False},
+                       {'url_name': 'video_4f66f493ac8f', 'display_name': 'video 4f66f493ac8f', 'graded': True,
+                        'format': '', 'due': '', 'active': False}],
+                      'url_name': 'Overview', 'display_name': u'Overview'},
+                     {'active': False, 'sections':
+                      [{'url_name': 'toyvideo', 'display_name': 'toyvideo', 'graded': True,
+                        'format': '', 'due': '', 'active': False}],
+                      'url_name': 'secret:magic', 'display_name': 'secret:magic'}])
 
         actual = render.toc_for_course(self.portal_user, request, self.toy_course, chapter, None, model_data_cache)
         self.assertEqual(expected, actual)
@@ -152,19 +150,19 @@ class TestTOC(TestCase):
             self.toy_course.id, self.portal_user, self.toy_course, depth=2)
 
         expected = ([{'active': True, 'sections':
-                    [{'url_name': 'Toy_Videos', 'display_name': u'Toy Videos', 'graded': True,
-                    'format': u'Lecture Sequence', 'due': '', 'active': False},
-                    {'url_name': 'Welcome', 'display_name': u'Welcome', 'graded': True,
-                    'format': '', 'due': '', 'active': True},
-                    {'url_name': 'video_123456789012', 'display_name': 'video 123456789012', 'graded': True,
-                    'format': '', 'due': '', 'active': False},
-                    {'url_name': 'video_4f66f493ac8f', 'display_name': 'video 4f66f493ac8f', 'graded': True,
-                    'format': '', 'due': '', 'active': False}],
-                    'url_name': 'Overview', 'display_name': u'Overview'},
-                    {'active': False, 'sections':
-                    [{'url_name': 'toyvideo', 'display_name': 'toyvideo', 'graded': True,
-                    'format': '', 'due': '', 'active': False}],
-                    'url_name': 'secret:magic', 'display_name': 'secret:magic'}])
+                      [{'url_name': 'Toy_Videos', 'display_name': u'Toy Videos', 'graded': True,
+                        'format': u'Lecture Sequence', 'due': '', 'active': False},
+                       {'url_name': 'Welcome', 'display_name': u'Welcome', 'graded': True,
+                        'format': '', 'due': '', 'active': True},
+                       {'url_name': 'video_123456789012', 'display_name': 'video 123456789012', 'graded': True,
+                        'format': '', 'due': '', 'active': False},
+                       {'url_name': 'video_4f66f493ac8f', 'display_name': 'video 4f66f493ac8f', 'graded': True,
+                        'format': '', 'due': '', 'active': False}],
+                      'url_name': 'Overview', 'display_name': u'Overview'},
+                     {'active': False, 'sections':
+                      [{'url_name': 'toyvideo', 'display_name': 'toyvideo', 'graded': True,
+                        'format': '', 'due': '', 'active': False}],
+                      'url_name': 'secret:magic', 'display_name': 'secret:magic'}])
 
         actual = render.toc_for_course(self.portal_user, request, self.toy_course, chapter, section, model_data_cache)
         self.assertEqual(expected, actual)
diff --git a/lms/djangoapps/courseware/tests/tests.py b/lms/djangoapps/courseware/tests/tests.py
index cd845b1e44..5613f8831f 100644
--- a/lms/djangoapps/courseware/tests/tests.py
+++ b/lms/djangoapps/courseware/tests/tests.py
@@ -1,8 +1,11 @@
-import logging
-log = logging.getLogger("mitx." + __name__)
+'''
+Test for lms courseware app
+'''
 
+import logging
 import json
 import time
+import random
 
 from urlparse import urlsplit, urlunsplit
 
@@ -14,8 +17,6 @@ from django.core.urlresolvers import reverse
 from django.test.utils import override_settings
 
 import xmodule.modulestore.django
-from xmodule.modulestore.mongo import MongoModuleStore
-
 
 # Need access to internal func to put users in the right group
 from courseware import grades
@@ -29,7 +30,8 @@ from xmodule.modulestore.django import modulestore
 from xmodule.modulestore import Location
 from xmodule.modulestore.xml_importer import import_from_xml
 from xmodule.modulestore.xml import XMLModuleStore
-from xmodule.timeparse import stringify_time
+
+log = logging.getLogger("mitx." + __name__)
 
 
 def parse_json(response):
@@ -37,21 +39,22 @@ def parse_json(response):
     return json.loads(response.content)
 
 
-def user(email):
+def get_user(email):
     '''look up a user by email'''
     return User.objects.get(email=email)
 
 
-def registration(email):
+def get_registration(email):
     '''look up registration object by email'''
     return Registration.objects.get(user__email=email)
 
-# A bit of a hack--want mongo modulestore for these tests, until
-# jump_to works with the xmlmodulestore or we have an even better solution
-# NOTE: this means this test requires mongo to be running.
-
 
 def mongo_store_config(data_dir):
+    '''
+    Defines default module store using MongoModuleStore
+
+    Use of this config requires mongo to be running
+    '''
     return {
         'default': {
             'ENGINE': 'xmodule.modulestore.mongo.MongoModuleStore',
@@ -68,6 +71,7 @@ def mongo_store_config(data_dir):
 
 
 def draft_mongo_store_config(data_dir):
+    '''Defines default module store using DraftMongoModuleStore'''
     return {
         'default': {
             'ENGINE': 'xmodule.modulestore.mongo.DraftMongoModuleStore',
@@ -84,6 +88,7 @@ def draft_mongo_store_config(data_dir):
 
 
 def xml_store_config(data_dir):
+    '''Defines default module store using XMLModuleStore'''
     return {
         'default': {
             'ENGINE': 'xmodule.modulestore.xml.XMLModuleStore',
@@ -100,8 +105,11 @@ TEST_DATA_MONGO_MODULESTORE = mongo_store_config(TEST_DATA_DIR)
 TEST_DATA_DRAFT_MONGO_MODULESTORE = draft_mongo_store_config(TEST_DATA_DIR)
 
 
-class ActivateLoginTestCase(TestCase):
-    '''Check that we can activate and log in'''
+class LoginEnrollmentTestCase(TestCase):
+    '''
+    Base TestCase providing support for user creation,
+    activation, login, and course enrollment
+    '''
 
     def assertRedirectsNoFollow(self, response, expected_url):
         """
@@ -112,37 +120,42 @@ class ActivateLoginTestCase(TestCase):
         Some of the code taken from django.test.testcases.py
         """
         self.assertEqual(response.status_code, 302,
-                         'Response status code was {0} instead of 302'.format(response.status_code))
+                         'Response status code was %d instead of 302'
+                         % (response.status_code))
         url = response['Location']
 
         e_scheme, e_netloc, e_path, e_query, e_fragment = urlsplit(expected_url)
         if not (e_scheme or e_netloc):
-            expected_url = urlunsplit(('http', 'testserver', e_path,
-                e_query, e_fragment))
+            expected_url = urlunsplit(('http', 'testserver',
+                                       e_path, e_query, e_fragment))
 
-        self.assertEqual(url, expected_url, "Response redirected to '{0}', expected '{1}'".format(
-            url, expected_url))
+        self.assertEqual(url, expected_url,
+                         "Response redirected to '%s', expected '%s'" %
+                         (url, expected_url))
 
-    def setUp(self):
-        email = 'view@test.com'
-        password = 'foo'
-        self.create_account('viewtest', email, password)
-        self.activate_user(email)
-        self.login(email, password)
+    def setup_viewtest_user(self):
+        '''create a user account, activate, and log in'''
+        self.viewtest_email = 'view@test.com'
+        self.viewtest_password = 'foo'
+        self.viewtest_username = 'viewtest'
+        self.create_account(self.viewtest_username,
+                            self.viewtest_email, self.viewtest_password)
+        self.activate_user(self.viewtest_email)
+        self.login(self.viewtest_email, self.viewtest_password)
 
     # ============ User creation and login ==============
 
-    def _login(self, email, pw):
+    def _login(self, email, password):
         '''Login.  View should always return 200.  The success/fail is in the
         returned json'''
         resp = self.client.post(reverse('login'),
-                                {'email': email, 'password': pw})
+                                {'email': email, 'password': password})
         self.assertEqual(resp.status_code, 200)
         return resp
 
-    def login(self, email, pw):
+    def login(self, email, password):
         '''Login, check that it worked.'''
-        resp = self._login(email, pw)
+        resp = self._login(email, password)
         data = parse_json(resp)
         self.assertTrue(data['success'])
         return resp
@@ -154,56 +167,45 @@ class ActivateLoginTestCase(TestCase):
         self.assertEqual(resp.status_code, 302)
         return resp
 
-    def _create_account(self, username, email, pw):
+    def _create_account(self, username, email, password):
         '''Try to create an account.  No error checking'''
         resp = self.client.post('/create_account', {
             'username': username,
             'email': email,
-            'password': pw,
+            'password': password,
             'name': 'Fred Weasley',
             'terms_of_service': 'true',
             'honor_code': 'true',
         })
         return resp
 
-    def create_account(self, username, email, pw):
+    def create_account(self, username, email, password):
         '''Create the account and check that it worked'''
-        resp = self._create_account(username, email, pw)
+        resp = self._create_account(username, email, password)
         self.assertEqual(resp.status_code, 200)
         data = parse_json(resp)
         self.assertEqual(data['success'], True)
 
         # Check both that the user is created, and inactive
-        self.assertFalse(user(email).is_active)
+        self.assertFalse(get_user(email).is_active)
 
         return resp
 
     def _activate_user(self, email):
         '''Look up the activation key for the user, then hit the activate view.
         No error checking'''
-        activation_key = registration(email).activation_key
+        activation_key = get_registration(email).activation_key
 
         # and now we try to activate
-        resp = self.client.get(reverse('activate', kwargs={'key': activation_key}))
+        url = reverse('activate', kwargs={'key': activation_key})
+        resp = self.client.get(url)
         return resp
 
     def activate_user(self, email):
         resp = self._activate_user(email)
         self.assertEqual(resp.status_code, 200)
         # Now make sure that the user is now actually activated
-        self.assertTrue(user(email).is_active)
-
-    def test_activate_login(self):
-        '''The setup function does all the work'''
-        pass
-
-    def test_logout(self):
-        '''Setup function does login'''
-        self.logout()
-
-
-class PageLoader(ActivateLoginTestCase):
-    ''' Base class that adds a function to load all pages in a modulestore '''
+        self.assertTrue(get_user(email).is_active)
 
     def _enroll(self, course):
         """Post to the enrollment view, and return the parsed json response"""
@@ -216,7 +218,8 @@ class PageLoader(ActivateLoginTestCase):
     def try_enroll(self, course):
         """Try to enroll.  Return bool success instead of asserting it."""
         data = self._enroll(course)
-        print 'Enrollment in {0} result: {1}'.format(course.location.url(), data)
+        print ('Enrollment in %s result: %s'
+               % (course.location.url(), str(data)))
         return data['success']
 
     def enroll(self, course):
@@ -240,8 +243,8 @@ class PageLoader(ActivateLoginTestCase):
         """
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, code,
-                         "got code {0} for url '{1}'. Expected code {2}"
-                         .format(resp.status_code, url, code))
+                         "got code %d for url '%s'. Expected code %d"
+                         % (resp.status_code, url, code))
         return resp
 
     def check_for_post_code(self, code, url, data={}):
@@ -251,12 +254,32 @@ class PageLoader(ActivateLoginTestCase):
         """
         resp = self.client.post(url, data)
         self.assertEqual(resp.status_code, code,
-                         "got code {0} for url '{1}'. Expected code {2}"
-                         .format(resp.status_code, url, code))
+                         "got code %d for url '%s'. Expected code %d"
+                         % (resp.status_code, url, code))
         return resp
 
-    def check_pages_load(self, module_store):
-        """Make all locations in course load"""
+
+class ActivateLoginTest(LoginEnrollmentTestCase):
+    '''Test logging in and logging out'''
+    def setUp(self):
+        self.setup_viewtest_user()
+
+    def test_activate_login(self):
+        '''Test login -- the setup function does all the work'''
+        pass
+
+    def test_logout(self):
+        '''Test logout -- setup function does login'''
+        self.logout()
+
+
+class PageLoaderTestCase(LoginEnrollmentTestCase):
+    ''' Base class that adds a function to load all pages in a modulestore '''
+
+    def check_random_page_loads(self, module_store):
+        '''
+        Choose a page in the course randomly, and assert that it loads
+        '''
        # enroll in the course before trying to access pages
         courses = module_store.get_courses()
         self.assertEqual(len(courses), 1)
@@ -264,129 +287,108 @@ class PageLoader(ActivateLoginTestCase):
         self.enroll(course)
         course_id = course.id
 
-        n = 0
-        num_bad = 0
-        all_ok = True
+        # Search for items in the course
+        # None is treated as a wildcard
+        course_loc = course.location
+        location_query = Location(course_loc.tag, course_loc.org,
+                                  course_loc.course, None, None, None)
 
-        for descriptor in module_store.get_items(
-                Location(None, None, None, None, None)):
+        items = module_store.get_items(location_query)
 
-            n += 1
-            print "Checking ", descriptor.location.url()
+        if len(items) < 1:
+            self.fail('Could not retrieve any items from course')
+        else:
+            descriptor = random.choice(items)
 
-            # We have ancillary course information now as modules and we can't simply use 'jump_to' to view them
-            if descriptor.location.category == 'about':
-                resp = self.client.get(reverse('about_course', kwargs={'course_id': course_id}))
-                msg = str(resp.status_code)
+        # We have ancillary course information now as modules
+        # and we can't simply use 'jump_to' to view them
+        if descriptor.location.category == 'about':
+            self._assert_loads('about_course',
+                               {'course_id': course_id},
+                               descriptor)
 
-                if resp.status_code != 200:
-                    msg = "ERROR " + msg
-                    all_ok = False
-                    num_bad += 1
-            elif descriptor.location.category == 'static_tab':
-                resp = self.client.get(reverse('static_tab', kwargs={'course_id': course_id, 'tab_slug': descriptor.location.name}))
-                msg = str(resp.status_code)
+        elif descriptor.location.category == 'static_tab':
+            kwargs = {'course_id': course_id,
+                      'tab_slug': descriptor.location.name}
+            self._assert_loads('static_tab', kwargs, descriptor)
 
-                if resp.status_code != 200:
-                    msg = "ERROR " + msg
-                    all_ok = False
-                    num_bad += 1
-            elif descriptor.location.category == 'course_info':
-                resp = self.client.get(reverse('info', kwargs={'course_id': course_id}))
-                msg = str(resp.status_code)
+        elif descriptor.location.category == 'course_info':
+            self._assert_loads('info', {'course_id': course_id},
+                               descriptor)
 
-                if resp.status_code != 200:
-                    msg = "ERROR " + msg
-                    all_ok = False
-                    num_bad += 1
-            elif descriptor.location.category == 'custom_tag_template':
-                pass
-            else:
-                #print descriptor.__class__, descriptor.location
-                resp = self.client.get(reverse('jump_to',
-                                       kwargs={'course_id': course_id,
-                                               'location': descriptor.location.url()}), follow=True)
-                msg = str(resp.status_code)
+        elif descriptor.location.category == 'custom_tag_template':
+            pass
 
-                if resp.status_code != 200:
-                    msg = "ERROR " + msg + ": " + descriptor.location.url()
-                    all_ok = False
-                    num_bad += 1
-                elif resp.redirect_chain[0][1] != 302:
-                    msg = "ERROR on redirect from " + descriptor.location.url()
-                    all_ok = False
-                    num_bad += 1
+        else:
 
-                # check content to make sure there were no rendering failures
-                content = resp.content
-                if content.find("this module is temporarily unavailable") >= 0:
-                    msg = "ERROR unavailable module "
-                    all_ok = False
-                    num_bad += 1
-                elif isinstance(descriptor, ErrorDescriptor):
-                    msg = "ERROR error descriptor loaded: "
-                    msg = msg + descriptor.error_msg
-                    all_ok = False
-                    num_bad += 1
+            kwargs = {'course_id': course_id,
+                      'location': descriptor.location.url()}
 
-            print msg
-            self.assertTrue(all_ok)  # fail fast
+            self._assert_loads('jump_to', kwargs, descriptor,
+                               expect_redirect=True,
+                               check_content=True)
 
-        print "{0}/{1} good".format(n - num_bad, n)
-        log.info("{0}/{1} good".format(n - num_bad, n))
-        self.assertTrue(all_ok)
+    def _assert_loads(self, django_url, kwargs, descriptor,
+                      expect_redirect=False,
+                      check_content=False):
+        '''
+        Assert that the url loads correctly.
+        If expect_redirect, then also check that we were redirected.
+        If check_content, then check that we don't get
+        an error message about unavailable modules.
+        '''
+
+        url = reverse(django_url, kwargs=kwargs)
+        response = self.client.get(url, follow=True)
+
+        if response.status_code != 200:
+            self.fail('Status %d for page %s' %
+                      (response.status_code, descriptor.location.url()))
+
+        if expect_redirect:
+            self.assertEqual(response.redirect_chain[0][1], 302)
+
+        if check_content:
+            unavailable_msg = "this module is temporarily unavailable"
+            self.assertEqual(response.content.find(unavailable_msg), -1)
+            self.assertFalse(isinstance(descriptor, ErrorDescriptor))
 
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-class TestCoursesLoadTestCase_XmlModulestore(PageLoader):
-    '''Check that all pages in test courses load properly'''
+class TestCoursesLoadTestCase_XmlModulestore(PageLoaderTestCase):
+    '''Check that all pages in test courses load properly from XML'''
 
     def setUp(self):
-        ActivateLoginTestCase.setUp(self)
+        self.setup_viewtest_user()
         xmodule.modulestore.django._MODULESTORES = {}
 
     def test_toy_course_loads(self):
-        module_store = XMLModuleStore(
-                                        TEST_DATA_DIR,
-                                        default_class='xmodule.hidden_module.HiddenDescriptor',
-                                        course_dirs=['toy'],
-                                        load_error_modules=True,
-        )
+        module_class = 'xmodule.hidden_module.HiddenDescriptor'
+        module_store = XMLModuleStore(TEST_DATA_DIR,
+                                      default_class=module_class,
+                                      course_dirs=['toy'],
+                                      load_error_modules=True)
 
-        self.check_pages_load(module_store)
-
-    def test_full_course_loads(self):
-        module_store = XMLModuleStore(
-                                        TEST_DATA_DIR,
-                                        default_class='xmodule.hidden_module.HiddenDescriptor',
-                                        course_dirs=['full'],
-                                        load_error_modules=True,
-        )
-        self.check_pages_load(module_store)
+        self.check_random_page_loads(module_store)
 
 
 @override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
-class TestCoursesLoadTestCase_MongoModulestore(PageLoader):
-    '''Check that all pages in test courses load properly'''
+class TestCoursesLoadTestCase_MongoModulestore(PageLoaderTestCase):
+    '''Check that all pages in test courses load properly from Mongo'''
 
     def setUp(self):
-        ActivateLoginTestCase.setUp(self)
+        self.setup_viewtest_user()
         xmodule.modulestore.django._MODULESTORES = {}
         modulestore().collection.drop()
 
     def test_toy_course_loads(self):
         module_store = modulestore()
         import_from_xml(module_store, TEST_DATA_DIR, ['toy'])
-        self.check_pages_load(module_store)
-
-    def test_full_course_loads(self):
-        module_store = modulestore()
-        import_from_xml(module_store, TEST_DATA_DIR, ['full'])
-        self.check_pages_load(module_store)
+        self.check_random_page_loads(module_store)
 
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-class TestNavigation(PageLoader):
+class TestNavigation(LoginEnrollmentTestCase):
     """Check that navigation state is saved properly"""
 
     def setUp(self):
@@ -412,42 +414,56 @@ class TestNavigation(PageLoader):
         self.enroll(self.full)
 
         # First request should redirect to ToyVideos
-        resp = self.client.get(reverse('courseware', kwargs={'course_id': self.toy.id}))
+        resp = self.client.get(reverse('courseware',
+                               kwargs={'course_id': self.toy.id}))
 
-        # Don't use no-follow, because state should only be saved once we actually hit the section
+        # Don't use no-follow, because state should
+        # only be saved once we actually hit the section
         self.assertRedirects(resp, reverse(
             'courseware_section', kwargs={'course_id': self.toy.id,
                                           'chapter': 'Overview',
                                           'section': 'Toy_Videos'}))
 
-        # Hitting the couseware tab again should redirect to the first chapter: 'Overview'
-        resp = self.client.get(reverse('courseware', kwargs={'course_id': self.toy.id}))
+        # Hitting the couseware tab again should
+        # redirect to the first chapter: 'Overview'
+        resp = self.client.get(reverse('courseware',
+                               kwargs={'course_id': self.toy.id}))
+
         self.assertRedirectsNoFollow(resp, reverse('courseware_chapter',
-                                                   kwargs={'course_id': self.toy.id, 'chapter': 'Overview'}))
+                                     kwargs={'course_id': self.toy.id,
+                                             'chapter': 'Overview'}))
 
         # Now we directly navigate to a section in a different chapter
         self.check_for_get_code(200, reverse('courseware_section',
                                              kwargs={'course_id': self.toy.id,
-                                                     'chapter': 'secret:magic', 'section': 'toyvideo'}))
+                                                     'chapter': 'secret:magic',
+                                                     'section': 'toyvideo'}))
 
         # And now hitting the courseware tab should redirect to 'secret:magic'
-        resp = self.client.get(reverse('courseware', kwargs={'course_id': self.toy.id}))
+        resp = self.client.get(reverse('courseware',
+                               kwargs={'course_id': self.toy.id}))
+
         self.assertRedirectsNoFollow(resp, reverse('courseware_chapter',
-                                                   kwargs={'course_id': self.toy.id, 'chapter': 'secret:magic'}))
+                                     kwargs={'course_id': self.toy.id,
+                                             'chapter': 'secret:magic'}))
 
 
 @override_settings(MODULESTORE=TEST_DATA_DRAFT_MONGO_MODULESTORE)
 class TestDraftModuleStore(TestCase):
     def test_get_items_with_course_items(self):
         store = modulestore()
+
         # fix was to allow get_items() to take the course_id parameter
-        store.get_items(Location(None, None, 'vertical', None, None), course_id='abc', depth=0)
-        # test success is just getting through the above statement. The bug was that 'course_id' argument was
+        store.get_items(Location(None, None, 'vertical', None, None),
+                        course_id='abc', depth=0)
+
+        # test success is just getting through the above statement.
+        # The bug was that 'course_id' argument was
         # not allowed to be passed in (i.e. was throwing exception)
 
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-class TestViewAuth(PageLoader):
+class TestViewAuth(LoginEnrollmentTestCase):
     """Check that view authentication works properly"""
 
     # NOTE: setUpClass() runs before override_settings takes effect, so
@@ -469,21 +485,29 @@ class TestViewAuth(PageLoader):
         self.activate_user(self.instructor)
 
     def test_instructor_pages(self):
-        """Make sure only instructors for the course or staff can load the instructor
+        """Make sure only instructors for the course
+        or staff can load the instructor
         dashboard, the grade views, and student profile pages"""
 
         # First, try with an enrolled student
         self.login(self.student, self.password)
         # shouldn't work before enroll
-        response = self.client.get(reverse('courseware', kwargs={'course_id': self.toy.id}))
-        self.assertRedirectsNoFollow(response, reverse('about_course', args=[self.toy.id]))
+        response = self.client.get(reverse('courseware',
+                                   kwargs={'course_id': self.toy.id}))
+
+        self.assertRedirectsNoFollow(response,
+                                     reverse('about_course',
+                                             args=[self.toy.id]))
         self.enroll(self.toy)
         self.enroll(self.full)
         # should work now -- redirect to first page
-        response = self.client.get(reverse('courseware', kwargs={'course_id': self.toy.id}))
-        self.assertRedirectsNoFollow(response, reverse('courseware_section', kwargs={'course_id': self.toy.id,
-                                                                                     'chapter': 'Overview',
-                                                                                     'section': 'Toy_Videos'}))
+        response = self.client.get(reverse('courseware',
+                                   kwargs={'course_id': self.toy.id}))
+        self.assertRedirectsNoFollow(response,
+                                     reverse('courseware_section',
+                                             kwargs={'course_id': self.toy.id,
+                                                     'chapter': 'Overview',
+                                                     'section': 'Toy_Videos'}))
 
         def instructor_urls(course):
             "list of urls that only instructors/staff should be able to see"
@@ -491,41 +515,47 @@ class TestViewAuth(PageLoader):
                 'instructor_dashboard',
                 'gradebook',
                 'grade_summary',)]
-            urls.append(reverse('student_progress', kwargs={'course_id': course.id,
-                                                     'student_id': user(self.student).id}))
+
+            urls.append(reverse('student_progress',
+                                kwargs={'course_id': course.id,
+                                        'student_id': get_user(self.student).id}))
             return urls
 
-        # shouldn't be able to get to the instructor pages
-        for url in instructor_urls(self.toy) + instructor_urls(self.full):
-            print 'checking for 404 on {0}'.format(url)
-            self.check_for_get_code(404, url)
+        # Randomly sample an instructor page
+        url = random.choice(instructor_urls(self.toy) +
+                            instructor_urls(self.full))
+
+        # Shouldn't be able to get to the instructor pages
+        print 'checking for 404 on {0}'.format(url)
+        self.check_for_get_code(404, url)
 
         # Make the instructor staff in the toy course
         group_name = _course_staff_group_name(self.toy.location)
-        g = Group.objects.create(name=group_name)
-        g.user_set.add(user(self.instructor))
+        group = Group.objects.create(name=group_name)
+        group.user_set.add(get_user(self.instructor))
 
         self.logout()
         self.login(self.instructor, self.password)
 
         # Now should be able to get to the toy course, but not the full course
-        for url in instructor_urls(self.toy):
-            print 'checking for 200 on {0}'.format(url)
-            self.check_for_get_code(200, url)
+        url = random.choice(instructor_urls(self.toy))
+        print 'checking for 200 on {0}'.format(url)
+        self.check_for_get_code(200, url)
 
-        for url in instructor_urls(self.full):
-            print 'checking for 404 on {0}'.format(url)
-            self.check_for_get_code(404, url)
+        url = random.choice(instructor_urls(self.full))
+        print 'checking for 404 on {0}'.format(url)
+        self.check_for_get_code(404, url)
 
         # now also make the instructor staff
-        u = user(self.instructor)
-        u.is_staff = True
-        u.save()
+        instructor = get_user(self.instructor)
+        instructor.is_staff = True
+        instructor.save()
 
         # and now should be able to load both
-        for url in instructor_urls(self.toy) + instructor_urls(self.full):
-            print 'checking for 200 on {0}'.format(url)
-            self.check_for_get_code(200, url)
+        url = random.choice(instructor_urls(self.toy) +
+                            instructor_urls(self.full))
+        print 'checking for 200 on {0}'.format(url)
+        self.check_for_get_code(200, url)
 
     def run_wrapped(self, test):
         """
@@ -569,7 +599,8 @@ class TestViewAuth(PageLoader):
 
         def reverse_urls(names, course):
             """Reverse a list of course urls"""
-            return [reverse(name, kwargs={'course_id': course.id}) for name in names]
+            return [reverse(name, kwargs={'course_id': course.id})
+                    for name in names]
 
         def dark_student_urls(course):
             """
@@ -578,7 +609,8 @@ class TestViewAuth(PageLoader):
             """
             urls = reverse_urls(['info', 'progress'], course)
             urls.extend([
-                reverse('book', kwargs={'course_id': course.id, 'book_index': book.title})
+                reverse('book', kwargs={'course_id': course.id,
+                                        'book_index': book.title})
                 for book in course.textbooks
             ])
             return urls
@@ -597,37 +629,46 @@ class TestViewAuth(PageLoader):
 
         def instructor_urls(course):
             """list of urls that only instructors/staff should be able to see"""
-            urls = reverse_urls(['instructor_dashboard', 'gradebook', 'grade_summary'],
-                                course)
+            urls = reverse_urls(['instructor_dashboard',
+                                 'gradebook', 'grade_summary'], course)
             return urls
 
         def check_non_staff(course):
             """Check that access is right for non-staff in course"""
             print '=== Checking non-staff access for {0}'.format(course.id)
-            for url in instructor_urls(course) + dark_student_urls(course) + reverse_urls(['courseware'], course):
-                print 'checking for 404 on {0}'.format(url)
-                self.check_for_get_code(404, url)
 
-            for url in light_student_urls(course):
-                print 'checking for 200 on {0}'.format(url)
-                self.check_for_get_code(200, url)
+            # Randomly sample a dark url
+            url = random.choice(instructor_urls(course) +
+                                dark_student_urls(course) +
+                                reverse_urls(['courseware'], course))
+            print 'checking for 404 on {0}'.format(url)
+            self.check_for_get_code(404, url)
+
+            # Randomly sample a light url
+            url = random.choice(light_student_urls(course))
+            print 'checking for 200 on {0}'.format(url)
+            self.check_for_get_code(200, url)
 
         def check_staff(course):
             """Check that access is right for staff in course"""
             print '=== Checking staff access for {0}'.format(course.id)
-            for url in (instructor_urls(course) +
-                        dark_student_urls(course) +
-                        light_student_urls(course)):
-                print 'checking for 200 on {0}'.format(url)
-                self.check_for_get_code(200, url)
+
+            # Randomly sample a url
+            url = random.choice(instructor_urls(course) +
+                                dark_student_urls(course) +
+                                light_student_urls(course))
+            print 'checking for 200 on {0}'.format(url)
+            self.check_for_get_code(200, url)
 
             # The student progress tab is not accessible to a student
-            # before launch, so the instructor view-as-student feature should return a 404 as well.
+            # before launch, so the instructor view-as-student feature
+            # should return a 404 as well.
             # TODO (vshnayder): If this is not the behavior we want, will need
             # to make access checking smarter and understand both the effective
             # user (the student), and the requesting user (the prof)
-            url = reverse('student_progress', kwargs={'course_id': course.id,
-                                                     'student_id': user(self.student).id})
+            url = reverse('student_progress',
+                          kwargs={'course_id': course.id,
+                                  'student_id': get_user(self.student).id})
             print 'checking for 404 on view-as-student: {0}'.format(url)
             self.check_for_get_code(404, url)
 
@@ -648,8 +689,8 @@ class TestViewAuth(PageLoader):
         print '=== Testing course instructor access....'
         # Make the instructor staff in the toy course
         group_name = _course_staff_group_name(self.toy.location)
-        g = Group.objects.create(name=group_name)
-        g.user_set.add(user(self.instructor))
+        group = Group.objects.create(name=group_name)
+        group.user_set.add(get_user(self.instructor))
 
         self.logout()
         self.login(self.instructor, self.password)
@@ -663,9 +704,9 @@ class TestViewAuth(PageLoader):
 
         print '=== Testing staff access....'
         # now also make the instructor staff
-        u = user(self.instructor)
-        u.is_staff = True
-        u.save()
+        instructor = get_user(self.instructor)
+        instructor.is_staff = True
+        instructor.save()
 
         # and now should be able to load both
         check_staff(self.toy)
@@ -698,8 +739,8 @@ class TestViewAuth(PageLoader):
         print '=== Testing course instructor access....'
         # Make the instructor staff in the toy course
         group_name = _course_staff_group_name(self.toy.location)
-        g = Group.objects.create(name=group_name)
-        g.user_set.add(user(self.instructor))
+        group = Group.objects.create(name=group_name)
+        group.user_set.add(get_user(self.instructor))
 
         print "logout/login"
         self.logout()
@@ -709,10 +750,10 @@ class TestViewAuth(PageLoader):
 
         print '=== Testing staff access....'
         # now make the instructor global staff, but not in the instructor group
-        g.user_set.remove(user(self.instructor))
-        u = user(self.instructor)
-        u.is_staff = True
-        u.save()
+        group.user_set.remove(get_user(self.instructor))
+        instructor = get_user(self.instructor)
+        instructor.is_staff = True
+        instructor.save()
 
         # unenroll and try again
         self.unenroll(self.toy)
@@ -726,8 +767,8 @@ class TestViewAuth(PageLoader):
 
         # Make courses start in the future
         tomorrow = time.time() + 24 * 3600
-        nextday = tomorrow + 24 * 3600
-        yesterday = time.time() - 24 * 3600
+        # nextday = tomorrow + 24 * 3600
+        # yesterday = time.time() - 24 * 3600
 
         # toy course's hasn't started
         self.toy.lms.start = time.gmtime(tomorrow)
@@ -737,20 +778,20 @@ class TestViewAuth(PageLoader):
         self.toy.lms.days_early_for_beta = 2
 
         # student user shouldn't see it
-        student_user = user(self.student)
+        student_user = get_user(self.student)
         self.assertFalse(has_access(student_user, self.toy, 'load'))
 
         # now add the student to the beta test group
         group_name = course_beta_test_group_name(self.toy.location)
-        g = Group.objects.create(name=group_name)
-        g.user_set.add(student_user)
+        group = Group.objects.create(name=group_name)
+        group.user_set.add(student_user)
 
         # now the student should see it
         self.assertTrue(has_access(student_user, self.toy, 'load'))
 
 
 @override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-class TestCourseGrader(PageLoader):
+class TestCourseGrader(LoginEnrollmentTestCase):
     """Check that a course gets graded properly"""
 
     # NOTE: setUpClass() runs before override_settings takes effect, so
@@ -773,35 +814,41 @@ class TestCourseGrader(PageLoader):
         self.activate_user(self.student)
         self.enroll(self.graded_course)
 
-        self.student_user = user(self.student)
+        self.student_user = get_user(self.student)
 
         self.factory = RequestFactory()
 
     def get_grade_summary(self):
+        '''calls grades.grade for current user and course'''
         model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
             self.graded_course.id, self.student_user, self.graded_course)
 
         fake_request = self.factory.get(reverse('progress',
-                                       kwargs={'course_id': self.graded_course.id}))
+                                        kwargs={'course_id': self.graded_course.id}))
 
         return grades.grade(self.student_user, fake_request,
                             self.graded_course, model_data_cache)
 
     def get_homework_scores(self):
+        '''get scores for homeworks'''
         return self.get_grade_summary()['totaled_scores']['Homework']
 
     def get_progress_summary(self):
+        '''return progress summary structure for current user and course'''
         model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
             self.graded_course.id, self.student_user, self.graded_course)
 
         fake_request = self.factory.get(reverse('progress',
-                                       kwargs={'course_id': self.graded_course.id}))
+                                        kwargs={'course_id': self.graded_course.id}))
 
-        progress_summary = grades.progress_summary(self.student_user, fake_request,
-                                                   self.graded_course, model_data_cache)
+        progress_summary = grades.progress_summary(self.student_user,
+                                                   fake_request,
+                                                   self.graded_course,
+                                                   model_data_cache)
         return progress_summary
 
     def check_grade_percent(self, percent):
+        '''assert that percent grade is as expected'''
         grade_summary = self.get_grade_summary()
         self.assertEqual(grade_summary['percent'], percent)
 
@@ -813,34 +860,34 @@ class TestCourseGrader(PageLoader):
         input_i4x-edX-graded-problem-H1P3_2_1
         input_i4x-edX-graded-problem-H1P3_2_2
         """
-        problem_location = "i4x://edX/graded/problem/{0}".format(problem_url_name)
+        problem_location = "i4x://edX/graded/problem/%s" % problem_url_name
 
         modx_url = reverse('modx_dispatch',
-                            kwargs={
-                                'course_id': self.graded_course.id,
-                                'location': problem_location,
-                                'dispatch': 'problem_check', })
+                           kwargs={'course_id': self.graded_course.id,
+                                   'location': problem_location,
+                                   'dispatch': 'problem_check', })
 
         resp = self.client.post(modx_url, {
-            'input_i4x-edX-graded-problem-{0}_2_1'.format(problem_url_name): responses[0],
-            'input_i4x-edX-graded-problem-{0}_2_2'.format(problem_url_name): responses[1],
-        })
+                                'input_i4x-edX-graded-problem-%s_2_1' % problem_url_name: responses[0],
+                                'input_i4x-edX-graded-problem-%s_2_2' % problem_url_name: responses[1],
+                                })
         print "modx_url", modx_url, "responses", responses
         print "resp", resp
 
         return resp
 
     def problem_location(self, problem_url_name):
+        '''Get location string for problem, assuming hardcoded course_id'''
         return "i4x://edX/graded/problem/{0}".format(problem_url_name)
 
     def reset_question_answer(self, problem_url_name):
+        '''resets specified problem for current user'''
         problem_location = self.problem_location(problem_url_name)
 
         modx_url = reverse('modx_dispatch',
-                            kwargs={
-                                'course_id': self.graded_course.id,
-                                'location': problem_location,
-                                'dispatch': 'problem_reset', })
+                           kwargs={'course_id': self.graded_course.id,
+                                   'location': problem_location,
+                                   'dispatch': 'problem_reset', })
 
         resp = self.client.post(modx_url)
         return resp
@@ -855,6 +902,7 @@ class TestCourseGrader(PageLoader):
             return [s.earned for s in self.get_homework_scores()]
 
         def score_for_hw(hw_url_name):
+            """returns list of scores for a given url"""
             hw_section = [section for section
                           in self.get_progress_summary()[0]['sections']
                           if section.get('url_name') == hw_url_name][0]
@@ -879,7 +927,8 @@ class TestCourseGrader(PageLoader):
         self.assertEqual(earned_hw_scores(), [4.0, 0.0, 0])
         self.assertEqual(score_for_hw('Homework1'), [2.0, 2.0])
 
-        # This problem is hidden in an ABTest. Getting it correct doesn't change total grade
+        # This problem is hidden in an ABTest.
+        # Getting it correct doesn't change total grade
         self.submit_question_answer('H1P3', ['Correct', 'Correct'])
         self.check_grade_percent(0.25)
         self.assertEqual(score_for_hw('Homework1'), [2.0, 2.0])
diff --git a/lms/djangoapps/courseware/views.py b/lms/djangoapps/courseware/views.py
index e75ef8e8cf..b2b0874786 100644
--- a/lms/djangoapps/courseware/views.py
+++ b/lms/djangoapps/courseware/views.py
@@ -522,6 +522,12 @@ def static_university_profile(request, org_id):
     """
     Return the profile for the particular org_id that does not have any courses.
     """
+    # Redirect to the properly capitalized org_id
+    last_path = request.path.split('/')[-1]
+    if last_path != org_id:
+        return redirect('static_university_profile', org_id=org_id)
+
+    # Render template
     template_file = "university_profile/{0}.html".format(org_id).lower()
     context = dict(courses=[], org_id=org_id)
     return render_to_response(template_file, context)
@@ -533,17 +539,28 @@ def university_profile(request, org_id):
     """
     Return the profile for the particular org_id.  404 if it's not valid.
     """
+    virtual_orgs_ids = settings.VIRTUAL_UNIVERSITIES
+    meta_orgs = getattr(settings, 'META_UNIVERSITIES', {})
+
+    # Get all the ids associated with this organization
     all_courses = modulestore().get_courses()
-    valid_org_ids = set(c.org for c in all_courses).union(settings.VIRTUAL_UNIVERSITIES)
-    if org_id not in valid_org_ids:
+    valid_orgs_ids = set(c.org for c in all_courses)
+    valid_orgs_ids.update(virtual_orgs_ids + meta_orgs.keys())
+
+    if org_id not in valid_orgs_ids:
         raise Http404("University Profile not found for {0}".format(org_id))
 
-    # Only grab courses for this org...
-    courses = get_courses_by_university(request.user,
-                                        domain=request.META.get('HTTP_HOST'))[org_id]
-    courses = sort_by_announcement(courses)
+    # Grab all courses for this organization(s)
+    org_ids = set([org_id] + meta_orgs.get(org_id, []))
+    org_courses = []
+    domain = request.META.get('HTTP_HOST')
+    for key in org_ids:
+        cs = get_courses_by_university(request.user, domain=domain)[key]
+        org_courses.extend(cs)
 
-    context = dict(courses=courses, org_id=org_id)
+    org_courses = sort_by_announcement(org_courses)
+
+    context = dict(courses=org_courses, org_id=org_id)
     template_file = "university_profile/{0}.html".format(org_id).lower()
 
     return render_to_response(template_file, context)
@@ -646,13 +663,13 @@ def submission_history(request, course_id, student_username, location):
                             .format(student_username, location))
 
     history_entries = StudentModuleHistory.objects \
-                      .filter(student_module=student_module).order_by('-created')
+                      .filter(student_module=student_module).order_by('-id')
 
     # If no history records exist, let's force a save to get history started.
     if not history_entries:
         student_module.save()
         history_entries = StudentModuleHistory.objects \
-                          .filter(student_module=student_module).order_by('-created')
+                          .filter(student_module=student_module).order_by('-id')
 
     context = {
         'history_entries': history_entries,
diff --git a/lms/djangoapps/django_comment_client/forum/views.py b/lms/djangoapps/django_comment_client/forum/views.py
index 3eee0948da..3a517af26e 100644
--- a/lms/djangoapps/django_comment_client/forum/views.py
+++ b/lms/djangoapps/django_comment_client/forum/views.py
@@ -1,28 +1,22 @@
 import json
 import logging
+import xml.sax.saxutils as saxutils
 
 from django.contrib.auth.decorators import login_required
-from django.views.decorators.http import require_POST
-from django.http import HttpResponse, Http404
-from django.utils import simplejson
+from django.http import Http404
 from django.core.context_processors import csrf
-from django.core.urlresolvers import reverse
 from django.contrib.auth.models import User
 
 from mitxmako.shortcuts import render_to_response, render_to_string
 from courseware.courses import get_course_with_access
-from course_groups.cohorts import is_course_cohorted, get_cohort_id, is_commentable_cohorted, get_cohorted_commentables, get_cohort, get_course_cohorts, get_cohort_by_id
+from course_groups.cohorts import (is_course_cohorted, get_cohort_id, is_commentable_cohorted, 
+                                   get_cohorted_commentables, get_course_cohorts, get_cohort_by_id)
 from courseware.access import has_access
 
-from urllib import urlencode
-from operator import methodcaller
-from django_comment_client.permissions import check_permissions_by_view, cached_has_permission
-from django_comment_client.utils import (merge_dict, extract, strip_none,
-                                         strip_blank, get_courseware_context)
-
+from django_comment_client.permissions import cached_has_permission
+from django_comment_client.utils import (merge_dict, extract, strip_none, get_courseware_context)
 import django_comment_client.utils as utils
 import comment_client as cc
-import xml.sax.saxutils as saxutils
 
 THREADS_PER_PAGE = 20
 INLINE_THREADS_PER_PAGE = 20
@@ -31,6 +25,7 @@ escapedict = {'"': '&quot;'}
 log = logging.getLogger("edx.discussions")
 
 
+@login_required
 def get_threads(request, course_id, discussion_id=None, per_page=THREADS_PER_PAGE):
     """
     This may raise cc.utils.CommentClientError or
@@ -60,7 +55,6 @@ def get_threads(request, course_id, discussion_id=None, per_page=THREADS_PER_PAG
         cc_user.default_sort_key = request.GET.get('sort_key')
         cc_user.save()
 
-
     #there are 2 dimensions to consider when executing a search with respect to group id
     #is user a moderator
     #did the user request a group
@@ -91,18 +85,17 @@ def get_threads(request, course_id, discussion_id=None, per_page=THREADS_PER_PAG
 
     #now add the group name if the thread has a group id
     for thread in threads:
-        
+
         if thread.get('group_id'):
             thread['group_name'] = get_cohort_by_id(course_id, thread.get('group_id')).name
             thread['group_string'] = "This post visible only to Group %s." % (thread['group_name'])
         else:
             thread['group_name'] = ""
             thread['group_string'] = "This post visible to everyone."
-        
+    
         #patch for backward compatibility to comments service
         if not 'pinned' in thread:
             thread['pinned'] = False
-        
 
     query_params['page'] = page
     query_params['num_pages'] = num_pages
@@ -110,6 +103,7 @@ def get_threads(request, course_id, discussion_id=None, per_page=THREADS_PER_PAG
     return threads, query_params
 
 
+@login_required
 def inline_discussion(request, course_id, discussion_id):
     """
     Renders JSON for DiscussionModules
@@ -142,14 +136,14 @@ def inline_discussion(request, course_id, discussion_id):
     cohorts_list = list()
 
     if is_cohorted:
-        cohorts_list.append({'name':'All Groups','id':None})
+        cohorts_list.append({'name': 'All Groups', 'id': None})
 
         #if you're a mod, send all cohorts and let you pick
 
         if is_moderator:
             cohorts = get_course_cohorts(course_id)
             for c in cohorts:
-                cohorts_list.append({'name':c.name, 'id':c.id})
+                cohorts_list.append({'name': c.name, 'id': c.id})
 
         else:
             #students don't get to choose
@@ -216,9 +210,6 @@ def forum_form_discussion(request, course_id):
 
         user_cohort_id = get_cohort_id(request.user, course_id)
 
-    
-        
-
         context = {
             'csrf': csrf(request)['csrf_token'],
             'course': course,
@@ -242,6 +233,7 @@ def forum_form_discussion(request, course_id):
 
         return render_to_response('discussion/index.html', context)
 
+
 @login_required
 def single_thread(request, course_id, discussion_id, thread_id):
     course = get_course_with_access(request.user, course_id, 'load')
@@ -250,11 +242,11 @@ def single_thread(request, course_id, discussion_id, thread_id):
 
     try:
         thread = cc.Thread.find(thread_id).retrieve(recursive=True, user_id=request.user.id)
-        
+
         #patch for backward compatibility with comments service
         if not 'pinned' in thread.attributes:
             thread['pinned'] = False
-        
+
     except (cc.utils.CommentClientError, cc.utils.CommentClientUnknownError) as err:
         log.error("Error loading single thread.")
         raise Http404
@@ -352,7 +344,7 @@ def user_profile(request, course_id, user_id):
         query_params = {
             'page': request.GET.get('page', 1),
             'per_page': THREADS_PER_PAGE,   # more than threads_per_page to show more activities
-            }
+        }
 
         threads, page, num_pages = profiled_user.active_threads(query_params)
         query_params['page'] = page
@@ -369,8 +361,6 @@ def user_profile(request, course_id, user_id):
                 'annotated_content_info': saxutils.escape(json.dumps(annotated_content_info), escapedict),
             })
         else:
-
-
             context = {
                 'course': course,
                 'user': request.user,
@@ -426,5 +416,5 @@ def followed_threads(request, course_id, user_id):
             }
 
             return render_to_response('discussion/user_profile.html', context)
-    except (cc.utils.CommentClientError, cc.utils.CommentClientUnknownError) as err:
+    except (cc.utils.CommentClientError, cc.utils.CommentClientUnknownError):
         raise Http404
diff --git a/lms/djangoapps/django_comment_client/middleware.py b/lms/djangoapps/django_comment_client/middleware.py
index abf2d40cab..b9efc1589e 100644
--- a/lms/djangoapps/django_comment_client/middleware.py
+++ b/lms/djangoapps/django_comment_client/middleware.py
@@ -1,10 +1,24 @@
 from comment_client import CommentClientError
 from django_comment_client.utils import JsonError
 import json
+import logging
+
+log = logging.getLogger(__name__)
 
 
 class AjaxExceptionMiddleware(object):
+    """
+    Middleware that captures CommentClientErrors during ajax requests
+    and tranforms them into json responses
+    """
     def process_exception(self, request, exception):
+        """
+        Processes CommentClientErrors in ajax requests. If the request is an ajax request,
+        returns a http response that encodes the error as json
+        """
         if isinstance(exception, CommentClientError) and request.is_ajax():
-            return JsonError(json.loads(exception.message))
+            try:
+                return JsonError(json.loads(exception.message))
+            except ValueError:
+                return JsonError(exception.message)
         return None
diff --git a/lms/djangoapps/django_comment_client/tests.py b/lms/djangoapps/django_comment_client/tests.py
index 1d925cdb8e..a35df54cd9 100644
--- a/lms/djangoapps/django_comment_client/tests.py
+++ b/lms/djangoapps/django_comment_client/tests.py
@@ -1,73 +1,12 @@
-from django.contrib.auth.models import User, Group
-from django.core.urlresolvers import reverse
-from django.test import TestCase
-from django.test.client import RequestFactory
-from django.conf import settings
-
-from mock import Mock
-
-from django.test.utils import override_settings
-
-import xmodule.modulestore.django
-
-from student.models import CourseEnrollment
-
-from django.db.models.signals import m2m_changed, pre_delete, pre_save, post_delete, post_save
-from django.dispatch.dispatcher import _make_id
 import string
 import random
-from .permissions import has_permission
-from .models import Role, Permission
 
-from xmodule.modulestore.django import modulestore
-from xmodule.modulestore import Location
-from xmodule.modulestore.xml_importer import import_from_xml
-from xmodule.modulestore.xml import XMLModuleStore
-
-import comment_client
-
-from courseware.tests.tests import PageLoader, TEST_DATA_XML_MODULESTORE
-
-#@override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
-#class TestCohorting(PageLoader):
-#    """Check that cohorting works properly"""
-#
-#    def setUp(self):
-#        xmodule.modulestore.django._MODULESTORES = {}
-#
-#        # Assume courses are there
-#        self.toy = modulestore().get_course("edX/toy/2012_Fall")
-#
-#        # Create two accounts
-#        self.student = 'view@test.com'
-#        self.student2 = 'view2@test.com'
-#        self.password = 'foo'
-#        self.create_account('u1', self.student, self.password)
-#        self.create_account('u2', self.student2, self.password)
-#        self.activate_user(self.student)
-#        self.activate_user(self.student2)
-#
-#    def test_create_thread(self):
-#        my_save = Mock()
-#        comment_client.perform_request = my_save
-#
-#        resp = self.client.post(
-#            reverse('django_comment_client.base.views.create_thread',
-#                    kwargs={'course_id': 'edX/toy/2012_Fall',
-#                            'commentable_id': 'General'}),
-#                                        {'some': "some",
-#                                         'data': 'data'})
-#        self.assertTrue(my_save.called)
-#
-#        #self.assertEqual(resp.status_code, 200)
-#        #self.assertEqual(my_save.something, "expected", "complaint if not true")
-#
-#        self.toy.cohort_config = {"cohorted": True}
-#
-#        # call the view again ...
-#
-#       # assert that different things happened
+from django.contrib.auth.models import User
+from django.test import TestCase
 
+from student.models import CourseEnrollment
+from django_comment_client.permissions import has_permission
+from django_comment_client.models import Role
 
 
 class PermissionsTestCase(TestCase):
diff --git a/lms/djangoapps/django_comment_client/tests/test_middleware.py b/lms/djangoapps/django_comment_client/tests/test_middleware.py
index 55e4c72c75..ab9517c160 100644
--- a/lms/djangoapps/django_comment_client/tests/test_middleware.py
+++ b/lms/djangoapps/django_comment_client/tests/test_middleware.py
@@ -1,7 +1,3 @@
-import string
-import random
-import collections
-
 from django.test import TestCase
 
 import comment_client
@@ -13,17 +9,19 @@ class AjaxExceptionTestCase(TestCase):
 
 # TODO: check whether the correct error message is produced.
 # The error message should be the same as the argument to CommentClientError
-        def setUp(self):
-                self.a = middleware.AjaxExceptionMiddleware()
-                self.request1 = django.http.HttpRequest()
-                self.request0 = django.http.HttpRequest()
-                self.exception1 = comment_client.CommentClientError('{}')
-                self.exception0 = ValueError()
-                self.request1.META['HTTP_X_REQUESTED_WITH'] = "XMLHttpRequest"
-                self.request0.META['HTTP_X_REQUESTED_WITH'] = "SHADOWFAX"
+    def setUp(self):
+        self.a = middleware.AjaxExceptionMiddleware()
+        self.request1 = django.http.HttpRequest()
+        self.request0 = django.http.HttpRequest()
+        self.exception1 = comment_client.CommentClientError('{}')
+        self.exception2 = comment_client.CommentClientError('Foo!')
+        self.exception0 = ValueError()
+        self.request1.META['HTTP_X_REQUESTED_WITH'] = "XMLHttpRequest"
+        self.request0.META['HTTP_X_REQUESTED_WITH'] = "SHADOWFAX"
 
-        def test_process_exception(self):
-                self.assertIsInstance(self.a.process_exception(self.request1, self.exception1), middleware.JsonError)
-                self.assertIsNone(self.a.process_exception(self.request1, self.exception0))
-                self.assertIsNone(self.a.process_exception(self.request0, self.exception1))
-                self.assertIsNone(self.a.process_exception(self.request0, self.exception0))
+    def test_process_exception(self):
+        self.assertIsInstance(self.a.process_exception(self.request1, self.exception1), middleware.JsonError)
+        self.assertIsInstance(self.a.process_exception(self.request1, self.exception2), middleware.JsonError)
+        self.assertIsNone(self.a.process_exception(self.request1, self.exception0))
+        self.assertIsNone(self.a.process_exception(self.request0, self.exception1))
+        self.assertIsNone(self.a.process_exception(self.request0, self.exception0))
diff --git a/lms/djangoapps/instructor/tests.py b/lms/djangoapps/instructor/tests.py
index b775aa158a..fd8e652997 100644
--- a/lms/djangoapps/instructor/tests.py
+++ b/lms/djangoapps/instructor/tests.py
@@ -8,13 +8,6 @@ Notes for running by hand:
 django-admin.py test --settings=lms.envs.test --pythonpath=. lms/djangoapps/instructor
 """
 
-import courseware.tests.tests as ct
-
-import json
-
-from nose import SkipTest
-from mock import patch, Mock
-
 from django.test.utils import override_settings
 
 # Need access to internal func to put users in the right group
@@ -26,13 +19,13 @@ from django_comment_client.models import Role, FORUM_ROLE_ADMINISTRATOR, \
 from django_comment_client.utils import has_forum_access
 
 from courseware.access import _course_staff_group_name
-import courseware.tests.tests as ct
+from courseware.tests.tests import LoginEnrollmentTestCase, TEST_DATA_XML_MODULESTORE, get_user
 from xmodule.modulestore.django import modulestore
 import xmodule.modulestore.django
 
 
-@override_settings(MODULESTORE=ct.TEST_DATA_XML_MODULESTORE)
-class TestInstructorDashboardGradeDownloadCSV(ct.PageLoader):
+@override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
+class TestInstructorDashboardGradeDownloadCSV(LoginEnrollmentTestCase):
     '''
     Check for download of csv
     '''
@@ -55,7 +48,7 @@ class TestInstructorDashboardGradeDownloadCSV(ct.PageLoader):
         def make_instructor(course):
             group_name = _course_staff_group_name(course.location)
             g = Group.objects.create(name=group_name)
-            g.user_set.add(ct.user(self.instructor))
+            g.user_set.add(get_user(self.instructor))
 
         make_instructor(self.toy)
 
@@ -63,7 +56,6 @@ class TestInstructorDashboardGradeDownloadCSV(ct.PageLoader):
         self.login(self.instructor, self.password)
         self.enroll(self.toy)
 
-
     def test_download_grades_csv(self):
         course = self.toy
         url = reverse('instructor_dashboard', kwargs={'course_id': course.id})
@@ -82,8 +74,8 @@ class TestInstructorDashboardGradeDownloadCSV(ct.PageLoader):
 
         # All the not-actually-in-the-course hw and labs come from the
         # default grading policy string in graders.py
-        expected_body = '''"ID","Username","Full Name","edX email","External email","HW 01","HW 02","HW 03","HW 04","HW 05","HW 06","HW 07","HW 08","HW 09","HW 10","HW 11","HW 12","HW Avg","Lab 01","Lab 02","Lab 03","Lab 04","Lab 05","Lab 06","Lab 07","Lab 08","Lab 09","Lab 10","Lab 11","Lab 12","Lab Avg","Midterm 01","Midterm Avg","Final 01","Final Avg"
-"2","u2","Fred Weasley","view2@test.com","","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"
+        expected_body = '''"ID","Username","Full Name","edX email","External email","HW 01","HW 02","HW 03","HW 04","HW 05","HW 06","HW 07","HW 08","HW 09","HW 10","HW 11","HW 12","HW Avg","Lab 01","Lab 02","Lab 03","Lab 04","Lab 05","Lab 06","Lab 07","Lab 08","Lab 09","Lab 10","Lab 11","Lab 12","Lab Avg","Midterm","Final"
+"2","u2","Fred Weasley","view2@test.com","","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"
 '''
 
         self.assertEqual(body, expected_body, msg)
@@ -101,9 +93,8 @@ def action_name(operation, rolename):
         return '{0} forum {1}'.format(operation, FORUM_ADMIN_ACTION_SUFFIX[rolename])
 
 
-
-@override_settings(MODULESTORE=ct.TEST_DATA_XML_MODULESTORE)
-class TestInstructorDashboardForumAdmin(ct.PageLoader):
+@override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
+class TestInstructorDashboardForumAdmin(LoginEnrollmentTestCase):
     '''
     Check for change in forum admin role memberships
     '''
@@ -112,7 +103,6 @@ class TestInstructorDashboardForumAdmin(ct.PageLoader):
         xmodule.modulestore.django._MODULESTORES = {}
         courses = modulestore().get_courses()
 
-
         self.course_id = "edX/toy/2012_Fall"
         self.toy = modulestore().get_course(self.course_id)
 
@@ -127,14 +117,12 @@ class TestInstructorDashboardForumAdmin(ct.PageLoader):
 
         group_name = _course_staff_group_name(self.toy.location)
         g = Group.objects.create(name=group_name)
-        g.user_set.add(ct.user(self.instructor))
+        g.user_set.add(get_user(self.instructor))
 
         self.logout()
         self.login(self.instructor, self.password)
         self.enroll(self.toy)
 
-
-
     def initialize_roles(self, course_id):
         self.admin_role = Role.objects.get_or_create(name=FORUM_ROLE_ADMINISTRATOR, course_id=course_id)[0]
         self.moderator_role = Role.objects.get_or_create(name=FORUM_ROLE_MODERATOR, course_id=course_id)[0]
diff --git a/lms/djangoapps/licenses/tests.py b/lms/djangoapps/licenses/tests.py
index 232c853b62..5289c31bc6 100644
--- a/lms/djangoapps/licenses/tests.py
+++ b/lms/djangoapps/licenses/tests.py
@@ -1,22 +1,138 @@
+"""Tests for License package"""
 import logging
+import json
+
 from uuid import uuid4
 from random import shuffle
 from tempfile import NamedTemporaryFile
+from factory import Factory, SubFactory
 
 from django.test import TestCase
 from django.core.management import call_command
-
-from .models import CourseSoftware, UserLicense
+from django.core.urlresolvers import reverse
+from licenses.models import CourseSoftware, UserLicense
+from courseware.tests.tests import LoginEnrollmentTestCase, get_user
 
 COURSE_1 = 'edX/toy/2012_Fall'
 
 SOFTWARE_1 = 'matlab'
 SOFTWARE_2 = 'stata'
 
+SERIAL_1 = '123456abcde'
+
 log = logging.getLogger(__name__)
 
 
+class CourseSoftwareFactory(Factory):
+    '''Factory for generating CourseSoftware objects in database'''
+    FACTORY_FOR = CourseSoftware
+
+    name = SOFTWARE_1
+    full_name = SOFTWARE_1
+    url = SOFTWARE_1
+    course_id = COURSE_1
+
+
+class UserLicenseFactory(Factory):
+    '''
+    Factory for generating UserLicense objects in database
+
+    By default, the user assigned is null, indicating that the
+    serial number has not yet been assigned.
+    '''
+    FACTORY_FOR = UserLicense
+
+    software = SubFactory(CourseSoftwareFactory)
+    serial = SERIAL_1
+
+
+class LicenseTestCase(LoginEnrollmentTestCase):
+    '''Tests for licenses.views'''
+    def setUp(self):
+        '''creates a user and logs in'''
+        self.setup_viewtest_user()
+        self.software = CourseSoftwareFactory()
+
+    def test_get_license(self):
+        UserLicenseFactory(user=get_user(self.viewtest_email), software=self.software)
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'false'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        self.assertEqual(200, response.status_code)
+        json_returned = json.loads(response.content)
+        self.assertFalse('error' in json_returned)
+        self.assertTrue('serial' in json_returned)
+        self.assertEquals(json_returned['serial'], SERIAL_1)
+
+    def test_get_nonexistent_license(self):
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'false'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        self.assertEqual(200, response.status_code)
+        json_returned = json.loads(response.content)
+        self.assertFalse('serial' in json_returned)
+        self.assertTrue('error' in json_returned)
+
+    def test_create_nonexistent_license(self):
+        '''Should not assign a license to an unlicensed user when none are available'''
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'true'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        self.assertEqual(200, response.status_code)
+        json_returned = json.loads(response.content)
+        self.assertFalse('serial' in json_returned)
+        self.assertTrue('error' in json_returned)
+
+    def test_create_license(self):
+        '''Should assign a license to an unlicensed user if one is unassigned'''
+        # create an unassigned license
+        UserLicenseFactory(software=self.software)
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'true'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        self.assertEqual(200, response.status_code)
+        json_returned = json.loads(response.content)
+        self.assertFalse('error' in json_returned)
+        self.assertTrue('serial' in json_returned)
+        self.assertEquals(json_returned['serial'], SERIAL_1)
+
+    def test_get_license_from_wrong_course(self):
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'false'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format('some/other/course'))
+        self.assertEqual(404, response.status_code)
+
+    def test_get_license_from_non_ajax(self):
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'false'},
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        self.assertEqual(404, response.status_code)
+
+    def test_get_license_without_software(self):
+        response = self.client.post(reverse('user_software_license'),
+                                    {'generate': 'false'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        self.assertEqual(404, response.status_code)
+
+    def test_get_license_without_login(self):
+        self.logout()
+        response = self.client.post(reverse('user_software_license'),
+                                    {'software': SOFTWARE_1, 'generate': 'false'},
+                                    HTTP_X_REQUESTED_WITH='XMLHttpRequest',
+                                    HTTP_REFERER='/courses/{0}/some_page'.format(COURSE_1))
+        # if we're not logged in, we should be referred to the login page
+        self.assertEqual(302, response.status_code)
+
+
 class CommandTest(TestCase):
+    '''Test management command for importing serial numbers'''
+
     def test_import_serial_numbers(self):
         size = 20
 
@@ -51,31 +167,33 @@ class CommandTest(TestCase):
         licenses_count = UserLicense.objects.all().count()
         self.assertEqual(3 * size, licenses_count)
 
-        cs = CourseSoftware.objects.get(pk=1)
+        software = CourseSoftware.objects.get(pk=1)
 
-        lics = UserLicense.objects.filter(software=cs)[:size]
+        lics = UserLicense.objects.filter(software=software)[:size]
         known_serials = list(l.serial for l in lics)
         known_serials.extend(generate_serials(10))
 
         shuffle(known_serials)
 
         log.debug('Adding some new and old serials to {0}'.format(SOFTWARE_1))
-        with NamedTemporaryFile() as f:
-            f.write('\n'.join(known_serials))
-            f.flush()
-            args = [COURSE_1, SOFTWARE_1, f.name]
+        with NamedTemporaryFile() as tmpfile:
+            tmpfile.write('\n'.join(known_serials))
+            tmpfile.flush()
+            args = [COURSE_1, SOFTWARE_1, tmpfile.name]
             call_command('import_serial_numbers', *args)
 
         log.debug('Check if we added only the new ones')
-        licenses_count = UserLicense.objects.filter(software=cs).count()
+        licenses_count = UserLicense.objects.filter(software=software).count()
         self.assertEqual((2 * size) + 10, licenses_count)
 
 
 def generate_serials(size=20):
+    '''generate a list of serial numbers'''
     return [str(uuid4()) for _ in range(size)]
 
 
 def generate_serials_file(size=20):
+    '''output list of generated serial numbers to a temp file'''
     serials = generate_serials(size)
 
     temp_file = NamedTemporaryFile()
diff --git a/lms/djangoapps/licenses/views.py b/lms/djangoapps/licenses/views.py
index 20966427ba..1c1a80ed31 100644
--- a/lms/djangoapps/licenses/views.py
+++ b/lms/djangoapps/licenses/views.py
@@ -7,12 +7,13 @@ from collections import namedtuple, defaultdict
 
 from mitxmako.shortcuts import render_to_string
 
+from django.contrib.auth.decorators import login_required
 from django.contrib.auth.models import User
 from django.http import HttpResponse, Http404
-from django.views.decorators.csrf import requires_csrf_token, csrf_protect
+from django.views.decorators.csrf import requires_csrf_token
 
-from .models import CourseSoftware
-from .models import get_courses_licenses, get_or_create_license, get_license
+from licenses.models import CourseSoftware
+from licenses.models import get_courses_licenses, get_or_create_license, get_license
 
 
 log = logging.getLogger("mitx.licenses")
@@ -44,6 +45,7 @@ def get_licenses_by_course(user, courses):
     return data_by_course
 
 
+@login_required
 @requires_csrf_token
 def user_software_license(request):
     if request.method != 'POST' or not request.is_ajax():
@@ -65,19 +67,21 @@ def user_software_license(request):
     try:
         software = CourseSoftware.objects.get(name=software_name,
                                               course_id=course_id)
-        print software
     except CourseSoftware.DoesNotExist:
         raise Http404
 
-    user = User.objects.get(id=user_id)
+    try:
+        user = User.objects.get(id=user_id)
+    except User.DoesNotExist:
+        raise Http404
 
     if generate:
-        license = get_or_create_license(user, software)
+        software_license = get_or_create_license(user, software)
     else:
-        license = get_license(user, software)
+        software_license = get_license(user, software)
 
-    if license:
-        response = {'serial': license.serial}
+    if software_license:
+        response = {'serial': software_license.serial}
     else:
         response = {'error': 'No serial number found'}
 
diff --git a/lms/djangoapps/open_ended_grading/tests.py b/lms/djangoapps/open_ended_grading/tests.py
index 1fd871d0cd..e554fdf0e1 100644
--- a/lms/djangoapps/open_ended_grading/tests.py
+++ b/lms/djangoapps/open_ended_grading/tests.py
@@ -4,22 +4,22 @@ Tests for open ended grading interfaces
 django-admin.py test --settings=lms.envs.test --pythonpath=. lms/djangoapps/open_ended_grading
 """
 
-from django.test import TestCase
-from open_ended_grading import staff_grading_service
-from xmodule.open_ended_grading_classes import peer_grading_service
-from xmodule import peer_grading_module
+import json
+from mock import MagicMock
+
 from django.core.urlresolvers import reverse
 from django.contrib.auth.models import Group
+from mitxmako.shortcuts import render_to_string
 
-from courseware.access import _course_staff_group_name
-import courseware.tests.tests as ct
+from xmodule.open_ended_grading_classes import peer_grading_service
+from xmodule import peer_grading_module
 from xmodule.modulestore.django import modulestore
 import xmodule.modulestore.django
-from nose import SkipTest
-from mock import patch, Mock, MagicMock
-import json
 from xmodule.x_module import ModuleSystem
-from mitxmako.shortcuts import render_to_string
+
+from open_ended_grading import staff_grading_service
+from courseware.access import _course_staff_group_name
+from courseware.tests.tests import LoginEnrollmentTestCase, TEST_DATA_XML_MODULESTORE, get_user
 
 import logging
 
@@ -30,8 +30,8 @@ from django.http import QueryDict
 from xmodule.tests import test_util_open_ended
 
 
-@override_settings(MODULESTORE=ct.TEST_DATA_XML_MODULESTORE)
-class TestStaffGradingService(ct.PageLoader):
+@override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
+class TestStaffGradingService(LoginEnrollmentTestCase):
     '''
     Check that staff grading service proxy works.  Basically just checking the
     access control and error handling logic -- all the actual work is on the
@@ -56,7 +56,7 @@ class TestStaffGradingService(ct.PageLoader):
         def make_instructor(course):
             group_name = _course_staff_group_name(course.location)
             g = Group.objects.create(name=group_name)
-            g.user_set.add(ct.user(self.instructor))
+            g.user_set.add(get_user(self.instructor))
 
         make_instructor(self.toy)
 
@@ -126,8 +126,8 @@ class TestStaffGradingService(ct.PageLoader):
         self.assertIsNotNone(d['problem_list'])
 
 
-@override_settings(MODULESTORE=ct.TEST_DATA_XML_MODULESTORE)
-class TestPeerGradingService(ct.PageLoader):
+@override_settings(MODULESTORE=TEST_DATA_XML_MODULESTORE)
+class TestPeerGradingService(LoginEnrollmentTestCase):
     '''
     Check that staff grading service proxy works.  Basically just checking the
     access control and error handling logic -- all the actual work is on the
diff --git a/lms/djangoapps/open_ended_grading/views.py b/lms/djangoapps/open_ended_grading/views.py
index 65cfe22ed0..78da00bf2b 100644
--- a/lms/djangoapps/open_ended_grading/views.py
+++ b/lms/djangoapps/open_ended_grading/views.py
@@ -111,7 +111,7 @@ def peer_grading(request, course_id):
         #Get the peer grading modules currently in the course
         items = modulestore().get_items(['i4x', None, course_id_parts[1], 'peergrading', None])
         #See if any of the modules are centralized modules (ie display info from multiple problems)
-        items = [i for i in items if i.metadata.get("use_for_single_location", True) in false_dict]
+        items = [i for i in items if getattr(i,"use_for_single_location", True) in false_dict]
         #Get the first one
         item_location = items[0].location
         #Generate a url for the first module and redirect the user to it
diff --git a/lms/envs/aws.py b/lms/envs/aws.py
index cc9247b876..aa30315eca 100644
--- a/lms/envs/aws.py
+++ b/lms/envs/aws.py
@@ -76,6 +76,7 @@ LOGGING = get_logger_config(LOG_DIR,
 COURSE_LISTINGS = ENV_TOKENS.get('COURSE_LISTINGS', {})
 SUBDOMAIN_BRANDING = ENV_TOKENS.get('SUBDOMAIN_BRANDING', {})
 VIRTUAL_UNIVERSITIES = ENV_TOKENS.get('VIRTUAL_UNIVERSITIES', [])
+META_UNIVERSITIES = ENV_TOKENS.get('META_UNIVERSITIES', {})
 COMMENTS_SERVICE_URL = ENV_TOKENS.get("COMMENTS_SERVICE_URL", '')
 COMMENTS_SERVICE_KEY = ENV_TOKENS.get("COMMENTS_SERVICE_KEY", '')
 CERT_QUEUE = ENV_TOKENS.get("CERT_QUEUE", 'test-pull')
diff --git a/lms/envs/cms/dev.py b/lms/envs/cms/dev.py
index 4b6b0a12f0..9333b7883c 100644
--- a/lms/envs/cms/dev.py
+++ b/lms/envs/cms/dev.py
@@ -9,6 +9,7 @@ MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES'] = False
 SUBDOMAIN_BRANDING['edge'] = 'edge'
 SUBDOMAIN_BRANDING['preview.edge'] = 'edge'
 VIRTUAL_UNIVERSITIES = ['edge']
+META_UNIVERSITIES = {}
 
 modulestore_options = {
     'default_class': 'xmodule.raw_module.RawDescriptor',
diff --git a/lms/envs/common.py b/lms/envs/common.py
index cfd6fc34de..8654b5ebf5 100644
--- a/lms/envs/common.py
+++ b/lms/envs/common.py
@@ -364,6 +364,7 @@ TEMPLATE_LOADERS = (
 
 MIDDLEWARE_CLASSES = (
     'contentserver.middleware.StaticContentServer',
+    'request_cache.middleware.RequestCache',
     'django_comment_client.middleware.AjaxExceptionMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
diff --git a/lms/envs/dev.py b/lms/envs/dev.py
index f204dc287b..8363f744a0 100644
--- a/lms/envs/dev.py
+++ b/lms/envs/dev.py
@@ -113,6 +113,9 @@ SUBDOMAIN_BRANDING = {
 # have an actual course with that org set
 VIRTUAL_UNIVERSITIES = []
 
+# Organization that contain other organizations
+META_UNIVERSITIES = {'UTx': ['UTAustinX']}
+
 COMMENTS_SERVICE_KEY = "PUT_YOUR_API_KEY_HERE"
 
 ############################## Course static files ##########################
@@ -218,7 +221,7 @@ FILE_UPLOAD_HANDLERS = (
 
 ########################### PIPELINE #################################
 
-PIPELINE_SASS_ARGUMENTS = '-r {proj_dir}/static/sass/bourbon/lib/bourbon.rb'.format(proj_dir=PROJECT_ROOT)
+PIPELINE_SASS_ARGUMENTS = '--debug-info --require {proj_dir}/static/sass/bourbon/lib/bourbon.rb'.format(proj_dir=PROJECT_ROOT)
 
 ########################## PEARSON TESTING ###########################
 MITX_FEATURES['ENABLE_PEARSON_HACK_TEST'] = True
diff --git a/lms/lib/symmath/formula.py b/lms/lib/symmath/formula.py
index f3f26699f2..604941ffdd 100644
--- a/lms/lib/symmath/formula.py
+++ b/lms/lib/symmath/formula.py
@@ -74,6 +74,15 @@ def to_latex(x):
     # LatexPrinter._print_dot = _print_dot
     xs = latex(x)
     xs = xs.replace(r'\XI', 'XI')	 # workaround for strange greek
+
+    # substitute back into latex form for scripts
+    # literally something of the form
+    # 'scriptN' becomes '\\mathcal{N}'
+    # note: can't use something akin to the _print_hat method above because we sometimes get 'script(N)__B' or more complicated terms
+    xs = re.sub(r'script([a-zA-Z0-9]+)',
+                '\\mathcal{\\1}',
+                xs)
+
     #return '<math>%s{}{}</math>' % (xs[1:-1])
     if xs[0] == '$':
         return '[mathjax]%s[/mathjax]<br>' % (xs[1:-1])	 # for sympy v6
@@ -106,6 +115,7 @@ def my_sympify(expr, normphase=False, matrix=False, abcsym=False, do_qubit=False
                   'i': sympy.I,			# lowercase i is also sqrt(-1)
                   'Q': sympy.Symbol('Q'),	 # otherwise it is a sympy "ask key"
                   'I': sympy.Symbol('I'),	 # otherwise it is sqrt(-1)
+                  'N': sympy.Symbol('N'),	 # or it is some kind of sympy function
                   #'X':sympy.sympify('Matrix([[0,1],[1,0]])'),
                   #'Y':sympy.sympify('Matrix([[0,-I],[I,0]])'),
                   #'Z':sympy.sympify('Matrix([[1,0],[0,-1]])'),
@@ -247,6 +257,127 @@ class formula(object):
                 fix_hat(k)
         fix_hat(xml)
 
+        def flatten_pmathml(xml):
+            ''' Give the text version of certain PMathML elements
+
+            Sometimes MathML will be given with each letter separated (it
+            doesn't know if its implicit multiplication or what). From an xml
+            node, find the (text only) variable name it represents. So it takes
+            <mrow>
+              <mi>m</mi>
+              <mi>a</mi>
+              <mi>x</mi>
+            </mrow>
+            and returns 'max', for easier use later on.
+            '''
+            tag = gettag(xml)
+            if tag == 'mn': return xml.text
+            elif tag == 'mi': return xml.text
+            elif tag == 'mrow': return ''.join([flatten_pmathml(y) for y in xml])
+            raise Exception, '[flatten_pmathml] unknown tag %s' % tag
+
+        def fix_mathvariant(parent):
+            '''Fix certain kinds of math variants
+
+            Literally replace <mstyle mathvariant="script"><mi>N</mi></mstyle>
+            with 'scriptN'. There have been problems using script_N or script(N)
+            '''
+            for child in parent:
+                if (gettag(child) == 'mstyle' and child.get('mathvariant') == 'script'):
+                    newchild = etree.Element('mi')
+                    newchild.text = 'script%s' % flatten_pmathml(child[0])
+                    parent.replace(child, newchild)
+                fix_mathvariant(child)
+        fix_mathvariant(xml)
+
+
+        # find "tagged" superscripts
+        # they have the character \u200b in the superscript
+        # replace them with a__b so snuggle doesn't get confused
+        def fix_superscripts(xml):
+            ''' Look for and replace sup elements with 'X__Y' or 'X_Y__Z'
+
+            In the javascript, variables with '__X' in them had an invisible
+            character inserted into the sup (to distinguish from powers)
+            E.g. normal:
+            <msubsup>
+              <mi>a</mi>
+              <mi>b</mi>
+              <mi>c</mi>
+            </msubsup>
+            to be interpreted '(a_b)^c' (nothing done by this method)
+
+            And modified:
+            <msubsup>
+              <mi>b</mi>
+              <mi>x</mi>
+              <mrow>
+                <mo>&#x200B;</mo>
+                <mi>d</mi>
+              </mrow>
+            </msubsup>
+            to be interpreted 'a_b__c'
+
+            also:
+            <msup>
+              <mi>x</mi>
+              <mrow>
+                <mo>&#x200B;</mo>
+                <mi>B</mi>
+              </mrow>
+            </msup>
+            to be 'x__B'
+            '''
+            for k in xml:
+                tag = gettag(k)
+
+                # match things like the last example--
+                # the second item in msub is an mrow with the first
+                # character equal to \u200b
+                if (tag == 'msup' and
+                    len(k) == 2 and gettag(k[1]) == 'mrow' and
+                    gettag(k[1][0]) == 'mo' and k[1][0].text == u'\u200b'): # whew
+
+                    # replace the msup with 'X__Y'
+                    k[1].remove(k[1][0])
+                    newk = etree.Element('mi')
+                    newk.text = '%s__%s' % (flatten_pmathml(k[0]), flatten_pmathml(k[1]))
+                    xml.replace(k, newk)
+
+                # match things like the middle example-
+                # the third item in msubsup is an mrow with the first
+                # character equal to \u200b
+                if (tag == 'msubsup' and
+                    len(k) == 3 and gettag(k[2]) == 'mrow' and
+                    gettag(k[2][0]) == 'mo' and k[2][0].text == u'\u200b'): # whew
+
+                    # replace the msubsup with 'X_Y__Z'
+                    k[2].remove(k[2][0])
+                    newk = etree.Element('mi')
+                    newk.text = '%s_%s__%s' % (flatten_pmathml(k[0]), flatten_pmathml(k[1]), flatten_pmathml(k[2]))
+                    xml.replace(k, newk)
+
+                fix_superscripts(k)
+        fix_superscripts(xml)
+
+        # Snuggle returns an error when it sees an <msubsup>
+        # replace such elements with an <msup>, except the first element is of
+        # the form a_b. I.e. map a_b^c => (a_b)^c
+        def fix_msubsup(parent):
+            for child in parent:
+                # fix msubsup
+                if (gettag(child) == 'msubsup' and len(child) == 3):
+                    newchild = etree.Element('msup')
+                    newbase = etree.Element('mi')
+                    newbase.text = '%s_%s' % (flatten_pmathml(child[0]), flatten_pmathml(child[1]))
+                    newexp = child[2]
+                    newchild.append(newbase)
+                    newchild.append(newexp)
+                    parent.replace(child, newchild)
+
+                fix_msubsup(child)
+        fix_msubsup(xml)
+
         self.xml = xml
         return self.xml
 
@@ -257,6 +388,7 @@ class formula(object):
         try:
             xml = self.preprocess_pmathml(self.expr)
         except Exception, err:
+            log.warning('Err %s while preprocessing; expr=%s' % (err, self.expr))
             return "<html>Error! Cannot process pmathml</html>"
         pmathml = etree.tostring(xml, pretty_print=True)
         self.the_pmathml = pmathml
diff --git a/lms/lib/symmath/test_formula.py b/lms/lib/symmath/test_formula.py
new file mode 100644
index 0000000000..d3f16ed6b3
--- /dev/null
+++ b/lms/lib/symmath/test_formula.py
@@ -0,0 +1,115 @@
+"""
+Tests of symbolic math
+"""
+
+
+import unittest
+import formula
+import re
+from lxml import etree
+
+def stripXML(xml):
+    xml = xml.replace('\n', '')
+    xml = re.sub(r'\> +\<', '><', xml)
+    return xml
+
+class FormulaTest(unittest.TestCase):
+    # for readability later
+    mathml_start = '<math xmlns="http://www.w3.org/1998/Math/MathML"><mstyle displaystyle="true">'
+    mathml_end = '</mstyle></math>'
+
+    def setUp(self):
+        self.formulaInstance = formula.formula('')
+
+    def test_replace_mathvariants(self):
+        expr = '''
+<mstyle mathvariant="script">
+  <mi>N</mi>
+</mstyle>'''
+
+        expected = '<mi>scriptN</mi>'
+
+        # wrap
+        expr = stripXML(self.mathml_start + expr + self.mathml_end)
+        expected = stripXML(self.mathml_start + expected + self.mathml_end)
+
+        # process the expression
+        xml = etree.fromstring(expr)
+        xml = self.formulaInstance.preprocess_pmathml(xml)
+        test = etree.tostring(xml)
+
+        # success?
+        self.assertEqual(test, expected)
+
+
+    def test_fix_simple_superscripts(self):
+        expr = '''
+<msup>
+  <mi>a</mi>
+  <mrow>
+    <mo>&#x200B;</mo>
+    <mi>b</mi>
+  </mrow>
+</msup>'''
+
+        expected = '<mi>a__b</mi>'
+
+        # wrap
+        expr = stripXML(self.mathml_start + expr + self.mathml_end)
+        expected = stripXML(self.mathml_start + expected + self.mathml_end)
+
+        # process the expression
+        xml = etree.fromstring(expr)
+        xml = self.formulaInstance.preprocess_pmathml(xml)
+        test = etree.tostring(xml)
+
+        # success?
+        self.assertEqual(test, expected)
+
+    def test_fix_complex_superscripts(self):
+        expr = '''
+<msubsup>
+  <mi>a</mi>
+  <mi>b</mi>
+  <mrow>
+    <mo>&#x200B;</mo>
+    <mi>c</mi>
+  </mrow>
+</msubsup>'''
+
+        expected = '<mi>a_b__c</mi>'
+
+        # wrap
+        expr = stripXML(self.mathml_start + expr + self.mathml_end)
+        expected = stripXML(self.mathml_start + expected + self.mathml_end)
+
+        # process the expression
+        xml = etree.fromstring(expr)
+        xml = self.formulaInstance.preprocess_pmathml(xml)
+        test = etree.tostring(xml)
+
+        # success?
+        self.assertEqual(test, expected)
+
+
+    def test_fix_msubsup(self):
+        expr = '''
+<msubsup>
+  <mi>a</mi>
+  <mi>b</mi>
+  <mi>c</mi>
+</msubsup>'''
+
+        expected = '<msup><mi>a_b</mi><mi>c</mi></msup>' # which is (a_b)^c
+
+        # wrap
+        expr = stripXML(self.mathml_start + expr + self.mathml_end)
+        expected = stripXML(self.mathml_start + expected + self.mathml_end)
+
+        # process the expression
+        xml = etree.fromstring(expr)
+        xml = self.formulaInstance.preprocess_pmathml(xml)
+        test = etree.tostring(xml)
+
+        # success?
+        self.assertEqual(test, expected)
diff --git a/lms/one_time_startup.py b/lms/one_time_startup.py
index 6b3c45d60f..e1b1f79444 100644
--- a/lms/one_time_startup.py
+++ b/lms/one_time_startup.py
@@ -2,13 +2,15 @@ import logging
 from dogapi import dog_http_api, dog_stats_api
 from django.conf import settings
 from xmodule.modulestore.django import modulestore
+from request_cache.middleware import RequestCache
 
 from django.core.cache import get_cache, InvalidCacheBackendError
 
 cache = get_cache('mongo_metadata_inheritance')
 for store_name in settings.MODULESTORE:
     store = modulestore(store_name)
-    store.metadata_inheritance_cache = cache
+    store.metadata_inheritance_cache_subsystem = cache
+    store.request_cache = RequestCache.get_request_cache()
 
 if hasattr(settings, 'DATADOG_API'):
     dog_http_api.api_key = settings.DATADOG_API
diff --git a/lms/static/images/university/utaustin/utaustin-cover_2025x550.jpg b/lms/static/images/university/utaustin/utaustin-cover_2025x550.jpg
new file mode 100644
index 0000000000..7294b53f1b
Binary files /dev/null and b/lms/static/images/university/utaustin/utaustin-cover_2025x550.jpg differ
diff --git a/lms/static/images/university/utaustin/utaustin-standalone_187x80.png b/lms/static/images/university/utaustin/utaustin-standalone_187x80.png
new file mode 100644
index 0000000000..5349800763
Binary files /dev/null and b/lms/static/images/university/utaustin/utaustin-standalone_187x80.png differ
diff --git a/lms/templates/university_profile/utaustinx.html b/lms/templates/university_profile/utaustinx.html
new file mode 100644
index 0000000000..b4f6b4446e
--- /dev/null
+++ b/lms/templates/university_profile/utaustinx.html
@@ -0,0 +1,23 @@
+<%inherit file="base.html" />
+<%namespace name='static' file='../static_content.html'/>
+
+<%block name="title"><title>UTAustinX</title></%block>
+
+<%block name="university_header">
+  <header class="search" style="background: url('/static/images/university/utaustin/utaustin-cover_2025x550.jpg')">
+    <div class="inner-wrapper university-search">
+      <hgroup>
+        <div class="logo">
+           <img src="${static.url('images/university/utaustin/utaustin-standalone_187x80.png')}" />
+        </div>
+        <h1>UTAustinx</h1>
+      </hgroup>
+    </div>
+  </header>
+</%block>
+
+<%block name="university_description">
+    <p>The University of Texas at Austin is the top-ranked public university in a nearly 1,000-mile radius, and is ranked in the top 25 universities in the world. Students have been finding their passion in life at UT Austin for more than 130 years, and it has been a member of the prestigious AAU since 1929. UT Austin combines the academic depth and breadth of a world research institute (regularly ranking within the top three producers of doctoral degrees in the country) with the fun and excitement of a big-time collegiate experience. It is currently the fifth-largest university in America, with more than 50,000 students and 3,000 professors across 17 colleges and schools, and is the first major American university to build a medical school in the past 50 years.</p>
+</%block>
+
+${parent.body()}
diff --git a/lms/templates/university_profile/utx.html b/lms/templates/university_profile/utx.html
index b9378f6ce3..ea34ddb85b 100644
--- a/lms/templates/university_profile/utx.html
+++ b/lms/templates/university_profile/utx.html
@@ -1,5 +1,8 @@
 <%inherit file="base.html" />
 <%namespace name='static' file='../static_content.html'/>
+<%!
+    from django.core.urlresolvers import reverse
+%>
 
 <%block name="title"><title>UTx</title></%block>
 
@@ -19,6 +22,7 @@
 
 <%block name="university_description">
     <p>Educating students, providing care for patients, conducting groundbreaking research and serving the needs of Texans and the nation for more than 130 years, The University of Texas System is one of the largest public university systems in the United States, with nine academic universities and six health science centers. Student enrollment exceeded 215,000 in the 2011 academic year. The UT System confers more than one-third of the state’s undergraduate degrees and educates nearly three-fourths of the state’s health care professionals annually. The UT System has an annual operating budget of $13.1 billion (FY 2012) including $2.3 billion in sponsored programs funded by federal, state, local and private sources. With roughly 87,000 employees, the UT System is one of the largest employers in the state.</p>
+    <p>Find out about the <a href="${reverse('university_profile', args=['UTAustinX'])}">University of Texas Austin</a>.</p>
 </%block>
 
 ${parent.body()}
diff --git a/lms/urls.py b/lms/urls.py
index ee213f2b8c..de5c8184fa 100644
--- a/lms/urls.py
+++ b/lms/urls.py
@@ -69,44 +69,22 @@ urlpatterns = ('',
 
     url(r'^heartbeat$', include('heartbeat.urls')),
 
-    url(r'^university_profile/UTx$', 'courseware.views.static_university_profile',
-        name="static_university_profile", kwargs={'org_id': 'UTx'}),
-    url(r'^university_profile/WellesleyX$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/WellesleyX$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'WellesleyX'}),
-    url(r'^university_profile/GeorgetownX$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/GeorgetownX$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'GeorgetownX'}),
-
-    # Dan accidentally sent out a press release with lower case urls for McGill, Toronto,
-    # Rice, ANU, Delft, and EPFL.  Hence the redirects.
-    url(r'^university_profile/McGillX$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/McGillX$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'McGillX'}),
-    url(r'^university_profile/mcgillx$',
-        RedirectView.as_view(url='/university_profile/McGillX')),
-
-    url(r'^university_profile/TorontoX$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/TorontoX$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'TorontoX'}),
-    url(r'^university_profile/torontox$',
-        RedirectView.as_view(url='/university_profile/TorontoX')),
-
-    url(r'^university_profile/RiceX$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/RiceX$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'RiceX'}),
-    url(r'^university_profile/ricex$',
-        RedirectView.as_view(url='/university_profile/RiceX')),
-
-    url(r'^university_profile/ANUx$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/ANUx$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'ANUx'}),
-    url(r'^university_profile/anux$',
-        RedirectView.as_view(url='/university_profile/ANUx')),
-
-    url(r'^university_profile/DelftX$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/DelftX$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'DelftX'}),
-    url(r'^university_profile/delftx$',
-        RedirectView.as_view(url='/university_profile/DelftX')),
-
-    url(r'^university_profile/EPFLx$', 'courseware.views.static_university_profile',
+    url(r'^(?i)university_profile/EPFLx$', 'courseware.views.static_university_profile',
         name="static_university_profile", kwargs={'org_id': 'EPFLx'}),
-    url(r'^university_profile/epflx$',
-        RedirectView.as_view(url='/university_profile/EPFLx')),
 
     url(r'^university_profile/(?P<org_id>[^/]+)$', 'courseware.views.university_profile',
         name="university_profile"),
diff --git a/requirements.txt b/requirements.txt
index 3dc732e013..1a383e6cc0 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -51,7 +51,7 @@ python-memcached==1.48
 python-openid==2.2.5
 pytz==2012h
 PyYAML==3.10
-rednose==0.3.3
+rednose==0.3
 requests==0.14.2
 scipy==0.11.0
 Shapely==1.2.16