merge from master. resolved conflict with test_responsetypes.py by using the version from master.

cms/djangoapps/contentstore/features/advanced-settings.feature

+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
+
+  Scenario: A course author sees only display_name on a newly created course
+    Given I have opened a new course in Studio
+    When I select the Advanced Settings
+    Then I see only the display name
+
+  Scenario: Test if there are no policy settings without existing UI controls
+    Given I am on the Advanced Course Settings page in Studio
+    When I delete the display name
+    Then there are no advanced policy settings
+    And I reload the page
+    Then there are no advanced policy settings
+
+  Scenario: Test cancel editing key name
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the name of a policy key
+    And I press the "Cancel" notification button
+    Then the policy key name is unchanged
+
+  Scenario: Test editing key name
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the name of a policy key
+    And I press the "Save" notification button
+    Then the policy key name is changed
+
+  Scenario: Test cancel editing key value
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the value of a policy key
+    And I press the "Cancel" notification button
+    Then the policy key value is unchanged
+
+  Scenario: Test editing key value
+    Given I am on the Advanced Course Settings page in Studio
+    When I edit the value of a policy key
+    And I press the "Save" notification button
+    Then the policy key value is changed
+
+  Scenario: Add new entries, and they appear alphabetically after save
+    Given I am on the Advanced Course Settings page in Studio
+    When I create New Entries
+    Then they are alphabetized
+    And I reload the page
+    Then they are alphabetized
+
+  Scenario: Test how multi-line input appears
+    Given I am on the Advanced Course Settings page in Studio
+    When I create a JSON object
+    Then it is displayed as formatted

cms/djangoapps/contentstore/features/advanced-settings.py

+from lettuce import world, step
+from common import *
+import time
+
+from nose.tools import assert_equal
+from nose.tools import assert_true
+
+"""
+http://selenium.googlecode.com/svn/trunk/docs/api/py/webdriver/selenium.webdriver.common.keys.html
+"""
+from selenium.webdriver.common.keys import Keys
+
+
+############### 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)
+    link_css = 'li.nav-course-settings-advanced a'
+    css_click(link_css)
+
+
+@step('I am on the Advanced Course Settings page in Studio$')
+def i_am_on_advanced_course_settings(step):
+    step.given('I have opened a new course in Studio')
+    step.given('I select the Advanced Settings')
+
+
+# TODO: this is copied from terrain's step.py. Need to figure out how to share that code.
+@step('I reload the page$')
+def reload_the_page(step):
+    world.browser.reload()
+
+
+@step(u'I edit the name of a policy key$')
+def edit_the_name_of_a_policy_key(step):
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    e.fill('new')
+
+
+@step(u'I press the "([^"]*)" notification button$')
+def press_the_notification_button(step, name):
+    world.browser.click_link_by_text(name)
+
+
+@step(u'I edit the value of a policy key$')
+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 :)
+    """
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    e._element.send_keys(Keys.TAB, Keys.END, Keys.ARROW_LEFT, ' ', 'X')
+
+
+@step('I delete the display name$')
+def delete_the_display_name(step):
+    delete_entry(0)
+    click_save()
+
+
+@step('create New Entries$')
+def create_new_entries(step):
+    create_entry("z", "apple")
+    create_entry("a", "zebra")
+    click_save()
+
+
+@step('I create a JSON object$')
+def create_JSON_object(step):
+    create_entry("json", '{"key": "value", "key_2": "value_2"}')
+    click_save()
+
+
+############### RESULTS ####################
+@step('I see only the display name$')
+def i_see_only_display_name(step):
+    assert_policy_entries(["display_name"], ['"Robot Super Course"'])
+
+
+@step('there are no advanced policy settings$')
+def no_policy_settings(step):
+    assert_policy_entries([], [])
+
+
+@step('they are alphabetized$')
+def they_are_alphabetized(step):
+    assert_policy_entries(["a", "display_name", "z"], ['"zebra"', '"Robot Super Course"', '"apple"'])
+
+
+@step('it is displayed as formatted$')
+def it_is_formatted(step):
+    assert_policy_entries(["display_name", "json"], ['"Robot Super Course"', '{\n    "key": "value",\n    "key_2": "value_2"\n}'])
+
+
+@step(u'the policy key name is unchanged$')
+def the_policy_key_name_is_unchanged(step):
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    assert_equal(e.value, 'display_name')
+
+
+@step(u'the policy key name is changed$')
+def the_policy_key_name_is_changed(step):
+    policy_key_css = 'input.policy-key'
+    e = css_find(policy_key_css).first
+    assert_equal(e.value, 'new')
+
+
+@step(u'the policy key value is unchanged$')
+def the_policy_key_value_is_unchanged(step):
+    policy_value_css = 'li.course-advanced-policy-list-item div.value textarea'
+    e = css_find(policy_value_css).first
+    assert_equal(e.value, '"Robot Super Course"')
+
+
+@step(u'the policy key value is changed$')
+def the_policy_key_value_is_unchanged(step):
+    policy_value_css = 'li.course-advanced-policy-list-item div.value textarea'
+    e = css_find(policy_value_css).first
+    assert_equal(e.value, '"Robot Super Course X"')
+
+
+############# HELPERS ###############
+def create_entry(key, value):
+    # Scroll down the page so the button is visible
+    world.scroll_to_bottom()
+    css_click_at('a.new-advanced-policy-item', 10, 10)
+    new_key_css = 'div#__new_advanced_key__ input'
+    new_key_element = css_find(new_key_css).first
+    new_key_element.fill(key)
+#   For some reason have to get the instance for each command (get error that it is no longer attached to the DOM)
+#   Have to do all this because Selenium has a bug that fill does not remove existing text
+    new_value_css = 'div.CodeMirror textarea'
+    css_find(new_value_css).last.fill("")
+    css_find(new_value_css).last._element.send_keys(Keys.DELETE, Keys.DELETE)
+    css_find(new_value_css).last.fill(value)
+
+
+def delete_entry(index):
+    """ 
+    Delete the nth entry where index is 0-based
+    """
+    css = '.delete-button'
+    assert_true(world.browser.is_element_present_by_css(css, 5))
+    delete_buttons = css_find(css)
+    assert_true(len(delete_buttons) > index, "no delete button exists for entry " + str(index))
+    delete_buttons[index].click()
+
+
+def assert_policy_entries(expected_keys, expected_values):
+    assert_entries('.key input', expected_keys)
+    assert_entries('.json', expected_values)
+
+
+def assert_entries(css, expected_values):
+    webElements = css_find(css)
+    assert_equal(len(expected_values), len(webElements))
+#   Sometimes get stale reference if I hold on to the array of elements
+    for counter in range(len(expected_values)):
+        assert_equal(expected_values[counter], css_find(css)[counter].value)
+
+
+def click_save():
+    css = ".save-button"
+
+    def is_shown(driver):
+        visible = css_find(css).first.visible
+        if visible:
+            # Even when waiting for visible, this fails sporadically. Adding in a small wait.
+            time.sleep(float(1))
+        return visible
+    wait_for(is_shown)
+    css_click(css)
+
+
+def fill_last_field(value):
+    newValue = css_find('#__new_advanced_key__ input').first
+    newValue.fill(value)

cms/djangoapps/contentstore/features/common.py

 from lettuce import world, step
-from factories import *
-from django.core.management import call_command
 from lettuce.django import django_url
-from django.conf import settings
-from django.core.management import call_command
 from nose.tools import assert_true
 from nose.tools import assert_equal
+from selenium.webdriver.support.ui import WebDriverWait
+
+from terrain.factories import UserFactory, RegistrationFactory, UserProfileFactory
+from terrain.factories import CourseFactory, GroupFactory
 import xmodule.modulestore.django
+from auth.authz import get_user_by_email
 
 from logging import getLogger
 logger = getLogger(__name__)
@@ -44,6 +45,13 @@ def i_press_the_category_delete_icon(step, category):
         assert False, 'Invalid category: %s' % category
     css_click(css)
 
+
+@step('I have opened a new course in Studio$')
+def i_have_opened_a_new_course(step):
+    clear_courses()
+    log_into_studio()
+    create_a_course()
+
 ####### HELPER FUNCTIONS ##############
 
 
@@ -86,13 +94,38 @@ def assert_css_with_text(css, text):
 
 
 def css_click(css):
+    assert_true(world.browser.is_element_present_by_css(css, 5))
     world.browser.find_by_css(css).first.click()
 
 
+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
+    '''
+    assert_true(world.browser.is_element_present_by_css(css, 5))
+    e = world.browser.find_by_css(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):
+    return world.browser.find_by_css(css)
+
+
+def wait_for(func):
+    WebDriverWait(world.browser.driver, 10).until(func)
+
+
+def id_find(id):
+    return world.browser.find_by_id(id)
+
+
 def clear_courses():
     flush_xmodule_store()
 
@@ -129,9 +162,18 @@ def log_into_studio(
 
 
 def create_a_course():
-    css_click('a.new-course-button')
-    fill_in_course_info()
-    css_click('input.new-course-save')
+    c = CourseFactory.create(org='MITx', course='999', display_name='Robot Super Course')
+
+    # Add the user to the instructor group of the course
+    # so they will have the permissions to see it in studio
+    g = GroupFactory.create(name='instructor_MITx/999/Robot_Super_Course')
+    u = get_user_by_email('robot+studio@edx.org')
+    u.groups.add(g)
+    u.save()
+    world.browser.reload()
+
+    course_link_css = 'span.class-name'
+    css_click(course_link_css)
     course_title_css = 'span.course-title'
     assert_true(world.browser.is_element_present_by_css(course_title_css, 5))
 

cms/djangoapps/contentstore/features/section.py

@@ -4,13 +4,6 @@ from common import *
 ############### ACTIONS ####################
 
 
-@step('I have opened a new course in Studio$')
-def i_have_opened_a_new_course(step):
-    clear_courses()
-    log_into_studio()
-    create_a_course()
-
-
 @step('I click the new section link$')
 def i_click_new_section_link(step):
     link_css = 'a.new-courseware-section-button'
@@ -46,6 +39,7 @@ def i_save_a_new_section_release_date(step):
     css_fill(time_css, '12:00am')
     css_click('a.save-button')
 
+
 ############ ASSERTIONS ###################
 
 

cms/djangoapps/contentstore/tests/test_course_settings.py

 import datetime
-import time
 import json
-import calendar
 import copy
 from util import converters
 from util.converters import jsdate_to_time
@@ -11,7 +9,6 @@ from django.test.client import Client
 from django.core.urlresolvers import reverse
 from django.utils.timezone import UTC
 
-import xmodule
 from xmodule.modulestore import Location
 from cms.djangoapps.models.settings.course_details import (CourseDetails,
                                                     CourseSettingsEncoder)
@@ -22,6 +19,10 @@ from django.test import TestCase
 from utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
+from cms.djangoapps.models.settings.course_metadata import CourseMetadata
+from xmodule.modulestore.xml_importer import import_from_xml
+from xmodule.modulestore.django import modulestore
+
 
 # YYYY-MM-DDThh:mm:ss.s+/-HH:MM
 class ConvertersTestCase(TestCase):
@@ -261,3 +262,64 @@ class CourseGradingTest(CourseTestCase):
         test_grader.graders[1]['drop_count'] = test_grader.graders[1].get('drop_count') + 1
         altered_grader = CourseGradingModel.update_grader_from_json(test_grader.course_location, test_grader.graders[1])
         self.assertDictEqual(test_grader.graders[1], altered_grader, "drop_count[1] + 2")
+
+class CourseMetadataEditingTest(CourseTestCase):
+    def setUp(self):
+        CourseTestCase.setUp(self)
+        # add in the full class too
+        import_from_xml(modulestore(), 'common/test/data/', ['full'])
+        self.fullcourse_location = Location(['i4x','edX','full','course','6.002_Spring_2012', None])
+
+
+    def test_fetch_initial_fields(self):
+        test_model = CourseMetadata.fetch(self.course_location)
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
+
+        test_model = CourseMetadata.fetch(self.fullcourse_location)
+        self.assertNotIn('graceperiod', test_model, 'blacklisted field leaked in')
+        self.assertIn('display_name', test_model, 'full missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Testing', "not expected value")
+        self.assertIn('rerandomize', test_model, 'Missing rerandomize metadata field')
+        self.assertIn('showanswer', test_model, 'showanswer field ')
+        self.assertIn('xqa_key', test_model, 'xqa_key field ')
+
+    def test_update_from_json(self):
+        test_model = CourseMetadata.update_from_json(self.course_location,
+            { "a" : 1,
+              "b_a_c_h" : { "c" : "test" },
+              "test_text" : "a text string"})
+        self.update_check(test_model)
+        # try fresh fetch to ensure persistence
+        test_model = CourseMetadata.fetch(self.course_location)
+        self.update_check(test_model)
+        # now change some of the existing metadata
+        test_model = CourseMetadata.update_from_json(self.course_location,
+            { "a" : 2,
+              "display_name" : "jolly roger"})
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'jolly roger', "not expected value")
+        self.assertIn('a', test_model, 'Missing revised a metadata field')
+        self.assertEqual(test_model['a'], 2, "a not expected value")
+
+    def update_check(self, test_model):
+        self.assertIn('display_name', test_model, 'Missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Robot Super Course', "not expected value")
+        self.assertIn('a', test_model, 'Missing new a metadata field')
+        self.assertEqual(test_model['a'], 1, "a not expected value")
+        self.assertIn('b_a_c_h', test_model, 'Missing b_a_c_h metadata field')
+        self.assertDictEqual(test_model['b_a_c_h'], { "c" : "test" }, "b_a_c_h not expected value")
+        self.assertIn('test_text', test_model, 'Missing test_text metadata field')
+        self.assertEqual(test_model['test_text'], "a text string", "test_text not expected value")
+
+
+    def test_delete_key(self):
+        test_model = CourseMetadata.delete_key(self.fullcourse_location, { 'deleteKeys' : ['doesnt_exist', 'showanswer', 'xqa_key']})
+        # ensure no harm
+        self.assertNotIn('graceperiod', test_model, 'blacklisted field leaked in')
+        self.assertIn('display_name', test_model, 'full missing editable metadata field')
+        self.assertEqual(test_model['display_name'], 'Testing', "not expected value")
+        self.assertIn('rerandomize', test_model, 'Missing rerandomize metadata field')
+        # check for deletion effectiveness
+        self.assertNotIn('showanswer', test_model, 'showanswer field still in')
+        self.assertNotIn('xqa_key', test_model, 'xqa_key field still in')
\ No newline at end of file

cms/djangoapps/contentstore/utils.py

@@ -75,12 +75,15 @@ def get_course_for_item(location):
     return courses[0]
 
 
-def get_lms_link_for_item(location, preview=False):
+def get_lms_link_for_item(location, preview=False, course_id=None):
+    if course_id is None:
+        course_id = get_course_id(location)
+
     if settings.LMS_BASE is not None:
         lms_link = "//{preview}{lms_base}/courses/{course_id}/jump_to/{location}".format(
             preview='preview.' if preview else '',
             lms_base=settings.LMS_BASE,
-            course_id=get_course_id(location),
+            course_id= course_id,
             location=Location(location)
         )
     else:

cms/djangoapps/contentstore/views.py

@@ -58,8 +58,8 @@ from cms.djangoapps.models.settings.course_details import CourseDetails,\
     CourseSettingsEncoder
 from cms.djangoapps.models.settings.course_grading import CourseGradingModel
 from cms.djangoapps.contentstore.utils import get_modulestore
-from lxml import etree
 from django.shortcuts import redirect
+from cms.djangoapps.models.settings.course_metadata import CourseMetadata
 
 # to install PIL on MacOSX: 'easy_install http://dist.repoze.org/PIL-1.1.6.tar.gz'
 
@@ -114,7 +114,7 @@ def index(request):
     """
     List all courses available to the logged in user
     """
-    courses = modulestore().get_items(['i4x', None, None, 'course', None])
+    courses = modulestore('direct').get_items(['i4x', None, None, 'course', None])
 
     # filter out courses that we don't have access too
     def course_filter(course):
@@ -132,7 +132,7 @@ def index(request):
                         course.location.org,
                         course.location.course,
                         course.location.name]),
-                    get_lms_link_for_item(course.location))
+                    get_lms_link_for_item(course.location, course_id=course.location.course_id))
                     for course in courses],
         'user': request.user,
         'disable_course_creation': settings.MITX_FEATURES.get('DISABLE_COURSE_CREATION', False) and not request.user.is_staff
@@ -365,7 +365,6 @@ def preview_component(request, location):
         'editor': wrap_xmodule(component.get_html, component, 'xmodule_edit.html')(),
     })
 
-
 @expect_json
 @login_required
 @ensure_csrf_cookie
@@ -682,7 +681,6 @@ def create_draft(request):
 
     return HttpResponse()
 
-
 @login_required
 @expect_json
 def publish_draft(request):
@@ -712,7 +710,6 @@ def unpublish_unit(request):
 
     return HttpResponse()
 
-
 @login_required
 @expect_json
 def clone_item(request):
@@ -901,7 +898,6 @@ def remove_user(request, location):
 def landing(request, org, course, coursename):
     return render_to_response('temp-course-landing.html', {})
 
-
 @login_required
 @ensure_csrf_cookie
 def static_pages(request, org, course, coursename):
@@ -1005,7 +1001,6 @@ def edit_tabs(request, org, course, coursename):
         'components': components
         })
 
-
 def not_found(request):
     return render_to_response('error.html', {'error': '404'})
 
@@ -1041,7 +1036,6 @@ def course_info(request, org, course, name, provided_id=None):
         'handouts_location': Location(['i4x', org, course, 'course_info', 'handouts']).url()
     })
 
-
 @expect_json
 @login_required
 @ensure_csrf_cookie
@@ -1112,7 +1106,6 @@ def module_info(request, module_location):
     else:
         return HttpResponseBadRequest()
 
-
 @login_required
 @ensure_csrf_cookie
 def get_course_settings(request, org, course, name):
@@ -1159,6 +1152,28 @@ def course_config_graders_page(request, org, course, name):
         'course_details': json.dumps(course_details, cls=CourseSettingsEncoder)
     })
 
+@login_required
+@ensure_csrf_cookie
+def course_config_advanced_page(request, org, course, name):
+    """
+    Send models and views as well as html for editing the advanced course settings to the client.
+
+    org, course, name: Attributes of the Location for the item to edit
+    """
+    location = ['i4x', org, course, 'course', name]
+
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    course_module = modulestore().get_item(location)
+
+    return render_to_response('settings_advanced.html', {
+        'context_course': course_module,
+        'course_location' : location,
+        'advanced_blacklist' : json.dumps(CourseMetadata.FILTERED_LIST),
+        'advanced_dict' : json.dumps(CourseMetadata.fetch(location)),
+    })
 
 @expect_json
 @login_required
@@ -1191,7 +1206,6 @@ def course_settings_updates(request, org, course, name, section):
         return HttpResponse(json.dumps(manager.update_from_json(request.POST), cls=CourseSettingsEncoder),
                             mimetype="application/json")
 
-
 @expect_json
 @login_required
 @ensure_csrf_cookie
@@ -1226,6 +1240,37 @@ def course_grader_updates(request, org, course, name, grader_index=None):
         return HttpResponse(json.dumps(CourseGradingModel.update_grader_from_json(Location(['i4x', org, course, 'course', name]), request.POST)),
                             mimetype="application/json")
 
+        
+## NB: expect_json failed on ["key", "key2"] and json payload
+@login_required
+@ensure_csrf_cookie
+def course_advanced_updates(request, org, course, name):
+    """
+    restful CRUD operations on metadata. The payload is a json rep of the metadata dicts. For delete, otoh,
+    the payload is either a key or a list of keys to delete.
+
+    org, course: Attributes of the Location for the item to edit
+    """
+    location = ['i4x', org, course, 'course', name]
+    
+    # check that logged in user has permissions to this item
+    if not has_access(request.user, location):
+        raise PermissionDenied()
+
+    # NB: we're setting Backbone.emulateHTTP to true on the client so everything comes as a post!!!
+    if request.method == 'POST' and 'HTTP_X_HTTP_METHOD_OVERRIDE' in request.META:
+        real_method = request.META['HTTP_X_HTTP_METHOD_OVERRIDE']
+    else:
+        real_method = request.method
+        
+    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")
+    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")
+
 
 @login_required
 @ensure_csrf_cookie
@@ -1286,7 +1331,6 @@ def asset_index(request, org, course, name):
 def edge(request):
     return render_to_response('university_profiles/edge.html', {})
 
-
 @login_required
 @expect_json
 def create_new_course(request):
@@ -1342,7 +1386,6 @@ def create_new_course(request):
 
     return HttpResponse(json.dumps({'id': new_course.location.url()}))
 
-
 def initialize_course_tabs(course):
     # set up the default tabs
     # I've added this because when we add static tabs, the LMS either expects a None for the tabs list or
@@ -1360,7 +1403,6 @@ def initialize_course_tabs(course):
 
     modulestore('direct').update_metadata(course.location.url(), course.own_metadata)
 
-
 @ensure_csrf_cookie
 @login_required
 def import_course(request, org, course, name):
@@ -1438,7 +1480,6 @@ def import_course(request, org, course, name):
                         course_module.location.name])
         })
 
-
 @ensure_csrf_cookie
 @login_required
 def generate_export_course(request, org, course, name):
@@ -1490,7 +1531,6 @@ def export_course(request, org, course, name):
         'successful_import_redirect_url': ''
     })
 
-
 def event(request):
     '''
     A noop to swallow the analytics call so that cms methods don't spook and poor developers looking at

cms/djangoapps/models/settings/course_metadata.py

+from xmodule.modulestore import Location
+from contentstore.utils import get_modulestore
+from xmodule.x_module import XModuleDescriptor
+
+
+class CourseMetadata(object):
+    '''
+    For CRUD operations on metadata fields which do not have specific editors on the other pages including any user generated ones.
+    The objects have no predefined attrs but instead are obj encodings of the editable metadata.
+    '''
+    # __new_advanced_key__ is used by client not server; so, could argue against it being here
+    FILTERED_LIST = XModuleDescriptor.system_metadata_fields + ['start', 'end', 'enrollment_start', 'enrollment_end', 'tabs', 'graceperiod', '__new_advanced_key__']
+    
+    @classmethod
+    def fetch(cls, course_location):
+        """
+        Fetch the key:value editable course details for the given course from persistence and return a CourseMetadata model.
+        """
+        if not isinstance(course_location, Location):
+            course_location = Location(course_location)
+            
+        course = {}
+        
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        
+        for k, v in descriptor.metadata.iteritems():
+            if k not in cls.FILTERED_LIST:
+                course[k] = v
+                
+        return course
+        
+    @classmethod
+    def update_from_json(cls, course_location, jsondict):
+        """
+        Decode the json into CourseMetadata and save any changed attrs to the db.
+        
+        Ensures none of the fields are in the blacklist.
+        """
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        
+        dirty = False
+
+        for k, v in jsondict.iteritems():
+            # should it be an error if one of the filtered list items is in the payload?
+            if k not in cls.FILTERED_LIST and (k not in descriptor.metadata or descriptor.metadata[k] != v):
+                dirty = True
+                descriptor.metadata[k] = v
+            
+        if dirty:
+            get_modulestore(course_location).update_metadata(course_location, descriptor.metadata)
+            
+        # Could just generate and return a course obj w/o doing any db reads, but I put the reads in as a means to confirm
+        # it persisted correctly
+        return cls.fetch(course_location)
+    
+    @classmethod
+    def delete_key(cls, course_location, payload):
+        '''
+        Remove the given metadata key(s) from the course. payload can be a single key or [key..]
+        '''
+        descriptor = get_modulestore(course_location).get_item(course_location)
+        
+        for key in payload['deleteKeys']:
+            if key in descriptor.metadata:
+                del descriptor.metadata[key]
+    
+        get_modulestore(course_location).update_metadata(course_location, descriptor.metadata)
+        
+        return cls.fetch(course_location)
+        
\ No newline at end of file

cms/static/client_templates/advanced_entry.html

+<li class="field-group course-advanced-policy-list-item">
+	<div class="field text key" id="<%= (_.isEmpty(key) ? '__new_advanced_key__' : key) %>">
+		<label for="<%= keyUniqueId %>">Policy Key:</label>
+		<input type="text" class="short policy-key" id="<%= keyUniqueId %>" value="<%= key %>" />
+		<span class="tip tip-stacked">Keys are case	sensitive and cannot contain spaces or start with a number</span>
+  </div>
+  
+  <div class="field text value">
+    <label for="<%= valueUniqueId %>">Policy Value:</label>
+    <textarea class="json text" id="<%= valueUniqueId %>"><%= value %></textarea>
+  </div>
+	
+	<div class="actions">
+		<a href="#" class="button delete-button standard remove-item remove-grading-data"><span class="delete-icon"></span>Delete</a>
+	</div>
+</li>
\ No newline at end of file

cms/static/js/models/settings/advanced.js

+if (!CMS.Models['Settings']) CMS.Models.Settings = {};
+
+CMS.Models.Settings.Advanced = Backbone.Model.extend({
+    // the key for a newly added policy-- before the user has entered a key value
+    new_key : "__new_advanced_key__",
+
+    defaults: {
+        // the properties are whatever the user types in (in addition to whatever comes originally from the server)
+    },
+    // which keys to send as the deleted keys on next save
+    deleteKeys : [],
+    blacklistKeys : [], // an array which the controller should populate directly for now [static not instance based]
+
+    validate: function (attrs) {
+        var errors = {};
+        for (var key in attrs) {
+            if (key === this.new_key || _.isEmpty(key)) {
+                errors[key] = "A key must be entered.";
+            }
+            else if (_.contains(this.blacklistKeys, key)) {
+                errors[key] = key + " is a reserved keyword or can be edited on another screen";
+            }
+        }
+        if (!_.isEmpty(errors)) return errors;
+    },
+    
+    save : function (attrs, options) {
+        // wraps the save call w/ the deletion of the removed keys after we know the saved ones worked
+        options = options ? _.clone(options) : {};
+        // add saveSuccess to the success
+        var success = options.success;
+        options.success = function(model, resp, options) {
+          model.afterSave(model);
+          if (success) success(model, resp, options);
+        };
+        Backbone.Model.prototype.save.call(this, attrs, options);
+    },
+    
+    afterSave : function(self) {
+        // remove deleted attrs
+        if (!_.isEmpty(self.deleteKeys)) {
+            // remove the to be deleted keys from the returned model
+            _.each(self.deleteKeys, function(key) { self.unset(key); });
+            // not able to do via backbone since we're not destroying the model
+            $.ajax({
+                url : self.url,
+                // json to and fro
+                contentType : "application/json",
+                dataType : "json",
+                // delete
+                type : 'DELETE',
+                // data
+                data : JSON.stringify({ deleteKeys : self.deleteKeys})
+            })
+            .fail(function(hdr, status, error) { CMS.ServerError(self, "Deleting keys:" + status); })
+            .done(function(data, status, error) {
+                // clear deleteKeys on success
+                self.deleteKeys = [];
+            });
+        }
+    }
+});

cms/static/js/template_loader.js

@@ -5,7 +5,7 @@
 	if (typeof window.templateLoader == 'function') return;
 	
     var templateLoader = {
-      templateVersion: "0.0.12",
+      templateVersion: "0.0.15",
       templates: {},
       loadRemoteTemplate: function(templateName, filename, callback) {
         if (!this.templates[templateName]) {

cms/static/js/views/settings/advanced_view.js

+if (!CMS.Views['Settings']) CMS.Views.Settings = {};
+
+CMS.Views.Settings.Advanced = CMS.Views.ValidatingView.extend({
+    error_saving : "error_saving",
+    successful_changes: "successful_changes",
+
+    // Model class is CMS.Models.Settings.Advanced
+    events : {
+        'click .delete-button' : "deleteEntry",
+        'click .new-button' : "addEntry",
+        // update model on changes
+        'change .policy-key' : "updateKey",
+        // keypress to catch alpha keys and backspace/delete on some browsers
+        'keypress .policy-key' : "showSaveCancelButtons",
+        // keyup to catch backspace/delete reliably
+        'keyup .policy-key' : "showSaveCancelButtons",
+        'focus :input' : "focusInput",
+        'blur :input' : "blurInput"
+        // TODO enable/disable save based on validation (currently enabled whenever there are changes)
+    },
+    initialize : function() {
+        var self = this;
+        // instantiates an editor template for each update in the collection
+        window.templateLoader.loadRemoteTemplate("advanced_entry",
+            "/static/client_templates/advanced_entry.html",
+            function (raw_template) {
+                self.template = _.template(raw_template);
+                self.render();
+            }
+        );
+        // because these are outside of this.$el, they can't be in the event hash
+        $('.save-button').on('click', this, this.saveView);
+        $('.cancel-button').on('click', this, this.revertView);
+        this.model.on('error', this.handleValidationError, this);
+    },
+    render: function() {
+        // catch potential outside call before template loaded
+        if (!this.template) return this;
+
+        var listEle$ = this.$el.find('.course-advanced-policy-list');
+        listEle$.empty();
+        
+        // b/c we've deleted all old fields, clear the map and repopulate
+        this.fieldToSelectorMap = {};
+        this.selectorToField = {};
+
+        // iterate through model and produce key : value editors for each property in model.get
+        var self = this;
+        _.each(_.sortBy(_.keys(this.model.attributes), _.identity),
+            function(key) {
+                listEle$.append(self.renderTemplate(key, self.model.get(key)));
+            });
+
+        var policyValues = listEle$.find('.json');
+        _.each(policyValues, this.attachJSONEditor, this);
+        this.showMessage();
+        return this;
+    },
+    attachJSONEditor : function (textarea) {
+        // Since we are allowing duplicate keys at the moment, it is possible that we will try to attach
+        // JSON Editor to a value that already has one. Therefore only attach if no CodeMirror peer exists.
+        if ( $(textarea).siblings().hasClass('CodeMirror')) {
+            return;
+        }
+
+        var self = this;
+        var oldValue = $(textarea).val();
+        CodeMirror.fromTextArea(textarea, {
+            mode: "application/json", lineNumbers: false, lineWrapping: false,
+            onChange: function(instance, changeobj) {
+                // this event's being called even when there's no change :-(
+                if (instance.getValue() !== oldValue) self.showSaveCancelButtons();
+            },
+            onFocus : function(mirror) {
+              $(textarea).parent().children('label').addClass("is-focused");
+            },
+            onBlur: function (mirror) {
+                $(textarea).parent().children('label').removeClass("is-focused");
+                var key = $(mirror.getWrapperElement()).closest('.field-group').children('.key').attr('id');
+                var stringValue = $.trim(mirror.getValue());
+                // update CodeMirror to show the trimmed value.
+                mirror.setValue(stringValue);
+                var JSONValue = undefined;
+                try {
+                    JSONValue = JSON.parse(stringValue);
+                } catch (e) {
+                    // If it didn't parse, try converting non-arrays/non-objects to a String.
+                    // But don't convert single-quote strings, which are most likely errors.
+                    var firstNonWhite = stringValue.substring(0, 1);
+                    if (firstNonWhite !== "{" && firstNonWhite !== "[" && firstNonWhite !== "'") {
+                        try {
+                            stringValue = '"'+stringValue +'"';
+                            JSONValue = JSON.parse(stringValue);
+                            mirror.setValue(stringValue);
+                        } catch(quotedE) {
+                            // TODO: validation error
+                            console.log("Error with JSON, even after converting to String.");
+                            console.log(quotedE);
+                            JSONValue = undefined;
+                        }
+                    }
+                    else {
+                        // TODO: validation error
+                        console.log("Error with JSON, but will not convert to String.");
+                        console.log(e);
+                    }
+                }
+                if (JSONValue !== undefined) {
+                    self.clearValidationErrors();
+                    self.model.set(key, JSONValue, {validate: true});
+                }
+            }
+        });
+    },
+
+    showMessage: function (type) {
+        this.$el.find(".message-status").removeClass("is-shown");
+        if (type) {
+            if (type === this.error_saving) {
+                this.$el.find(".message-status.error").addClass("is-shown");
+            }
+            else if (type === this.successful_changes) {
+                this.$el.find(".message-status.confirm").addClass("is-shown");
+                this.hideSaveCancelButtons();
+            }
+        }
+        else {
+            // This is the case of the page first rendering, or when Cancel is pressed.
+            this.hideSaveCancelButtons();
+            this.toggleNewButton(true);
+        }
+    },
+
+    showSaveCancelButtons: function(event) {
+        if (!this.buttonsVisible) {
+            if (event && (event.type === 'keypress' || event.type === 'keyup')) {
+                // check whether it's really an altering event: note, String.fromCharCode(keyCode) will 
+                // give positive values for control/command/option-letter combos; so, don't use it
+                if (!((event.charCode && String.fromCharCode(event.charCode) !== "") ||
+                        // 8 = backspace, 46 = delete
+                        event.keyCode === 8 || event.keyCode === 46)) return;
+            }
+            this.$el.find(".message-status").removeClass("is-shown");
+            $('.wrapper-notification').addClass('is-shown');
+            this.buttonsVisible = true;
+        }
+    },
+
+    hideSaveCancelButtons: function() {
+        $('.wrapper-notification').removeClass('is-shown');
+        this.buttonsVisible = false;
+    },
+
+    toggleNewButton: function (enable) {
+        var newButton = this.$el.find(".new-button");
+        if (enable) {
+            newButton.removeClass('disabled');
+        }
+        else {
+            newButton.addClass('disabled');
+        }
+    },
+
+    deleteEntry : function(event) {
+        event.preventDefault();
+        // find out which entry
+        var li$ = $(event.currentTarget).closest('li');
+        // Not data b/c the validation view uses it for a selector
+        var key = $('.key', li$).attr('id');
+
+        delete this.selectorToField[this.fieldToSelectorMap[key]];
+        delete this.fieldToSelectorMap[key];
+        if (key !== this.model.new_key) {
+            this.model.deleteKeys.push(key);
+            this.model.unset(key);
+        }
+        li$.remove();
+        this.showSaveCancelButtons();
+    },
+    saveView : function(event) {
+        // TODO one last verification scan:
+        //    call validateKey on each to ensure proper format
+        //    check for dupes
+        var self = event.data;
+        self.model.save({},
+            {
+            success : function() {
+                self.render();
+                self.showMessage(self.successful_changes);
+            },
+            error : CMS.ServerError
+        });
+    },
+    revertView : function(event) {
+        var self = event.data;
+        self.model.deleteKeys = [];
+        self.model.clear({silent : true});
+        self.model.fetch({
+            success : function() { self.render(); },
+            error : CMS.ServerError
+        });
+    },
+    addEntry : function() {
+        var listEle$ = this.$el.find('.course-advanced-policy-list');
+        var newEle = this.renderTemplate("", "");
+        listEle$.append(newEle);
+        // need to re-find b/c replaceWith seems to copy rather than use the specific ele instance
+        var policyValueDivs = this.$el.find('#' + this.model.new_key).closest('li').find('.json');
+        // only 1 but hey, let's take advantage of the context mechanism
+        _.each(policyValueDivs, this.attachJSONEditor, this);
+        this.toggleNewButton(false);
+    },
+    updateKey : function(event) {
+        var parentElement = $(event.currentTarget).closest('.key');
+        // old key: either the key as in the model or new_key.
+        // That is, it doesn't change as the val changes until val is accepted.
+        var oldKey = parentElement.attr('id');
+        // TODO: validation of keys with spaces. For now at least trim strings to remove initial and
+        // trailing whitespace
+        var newKey = $.trim($(event.currentTarget).val());
+        if (oldKey !== newKey) {
+            // TODO: is it OK to erase other validation messages?
+            this.clearValidationErrors();
+
+            if (!this.validateKey(oldKey, newKey)) return;
+
+            if (this.model.has(newKey)) {
+                var error = {};
+                error[oldKey] = 'You have already defined "' + newKey + '" in the manual policy definitions.';
+                error[newKey] = "You tried to enter a duplicate of this key.";
+                this.model.trigger("error", this.model, error);
+                return false;
+            }
+
+            // explicitly call validate to determine whether to proceed (relying on triggered error means putting continuation in the success
+            // method which is uglier I think?)
+            var newEntryModel = {};
+            // set the new key's value to the old one's
+            newEntryModel[newKey] = (oldKey === this.model.new_key ? '' : this.model.get(oldKey));
+
+            var validation = this.model.validate(newEntryModel);
+            if (validation) {
+                if (_.has(validation, newKey)) {
+                    // swap to the key which the map knows about
+                    validation[oldKey] = validation[newKey];
+                }
+                this.model.trigger("error", this.model, validation);
+                // abandon update
+                return;
+            }
+
+            // Now safe to actually do the update
+            this.model.set(newEntryModel);
+
+            // update maps
+            var selector = this.fieldToSelectorMap[oldKey];
+            this.selectorToField[selector] = newKey;
+            this.fieldToSelectorMap[newKey] = selector;
+            delete this.fieldToSelectorMap[oldKey];
+
+            if (oldKey !== this.model.new_key) {
+                // mark the old key for deletion and delete from field maps
+                this.model.deleteKeys.push(oldKey);
+                this.model.unset(oldKey) ;
+            }
+            else {
+                // id for the new entry will now be the key value. Enable new entry button.
+                this.toggleNewButton(true);
+            }
+            
+            // check for newkey being the name of one which was previously deleted in this session
+            var wasDeleting = this.model.deleteKeys.indexOf(newKey);
+            if (wasDeleting >= 0) {
+                this.model.deleteKeys.splice(wasDeleting, 1);
+            }
+
+            // Update the ID to the new value.
+            parentElement.attr('id', newKey);
+            
+        }
+    },
+    validateKey : function(oldKey, newKey) {
+        // model validation can't handle malformed keys nor notice if 2 fields have same key; so, need to add that chk here
+        // TODO ensure there's no spaces or illegal chars (note some checking for spaces currently done in model's
+        // validate method.
+        return true;
+    },
+
+    renderTemplate: function (key, value) {
+        var newKeyId = _.uniqueId('policy_key_'),
+        newEle = this.template({ key : key, value : JSON.stringify(value, null, 4),
+            keyUniqueId: newKeyId, valueUniqueId: _.uniqueId('policy_value_')});
+        
+        this.fieldToSelectorMap[(_.isEmpty(key) ? this.model.new_key : key)] = newKeyId;
+        this.selectorToField[newKeyId] = (_.isEmpty(key) ? this.model.new_key : key);
+        return newEle;
+    },
+    
+    focusInput : function(event) {
+        $(event.target).prev().addClass("is-focused");
+    },
+    blurInput : function(event) {
+        $(event.target).prev().removeClass("is-focused");
+    }
+});
\ No newline at end of file

cms/static/js/views/settings/main_settings_view.js

-if (!CMS.Views['Settings']) CMS.Views.Settings = {}; // ensure the pseudo pkg exists
+if (!CMS.Views['Settings']) CMS.Views.Settings = {};
 
 CMS.Views.Settings.Details = CMS.Views.ValidatingView.extend({
     // Model class is CMS.Models.Settings.CourseDetails
     events : {
-        "blur input" : "updateModel",
-        "blur textarea" : "updateModel",
+        "change input" : "updateModel",
+        "change textarea" : "updateModel",
         'click .remove-course-syllabus' : "removeSyllabus",
         'click .new-course-syllabus' : 'assetSyllabus',
         'click .remove-course-introduction-video' : "removeVideo",

cms/static/js/views/settings/settings_grading_view.js

@@ -3,9 +3,9 @@ if (!CMS.Views['Settings']) CMS.Views.Settings = {}; // ensure the pseudo pkg ex
 CMS.Views.Settings.Grading = CMS.Views.ValidatingView.extend({
     // Model class is CMS.Models.Settings.CourseGradingPolicy
     events : {
-        "blur input" : "updateModel",
-        "blur textarea" : "updateModel",
-        "blur span[contenteditable=true]" : "updateDesignation",
+        "change input" : "updateModel",
+        "change textarea" : "updateModel",
+        "change span[contenteditable=true]" : "updateDesignation",
         "click .settings-extra header" : "showSettingsExtras",
         "click .new-grade-button" : "addNewGrade",
         "click .remove-button" : "removeGrade",
@@ -310,8 +310,8 @@ CMS.Views.Settings.Grading = CMS.Views.ValidatingView.extend({
 CMS.Views.Settings.GraderView = CMS.Views.ValidatingView.extend({
     // Model class is CMS.Models.Settings.CourseGrader
     events : {
-        "blur input" : "updateModel",
-        "blur textarea" : "updateModel",
+        "change input" : "updateModel",
+        "change textarea" : "updateModel",
         "click .remove-grading-data" : "deleteModel",
         // would love to move to a general superclass, but event hashes don't inherit in backbone :-(
         'focus :input' : "inputFocus",

cms/static/js/views/validating_view.js

@@ -10,8 +10,8 @@ CMS.Views.ValidatingView = Backbone.View.extend({
     errorTemplate : _.template('<span class="message-error"><%= message %></span>'),
 
     events : {
-        "blur input" : "clearValidationErrors",
-        "blur textarea" : "clearValidationErrors"
+        "change input" : "clearValidationErrors",
+        "change textarea" : "clearValidationErrors"
     },
     fieldToSelectorMap : {
         // Your subclass must populate this w/ all of the model keys and dom selectors 

cms/static/sass/_alerts.scss

+// notifications
+.wrapper-notification {
+	@include clearfix();
+	@include box-sizing(border-box);
+	@include transition (bottom 2.0s ease-in-out 5s);
+	@include box-shadow(0 -1px 2px rgba(0,0,0,0.1));
+	position: fixed;
+	bottom: -100px;
+	z-index: 1000;
+	width: 100%;
+	overflow: hidden;
+	opacity: 0;
+	border-top: 1px solid $darkGrey;
+	padding: 20px 40px;
+
+	&.is-shown {
+		bottom: 0;
+		opacity: 1.0;
+	}
+
+	&.wrapper-notification-warning {
+		border-color: shade($yellow, 25%);
+		background: tint($yellow, 25%);
+	}
+
+	&.wrapper-notification-error {
+		border-color: shade($red, 50%);
+		background: tint($red, 20%);
+		color: $white;
+	}
+
+	&.wrapper-notification-confirm {
+		border-color: shade($green, 30%);
+		background: tint($green, 40%);
+		color: shade($green, 30%);
+	}
+}
+
+.notification {
+	@include box-sizing(border-box);
+	margin: 0 auto;
+	width: flex-grid(12);
+	max-width: $fg-max-width;
+	min-width: $fg-min-width;
+
+	.copy {
+		float: left;
+		width: flex-grid(9, 12);
+		margin-right: flex-gutter();
+		margin-top: 5px;
+		font-size: 14px;
+
+		.icon {
+			display: inline-block;
+			vertical-align: top;
+			margin-right: 5px;
+			font-size: 20px;
+		}
+
+		p {
+			width: flex-grid(8, 9);
+			display: inline-block;
+			vertical-align: top;
+		}
+	}
+
+	.actions {
+		float: right;
+		width: flex-grid(3, 12);
+		margin-top: ($baseline/2);
+		text-align: right;
+
+		li {
+			display: inline-block;
+			vertical-align: middle;
+			margin-right: 10px;
+
+			&:last-child {
+				margin-right: 0;
+			}
+		}
+
+		.save-button {
+			@include blue-button;
+		}
+
+		.cancel-button {
+		  @include white-button;
+		}
+	}
+
+	strong {
+		font-weight: 700;
+	}
+}
+
+// adopted alerts
 .alert {
 	padding: 15px 20px;
 	margin-bottom: 30px;

cms/static/sass/_settings.scss

@@ -14,6 +14,44 @@ body.course.settings {
     padding: $baseline ($baseline*1.5);
   }
 
+  // messages - should be synced up with global messages in the future
+  .message {
+    display: block;
+    font-size: 14px;
+  }
+
+  .message-status {
+    display: none;
+    @include border-top-radius(2px);
+    @include box-sizing(border-box);
+    border-bottom: 2px solid $yellow;
+    margin: 0 0 20px 0;
+    padding: 10px 20px;
+    font-weight: 500;
+    background: $paleYellow;
+
+    .text {
+      display: inline-block;
+    }
+
+    &.error {
+      border-color: shade($red, 50%);
+      background: tint($red, 20%);
+      color: $white;
+    }
+
+    &.confirm {
+      border-color: shade($green, 50%);
+      background: tint($green, 20%);
+      color: $white;
+    }
+
+    &.is-shown {
+      display: block;
+    }
+  }
+
+  // in form - elements
   .group-settings {
     margin: 0 0 ($baseline*2) 0;
 
@@ -45,7 +83,12 @@ body.course.settings {
 
     }
 
-    // UI hints/tips/messages
+    // in form  -UI hints/tips/messages
+    .instructions {
+      @include font-size(14);
+      margin: 0 0 $baseline 0;
+    }
+
     .tip {
       @include transition(color, 0.15s, ease-in-out);
       @include font-size(13);
@@ -576,6 +619,119 @@ body.course.settings {
         }
       }
     }
+
+    // specific fields - advanced settings
+    &.advanced-policies {
+
+      .field-group {
+        margin-bottom: ($baseline*1.5);
+
+        &:last-child {
+          border: none;
+          padding-bottom: 0;
+        }
+      }
+
+      .course-advanced-policy-list-item {
+        @include clearfix();
+        position: relative;
+
+        .field {
+
+          input {
+            width: 100%;
+          }
+
+          .tip {
+            @include transition (opacity 0.5s ease-in-out 0s);
+            opacity: 0;
+            position: absolute;
+            bottom: ($baseline*1.25);
+          }
+
+          input:focus {
+
+            & + .tip {
+              opacity: 1.0;
+            }
+          }
+
+          input.error {
+
+            & + .tip {
+              opacity: 0;
+            }
+          }
+        }
+
+        .key, .value {
+          float: left;
+          margin: 0 0 ($baseline/2) 0;
+        }
+
+       .key {
+         width: flex-grid(3, 9);
+         margin-right: flex-gutter();
+        }
+
+        .value {
+          width: flex-grid(6, 9);
+        }
+
+        .actions {
+          float: left;
+          width: flex-grid(9, 9);
+
+          .delete-button {
+            margin: 0;
+          }
+        }
+      }
+
+      .message-error {
+        position: absolute;
+        bottom: ($baseline*0.75);
+      }
+
+      // specific to code mirror instance in JSON policy editing, need to sync up with other similar code mirror UIs
+      .CodeMirror {
+        @include font-size(16);
+        @include box-sizing(border-box);
+        @include box-shadow(0 1px 2px rgba(0, 0, 0, .1) inset);
+        @include linear-gradient($lightGrey, tint($lightGrey, 90%));
+        padding: 5px 8px;
+        border: 1px solid $mediumGrey;
+        border-radius: 2px;
+        background-color: $lightGrey;
+        font-family: 'Open Sans', sans-serif;
+        color: $baseFontColor;
+        outline: 0;
+
+        &.CodeMirror-focused {
+          @include linear-gradient($paleYellow, tint($paleYellow, 90%));
+          outline: 0;
+        }
+
+        .CodeMirror-scroll {
+          overflow: hidden;
+          height: auto;
+          min-height: ($baseline*1.5);
+          max-height: ($baseline*10);
+        }
+
+        // editor color changes just for JSON
+        .CodeMirror-lines {
+
+          .cm-string {
+            color: #cb9c40;
+          }
+
+          pre {
+            line-height: 2.0rem;
+          }
+        }
+      }
+    }
   }
 
   .content-supplementary {

cms/templates/settings.html

@@ -23,7 +23,8 @@ from contentstore import utils
   
   <script type="text/javascript">
     $(document).ready(function(){
-    
+      
+      // hilighting labels when fields are focused in
       $("form :input").focus(function() {
         $("label[for='" + this.id + "']").addClass("is-focused");
       }).blur(function() {
@@ -205,7 +206,7 @@ from contentstore import utils
 
     <aside class="content-supplementary" role="complimentary">
      <div class="bit">
-        <h3 class="title-3">How will these settings be used</h3>
+        <h3 class="title-3">How will these settings be used?</h3>
         <p>Your course's schedule settings determine when students can enroll in and begin a course as well as when the course.</p>
 
         <p>Additionally, details provided on this page are also used in edX's catalog of courses, which new and returning students use to choose new courses to study.</p>
@@ -220,6 +221,7 @@ from contentstore import utils
           <ul>
             <li class="nav-item"><a href="${reverse('contentstore.views.course_config_graders_page', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Grading</a></li>
             <li class="nav-item"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">Course Team</a></li>
+            <li class="nav-item"><a href="${reverse('course_advanced_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Advanced Settings</a></li>
           </ul>
         </nav>
       % endif

cms/templates/settings_advanced.html

+<%inherit file="base.html" />
+<%! from django.core.urlresolvers import reverse %>
+<%block name="title">Advanced Settings</%block>
+<%block name="bodyclass">is-signedin course advanced settings</%block>
+
+<%namespace name='static' file='static_content.html'/>
+<%!
+from contentstore import utils
+%>
+
+<%block name="jsextra">
+
+<script type="text/javascript" src="${static.url('js/template_loader.js')}"></script>
+<script type="text/javascript" src="${static.url('js/views/server_error.js')}"></script>
+<script type="text/javascript" src="${static.url('js/views/validating_view.js')}"></script>
+<script type="text/javascript" src="${static.url('js/models/settings/advanced.js')}"></script>
+<script type="text/javascript" src="${static.url('js/views/settings/advanced_view.js')}"></script>
+
+<script type="text/javascript">
+$(document).ready(function () {
+
+    // proactively populate advanced b/c it has the filtered list and doesn't really follow the model pattern
+    var advancedModel = new CMS.Models.Settings.Advanced(${advanced_dict | n}, {parse: true});
+    advancedModel.blacklistKeys = ${advanced_blacklist | n};
+    advancedModel.url = "${reverse('course_advanced_settings_updates', kwargs=dict(org=context_course.location.org, course=context_course.location.course, name=context_course.location.name))}";
+
+    var editor = new CMS.Views.Settings.Advanced({
+      el: $('.settings-advanced'),
+      model: advancedModel
+      });
+
+editor.render();
+
+});
+
+</script>
+</%block>
+
+<%block name="content">
+<div class="wrapper-content wrapper">
+  <section class="content">
+    <header class="page">
+      <span class="title-sub">Settings</span>
+      <h1 class="title-1">Advanced Settings</h1>
+    </header>
+
+    <article class="content-primary" role="main">
+      <form id="settings_advanced" class="settings-advanced" method="post" action="">
+
+        <div class="message message-status confirm">
+          Your policy changes have been saved.
+        </div>
+
+        <div class="message message-status error">
+          There was an error saving your information. Please see below.
+        </div>
+
+        <section class="group-settings advanced-policies">
+          <header>
+            <h2 class="title-2">Manual Policy Definition</h2>
+            <span class="tip">Manually Edit Course Policy Values (JSON Key / Value pairs)</span>
+          </header>
+
+          <p class="instructions"><strong>Warning</strong>: Add only manual policy data that you are familiar
+          with.</p>
+
+          <ul class="list-input course-advanced-policy-list enum">
+              
+          </ul>
+
+          <div class="actions">
+            <a href="#" class="button new-button new-advanced-policy-item add-policy-data">
+              <span class="plus-icon white"></span>New Manual Policy
+            </a>            
+          </div>
+        </section>
+      </form>
+    </article>
+
+    <aside class="content-supplementary" role="complimentary">
+      <div class="bit">
+        <h3 class="title-3">How will these settings be used?</h3>
+        <p>Manual policies are JSON-based key and value pairs that allow you add additional settings which edX Studio will use when generating your course.</p>
+
+        <p>Any policies you define here will override any other information you've defined elsewhere in Studio. With this in mind, please be very careful and do not add policies that you are unfamiliar with (both their purpose and their syntax).</p>
+      </div>
+
+      <div class="bit">
+      % if context_course:
+      <% ctx_loc = context_course.location %>
+      <%! from django.core.urlresolvers import reverse %>
+        <h3 class="title-3">Other Course Settings</h3>
+        <nav class="nav-related">
+          <ul>
+            <li class="nav-item"><a href="${reverse('contentstore.views.get_course_settings', kwargs=dict(org=ctx_loc.org, course=ctx_loc.course, name=ctx_loc.name))}">Details &amp; Schedule</a></li>
+            <li class="nav-item"><a href="${reverse('contentstore.views.course_config_graders_page', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Grading</a></li>
+            <li class="nav-item"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">Course Team</a></li>
+          </ul>
+        </nav>
+      % endif
+      </div>
+    </aside>
+  </section>
+</div>
+
+<!-- notification: change has been made and a save is needed -->
+<div class="wrapper wrapper-notification wrapper-notification-warning">
+  <div class="notification warning">
+    <div class="copy">
+      <i class="ss-icon ss-symbolicons-block icon icon-warning">&#x26A0;</i>
+
+      <p><strong>Note: </strong>Your changes will not take effect until you <strong>save your
+      progress</strong>. Take care with key and value formatting, as validation is <strong>not implemented</strong>.</p>
+    </div>
+
+    <div class="actions">
+      <ul>
+        <li><a href="#" class="save-button">Save</a></li>
+        <li><a href="#" class="cancel-button">Cancel</a></li>
+      </ul>
+    </div>
+  </div>
+</div>
+</%block>
\ No newline at end of file

cms/templates/settings_graders.html

@@ -126,7 +126,7 @@ from contentstore import utils
 
     <aside class="content-supplementary" role="complimentary">
       <div class="bit">
-        <h3 class="title-3">How will these settings be used</h3>
+        <h3 class="title-3">How will these settings be used?</h3>
         <p>Your grading settings will be used to calculate students grades and performance.</p>
 
         <p>Overall grade range will be used in students' final grades, which are calculated by the weighting you determine for each custom assignment type.</p>
@@ -141,6 +141,7 @@ from contentstore import utils
           <ul>
             <li class="nav-item"><a href="${reverse('contentstore.views.get_course_settings', kwargs=dict(org=ctx_loc.org, course=ctx_loc.course, name=ctx_loc.name))}">Details &amp; Schedule</a></li>
             <li class="nav-item"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">Course Team</a></li>
+            <li class="nav-item"><a href="${reverse('course_advanced_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Advanced Settings</a></li>
           </ul>
         </nav>
       % endif

cms/templates/widgets/header.html

@@ -44,7 +44,7 @@
                   <li class="nav-item nav-course-settings-schedule"><a href="${reverse('contentstore.views.get_course_settings', kwargs=dict(org=ctx_loc.org, course=ctx_loc.course, name=ctx_loc.name))}">Schedule &amp; Details</a></li>
                   <li class="nav-item nav-course-settings-grading"><a href="${reverse('contentstore.views.course_config_graders_page', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Grading</a></li>
                   <li class="nav-item nav-course-settings-team"><a href="${reverse('manage_users', kwargs=dict(location=ctx_loc))}">Course Team</a></li>
-                  <!-- <li class="nav-item nav-course-settings-advanced"><a href="${reverse('course_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Advanced Settings</a></li> -->
+                  <li class="nav-item nav-course-settings-advanced"><a href="${reverse('course_advanced_settings', kwargs={'org' : ctx_loc.org, 'course' : ctx_loc.course, 'name': ctx_loc.name})}">Advanced Settings</a></li>
                 </ul>
               </div>
             </div>            

cms/urls.py

@@ -47,6 +47,10 @@ urlpatterns = ('',
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-grading/(?P<name>[^/]+)$', 'contentstore.views.course_config_graders_page', name='course_settings'),
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-details/(?P<name>[^/]+)/section/(?P<section>[^/]+).*$', 'contentstore.views.course_settings_updates', name='course_settings'),
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-grading/(?P<name>[^/]+)/(?P<grader_index>.*)$', 'contentstore.views.course_grader_updates', name='course_settings'),
+    # This is the URL to initially render the course advanced settings.
+    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-advanced/(?P<name>[^/]+)$', 'contentstore.views.course_config_advanced_page', name='course_advanced_settings'),
+    # This is the URL used by BackBone for updating and re-fetching the model.
+    url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/settings-advanced/(?P<name>[^/]+)/update.*$', 'contentstore.views.course_advanced_updates', name='course_advanced_settings_updates'),
 
     url(r'^(?P<org>[^/]+)/(?P<course>[^/]+)/(?P<category>[^/]+)/(?P<name>[^/]+)/gradeas.*$', 'contentstore.views.assignment_type_update', name='assignment_type_update'),
 

common/djangoapps/terrain/factories.py

 from student.models import User, UserProfile, Registration
+from django.contrib.auth.models import Group
 from datetime import datetime
 from factory import Factory
 from xmodule.modulestore import Location
@@ -8,6 +9,12 @@ from uuid import uuid4
 from xmodule.timeparse import stringify_time
 
 
+class GroupFactory(Factory):
+    FACTORY_FOR = Group
+
+    name = 'staff_MITx/999/Robot_Super_Course'
+    
+
 class UserProfileFactory(Factory):
     FACTORY_FOR = UserProfile
 

common/djangoapps/terrain/steps.py

 from lettuce import world, step
 from factories import *
-from django.core.management import call_command
 from lettuce.django import django_url
-from django.conf import settings
 from django.contrib.auth.models import User
 from student.models import CourseEnrollment
 from urllib import quote_plus
@@ -21,6 +19,11 @@ def wait(step, seconds):
     time.sleep(float(seconds))
 
 
+@step('I reload the page$')
+def reload_the_page(step):
+    world.browser.reload()
+
+
 @step('I (?:visit|access|open) the homepage$')
 def i_visit_the_homepage(step):
     world.browser.visit(django_url('/'))
@@ -105,6 +108,11 @@ def i_am_an_edx_user(step):
 
 #### helper functions
 
+@world.absorb
+def scroll_to_bottom():
+    # Maximize the browser
+    world.browser.execute_script("window.scrollTo(0, screen.height);")
+
 
 @world.absorb
 def create_user(uname):

common/lib/capa/capa/tests/response_xml_factory.py

+from lxml import etree
+from abc import ABCMeta, abstractmethod
+
+class ResponseXMLFactory(object):
+    """ Abstract base class for capa response XML factories.
+    Subclasses override create_response_element and
+    create_input_element to produce XML of particular response types"""
+
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def create_response_element(self, **kwargs):
+        """ Subclasses override to return an etree element
+        representing the capa response XML
+        (e.g. <numericalresponse>).
+        
+        The tree should NOT contain any input elements
+        (such as <textline />) as these will be added later."""
+        return None
+
+    @abstractmethod
+    def create_input_element(self, **kwargs):
+        """ Subclasses override this to return an etree element
+        representing the capa input XML (such as <textline />)"""
+        return None
+
+    def build_xml(self, **kwargs):
+        """ Construct an XML string for a capa response 
+        based on **kwargs.
+
+        **kwargs is a dictionary that will be passed
+        to create_response_element() and create_input_element().
+        See the subclasses below for other keyword arguments
+        you can specify.
+
+        For all response types, **kwargs can contain:
+
+        *question_text*: The text of the question to display,
+            wrapped in <p> tags.
+        
+        *explanation_text*: The detailed explanation that will
+            be shown if the user answers incorrectly.
+
+        *script*: The embedded Python script (a string)
+
+        *num_responses*: The number of responses to create [DEFAULT: 1]
+
+        *num_inputs*: The number of input elements
+            to create [DEFAULT: 1]
+
+        Returns a string representation of the XML tree.
+        """
+
+        # Retrieve keyward arguments
+        question_text = kwargs.get('question_text', '')
+        explanation_text = kwargs.get('explanation_text', '')
+        script = kwargs.get('script', None)
+        num_responses = kwargs.get('num_responses', 1)
+        num_inputs = kwargs.get('num_inputs', 1)
+
+        # The root is <problem>
+        root = etree.Element("problem")
+
+        # Add a script if there is one
+        if script:
+            script_element = etree.SubElement(root, "script")
+            script_element.set("type", "loncapa/python")
+            script_element.text = str(script)
+
+        # The problem has a child <p> with question text
+        question = etree.SubElement(root, "p")
+        question.text = question_text
+
+        # Add the response(s)
+        for i in range(0, int(num_responses)):
+            response_element = self.create_response_element(**kwargs)
+            root.append(response_element)
+            
+            # Add input elements
+            for j in range(0, int(num_inputs)):
+                input_element = self.create_input_element(**kwargs)
+                if not (None == input_element):
+                    response_element.append(input_element)
+
+            # The problem has an explanation of the solution
+            if explanation_text:
+                explanation = etree.SubElement(root, "solution")
+                explanation_div = etree.SubElement(explanation, "div")
+                explanation_div.set("class", "detailed-solution")
+                explanation_div.text = explanation_text
+
+        return etree.tostring(root)
+
+    @staticmethod
+    def textline_input_xml(**kwargs):
+        """ Create a <textline/> XML element
+
+        Uses **kwargs:
+
+        *math_display*: If True, then includes a MathJax display of user input
+
+        *size*: An integer representing the width of the text line
+        """
+        math_display = kwargs.get('math_display', False)
+        size = kwargs.get('size', None)
+
+        input_element = etree.Element('textline')
+
+        if math_display:
+            input_element.set('math', '1')
+
+        if size:
+            input_element.set('size', str(size))
+
+        return input_element
+
+    @staticmethod
+    def choicegroup_input_xml(**kwargs):
+        """ Create a <choicegroup> XML element
+
+        Uses **kwargs:
+
+        *choice_type*: Can be "checkbox", "radio", or "multiple"
+
+        *choices*: List of True/False values indicating whether
+                            a particular choice is correct or not.
+                            Users must choose *all* correct options in order
+                            to be marked correct.
+                            DEFAULT: [True]
+
+        *choice_names": List of strings identifying the choices.
+                        If specified, you must ensure that
+                        len(choice_names) == len(choices)
+        """
+        # Names of group elements
+        group_element_names = {'checkbox': 'checkboxgroup',
+                                'radio': 'radiogroup',
+                                'multiple': 'choicegroup' }
+
+        # Retrieve **kwargs
+        choices = kwargs.get('choices', [True])
+        choice_type = kwargs.get('choice_type', 'multiple')
+        choice_names = kwargs.get('choice_names', [None] * len(choices))
+
+        # Create the <choicegroup>, <checkboxgroup>, or <radiogroup> element
+        assert(choice_type in group_element_names)
+        group_element = etree.Element(group_element_names[choice_type])
+
+        # Create the <choice> elements
+        for (correct_val, name) in zip(choices, choice_names):
+            choice_element = etree.SubElement(group_element, "choice")
+            choice_element.set("correct", "true" if correct_val else "false")
+
+            # Add some text describing the choice
+            etree.SubElement(choice_element, "startouttext")
+            etree.text = "Choice description"
+            etree.SubElement(choice_element, "endouttext")
+
+            # Add a name identifying the choice, if one exists
+            if name:
+                choice_element.set("name", str(name))
+
+        return group_element
+
+
+class NumericalResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <numericalresponse> XML trees """
+
+    def create_response_element(self, **kwargs):
+        """ Create a <numericalresponse> XML element.
+        Uses **kwarg keys:
+
+        *answer*: The correct answer (e.g. "5")
+
+        *tolerance*: The tolerance within which a response
+        is considered correct.  Can be a decimal (e.g. "0.01")
+        or percentage (e.g. "2%")
+        """
+
+        answer = kwargs.get('answer', None)
+        tolerance = kwargs.get('tolerance', None)
+
+        response_element = etree.Element('numericalresponse')
+
+        if answer:
+            response_element.set('answer', str(answer))
+
+        if tolerance:
+            responseparam_element = etree.SubElement(response_element, 'responseparam')
+            responseparam_element.set('type', 'tolerance')
+            responseparam_element.set('default', str(tolerance))
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        return ResponseXMLFactory.textline_input_xml(**kwargs)
+
+
+class CustomResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <customresponse> XML trees """
+
+    def create_response_element(self, **kwargs):
+        """ Create a <customresponse> XML element.
+
+        Uses **kwargs:
+
+        *cfn*: the Python code to run.  Can be inline code,
+        or the name of a function defined in earlier <script> tags.
+
+        Should have the form: cfn(expect, answer_given, student_answers)
+        where expect is a value (see below),
+        answer_given is a single value (for 1 input)
+        or a list of values (for multiple inputs),
+        and student_answers is a dict of answers by input ID.
+
+        *expect*: The value passed to the function cfn
+
+        *answer*: Inline script that calculates the answer
+        """
+        
+        # Retrieve **kwargs
+        cfn = kwargs.get('cfn', None)
+        expect = kwargs.get('expect', None)
+        answer = kwargs.get('answer', None)
+
+        # Create the response element
+        response_element = etree.Element("customresponse")
+
+        if cfn:
+            response_element.set('cfn', str(cfn))
+
+        if expect:
+            response_element.set('expect', str(expect))
+
+        if answer:
+            answer_element = etree.SubElement(response_element, "answer")
+            answer_element.text = str(answer)
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        return ResponseXMLFactory.textline_input_xml(**kwargs)
+
+
+class SchematicResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for creating <schematicresponse> XML trees """
+
+    def create_response_element(self, **kwargs):
+        """ Create the <schematicresponse> XML element.
+        
+        Uses *kwargs*:
+
+        *answer*: The Python script used to evaluate the answer.
+        """
+        answer_script = kwargs.get('answer', None)
+
+        # Create the <schematicresponse> element
+        response_element = etree.Element("schematicresponse")
+
+        # Insert the <answer> script if one is provided
+        if answer_script:
+            answer_element = etree.SubElement(response_element, "answer")
+            answer_element.set("type", "loncapa/python")
+            answer_element.text = str(answer_script)
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        """ Create the <schematic> XML element.
+
+        Although <schematic> can have several attributes,
+        (*height*, *width*, *parts*, *analyses*, *submit_analysis*, and *initial_value*),
+        none of them are used in the capa module.
+        For testing, we create a bare-bones version of <schematic>."""
+        return etree.Element("schematic")
+
+class CodeResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for creating <coderesponse> XML trees """
+
+    def build_xml(self, **kwargs):
+        # Since we are providing an <answer> tag,
+        # we should override the default behavior
+        # of including a <solution> tag as well
+        kwargs['explanation_text'] = None
+        return super(CodeResponseXMLFactory, self).build_xml(**kwargs)
+
+    def create_response_element(self, **kwargs):
+        """ Create a <coderesponse> XML element:
+            
+            Uses **kwargs:
+                
+            *initial_display*: The code that initially appears in the textbox
+                                [DEFAULT: "Enter code here"]
+            *answer_display*: The answer to display to the student
+                                [DEFAULT: "This is the correct answer!"]
+            *grader_payload*: A JSON-encoded string sent to the grader
+                                [DEFAULT: empty dict string]
+        """
+        # Get **kwargs
+        initial_display = kwargs.get("initial_display", "Enter code here")
+        answer_display = kwargs.get("answer_display", "This is the correct answer!")
+        grader_payload = kwargs.get("grader_payload", '{}')
+
+        # Create the <coderesponse> element
+        response_element = etree.Element("coderesponse")
+        codeparam_element = etree.SubElement(response_element, "codeparam")
+
+        # Set the initial display text
+        initial_element = etree.SubElement(codeparam_element, "initial_display")
+        initial_element.text = str(initial_display)
+
+        # Set the answer display text
+        answer_element = etree.SubElement(codeparam_element, "answer_display")
+        answer_element.text = str(answer_display)
+
+        # Set the grader payload string
+        grader_element = etree.SubElement(codeparam_element, "grader_payload")
+        grader_element.text = str(grader_payload)
+
+        # Create the input within the response
+        input_element = etree.SubElement(response_element, "textbox")
+        input_element.set("mode", "python")
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        # Since we create this in create_response_element(),
+        # return None here
+        return None
+
+class ChoiceResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for creating <choiceresponse> XML trees """
+
+    def create_response_element(self, **kwargs):
+        """ Create a <choiceresponse> element """
+        return etree.Element("choiceresponse")
+
+    def create_input_element(self, **kwargs):
+        """ Create a <checkboxgroup> element."""
+        return ResponseXMLFactory.choicegroup_input_xml(**kwargs)
+
+
+class FormulaResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for creating <formularesponse> XML trees """
+
+    def create_response_element(self, **kwargs):
+        """ Create a <formularesponse> element.
+
+        *sample_dict*: A dictionary of the form:
+                        { VARIABLE_NAME: (MIN, MAX), ....}
+
+                        This specifies the range within which
+                        to numerically sample each variable to check
+                        student answers.
+                        [REQUIRED]
+
+        *num_samples*: The number of times to sample the student's answer
+                        to numerically compare it to the correct answer.
+        
+        *tolerance*: The tolerance within which answers will be accepted
+                        [DEFAULT: 0.01] 
+
+        *answer*: The answer to the problem.  Can be a formula string
+                    or a Python variable defined in a script 
+                    (e.g. "$calculated_answer" for a Python variable 
+                    called calculated_answer)
+                    [REQUIRED]
+
+        *hints*: List of (hint_prompt, hint_name, hint_text) tuples
+                Where *hint_prompt* is the formula for which we show the hint,
+                *hint_name* is an internal identifier for the hint,
+                and *hint_text* is the text we show for the hint.
+        """
+        # Retrieve kwargs
+        sample_dict = kwargs.get("sample_dict", None)
+        num_samples = kwargs.get("num_samples", None)
+        tolerance = kwargs.get("tolerance", 0.01)
+        answer = kwargs.get("answer", None)
+        hint_list = kwargs.get("hints", None)
+
+        assert(answer)
+        assert(sample_dict and num_samples)
+
+        # Create the <formularesponse> element
+        response_element = etree.Element("formularesponse")
+
+        # Set the sample information
+        sample_str = self._sample_str(sample_dict, num_samples, tolerance)
+        response_element.set("samples", sample_str)
+                
+
+        # Set the tolerance
+        responseparam_element = etree.SubElement(response_element, "responseparam")
+        responseparam_element.set("type", "tolerance")
+        responseparam_element.set("default", str(tolerance))
+
+        # Set the answer
+        response_element.set("answer", str(answer))
+
+        # Include hints, if specified
+        if hint_list:
+            hintgroup_element = etree.SubElement(response_element, "hintgroup")
+
+            for (hint_prompt, hint_name, hint_text) in hint_list:
+
+                # For each hint, create a <formulahint> element
+                formulahint_element = etree.SubElement(hintgroup_element, "formulahint")
+
+                # We could sample a different range, but for simplicity,
+                # we use the same sample string for the hints
+                # that we used previously.  
+                formulahint_element.set("samples", sample_str)
+
+                formulahint_element.set("answer", str(hint_prompt))
+                formulahint_element.set("name", str(hint_name))
+
+                # For each hint, create a <hintpart> element
+                # corresponding to the <formulahint>
+                hintpart_element = etree.SubElement(hintgroup_element, "hintpart")
+                hintpart_element.set("on", str(hint_name))
+                text_element = etree.SubElement(hintpart_element, "text")
+                text_element.text = str(hint_text)
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        return ResponseXMLFactory.textline_input_xml(**kwargs)
+
+    def _sample_str(self, sample_dict, num_samples, tolerance):
+        # Loncapa uses a special format for sample strings:
+        # "x,y,z@4,5,3:10,12,8#4" means plug in values for (x,y,z)
+        # from within the box defined by points (4,5,3) and (10,12,8)
+        # The "#4" means to repeat 4 times.
+        variables = [str(v) for v in sample_dict.keys()]
+        low_range_vals = [str(f[0]) for f in sample_dict.values()]
+        high_range_vals = [str(f[1]) for f in sample_dict.values()]
+        sample_str = (",".join(sample_dict.keys()) + "@" +
+                        ",".join(low_range_vals) + ":" +
+                        ",".join(high_range_vals) + 
+                        "#" + str(num_samples))
+        return sample_str
+
+class ImageResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <imageresponse> XML """
+
+    def create_response_element(self, **kwargs):
+        """ Create the <imageresponse> element."""
+        return etree.Element("imageresponse")
+
+
+    def create_input_element(self, **kwargs):
+        """ Create the <imageinput> element.
+        
+        Uses **kwargs:
+            
+        *src*: URL for the image file [DEFAULT: "/static/image.jpg"]
+
+        *width*: Width of the image [DEFAULT: 100]
+
+        *height*: Height of the image [DEFAULT: 100]
+
+        *rectangle*: String representing the rectangles the user should select.
+
+                    Take the form "(x1,y1)-(x2,y2)", where the two (x,y)
+                    tuples define the corners of the rectangle.
+
+                    Can include multiple rectangles separated by a semicolon, e.g.
+                    "(490,11)-(556,98);(242,202)-(296,276)"
+
+        *regions*: String representing the regions a user can select
+
+                    Take the form "[ [[x1,y1], [x2,y2], [x3,y3]],
+                                    [[x1,y1], [x2,y2], [x3,y3]] ]"
+                    (Defines two regions, each with 3 points)
+
+        REQUIRED: Either *rectangle* or *region* (or both)
+        """
+
+        # Get the **kwargs
+        src = kwargs.get("src", "/static/image.jpg")
+        width = kwargs.get("width", 100)
+        height = kwargs.get("height", 100)
+        rectangle = kwargs.get('rectangle', None)
+        regions = kwargs.get('regions', None)
+
+        assert(rectangle or regions)
+
+        # Create the <imageinput> element
+        input_element = etree.Element("imageinput")
+        input_element.set("src", str(src))
+        input_element.set("width", str(width))
+        input_element.set("height", str(height))
+        
+        if rectangle:
+            input_element.set("rectangle", rectangle)
+
+        if regions:
+            input_element.set("regions", regions)
+
+        return input_element
+
+class JavascriptResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <javascriptresponse> XML """
+
+    def create_response_element(self, **kwargs):
+        """ Create the <javascriptresponse> element.
+
+        Uses **kwargs:
+
+        *generator_src*: Name of the JS file to generate the problem.
+        *grader_src*: Name of the JS file to grade the problem.
+        *display_class*: Name of the class used to display the problem
+        *display_src*: Name of the JS file used to display the problem
+        *param_dict*: Dictionary of parameters to pass to the JS
+        """
+        # Get **kwargs
+        generator_src = kwargs.get("generator_src", None)
+        grader_src = kwargs.get("grader_src", None)
+        display_class = kwargs.get("display_class", None)
+        display_src = kwargs.get("display_src", None)
+        param_dict = kwargs.get("param_dict", {})
+
+        # Both display_src and display_class given,
+        # or neither given
+        assert((display_src and display_class) or 
+                (not display_src and not display_class))
+
+        # Create the <javascriptresponse> element
+        response_element = etree.Element("javascriptresponse")
+
+        if generator_src:
+            generator_element = etree.SubElement(response_element, "generator")
+            generator_element.set("src", str(generator_src))
+
+        if grader_src:
+            grader_element = etree.SubElement(response_element, "grader")
+            grader_element.set("src", str(grader_src))
+
+        if display_class and display_src:
+            display_element = etree.SubElement(response_element, "display")
+            display_element.set("class", str(display_class))
+            display_element.set("src", str(display_src))
+
+        for (param_name, param_val) in param_dict.items():
+            responseparam_element = etree.SubElement(response_element, "responseparam")
+            responseparam_element.set("name", str(param_name))
+            responseparam_element.set("value", str(param_val))
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        """ Create the <javascriptinput> element """
+        return etree.Element("javascriptinput")
+
+class MultipleChoiceResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <multiplechoiceresponse> XML """
+
+    def create_response_element(self, **kwargs):
+        """ Create the <multiplechoiceresponse> element"""
+        return etree.Element('multiplechoiceresponse')
+
+    def create_input_element(self, **kwargs):
+        """ Create the <choicegroup> element"""
+        kwargs['choice_type'] = 'multiple'
+        return ResponseXMLFactory.choicegroup_input_xml(**kwargs)
+
+class TrueFalseResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <truefalseresponse> XML """
+
+    def create_response_element(self, **kwargs):
+        """ Create the <truefalseresponse> element"""
+        return etree.Element('truefalseresponse')
+
+    def create_input_element(self, **kwargs):
+        """ Create the <choicegroup> element"""
+        kwargs['choice_type'] = 'multiple'
+        return ResponseXMLFactory.choicegroup_input_xml(**kwargs)
+
+class OptionResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <optionresponse> XML"""
+
+    def create_response_element(self, **kwargs):
+        """ Create the <optionresponse> element"""
+        return etree.Element("optionresponse")
+
+    def create_input_element(self, **kwargs):
+        """ Create the <optioninput> element.
+
+        Uses **kwargs:
+
+        *options*: a list of possible options the user can choose from [REQUIRED]
+                    You must specify at least 2 options.
+        *correct_option*: the correct choice from the list of options [REQUIRED]
+        """
+
+        options_list = kwargs.get('options', None)
+        correct_option = kwargs.get('correct_option', None)
+
+        assert(options_list and correct_option)
+        assert(len(options_list) > 1)
+        assert(correct_option in options_list)
+
+        # Create the <optioninput> element
+        optioninput_element = etree.Element("optioninput")
+
+        # Set the "options" attribute
+        # Format: "('first', 'second', 'third')"
+        options_attr_string = ",".join(["'%s'" % str(o) for o in options_list])
+        options_attr_string = "(%s)" % options_attr_string
+        optioninput_element.set('options', options_attr_string)
+
+        # Set the "correct" attribute
+        optioninput_element.set('correct', str(correct_option))
+
+        return optioninput_element
+
+
+class StringResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <stringresponse> XML """
+
+    def create_response_element(self, **kwargs):
+        """ Create a <stringresponse> XML element.
+        
+            Uses **kwargs:
+
+            *answer*: The correct answer (a string) [REQUIRED]
+
+            *case_sensitive*: Whether the response is case-sensitive (True/False)
+                            [DEFAULT: True]
+
+            *hints*: List of (hint_prompt, hint_name, hint_text) tuples
+                Where *hint_prompt* is the string for which we show the hint,
+                *hint_name* is an internal identifier for the hint,
+                and *hint_text* is the text we show for the hint.
+        """
+        # Retrieve the **kwargs
+        answer = kwargs.get("answer", None)
+        case_sensitive = kwargs.get("case_sensitive", True)
+        hint_list = kwargs.get('hints', None)
+        assert(answer)
+
+        # Create the <stringresponse> element
+        response_element = etree.Element("stringresponse")
+
+        # Set the answer attribute 
+        response_element.set("answer", str(answer))
+
+        # Set the case sensitivity
+        response_element.set("type", "cs" if case_sensitive else "ci")
+
+        # Add the hints if specified
+        if hint_list:
+            hintgroup_element = etree.SubElement(response_element, "hintgroup")
+            for (hint_prompt, hint_name, hint_text) in hint_list:
+                stringhint_element = etree.SubElement(hintgroup_element, "stringhint")
+                stringhint_element.set("answer", str(hint_prompt))
+                stringhint_element.set("name", str(hint_name))
+
+                hintpart_element = etree.SubElement(hintgroup_element, "hintpart")
+                hintpart_element.set("on", str(hint_name))
+
+                hint_text_element = etree.SubElement(hintpart_element, "text")
+                hint_text_element.text = str(hint_text)
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        return ResponseXMLFactory.textline_input_xml(**kwargs)

common/lib/capa/capa/tests/test_files/choiceresponse_checkbox.xml

-<problem>
-<choiceresponse>
-  <checkboxgroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </checkboxgroup>
-</choiceresponse>
-<choiceresponse>
-  <checkboxgroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </checkboxgroup>
-</choiceresponse>
-<choiceresponse>
-  <checkboxgroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </checkboxgroup>
-</choiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/choiceresponse_radio.xml

-<problem>
-<choiceresponse>
-  <radiogroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </radiogroup>
-</choiceresponse>
-<choiceresponse>
-  <radiogroup>
-    <choice correct="false">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="true">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </radiogroup>
-</choiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/coderesponse.xml

-<problem>
-<text>
-<h2>Code response</h2>
-
-<p>
-</p>
-
-<text>
-Write a program to compute the square of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <codeparam>
-      <initial_display>def square(x):</initial_display>
-      <answer_display>answer</answer_display>
-      <grader_payload>grader stuff</grader_payload>
-    </codeparam>
-  </coderesponse>
-</text>
-
-<text>
-Write a program to compute the square of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <codeparam>
-      <initial_display>def square(x):</initial_display>
-      <answer_display>answer</answer_display>
-      <grader_payload>grader stuff</grader_payload>
-    </codeparam>
-  </coderesponse>
-</text>
-
-</text>
-</problem>

common/lib/capa/capa/tests/test_files/coderesponse_externalresponseformat.xml

-<problem>
-<text>
-<h2>Code response</h2>
-
-<p>
-</p>
-
-<text>
-Write a program to compute the square of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <answer><![CDATA[
-initial_display = """
-def square(n):
-"""
-
-answer = """
-def square(n):
-    return n**2    
-"""
-
-preamble = """ 
-import sys, time
-"""
-
-test_program = """
-import random
-import operator
-
-def testSquare(n = None):
-    if n is None:
-       n = random.randint(2, 20)
-    print 'Test is: square(%d)'%n
-    return str(square(n))
-
-def main():
-   f = os.fdopen(3,'w')
-   test = int(sys.argv[1])
-   rndlist = map(int,os.getenv('rndlist').split(','))
-   random.seed(rndlist[0])
-   if test == 1: f.write(testSquare(0))
-   elif test == 2: f.write(testSquare(1))
-   else:  f.write(testSquare())
-   f.close()
-
-main()
-sys.exit(0)
-"""
-]]>
-    </answer>
-  </coderesponse>
-</text>
-
-<text>
-Write a program to compute the cube of a number
-  <coderesponse tests="repeat:2,generate">
-    <textbox rows="10" cols="70"  mode="python"/>
-    <answer><![CDATA[
-initial_display = """
-def cube(n):
-"""
-
-answer = """
-def cube(n):
-    return n**3    
-"""
-
-preamble = """ 
-import sys, time
-"""
-
-test_program = """
-import random
-import operator
-
-def testCube(n = None):
-    if n is None:
-       n = random.randint(2, 20)
-    print 'Test is: cube(%d)'%n
-    return str(cube(n))
-
-def main():
-   f = os.fdopen(3,'w')
-   test = int(sys.argv[1])
-   rndlist = map(int,os.getenv('rndlist').split(','))
-   random.seed(rndlist[0])
-   if test == 1: f.write(testCube(0))
-   elif test == 2: f.write(testCube(1))
-   else:  f.write(testCube())
-   f.close()
-
-main()
-sys.exit(0)
-"""
-]]>
-    </answer>
-  </coderesponse>
-</text>
-
-</text>
-</problem>

common/lib/capa/capa/tests/test_files/filename_convert_test.txt

+This file is used to test converting file handles to filenames in the capa utility module

common/lib/capa/capa/tests/test_files/formularesponse_with_hint.xml

-<problem>
-<script type="loncapa/python">
-# from loncapa import *
-x1 = 4 # lc_random(2,4,1)
-y1 = 5 # lc_random(3,7,1)
-
-x2 = 10 # lc_random(x1+1,9,1)
-y2 = 20 # lc_random(y1+1,15,1)
-
-m = (y2-y1)/(x2-x1)
-b = y1 - m*x1
-answer = "%s*x+%s" % (m,b)
-answer = answer.replace('+-','-')
-
-inverted_m = (x2-x1)/(y2-y1)
-inverted_b = b
-wrongans = "%s*x+%s" % (inverted_m,inverted_b)
-wrongans = wrongans.replace('+-','-')
-</script>
-
-<text>
-<p>Hints can be provided to students, based on the last response given, as well as the history of responses given.  Here is an example of a hint produced by a Formula Response problem.</p>
-
-<p>
-What is the equation of the line which passess through ($x1,$y1) and
-($x2,$y2)?</p>
-
-<p>The correct answer is <tt>$answer</tt>. A common error is to invert the equation for the slope.  Enter <tt>
-$wrongans</tt> to see a hint.</p>
-
-</text>
-
-<formularesponse samples="x@-5:5#11" id="11" answer="$answer">
- <responseparam description="Numerical Tolerance" type="tolerance" default="0.001" name="tol" /> 
- <text>y = <textline size="25" /></text>
-  <hintgroup>
-   <formulahint samples="x@-5:5#11" answer="$wrongans" name="inversegrad">
-   </formulahint>
-   <hintpart on="inversegrad">
-    <text>You have inverted the slope in the question.</text>
-   </hintpart>
-  </hintgroup>     
-</formularesponse>
-</problem>
-

common/lib/capa/capa/tests/test_files/imageresponse.xml

-<problem>
-<text><p>
-Two skiers are on frictionless black diamond ski slopes.
-Hello</p></text>
-
-<imageresponse max="1" loncapaid="11">
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98)"/>
-<text>Click on the image where the top skier will stop momentarily if the top skier starts from rest.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(242,202)-(296,276)"/>
-<text>Click on the image where the lower skier will stop momentarily if the lower skier starts from rest.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98);(242,202)-(296,276)"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98);(242,202)-(296,276)"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98);(242,202)-(296,276)"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<hintgroup showoncorrect="no">
-<text><p>Use conservation of energy.</p></text>
-</hintgroup>
-</imageresponse>
-
-
-<imageresponse max="1" loncapaid="12">
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98)" regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" rectangle="(490,11)-(556,98)" regions='[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]'/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[[10,10], [20,10], [20, 30]]]"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[10,10], [30,30], [15, 15]]"/>
-<imageinput src="/static/Physics801/Figures/Skier-conservation of energy.jpg" width="560" height="388" regions="[[10,10], [30,30], [10, 30], [30, 10]]"/>
-<text>Click on either of the two positions as discussed previously.</text>
-<hintgroup showoncorrect="no">
-<text><p>Use conservation of energy.</p></text>
-</hintgroup>
-</imageresponse>
-
-
-</problem>

common/lib/capa/capa/tests/test_files/javascriptresponse.xml

-<problem>
-
-<javascriptresponse>
-  <generator src="test_problem_generator.js"/>
-  <grader src="test_problem_grader.js"/>
-  <display class="TestProblemDisplay" src="test_problem_display.js"/>
-  <responseparam name="value" value="4"/>
-  <javascriptinput>
-  </javascriptinput>
-</javascriptresponse>
-
-</problem>
-

common/lib/capa/capa/tests/test_files/js/compiled/c9a9cd4242d84c924fe5f8324e9ae79d.js

-// Generated by CoffeeScript 1.3.3
-(function() {
-  var MinimaxProblemDisplay, root,
-    __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
-  MinimaxProblemDisplay = (function(_super) {
-
-    __extends(MinimaxProblemDisplay, _super);
-
-    function MinimaxProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
-      this.state = state;
-      this.submission = submission;
-      this.evaluation = evaluation;
-      this.container = container;
-      this.submissionField = submissionField;
-      this.parameters = parameters != null ? parameters : {};
-      MinimaxProblemDisplay.__super__.constructor.call(this, this.state, this.submission, this.evaluation, this.container, this.submissionField, this.parameters);
-    }
-
-    MinimaxProblemDisplay.prototype.render = function() {};
-
-    MinimaxProblemDisplay.prototype.createSubmission = function() {
-      var id, value, _ref, _results;
-      this.newSubmission = {};
-      if (this.submission != null) {
-        _ref = this.submission;
-        _results = [];
-        for (id in _ref) {
-          value = _ref[id];
-          _results.push(this.newSubmission[id] = value);
-        }
-        return _results;
-      }
-    };
-
-    MinimaxProblemDisplay.prototype.getCurrentSubmission = function() {
-      return this.newSubmission;
-    };
-
-    return MinimaxProblemDisplay;
-
-  })(XProblemDisplay);
-
-  root = typeof exports !== "undefined" && exports !== null ? exports : this;
-
-  root.TestProblemDisplay = TestProblemDisplay;
-
-}).call(this);
-;

common/lib/capa/capa/tests/test_files/js/compiled/javascriptresponse.js

-// Generated by CoffeeScript 1.3.3
-(function() {
-  var MinimaxProblemDisplay, root,
-    __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
-  MinimaxProblemDisplay = (function(_super) {
-
-    __extends(MinimaxProblemDisplay, _super);
-
-    function MinimaxProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
-      this.state = state;
-      this.submission = submission;
-      this.evaluation = evaluation;
-      this.container = container;
-      this.submissionField = submissionField;
-      this.parameters = parameters != null ? parameters : {};
-      MinimaxProblemDisplay.__super__.constructor.call(this, this.state, this.submission, this.evaluation, this.container, this.submissionField, this.parameters);
-    }
-
-    MinimaxProblemDisplay.prototype.render = function() {};
-
-    MinimaxProblemDisplay.prototype.createSubmission = function() {
-      var id, value, _ref, _results;
-      this.newSubmission = {};
-      if (this.submission != null) {
-        _ref = this.submission;
-        _results = [];
-        for (id in _ref) {
-          value = _ref[id];
-          _results.push(this.newSubmission[id] = value);
-        }
-        return _results;
-      }
-    };
-
-    MinimaxProblemDisplay.prototype.getCurrentSubmission = function() {
-      return this.newSubmission;
-    };
-
-    return MinimaxProblemDisplay;
-
-  })(XProblemDisplay);
-
-  root = typeof exports !== "undefined" && exports !== null ? exports : this;
-
-  root.TestProblemDisplay = TestProblemDisplay;
-
-}).call(this);
-;

common/lib/capa/capa/tests/test_files/multi_bare.xml

-<problem>
-<multiplechoiceresponse>
-  <choicegroup>
-    <choice correct="false" >
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false" >
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true" >
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </choicegroup>
-</multiplechoiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/multichoice.xml

-<problem>
-<multiplechoiceresponse>
-  <choicegroup>
-    <choice correct="false" name="foil1">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice correct="false" name="foil2">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice correct="true" name="foil3">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice correct="false" name="foil4">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice correct="false" name="foil5">
-      <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </choicegroup>
-</multiplechoiceresponse>
-</problem>

common/lib/capa/capa/tests/test_files/optionresponse.xml

-  <problem>
-    <text>
-      <p>
-Why do bicycles benefit from having larger wheels when going up a bump as shown in the picture? <br/>
-Assume that for both bicycles:<br/>
-1.)	The tires have equal air pressure.<br/>
-2.)	The bicycles never leave the contact with the bump.<br/>
-3.)	The bicycles have the same mass. The bicycle tires (regardless of size) have the same mass.<br/>
-</p>
-    </text>
-    <optionresponse texlayout="horizontal" max="10" randomize="yes">
-      <ul>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels have more time to go over the bump. This decreases the magnitude of the force needed to lift the bicycle.</p>
-          </text>
-          <optioninput name="Foil1" location="random" options="('True','False')" correct="True">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels always have a smaller vertical displacement regardless of speed.</p>
-          </text>
-          <optioninput name="Foil2" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels experience a force backward with less magnitude for the same amount of time.</p>
-          </text>
-          <optioninput name="Foil3" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels experience a force backward with less magnitude for a greater amount of time.</p>
-          </text>
-          <optioninput name="Foil4" location="random" options="('True','False')" correct="True">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels have more kinetic energy turned into gravitational potential energy.</p>
-          </text>
-          <optioninput name="Foil5" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-        <li>
-          <text>
-            <p>The bicycles with larger wheels have more rotational kinetic energy, so the horizontal velocity of the biker changes less.</p>
-          </text>
-          <optioninput name="Foil6" location="random" options="('True','False')" correct="False">
-</optioninput>
-        </li>
-      </ul>
-      <hintgroup showoncorrect="no">
-        <text>
-          <br/>
-          <br/>
-        </text>
-      </hintgroup>
-    </optionresponse>
-  </problem>

common/lib/capa/capa/tests/test_files/stringresponse_with_hint.xml

-<problem >
- <text><h2>Example: String Response Problem</h2>
- <br/>
- </text>
- 
- <text>Which US state has Lansing as its capital?</text>
-  <stringresponse answer="Michigan" type="ci">
-  <textline size="20" />
-  <hintgroup>
-   <stringhint answer="wisconsin" type="cs" name="wisc">
-   </stringhint>
-   <stringhint answer="minnesota" type="cs" name="minn">
-   </stringhint>
-   <hintpart on="wisc">
-    <text>The state capital of Wisconsin is Madison.</text>
-   </hintpart>
-   <hintpart on="minn">
-    <text>The state capital of Minnesota is St. Paul.</text>
-   </hintpart>
-   <hintpart on="default">
-    <text>The state you are looking for is also known as the 'Great Lakes State'</text>
-   </hintpart>     
-  </hintgroup>
- </stringresponse>
-</problem>

common/lib/capa/capa/tests/test_files/symbolicresponse.xml

-<problem>
-<text>
-<h2>Example: Symbolic Math Response Problem</h2>
-
-<p>
-A symbolic math response problem presents one or more symbolic math
-input fields for input.  Correctness of input is evaluated based on
-the symbolic properties of the expression entered.  The student enters
-text, but sees a proper symbolic rendition of the entered formula, in
-real time, next to the input box.
-</p>
-
-<p>This is a correct answer which may be entered below: </p>
-<p><tt>cos(theta)*[[1,0],[0,1]] + i*sin(theta)*[[0,1],[1,0]]</tt></p>
-
-<script>
-from symmath import *
-</script>
-  <text>Compute [mathjax] U = \exp\left( i \theta \left[ \begin{matrix} 0 &amp; 1 \\ 1 &amp; 0 \end{matrix} \right] \right) [/mathjax]
-      and give the resulting \(2 \times 2\) matrix. <br/>
-      Your input should be typed in as a list of lists, eg <tt>[[1,2],[3,4]]</tt>. <br/>
-       [mathjax]U=[/mathjax] <symbolicresponse cfn="symmath_check" answer="[[cos(theta),I*sin(theta)],[I*sin(theta),cos(theta)]]" options="matrix,imaginaryi" id="filenamedogi0VpEBOWedxsymmathresponse_1" state="unsubmitted">
-          <textline size="80" math="1" response_id="2" answer_id="1" id="filenamedogi0VpEBOWedxsymmathresponse_2_1"/>
-        </symbolicresponse>
-      <br/>
-  </text>
-
-</text>
-</problem>

common/lib/capa/capa/tests/test_files/truefalse.xml

-<problem>
-  <truefalseresponse max="10" randomize="yes">
-  <choicegroup>
-    <choice location="random" correct="true" name="foil1">
-      <startouttext />This is foil One.<endouttext />
-    </choice>
-    <choice location="random" correct="true" name="foil2">
-      <startouttext />This is foil Two.<endouttext />
-    </choice>
-    <choice location="random" correct="false" name="foil3">
-      <startouttext />This is foil Three.<endouttext />
-    </choice>
-    <choice location="random" correct="false" name="foil4">
-      <startouttext />This is foil Four.<endouttext />
-    </choice>
-    <choice location="random" correct="false" name="foil5">
-            <startouttext />This is foil Five.<endouttext />
-    </choice>
-  </choicegroup>
-</truefalseresponse>
-</problem>

common/lib/capa/capa/tests/test_responsetypes.py

@@ -16,93 +16,151 @@ from capa.correctmap import CorrectMap
 from capa.util import convert_files_to_filenames
 from capa.xqueue_interface import dateformat
 
-
-class MultiChoiceTest(unittest.TestCase):
-    def test_MC_grade(self):
-        multichoice_file = os.path.dirname(__file__) + "/test_files/multichoice.xml"
-        test_lcp = lcp.LoncapaProblem(open(multichoice_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': 'choice_foil3'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        false_answers = {'1_2_1': 'choice_foil2'}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-
-    def test_MC_bare_grades(self):
-        multichoice_file = os.path.dirname(__file__) + "/test_files/multi_bare.xml"
-        test_lcp = lcp.LoncapaProblem(open(multichoice_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': 'choice_2'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        false_answers = {'1_2_1': 'choice_1'}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-
-    def test_TF_grade(self):
-        truefalse_file = os.path.dirname(__file__) + "/test_files/truefalse.xml"
-        test_lcp = lcp.LoncapaProblem(open(truefalse_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': ['choice_foil2', 'choice_foil1']}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        false_answers = {'1_2_1': ['choice_foil1']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-        false_answers = {'1_2_1': ['choice_foil1', 'choice_foil3']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-        false_answers = {'1_2_1': ['choice_foil3']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-        false_answers = {'1_2_1': ['choice_foil1', 'choice_foil2', 'choice_foil3']}
-        self.assertEquals(test_lcp.grade_answers(false_answers).get_correctness('1_2_1'), 'incorrect')
-
-
-class ImageResponseTest(unittest.TestCase):
-    def test_ir_grade(self):
-        imageresponse_file = os.path.dirname(__file__) + "/test_files/imageresponse.xml"
-        test_lcp = lcp.LoncapaProblem(open(imageresponse_file).read(), '1', system=test_system)
-        # testing regions only
-        correct_answers = {
-           #regions
-           '1_2_1': '(490,11)-(556,98)',
-           '1_2_2': '(242,202)-(296,276)',
-           '1_2_3': '(490,11)-(556,98);(242,202)-(296,276)',
-           '1_2_4': '(490,11)-(556,98);(242,202)-(296,276)',
-           '1_2_5': '(490,11)-(556,98);(242,202)-(296,276)',
-           #testing regions and rectanges
-           '1_3_1': 'rectangle="(490,11)-(556,98)" \
-           regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"',
-           '1_3_2': 'rectangle="(490,11)-(556,98)" \
-           regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"',
-           '1_3_3': 'regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"',
-           '1_3_4': 'regions="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"',
-           '1_3_5': 'regions="[[[10,10], [20,10], [20, 30]]]"',
-           '1_3_6': 'regions="[[10,10], [30,30], [15, 15]]"',
-           '1_3_7': 'regions="[[10,10], [30,30], [10, 30], [30, 10]]"',
-                          }
-        test_answers = {
-            '1_2_1': '[500,20]',
-            '1_2_2': '[250,300]',
-            '1_2_3': '[500,20]',
-            '1_2_4': '[250,250]',
-            '1_2_5': '[10,10]',
-
-            '1_3_1': '[500,20]',
-            '1_3_2': '[15,15]',
-            '1_3_3': '[500,20]',
-            '1_3_4': '[115,115]',
-            '1_3_5': '[15,15]',
-            '1_3_6': '[20,20]',
-            '1_3_7': '[20,15]',
-                        }
-
-        # regions
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_2'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_3'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_4'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_5'), 'incorrect')
-
-        # regions and rectangles
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_2'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_3'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_4'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_5'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_6'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_7'), 'correct')
+class ResponseTest(unittest.TestCase):
+    """ Base class for tests of capa responses."""
+    
+    xml_factory_class = None
+
+    def setUp(self):
+        if self.xml_factory_class:
+            self.xml_factory = self.xml_factory_class()
+
+    def build_problem(self, **kwargs):
+        xml = self.xml_factory.build_xml(**kwargs)
+        return lcp.LoncapaProblem(xml, '1', system=test_system)
+
+    def assert_grade(self, problem, submission, expected_correctness):
+        input_dict = {'1_2_1': submission}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_correctness('1_2_1'), expected_correctness)
+
+    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')
+            self.assertEqual(result, 'correct',
+                        msg="%s should be marked correct" % str(input_str))
+
+        for input_str in incorrect_answers:
+            result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
+            self.assertEqual(result, 'incorrect', 
+                            msg="%s should be marked incorrect" % str(input_str))
+
+class MultiChoiceResponseTest(ResponseTest):
+    from response_xml_factory import MultipleChoiceResponseXMLFactory
+    xml_factory_class = MultipleChoiceResponseXMLFactory
+
+    def test_multiple_choice_grade(self):
+        problem = self.build_problem(choices=[False, True, False])
+
+        # Ensure that we get the expected grades
+        self.assert_grade(problem, 'choice_0', 'incorrect')
+        self.assert_grade(problem, 'choice_1', 'correct')
+        self.assert_grade(problem, 'choice_2', 'incorrect')
+
+    def test_named_multiple_choice_grade(self):
+        problem = self.build_problem(choices=[False, True, False],
+                                    choice_names=["foil_1", "foil_2", "foil_3"])
+        
+        # Ensure that we get the expected grades
+        self.assert_grade(problem, 'choice_foil_1', 'incorrect')
+        self.assert_grade(problem, 'choice_foil_2', 'correct')
+        self.assert_grade(problem, 'choice_foil_3', 'incorrect')
+
+
+class TrueFalseResponseTest(ResponseTest):
+    from response_xml_factory import TrueFalseResponseXMLFactory
+    xml_factory_class = TrueFalseResponseXMLFactory
+
+    def test_true_false_grade(self):
+        problem = self.build_problem(choices=[False, True, True])
+
+        # Check the results
+        # Mark correct if and only if ALL (and only) correct choices selected
+        self.assert_grade(problem, 'choice_0', 'incorrect')
+        self.assert_grade(problem, 'choice_1', 'incorrect')
+        self.assert_grade(problem, 'choice_2', 'incorrect')
+        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_2'], 'incorrect')
+        self.assert_grade(problem, ['choice_0', 'choice_2'], 'incorrect')
+        self.assert_grade(problem, ['choice_0', 'choice_1'], 'incorrect')
+        self.assert_grade(problem, ['choice_1', 'choice_2'], 'correct')
+
+        # Invalid choices should be marked incorrect (we have no choice 3)
+        self.assert_grade(problem, 'choice_3', 'incorrect')
+        self.assert_grade(problem, 'not_a_choice', 'incorrect')
+
+    def test_named_true_false_grade(self):
+        problem = self.build_problem(choices=[False, True, True],
+                                    choice_names=['foil_1','foil_2','foil_3'])
+
+        # Check the results
+        # Mark correct if and only if ALL (and only) correct chocies selected
+        self.assert_grade(problem, 'choice_foil_1', 'incorrect')
+        self.assert_grade(problem, 'choice_foil_2', 'incorrect')
+        self.assert_grade(problem, 'choice_foil_3', 'incorrect')
+        self.assert_grade(problem, ['choice_foil_1', 'choice_foil_2', 'choice_foil_3'], 'incorrect')
+        self.assert_grade(problem, ['choice_foil_1', 'choice_foil_3'], 'incorrect')
+        self.assert_grade(problem, ['choice_foil_1', 'choice_foil_2'], 'incorrect')
+        self.assert_grade(problem, ['choice_foil_2', 'choice_foil_3'], 'correct')
+
+        # Invalid choices should be marked incorrect
+        self.assert_grade(problem, 'choice_foil_4', 'incorrect')
+        self.assert_grade(problem, 'not_a_choice', 'incorrect')
+
+class ImageResponseTest(ResponseTest):
+    from response_xml_factory import ImageResponseXMLFactory
+    xml_factory_class = ImageResponseXMLFactory
+
+    def test_rectangle_grade(self):
+        # Define a rectangle with corners (10,10) and (20,20)
+        problem = self.build_problem(rectangle="(10,10)-(20,20)")
+
+        # Anything inside the rectangle (and along the borders) is correct
+        # Everything else is incorrect
+        correct_inputs = ["[12,19]", "[10,10]", "[20,20]", 
+                            "[10,15]", "[20,15]", "[15,10]", "[15,20]"]
+        incorrect_inputs = ["[4,6]", "[25,15]", "[15,40]", "[15,4]"]
+        self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
+
+    def test_multiple_rectangles_grade(self):
+        # Define two rectangles
+        rectangle_str = "(10,10)-(20,20);(100,100)-(200,200)"
+
+        # Expect that only points inside the rectangles are marked correct
+        problem = self.build_problem(rectangle=rectangle_str)
+        correct_inputs = ["[12,19]", "[120, 130]"]
+        incorrect_inputs = ["[4,6]", "[25,15]", "[15,40]", "[15,4]",
+                            "[50,55]", "[300, 14]", "[120, 400]"]
+        self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
+
+    def test_region_grade(self):
+        # Define a triangular region with corners (0,0), (5,10), and (0, 10)
+        region_str = "[ [1,1], [5,10], [0,10] ]"
+
+        # Expect that only points inside the triangle are marked correct
+        problem = self.build_problem(regions=region_str)
+        correct_inputs = ["[2,4]", "[1,3]"]
+        incorrect_inputs = ["[0,0]", "[3,5]", "[5,15]", "[30, 12]"]
+        self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
+
+    def test_multiple_regions_grade(self):
+        # Define multiple regions that the user can select
+        region_str="[[[10,10], [20,10], [20, 30]], [[100,100], [120,100], [120,150]]]"
+
+        # Expect that only points inside the regions are marked correct
+        problem = self.build_problem(regions=region_str)
+        correct_inputs = ["[15,12]", "[110,112]"]
+        incorrect_inputs = ["[0,0]", "[600,300]"]
+        self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
+
+    def test_region_and_rectangle_grade(self):
+        rectangle_str = "(100,100)-(200,200)"
+        region_str="[[10,10], [20,10], [20, 30]]"
+
+        # Expect that only points inside the rectangle or region are marked correct
+        problem = self.build_problem(regions=region_str, rectangle=rectangle_str)
+        correct_inputs = ["[13,12]", "[110,112]"]
+        incorrect_inputs = ["[0,0]", "[600,300]"]
+        self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
 
 
 class SymbolicResponseTest(unittest.TestCase):
@@ -195,60 +253,165 @@ class SymbolicResponseTest(unittest.TestCase):
         self.assertEquals(test_lcp.grade_answers(wrong_answers).get_correctness('1_2_1'), 'incorrect')
 
 
-class OptionResponseTest(unittest.TestCase):
-    '''
-    Run this with
+class OptionResponseTest(ResponseTest):
+    from response_xml_factory import OptionResponseXMLFactory
+    xml_factory_class = OptionResponseXMLFactory
 
-    python manage.py test courseware.OptionResponseTest
-    '''
-    def test_or_grade(self):
-        optionresponse_file = os.path.dirname(__file__) + "/test_files/optionresponse.xml"
-        test_lcp = lcp.LoncapaProblem(open(optionresponse_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': 'True',
-                           '1_2_2': 'False'}
-        test_answers = {'1_2_1': 'True',
-                        '1_2_2': 'True',
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_2'), 'incorrect')
-
-
-class FormulaResponseWithHintTest(unittest.TestCase):
-    '''
-    Test Formula response problem with a hint
-    This problem also uses calc.
-    '''
-    def test_or_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/formularesponse_with_hint.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': '2.5*x-5.0'}
-        test_answers = {'1_2_1': '0.4*x-5.0'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        cmap = test_lcp.grade_answers(test_answers)
-        self.assertEquals(cmap.get_correctness('1_2_1'), 'incorrect')
-        self.assertTrue('You have inverted' in cmap.get_hint('1_2_1'))
-
-
-class StringResponseWithHintTest(unittest.TestCase):
-    '''
-    Test String response problem with a hint
-    '''
-    def test_or_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/stringresponse_with_hint.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': 'Michigan'}
-        test_answers = {'1_2_1': 'Minnesota'}
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-        cmap = test_lcp.grade_answers(test_answers)
-        self.assertEquals(cmap.get_correctness('1_2_1'), 'incorrect')
-        self.assertTrue('St. Paul' in cmap.get_hint('1_2_1'))
+    def test_grade(self):
+        problem = self.build_problem(options=["first", "second", "third"], 
+                                    correct_option="second")
+
+        # Assert that we get the expected grades
+        self.assert_grade(problem, "first", "incorrect")
+        self.assert_grade(problem, "second", "correct")
+        self.assert_grade(problem, "third", "incorrect")
+
+        # Options not in the list should be marked incorrect
+        self.assert_grade(problem, "invalid_option", "incorrect")
+
+
+class FormulaResponseTest(ResponseTest):
+    from response_xml_factory import FormulaResponseXMLFactory
+    xml_factory_class = FormulaResponseXMLFactory
+
+    def test_grade(self):
+        # Sample variables x and y in the range [-10, 10]
+        sample_dict = {'x': (-10, 10), 'y': (-10, 10)}
+
+        # The expected solution is numerically equivalent to x+2y
+        problem = self.build_problem(sample_dict=sample_dict,
+                                    num_samples=10,
+                                    tolerance=0.01,
+                                    answer="x+2*y")
+
+        # Expect an equivalent formula to be marked correct
+        # 2x - x + y + y = x + 2y
+        input_formula = "2*x - x + y + y"
+        self.assert_grade(problem, input_formula, "correct")
+
+        # Expect an incorrect formula to be marked incorrect
+        # x + y != x + 2y
+        input_formula = "x + y"
+        self.assert_grade(problem, input_formula, "incorrect")
+
+    def test_hint(self):
+        # Sample variables x and y in the range [-10, 10]
+        sample_dict = {'x': (-10, 10), 'y': (-10,10) }
+
+        # Give a hint if the user leaves off the coefficient
+        # or leaves out x
+        hints = [('x + 3*y', 'y_coefficient', 'Check the coefficient of y'),
+                ('2*y', 'missing_x', 'Try including the variable x')]
+
+
+        # The expected solution is numerically equivalent to x+2y
+        problem = self.build_problem(sample_dict=sample_dict,
+                                    num_samples=10,
+                                    tolerance=0.01,
+                                    answer="x+2*y",
+                                    hints=hints)
+
+        # Expect to receive a hint  if we add an extra y
+        input_dict = {'1_2_1': "x + 2*y + y"}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_hint('1_2_1'),
+                'Check the coefficient of y')
+
+        # Expect to receive a hint if we leave out x
+        input_dict = {'1_2_1': "2*y"}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_hint('1_2_1'),
+                'Try including the variable x')
+
+
+    def test_script(self):
+        # Calculate the answer using a script
+        script = "calculated_ans = 'x+x'"
+
+        # Sample x in the range [-10,10]
+        sample_dict = {'x': (-10, 10)}
+
+        # The expected solution is numerically equivalent to 2*x
+        problem = self.build_problem(sample_dict=sample_dict,
+                                    num_samples=10,
+                                    tolerance=0.01,
+                                    answer="$calculated_ans",
+                                    script=script)
+
+        # Expect that the inputs are graded correctly
+        self.assert_grade(problem, '2*x', 'correct')
+        self.assert_grade(problem, '3*x', 'incorrect')
+
+
+class StringResponseTest(ResponseTest):
+    from response_xml_factory import StringResponseXMLFactory
+    xml_factory_class = StringResponseXMLFactory
+
+
+    def test_case_sensitive(self):
+        problem = self.build_problem(answer="Second", case_sensitive=True)
+
+        # Exact string should be correct
+        self.assert_grade(problem, "Second", "correct")
+
+        # Other strings and the lowercase version of the string are incorrect
+        self.assert_grade(problem, "Other String", "incorrect")
+        self.assert_grade(problem, "second", "incorrect")
+
+    def test_case_insensitive(self):
+        problem = self.build_problem(answer="Second", case_sensitive=False)
+
+        # Both versions of the string should be allowed, regardless
+        # of capitalization
+        self.assert_grade(problem, "Second", "correct")
+        self.assert_grade(problem, "second", "correct")
+
+        # Other strings are not allowed
+        self.assert_grade(problem, "Other String", "incorrect")
+
+    def test_hints(self):
+        hints = [("wisconsin", "wisc", "The state capital of Wisconsin is Madison"),
+                ("minnesota", "minn", "The state capital of Minnesota is St. Paul")]
+
+        problem = self.build_problem(answer="Michigan", 
+                                    case_sensitive=False, 
+                                    hints=hints)
+
+        # We should get a hint for Wisconsin
+        input_dict = {'1_2_1': 'Wisconsin'}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_hint('1_2_1'),
+                        "The state capital of Wisconsin is Madison")
+
+        # We should get a hint for Minnesota
+        input_dict = {'1_2_1': 'Minnesota'}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_hint('1_2_1'),
+                        "The state capital of Minnesota is St. Paul")
+
+        # We should NOT get a hint for Michigan (the correct answer)
+        input_dict = {'1_2_1': 'Michigan'}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_hint('1_2_1'), "")
+
+        # We should NOT get a hint for any other string
+        input_dict = {'1_2_1': 'California'}
+        correct_map = problem.grade_answers(input_dict)
+        self.assertEquals(correct_map.get_hint('1_2_1'), "")
+
+class CodeResponseTest(ResponseTest):
+    from response_xml_factory import CodeResponseXMLFactory
+    xml_factory_class = CodeResponseXMLFactory
 
+    def setUp(self):
+        super(CodeResponseTest, self).setUp()
+
+        grader_payload = json.dumps({"grader": "ps04/grade_square.py"})
+        self.problem = self.build_problem(initial_display="def square(x):",
+                                        answer_display="answer",
+                                        grader_payload=grader_payload,
+                                        num_responses=2)
 
-class CodeResponseTest(unittest.TestCase):
-    '''
-    Test CodeResponse
-    TODO: Add tests for external grader messages
-    '''
     @staticmethod
     def make_queuestate(key, time):
         timestr = datetime.strftime(time, dateformat)
@@ -258,186 +421,354 @@ class CodeResponseTest(unittest.TestCase):
         """
         Simple test of whether LoncapaProblem knows when it's been queued
         """
-        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-        with open(problem_file) as input_file:
-            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=test_system)
 
-            answer_ids = sorted(test_lcp.get_question_answers())
+        answer_ids = sorted(self.problem.get_question_answers())
 
-            # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
-            cmap = CorrectMap()
-            for answer_id in answer_ids:
-                cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
-            test_lcp.correct_map.update(cmap)
+        # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
+        cmap = CorrectMap()
+        for answer_id in answer_ids:
+            cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
+        self.problem.correct_map.update(cmap)
 
-            self.assertEquals(test_lcp.is_queued(), False)
+        self.assertEquals(self.problem.is_queued(), False)
 
-            # Now we queue the LCP
-            cmap = CorrectMap()
-            for i, answer_id in enumerate(answer_ids):
-                queuestate = CodeResponseTest.make_queuestate(i, datetime.now())
-                cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
-            test_lcp.correct_map.update(cmap)
+        # Now we queue the LCP
+        cmap = CorrectMap()
+        for i, answer_id in enumerate(answer_ids):
+            queuestate = CodeResponseTest.make_queuestate(i, datetime.now())
+            cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
+        self.problem.correct_map.update(cmap)
 
-            self.assertEquals(test_lcp.is_queued(), True)
+        self.assertEquals(self.problem.is_queued(), True)
 
 
     def test_update_score(self):
         '''
         Test whether LoncapaProblem.update_score can deliver queued result to the right subproblem
         '''
-        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-        with open(problem_file) as input_file:
-            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=test_system)
+        answer_ids = sorted(self.problem.get_question_answers())
 
-            answer_ids = sorted(test_lcp.get_question_answers())
+        # CodeResponse requires internal CorrectMap state. Build it now in the queued state
+        old_cmap = CorrectMap()
+        for i, answer_id in enumerate(answer_ids):
+            queuekey = 1000 + i
+            queuestate = CodeResponseTest.make_queuestate(1000 + i, datetime.now())
+            old_cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
 
-            # CodeResponse requires internal CorrectMap state. Build it now in the queued state
-            old_cmap = CorrectMap()
-            for i, answer_id in enumerate(answer_ids):
-                queuekey = 1000 + i
-                queuestate = CodeResponseTest.make_queuestate(1000 + i, datetime.now())
-                old_cmap.update(CorrectMap(answer_id=answer_ids[i], queuestate=queuestate))
+        # Message format common to external graders
+        grader_msg = '<span>MESSAGE</span>'   # Must be valid XML
+        correct_score_msg = json.dumps({'correct': True, 'score': 1, 'msg': grader_msg})
+        incorrect_score_msg = json.dumps({'correct': False, 'score': 0, 'msg': grader_msg})
 
-            # Message format common to external graders
-            grader_msg = '<span>MESSAGE</span>'   # Must be valid XML
-            correct_score_msg = json.dumps({'correct': True, 'score': 1, 'msg': grader_msg})
-            incorrect_score_msg = json.dumps({'correct': False, 'score': 0, 'msg': grader_msg})
+        xserver_msgs = {'correct': correct_score_msg,
+                        'incorrect': incorrect_score_msg, }
 
-            xserver_msgs = {'correct': correct_score_msg,
-                            'incorrect': incorrect_score_msg, }
+        # Incorrect queuekey, state should not be updated
+        for correctness in ['correct', 'incorrect']:
+            self.problem.correct_map = CorrectMap()
+            self.problem.correct_map.update(old_cmap)  # Deep copy
 
-            # Incorrect queuekey, state should not be updated
-            for correctness in ['correct', 'incorrect']:
-                test_lcp.correct_map = CorrectMap()
-                test_lcp.correct_map.update(old_cmap)  # Deep copy
+            self.problem.update_score(xserver_msgs[correctness], queuekey=0)
+            self.assertEquals(self.problem.correct_map.get_dict(), old_cmap.get_dict())  # Deep comparison
 
-                test_lcp.update_score(xserver_msgs[correctness], queuekey=0)
-                self.assertEquals(test_lcp.correct_map.get_dict(), old_cmap.get_dict())  # Deep comparison
-
-                for answer_id in answer_ids:
-                    self.assertTrue(test_lcp.correct_map.is_queued(answer_id))  # Should be still queued, since message undelivered
+            for answer_id in answer_ids:
+                self.assertTrue(self.problem.correct_map.is_queued(answer_id))  # Should be still queued, since message undelivered
 
-            # Correct queuekey, state should be updated
-            for correctness in ['correct', 'incorrect']:
-                for i, answer_id in enumerate(answer_ids):
-                    test_lcp.correct_map = CorrectMap()
-                    test_lcp.correct_map.update(old_cmap)
+        # Correct queuekey, state should be updated
+        for correctness in ['correct', 'incorrect']:
+            for i, answer_id in enumerate(answer_ids):
+                self.problem.correct_map = CorrectMap()
+                self.problem.correct_map.update(old_cmap)
 
-                    new_cmap = CorrectMap()
-                    new_cmap.update(old_cmap)
-                    npoints = 1 if correctness == 'correct' else 0
-                    new_cmap.set(answer_id=answer_id, npoints=npoints, correctness=correctness, msg=grader_msg, queuestate=None)
+                new_cmap = CorrectMap()
+                new_cmap.update(old_cmap)
+                npoints = 1 if correctness == 'correct' else 0
+                new_cmap.set(answer_id=answer_id, npoints=npoints, correctness=correctness, msg=grader_msg, queuestate=None)
 
-                    test_lcp.update_score(xserver_msgs[correctness], queuekey=1000 + i)
-                    self.assertEquals(test_lcp.correct_map.get_dict(), new_cmap.get_dict())
+                self.problem.update_score(xserver_msgs[correctness], queuekey=1000 + i)
+                self.assertEquals(self.problem.correct_map.get_dict(), new_cmap.get_dict())
 
-                    for j, test_id in enumerate(answer_ids):
-                        if j == i:
-                            self.assertFalse(test_lcp.correct_map.is_queued(test_id))  # Should be dequeued, message delivered
-                        else:
-                            self.assertTrue(test_lcp.correct_map.is_queued(test_id))  # Should be queued, message undelivered
+                for j, test_id in enumerate(answer_ids):
+                    if j == i:
+                        self.assertFalse(self.problem.correct_map.is_queued(test_id))  # Should be dequeued, message delivered
+                    else:
+                        self.assertTrue(self.problem.correct_map.is_queued(test_id))  # Should be queued, message undelivered
 
 
     def test_recentmost_queuetime(self):
         '''
         Test whether the LoncapaProblem knows about the time of queue requests
         '''
-        problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-        with open(problem_file) as input_file:
-            test_lcp = lcp.LoncapaProblem(input_file.read(), '1', system=test_system)
+        answer_ids = sorted(self.problem.get_question_answers())
 
-            answer_ids = sorted(test_lcp.get_question_answers())
+        # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
+        cmap = CorrectMap()
+        for answer_id in answer_ids:
+            cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
+        self.problem.correct_map.update(cmap)
 
-            # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
-            cmap = CorrectMap()
-            for answer_id in answer_ids:
-                cmap.update(CorrectMap(answer_id=answer_id, queuestate=None))
-            test_lcp.correct_map.update(cmap)
+        self.assertEquals(self.problem.get_recentmost_queuetime(), None)
 
-            self.assertEquals(test_lcp.get_recentmost_queuetime(), None)
+        # CodeResponse requires internal CorrectMap state. Build it now in the queued state
+        cmap = CorrectMap()
+        for i, answer_id in enumerate(answer_ids):
+            queuekey = 1000 + i
+            latest_timestamp = datetime.now()
+            queuestate = CodeResponseTest.make_queuestate(1000 + i, latest_timestamp)
+            cmap.update(CorrectMap(answer_id=answer_id, queuestate=queuestate))
+        self.problem.correct_map.update(cmap)
 
-            # CodeResponse requires internal CorrectMap state. Build it now in the queued state
-            cmap = CorrectMap()
-            for i, answer_id in enumerate(answer_ids):
-                queuekey = 1000 + i
-                latest_timestamp = datetime.now()
-                queuestate = CodeResponseTest.make_queuestate(1000 + i, latest_timestamp)
-                cmap.update(CorrectMap(answer_id=answer_id, queuestate=queuestate))
-            test_lcp.correct_map.update(cmap)
-
-            # Queue state only tracks up to second
-            latest_timestamp = datetime.strptime(datetime.strftime(latest_timestamp, dateformat), dateformat)
-
-            self.assertEquals(test_lcp.get_recentmost_queuetime(), latest_timestamp)
-
-        def test_convert_files_to_filenames(self):
-            '''
-            Test whether file objects are converted to filenames without altering other structures
-            '''
-            problem_file = os.path.join(os.path.dirname(__file__), "test_files/coderesponse.xml")
-            with open(problem_file) as fp:
-                answers_with_file = {'1_2_1': 'String-based answer',
-                                     '1_3_1': ['answer1', 'answer2', 'answer3'],
-                                     '1_4_1': [fp, fp]}
-                answers_converted = convert_files_to_filenames(answers_with_file)
-                self.assertEquals(answers_converted['1_2_1'], 'String-based answer')
-                self.assertEquals(answers_converted['1_3_1'], ['answer1', 'answer2', 'answer3'])
-                self.assertEquals(answers_converted['1_4_1'], [fp.name, fp.name])
-
-
-class ChoiceResponseTest(unittest.TestCase):
-
-    def test_cr_rb_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/choiceresponse_radio.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': 'choice_2',
-                           '1_3_1': ['choice_2', 'choice_3']}
-        test_answers = {'1_2_1': 'choice_2',
-                        '1_3_1': 'choice_2',
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
-
-    def test_cr_cb_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/choiceresponse_checkbox.xml"
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': 'choice_2',
-                           '1_3_1': ['choice_2', 'choice_3'],
-                           '1_4_1': ['choice_2', 'choice_3']}
-        test_answers = {'1_2_1': 'choice_2',
-                        '1_3_1': 'choice_2',
-                        '1_4_1': ['choice_2', 'choice_3'],
-                        }
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_2_1'), 'correct')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_4_1'), 'correct')
+        # Queue state only tracks up to second
+        latest_timestamp = datetime.strptime(datetime.strftime(latest_timestamp, dateformat), dateformat)
 
+        self.assertEquals(self.problem.get_recentmost_queuetime(), latest_timestamp)
+
+    def test_convert_files_to_filenames(self):
+        '''
+        Test whether file objects are converted to filenames without altering other structures
+        '''
+        problem_file = os.path.join(os.path.dirname(__file__), "test_files/filename_convert_test.txt")
+        with open(problem_file) as fp:
+            answers_with_file = {'1_2_1': 'String-based answer',
+                                 '1_3_1': ['answer1', 'answer2', 'answer3'],
+                                 '1_4_1': [fp, fp]}
+            answers_converted = convert_files_to_filenames(answers_with_file)
+            self.assertEquals(answers_converted['1_2_1'], 'String-based answer')
+            self.assertEquals(answers_converted['1_3_1'], ['answer1', 'answer2', 'answer3'])
+            self.assertEquals(answers_converted['1_4_1'], [fp.name, fp.name])
 
-class JavascriptResponseTest(unittest.TestCase):
+class ChoiceResponseTest(ResponseTest):
+    from response_xml_factory import ChoiceResponseXMLFactory
+    xml_factory_class = ChoiceResponseXMLFactory
 
-    def test_jr_grade(self):
-        problem_file = os.path.dirname(__file__) + "/test_files/javascriptresponse.xml"
+    def test_radio_group_grade(self):
+        problem = self.build_problem(choice_type='radio', 
+                                        choices=[False, True, False])
+
+        # Check that we get the expected results
+        self.assert_grade(problem, 'choice_0', 'incorrect')
+        self.assert_grade(problem, 'choice_1', 'correct')
+        self.assert_grade(problem, 'choice_2', 'incorrect')
+
+        # No choice 3 exists --> mark incorrect
+        self.assert_grade(problem, 'choice_3', 'incorrect')
+
+
+    def test_checkbox_group_grade(self):
+        problem = self.build_problem(choice_type='checkbox',
+                                        choices=[False, True, True])
+
+        # Check that we get the expected results
+        # (correct if and only if BOTH correct choices chosen)
+        self.assert_grade(problem, ['choice_1', 'choice_2'], 'correct')
+        self.assert_grade(problem, 'choice_1', 'incorrect')
+        self.assert_grade(problem, 'choice_2', 'incorrect')
+        self.assert_grade(problem, ['choice_0', 'choice_1'], 'incorrect')
+        self.assert_grade(problem, ['choice_0', 'choice_2'], 'incorrect')
+
+        # No choice 3 exists --> mark incorrect
+        self.assert_grade(problem, 'choice_3', 'incorrect')
+
+
+class JavascriptResponseTest(ResponseTest):
+    from response_xml_factory import JavascriptResponseXMLFactory
+    xml_factory_class = JavascriptResponseXMLFactory
+
+    def test_grade(self):
+        # Compile coffee files into javascript used by the response
         coffee_file_path = os.path.dirname(__file__) + "/test_files/js/*.coffee"
         os.system("coffee -c %s" % (coffee_file_path))
-        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=test_system)
-        correct_answers = {'1_2_1': json.dumps({0: 4})}
-        incorrect_answers = {'1_2_1': json.dumps({0: 5})}
 
-        self.assertEquals(test_lcp.grade_answers(incorrect_answers).get_correctness('1_2_1'), 'incorrect')
-        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
-
-class AnnotationResponseTest(unittest.TestCase):
+        problem = self.build_problem(generator_src="test_problem_generator.js",
+                                    grader_src="test_problem_grader.js",
+                                    display_class="TestProblemDisplay",
+                                    display_src="test_problem_display.js",
+                                    param_dict={'value': '4'})
+
+        # Test that we get graded correctly
+        self.assert_grade(problem, json.dumps({0:4}), "correct")
+        self.assert_grade(problem, json.dumps({0:5}), "incorrect")
+
+class NumericalResponseTest(ResponseTest):
+    from response_xml_factory import NumericalResponseXMLFactory
+    xml_factory_class = NumericalResponseXMLFactory
+
+    def test_grade_exact(self):
+        problem = self.build_problem(question_text="What is 2 + 2?",
+                                        explanation="The answer is 4",
+                                        answer=4)
+        correct_responses = ["4", "4.0", "4.00"]
+        incorrect_responses = ["", "3.9", "4.1", "0"]
+        self.assert_multiple_grade(problem, correct_responses, incorrect_responses)
+        
+
+    def test_grade_decimal_tolerance(self):
+        problem = self.build_problem(question_text="What is 2 + 2 approximately?",
+                                        explanation="The answer is 4",
+                                        answer=4,
+                                        tolerance=0.1)
+        correct_responses = ["4.0", "4.00", "4.09", "3.91"] 
+        incorrect_responses = ["", "4.11", "3.89", "0"]
+        self.assert_multiple_grade(problem, correct_responses, incorrect_responses)
+                        
+    def test_grade_percent_tolerance(self):
+        problem = self.build_problem(question_text="What is 2 + 2 approximately?",
+                                        explanation="The answer is 4",
+                                        answer=4,
+                                        tolerance="10%")
+        correct_responses = ["4.0", "4.3", "3.7", "4.30", "3.70"]
+        incorrect_responses = ["", "4.5", "3.5", "0"]
+        self.assert_multiple_grade(problem, correct_responses, incorrect_responses)
+
+    def test_grade_with_script(self):
+        script_text = "computed_response = math.sqrt(4)"
+        problem = self.build_problem(question_text="What is sqrt(4)?",
+                                        explanation="The answer is 2",
+                                        answer="$computed_response",
+                                        script=script_text)
+        correct_responses = ["2", "2.0"]
+        incorrect_responses = ["", "2.01", "1.99", "0"]
+        self.assert_multiple_grade(problem, correct_responses, incorrect_responses)
+
+    def test_grade_with_script_and_tolerance(self):
+        script_text = "computed_response = math.sqrt(4)"
+        problem = self.build_problem(question_text="What is sqrt(4)?",
+                                        explanation="The answer is 2",
+                                        answer="$computed_response",
+                                        tolerance="0.1",
+                                        script=script_text)
+        correct_responses = ["2", "2.0", "2.05", "1.95"]
+        incorrect_responses = ["", "2.11", "1.89", "0"]
+        self.assert_multiple_grade(problem, correct_responses, incorrect_responses)
+
+
+class CustomResponseTest(ResponseTest):
+    from response_xml_factory import CustomResponseXMLFactory
+    xml_factory_class = CustomResponseXMLFactory
+
+    def test_inline_code(self):
+
+        # For inline code, we directly modify global context variables
+        # 'answers' is a list of answers provided to us
+        # 'correct' is a list we fill in with True/False
+        # 'expect' is given to us (if provided in the XML)
+        inline_script = """correct[0] = 'correct' if (answers['1_2_1'] == expect) else 'incorrect'"""
+        problem = self.build_problem(answer=inline_script, expect="42")
+
+        # Check results
+        self.assert_grade(problem, '42', 'correct')
+        self.assert_grade(problem, '0', 'incorrect')
+
+    def test_inline_message(self):
+
+        # Inline code can update the global messages list
+        # to pass messages to the CorrectMap for a particular input
+        inline_script = """messages[0] = "Test Message" """
+        problem = self.build_problem(answer=inline_script)
+
+        input_dict = {'1_2_1': '0'}
+        msg = problem.grade_answers(input_dict).get_msg('1_2_1')
+        self.assertEqual(msg, "Test Message")
+
+    def test_function_code(self):
+
+        # For function code, we pass in three arguments:
+        # 
+        #   'expect' is the expect attribute of the <customresponse>
+        #
+        #   'answer_given' is the answer the student gave (if there is just one input)
+        #       or an ordered list of answers (if there are multiple inputs)
+        #   
+        #   'student_answers' is a dictionary of answers by input ID
+        #
+        #
+        # The function should return a dict of the form 
+        # { 'ok': BOOL, 'msg': STRING }
+        #
+        script = """def check_func(expect, answer_given, student_answers):
+    return {'ok': answer_given == expect, 'msg': 'Message text'}"""
+
+        problem = self.build_problem(script=script, cfn="check_func", expect="42")
+
+        # Correct answer
+        input_dict = {'1_2_1': '42'}
+        correct_map = problem.grade_answers(input_dict)
+
+        correctness = correct_map.get_correctness('1_2_1')
+        msg = correct_map.get_msg('1_2_1')
+
+        self.assertEqual(correctness, 'correct')
+        self.assertEqual(msg, "Message text\n")
+
+        # Incorrect answer
+        input_dict = {'1_2_1': '0'}
+        correct_map = problem.grade_answers(input_dict)
+
+        correctness = correct_map.get_correctness('1_2_1')
+        msg = correct_map.get_msg('1_2_1')
+
+        self.assertEqual(correctness, 'incorrect')
+        self.assertEqual(msg, "Message text\n")
+
+    def test_multiple_inputs(self):
+        # When given multiple inputs, the 'answer_given' argument
+        # to the check_func() is a list of inputs
+        # The sample script below marks the problem as correct
+        # if and only if it receives answer_given=[1,2,3]
+        # (or string values ['1','2','3'])
+        script = """def check_func(expect, answer_given, student_answers):
+    check1 = (int(answer_given[0]) == 1)
+    check2 = (int(answer_given[1]) == 2)
+    check3 = (int(answer_given[2]) == 3)
+    return {'ok': (check1 and check2 and check3),  'msg': 'Message text'}"""
+
+        problem = self.build_problem(script=script, 
+                                    cfn="check_func", num_inputs=3)
+
+        # Grade the inputs (one input incorrect)
+        input_dict = {'1_2_1': '-999', '1_2_2': '2', '1_2_3': '3' }
+        correct_map = problem.grade_answers(input_dict)
+
+        # Everything marked incorrect
+        self.assertEqual(correct_map.get_correctness('1_2_1'), 'incorrect')
+        self.assertEqual(correct_map.get_correctness('1_2_2'), 'incorrect')
+        self.assertEqual(correct_map.get_correctness('1_2_3'), 'incorrect')
+
+        # Grade the inputs (everything correct)
+        input_dict = {'1_2_1': '1', '1_2_2': '2', '1_2_3': '3' }
+        correct_map = problem.grade_answers(input_dict)
+
+        # Everything marked incorrect
+        self.assertEqual(correct_map.get_correctness('1_2_1'), 'correct')
+        self.assertEqual(correct_map.get_correctness('1_2_2'), 'correct')
+        self.assertEqual(correct_map.get_correctness('1_2_3'), 'correct')
+
+
+class SchematicResponseTest(ResponseTest):
+    from response_xml_factory import SchematicResponseXMLFactory
+    xml_factory_class = SchematicResponseXMLFactory
 
     def test_grade(self):
-        annotationresponse_file = os.path.dirname(__file__) + "/test_files/annotationresponse.xml"
-        test_lcp = lcp.LoncapaProblem(open(annotationresponse_file).read(), '1', system=test_system)
-        answers_for = {
-            'correct': {'1_2_1': json.dumps({'options':[0]})},
-            'incorrect': {'1_2_1': json.dumps({'options':[1]})},
-            'partially-correct': {'1_2_1': json.dumps({'options':[2]})}
-        }
-
-        for expected_correctness in answers_for.keys():
-            actual_correctness = test_lcp.grade_answers(answers_for[expected_correctness]).get_correctness('1_2_1')
-            self.assertEquals(expected_correctness, actual_correctness)
+
+        # Most of the schematic-specific work is handled elsewhere
+        # (in client-side JavaScript)
+        # The <schematicresponse> is responsible only for executing the
+        # Python code in <answer> with *submission* (list)
+        # in the global context.
+
+        # To test that the context is set up correctly,
+        # we create a script that sets *correct* to true
+        # if and only if we find the *submission* (list)
+        script="correct = ['correct' if 'test' in submission[0] else 'incorrect']"
\ No newline at end of file
+        problem = self.build_problem(answer=script)
+
+        # The actual dictionary would contain schematic information
+        # sent from the JavaScript simulation
+        submission_dict = {'test': 'test'}
+        input_dict = { '1_2_1': json.dumps(submission_dict) }
+        correct_map = problem.grade_answers(input_dict)
+
+        # Expect that the problem is graded as true
+        # (That is, our script verifies that the context
+        # is what we expect)
+        self.assertEqual(correct_map.get_correctness('1_2_1'), 'correct')

common/lib/xmodule/xmodule/js/spec/problem/edit_spec.coffee

@@ -119,13 +119,13 @@ describe 'MarkdownEditingDescriptor', ->
         <p>The answer is correct if it is within a specified numerical tolerance of the expected answer.</p>
         
         <p>Enter the numerical value of Pi:</p>
-        <numericalresponse answer="3.14159 ">
+        <numericalresponse answer="3.14159">
           <responseparam type="tolerance" default=".02" />
           <textline />
         </numericalresponse>
         
         <p>Enter the approximate value of 502*9:</p>
-        <numericalresponse answer="4518 ">
+        <numericalresponse answer="4518">
           <responseparam type="tolerance" default="15%" />
           <textline />
         </numericalresponse>
@@ -148,6 +148,20 @@ describe 'MarkdownEditingDescriptor', ->
         </div>
         </solution>
         </problem>""")
+    it 'will convert 0 as a numerical response (instead of string response)', ->
+      data =  MarkdownEditingDescriptor.markdownToXml("""
+        Enter 0 with a tolerance:
+        = 0 +- .02
+        """)
+      expect(data).toEqual("""<problem>
+        <p>Enter 0 with a tolerance:</p>
+        <numericalresponse answer="0">
+          <responseparam type="tolerance" default=".02" />
+          <textline />
+        </numericalresponse>
+
+
+        </problem>""")
     it 'converts multiple choice to xml', ->
       data = MarkdownEditingDescriptor.markdownToXml("""A multiple choice problem presents radio buttons for student input. Students can only select a single option presented. Multiple Choice questions have been the subject of many areas of research due to the early invention and adoption of bubble sheets.
         

common/lib/xmodule/xmodule/js/src/problem/edit.coffee

@@ -231,13 +231,14 @@ class @MarkdownEditingDescriptor extends XModule.Descriptor
       // replace string and numerical
       xml = xml.replace(/^\=\s*(.*?$)/gm, function(match, p) {
         var string;
-        var params = /(.*?)\+\-\s*(.*?$)/.exec(p);
-        if(parseFloat(p)) {
+        var floatValue = parseFloat(p);
+        if(!isNaN(floatValue)) {
+          var params = /(.*?)\+\-\s*(.*?$)/.exec(p);
           if(params) {
-            string = '<numericalresponse answer="' + params[1] + '">\n';
+            string = '<numericalresponse answer="' + floatValue + '">\n';
             string += '  <responseparam type="tolerance" default="' + params[2] + '" />\n';
           } else {
-            string = '<numericalresponse answer="' + p + '">\n';
+            string = '<numericalresponse answer="' + floatValue + '">\n';
           }
           string += '  <textline />\n';
           string += '</numericalresponse>\n\n';

common/lib/xmodule/xmodule/modulestore/mongo.py

@@ -157,10 +157,15 @@ class MongoModuleStore(ModuleStoreBase):
         '''
         
         # get all collections in the course, this query should not return any leaf nodes
-        query = { '_id.org' : location.org,
-                '_id.course' : location.course,
-                '_id.revision' : None,
-                'definition.children':{'$ne': []}
+        query = { 
+                    '_id.org': location.org,
+                    '_id.course': location.course,
+                    '$or': [ 
+                    {"_id.category":"course"}, 
+                    {"_id.category":"chapter"},    
+                    {"_id.category":"sequential"},    
+                    {"_id.category":"vertical"}   
+                ]
                 }
         # we just want the Location, children, and metadata
         record_filter = {'_id':1,'definition.children':1,'metadata':1}
@@ -279,6 +284,13 @@ class MongoModuleStore(ModuleStoreBase):
 
         resource_fs = OSFS(root)
 
+        metadata_inheritance_tree = None
+
+        # if we are loading a course object, there is no parent to inherit the metadata from
+        # so don't bother getting it
+        if item['location']['category'] != 'course':
+            metadata_inheritance_tree = self.get_cached_metadata_inheritance_tree(Location(item['location']), 300)
+
         # TODO (cdodge): When the 'split module store' work has been completed, we should remove
         # the 'metadata_inheritance_tree' parameter
         system = CachingDescriptorSystem(
@@ -288,7 +300,7 @@ class MongoModuleStore(ModuleStoreBase):
             resource_fs,
             self.error_tracker,
             self.render_template,
-            metadata_inheritance_tree = self.get_cached_metadata_inheritance_tree(Location(item['location']), 60)
+            metadata_inheritance_tree = metadata_inheritance_tree
         )
         return system.load_item(item['location'])
 

common/static/js/vendor/CodeMirror/codemirror.js

+// CodeMirror version 2.23 (with edits)
+//
 // All functions that need access to the editor's state live inside
 // the CodeMirror function. Below that, at the bottom of the file,
 // some utilities are defined.

common/static/js/vendor/CodeMirror/javascript.js

+CodeMirror.defineMode("javascript", function(config, parserConfig) {
+  var indentUnit = config.indentUnit;
+  var jsonMode = parserConfig.json;
+
+  // Tokenizer
+
+  var keywords = function(){
+    function kw(type) {return {type: type, style: "keyword"};}
+    var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
+    var operator = kw("operator"), atom = {type: "atom", style: "atom"};
+    return {
+      "if": A, "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
+      "return": C, "break": C, "continue": C, "new": C, "delete": C, "throw": C,
+      "var": kw("var"), "const": kw("var"), "let": kw("var"),
+      "function": kw("function"), "catch": kw("catch"),
+      "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
+      "in": operator, "typeof": operator, "instanceof": operator,
+      "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom
+    };
+  }();
+
+  var isOperatorChar = /[+\-*&%=<>!?|]/;
+
+  function chain(stream, state, f) {
+    state.tokenize = f;
+    return f(stream, state);
+  }
+
+  function nextUntilUnescaped(stream, end) {
+    var escaped = false, next;
+    while ((next = stream.next()) != null) {
+      if (next == end && !escaped)
+        return false;
+      escaped = !escaped && next == "\\";
+    }
+    return escaped;
+  }
+
+  // Used as scratch variables to communicate multiple values without
+  // consing up tons of objects.
+  var type, content;
+  function ret(tp, style, cont) {
+    type = tp; content = cont;
+    return style;
+  }
+
+  function jsTokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == '"' || ch == "'")
+      return chain(stream, state, jsTokenString(ch));
+    else if (/[\[\]{}\(\),;\:\.]/.test(ch))
+      return ret(ch);
+    else if (ch == "0" && stream.eat(/x/i)) {
+      stream.eatWhile(/[\da-f]/i);
+      return ret("number", "number");
+    }      
+    else if (/\d/.test(ch)) {
+      stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
+      return ret("number", "number");
+    }
+    else if (ch == "/") {
+      if (stream.eat("*")) {
+        return chain(stream, state, jsTokenComment);
+      }
+      else if (stream.eat("/")) {
+        stream.skipToEnd();
+        return ret("comment", "comment");
+      }
+      else if (state.reAllowed) {
+        nextUntilUnescaped(stream, "/");
+        stream.eatWhile(/[gimy]/); // 'y' is "sticky" option in Mozilla
+        return ret("regexp", "string-2");
+      }
+      else {
+        stream.eatWhile(isOperatorChar);
+        return ret("operator", null, stream.current());
+      }
+    }
+    else if (ch == "#") {
+        stream.skipToEnd();
+        return ret("error", "error");
+    }
+    else if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return ret("operator", null, stream.current());
+    }
+    else {
+      stream.eatWhile(/[\w\$_]/);
+      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
+      return (known && state.kwAllowed) ? ret(known.type, known.style, word) :
+                     ret("variable", "variable", word);
+    }
+  }
+
+  function jsTokenString(quote) {
+    return function(stream, state) {
+      if (!nextUntilUnescaped(stream, quote))
+        state.tokenize = jsTokenBase;
+      return ret("string", "string");
+    };
+  }
+
+  function jsTokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == "/" && maybeEnd) {
+        state.tokenize = jsTokenBase;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return ret("comment", "comment");
+  }
+
+  // Parser
+
+  var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
+
+  function JSLexical(indented, column, type, align, prev, info) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.prev = prev;
+    this.info = info;
+    if (align != null) this.align = align;
+  }
+
+  function inScope(state, varname) {
+    for (var v = state.localVars; v; v = v.next)
+      if (v.name == varname) return true;
+  }
+
+  function parseJS(state, style, type, content, stream) {
+    var cc = state.cc;
+    // Communicate our context to the combinators.
+    // (Less wasteful than consing up a hundred closures on every call.)
+    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;
+  
+    if (!state.lexical.hasOwnProperty("align"))
+      state.lexical.align = true;
+
+    while(true) {
+      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
+      if (combinator(type, content)) {
+        while(cc.length && cc[cc.length - 1].lex)
+          cc.pop()();
+        if (cx.marked) return cx.marked;
+        if (type == "variable" && inScope(state, content)) return "variable-2";
+        return style;
+      }
+    }
+  }
+
+  // Combinator utils
+
+  var cx = {state: null, column: null, marked: null, cc: null};
+  function pass() {
+    for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
+  }
+  function cont() {
+    pass.apply(null, arguments);
+    return true;
+  }
+  function register(varname) {
+    var state = cx.state;
+    if (state.context) {
+      cx.marked = "def";
+      for (var v = state.localVars; v; v = v.next)
+        if (v.name == varname) return;
+      state.localVars = {name: varname, next: state.localVars};
+    }
+  }
+
+  // Combinators
+
+  var defaultVars = {name: "this", next: {name: "arguments"}};
+  function pushcontext() {
+    if (!cx.state.context) cx.state.localVars = defaultVars;
+    cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
+  }
+  function popcontext() {
+    cx.state.localVars = cx.state.context.vars;
+    cx.state.context = cx.state.context.prev;
+  }
+  function pushlex(type, info) {
+    var result = function() {
+      var state = cx.state;
+      state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info)
+    };
+    result.lex = true;
+    return result;
+  }
+  function poplex() {
+    var state = cx.state;
+    if (state.lexical.prev) {
+      if (state.lexical.type == ")")
+        state.indented = state.lexical.indented;
+      state.lexical = state.lexical.prev;
+    }
+  }
+  poplex.lex = true;
+
+  function expect(wanted) {
+    return function expecting(type) {
+      if (type == wanted) return cont();
+      else if (wanted == ";") return pass();
+      else return cont(arguments.callee);
+    };
+  }
+
+  function statement(type) {
+    if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
+    if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+    if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
+    if (type == "{") return cont(pushlex("}"), block, poplex);
+    if (type == ";") return cont();
+    if (type == "function") return cont(functiondef);
+    if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),
+                                      poplex, statement, poplex);
+    if (type == "variable") return cont(pushlex("stat"), maybelabel);
+    if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
+                                         block, poplex, poplex);
+    if (type == "case") return cont(expression, expect(":"));
+    if (type == "default") return cont(expect(":"));
+    if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
+                                        statement, poplex, popcontext);
+    return pass(pushlex("stat"), expression, expect(";"), poplex);
+  }
+  function expression(type) {
+    if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);
+    if (type == "function") return cont(functiondef);
+    if (type == "keyword c") return cont(maybeexpression);
+    if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeoperator);
+    if (type == "operator") return cont(expression);
+    if (type == "[") return cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
+    if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+    return cont();
+  }
+  function maybeexpression(type) {
+    if (type.match(/[;\}\)\],]/)) return pass();
+    return pass(expression);
+  }
+    
+  function maybeoperator(type, value) {
+    if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
+    if (type == "operator") return cont(expression);
+    if (type == ";") return;
+    if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
+    if (type == ".") return cont(property, maybeoperator);
+    if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
+  }
+  function maybelabel(type) {
+    if (type == ":") return cont(poplex, statement);
+    return pass(maybeoperator, expect(";"), poplex);
+  }
+  function property(type) {
+    if (type == "variable") {cx.marked = "property"; return cont();}
+  }
+  function objprop(type) {
+    if (type == "variable") cx.marked = "property";
+    if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);
+  }
+  function commasep(what, end) {
+    function proceed(type) {
+      if (type == ",") return cont(what, proceed);
+      if (type == end) return cont();
+      return cont(expect(end));
+    }
+    return function commaSeparated(type) {
+      if (type == end) return cont();
+      else return pass(what, proceed);
+    };
+  }
+  function block(type) {
+    if (type == "}") return cont();
+    return pass(statement, block);
+  }
+  function vardef1(type, value) {
+    if (type == "variable"){register(value); return cont(vardef2);}
+    return cont();
+  }
+  function vardef2(type, value) {
+    if (value == "=") return cont(expression, vardef2);
+    if (type == ",") return cont(vardef1);
+  }
+  function forspec1(type) {
+    if (type == "var") return cont(vardef1, forspec2);
+    if (type == ";") return pass(forspec2);
+    if (type == "variable") return cont(formaybein);
+    return pass(forspec2);
+  }
+  function formaybein(type, value) {
+    if (value == "in") return cont(expression);
+    return cont(maybeoperator, forspec2);
+  }
+  function forspec2(type, value) {
+    if (type == ";") return cont(forspec3);
+    if (value == "in") return cont(expression);
+    return cont(expression, expect(";"), forspec3);
+  }
+  function forspec3(type) {
+    if (type != ")") cont(expression);
+  }
+  function functiondef(type, value) {
+    if (type == "variable") {register(value); return cont(functiondef);}
+    if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, statement, popcontext);
+  }
+  function funarg(type, value) {
+    if (type == "variable") {register(value); return cont();}
+  }
+
+  // Interface
+
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: jsTokenBase,
+        reAllowed: true,
+        kwAllowed: true,
+        cc: [],
+        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
+        localVars: parserConfig.localVars,
+        context: parserConfig.localVars && {vars: parserConfig.localVars},
+        indented: 0
+      };
+    },
+
+    token: function(stream, state) {
+      if (stream.sol()) {
+        if (!state.lexical.hasOwnProperty("align"))
+          state.lexical.align = false;
+        state.indented = stream.indentation();
+      }
+      if (stream.eatSpace()) return null;
+      var style = state.tokenize(stream, state);
+      if (type == "comment") return style;
+      state.reAllowed = !!(type == "operator" || type == "keyword c" || type.match(/^[\[{}\(,;:]$/));
+      state.kwAllowed = type != '.';
+      return parseJS(state, style, type, content, stream);
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize != jsTokenBase) return 0;
+      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical,
+          type = lexical.type, closing = firstChar == type;
+      if (type == "vardef") return lexical.indented + 4;
+      else if (type == "form" && firstChar == "{") return lexical.indented;
+      else if (type == "stat" || type == "form") return lexical.indented + indentUnit;
+      else if (lexical.info == "switch" && !closing)
+        return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
+      else if (lexical.align) return lexical.column + (closing ? 0 : 1);
+      else return lexical.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: ":{}"
+  };
+});
+
+CodeMirror.defineMIME("text/javascript", "javascript");
+CodeMirror.defineMIME("application/json", {name: "javascript", json: true});

lms/djangoapps/courseware/access.py

@@ -342,6 +342,27 @@ def _does_course_group_name_exist(name):
     return len(Group.objects.filter(name=name)) > 0
 
 
+def _course_org_staff_group_name(location, course_context=None):
+    """
+    Get the name of the staff group for an organization which corresponds
+    to the organization in the course id.
+
+    location: something that can passed to Location
+    course_context: A course_id that specifies the course run in which
+                    the location occurs.
+                    Required if location doesn't have category 'course'
+
+    """
+    loc = Location(location)
+    if loc.category == 'course':
+        course_id = loc.course_id
+    else:
+        if course_context is None:
+            raise CourseContextRequired()
+        course_id = course_context
+    return 'staff_%s' % course_id.split('/')[0]
+
+
 def _course_staff_group_name(location, course_context=None):
     """
     Get the name of the staff group for a location in the context of a course run.
@@ -382,6 +403,27 @@ def course_beta_test_group_name(location):
 course_beta_test_group_name.__test__ = False
 
 
+def _course_org_instructor_group_name(location, course_context=None):
+    """
+    Get the name of the instructor group for an organization which corresponds
+    to the organization in the course id.
+
+    location: something that can passed to Location
+    course_context: A course_id that specifies the course run in which
+                    the location occurs.
+                    Required if location doesn't have category 'course'
+
+    """
+    loc = Location(location)
+    if loc.category == 'course':
+        course_id = loc.course_id
+    else:
+        if course_context is None:
+            raise CourseContextRequired()
+        course_id = course_context
+    return 'instructor_%s' % course_id.split('/')[0]
+
+
 def _course_instructor_group_name(location, course_context=None):
     """
     Get the name of the instructor group for a location, in the context of a course run.
@@ -499,14 +541,18 @@ def _has_access_to_location(user, location, access_level, course_context):
 
     if access_level == 'staff':
         staff_group = _course_staff_group_name(location, course_context)
-        if staff_group in user_groups:
+        # org_staff_group is a group for an entire organization
+        org_staff_group = _course_org_staff_group_name(location, course_context)
+        if staff_group in user_groups or org_staff_group in user_groups:
             debug("Allow: user in group %s", staff_group)
             return True
         debug("Deny: user not in group %s", staff_group)
 
     if access_level == 'instructor' or access_level == 'staff': 	# instructors get staff privileges
         instructor_group = _course_instructor_group_name(location, course_context)
-        if instructor_group in user_groups:
+        instructor_staff_group = _course_org_instructor_group_name(
+            location, course_context)
+        if instructor_group in user_groups or instructor_staff_group in user_groups:
             debug("Allow: user in group %s", instructor_group)
             return True
         debug("Deny: user not in group %s", instructor_group)

lms/lib/symmath/symmath_check.py

@@ -325,53 +325,3 @@ def symmath_check(expect, ans, dynamath=None, options=None, debug=None, xml=None
         msg += '<hr>'
 
     return {'ok': False, 'msg': msg, 'ex': fexpect, 'got': fsym}
-
-#-----------------------------------------------------------------------------
-# tests
-
-
-def sctest1():
-    x = "1/2*(1+(k_e* Q* q)/(m *g *h^2))"
-    y = '''
-<math xmlns="http://www.w3.org/1998/Math/MathML">
-  <mstyle displaystyle="true">
-    <mfrac>
-      <mn>1</mn>
-      <mn>2</mn>
-    </mfrac>
-    <mrow>
-      <mo>(</mo>
-      <mn>1</mn>
-      <mo>+</mo>
-      <mfrac>
-        <mrow>
-          <msub>
-            <mi>k</mi>
-            <mi>e</mi>
-          </msub>
-          <mo>⋅</mo>
-          <mi>Q</mi>
-          <mo>⋅</mo>
-          <mi>q</mi>
-        </mrow>
-        <mrow>
-          <mi>m</mi>
-          <mo>⋅</mo>
-          <mrow>
-            <mi>g</mi>
-            <mo>⋅</mo>
-          </mrow>
-          <msup>
-            <mi>h</mi>
-            <mn>2</mn>
-          </msup>
-        </mrow>
-      </mfrac>
-      <mo>)</mo>
-    </mrow>
-  </mstyle>
-</math>
-'''.strip()
-    z = "1/2(1+(k_e* Q* q)/(m *g *h^2))"
-    r = sympy_check2(x, z, {'a': z, 'a_fromjs': y}, 'a')
-    return r

lms/lib/symmath/test_symmath_check.py

@@ -10,6 +10,64 @@ class SymmathCheckTest(TestCase):
         number_list = [i + 0.01 for i in range(-100, 100)]
         self._symmath_check_numbers(number_list)
 
+    def test_symmath_check_same_symbols(self):
+        expected_str = "x+2*y"
+        dynamath = '''
+<math xmlns="http://www.w3.org/1998/Math/MathML">
+  <mstyle displaystyle="true">
+  <mrow>
+    <mi>x</mi>
+    <mo>+</mo>
+    <mn>2</mn>
+    <mo>*</mo>
+    <mi>y</mi>
+  </mrow>
+</mstyle>
+</math>'''.strip()
+
+        # Expect that the exact same symbolic string is marked correct
+        result = symmath_check(expected_str, expected_str, dynamath=[dynamath])
+        self.assertTrue('ok' in result and result['ok'])
+
+    def test_symmath_check_equivalent_symbols(self):
+        expected_str = "x+2*y"
+        input_str = "x+y+y"
+        dynamath = '''
+<math xmlns="http://www.w3.org/1998/Math/MathML">
+  <mstyle displaystyle="true">
+  <mrow>
+    <mi>x</mi>
+    <mo>+</mo>
+    <mi>y</mi>
+    <mo>+</mo>
+    <mi>y</mi>
+  </mrow>
+</mstyle>
+</math>'''.strip()
+
+        # Expect that equivalent symbolic strings are marked correct
+        result = symmath_check(expected_str, input_str, dynamath=[dynamath])
+        self.assertTrue('ok' in result and result['ok'])
+
+    def test_symmath_check_different_symbols(self):
+        expected_str = "0"
+        input_str = "x+y"
+        dynamath = '''
+<math xmlns="http://www.w3.org/1998/Math/MathML">
+  <mstyle displaystyle="true">
+  <mrow>
+    <mi>x</mi>
+    <mo>+</mo>
+    <mi>y</mi>
+  </mrow>
+</mstyle>
+</math>'''.strip()
+
+        # Expect that an incorrect response is marked incorrect
+        result = symmath_check(expected_str, input_str, dynamath=[dynamath])
+        self.assertTrue('ok' in result and not result['ok'])
+        self.assertFalse('fail' in result['msg'])
+
     def _symmath_check_numbers(self, number_list):
 
         for n in number_list:

lms/templates/static_pdfbook.html

@@ -90,41 +90,40 @@
           </div>
         </div>
 
-%if 'chapters' in textbook:
-    <section aria-label="Textbook Navigation" class="book-sidebar">
-
-      <ul id="booknav" class="treeview-booknav">
-          <%def name="print_entry(entry, index_value)">
-              <li id="pdfchapter-${index_value}">
-                <a class="chapter">
-                  ${entry.get('title')}
-                </a>
-              </li>
-          </%def>
+        %if 'chapters' in textbook:
+	<section aria-label="Textbook Navigation" class="book-sidebar">
+	  <ul id="booknav" class="treeview-booknav">
+	      <%def name="print_entry(entry, index_value)">
+		  <li id="pdfchapter-${index_value}">
+		    <a class="chapter">
+		      ${entry.get('title')}
+		    </a>
+		  </li>
+	      </%def>
 
-          % for (index, entry) in enumerate(textbook['chapters']):
-            ${print_entry(entry, index+1)}
-          % endfor
-      </ul>
-    </section>
-%endif
+	      % for (index, entry) in enumerate(textbook['chapters']):
+		${print_entry(entry, index+1)}
+	      % endfor
+	  </ul>
+	</section>
+        %endif
 
         <section id="viewerContainer" class="book">
-	  <!-- use same page-turning as used in image-based textbooks -->
-          <nav>
-            <ul>
-              <li class="last">
-                <a id="previous">Previous page</a>
-              </li>
-              <li class="next">
-                <a id="next">Next page</a>
-              </li>
-            </ul>
-          </nav>
-
-          <div id="viewer" contextmenu="viewerContextMenu"></div>
-        </div>
-
+	  <section class="page">
+	    <!-- use same page-turning as used in image-based textbooks -->
+            <nav>
+              <ul>
+                <li class="last">
+                  <a id="previous">Previous page</a>
+                </li>
+                <li class="next">
+                  <a id="next">Next page</a>
+                </li>
+              </ul>
+            </nav>
+            <div id="viewer" contextmenu="viewerContextMenu"></div>
+          </section>
+        </section>
 
       </div> <!-- mainContainer -->