Merge branch 'feature/ned/sandboxed-python'

.gitignore

@@ -9,7 +9,7 @@
 :2e#
 .AppleDouble
 database.sqlite
-private-requirements.txt
+requirements/private.txt
 courseware/static/js/mathjax/*
 flushdb.sh
 build

common/djangoapps/util/views.py

@@ -16,7 +16,7 @@ from mitxmako.shortcuts import render_to_response, render_to_string
 from urllib import urlencode
 import zendesk
 
-import capa.calc
+import calc
 import track.views
 
 
@@ -27,7 +27,7 @@ def calculate(request):
     ''' Calculator in footer of every page. '''
     equation = request.GET['equation']
     try:
-        result = capa.calc.evaluator({}, {}, equation)
+        result = calc.evaluator({}, {}, equation)
     except:
         event = {'error': map(str, sys.exc_info()),
                  'equation': equation}

common/lib/calc/setup.py

+from setuptools import setup
+
+setup(
+    name="calc",
+    version="0.1",
+    py_modules=["calc"],
+    install_requires=[
+        "pyparsing==1.5.6",
+        "numpy",
+        "scipy"
+    ],
+)

common/lib/capa/capa/capa_problem.py

@@ -13,33 +13,19 @@ Main module which shows problems (of "capa" type).
 This is used by capa_module.
 '''
 
-from __future__ import division
-
 from datetime import datetime
 import logging
 import math
 import numpy
-import os
-import random
+import os.path
 import re
-import scipy
-import struct
 import sys
 
 from lxml import etree
 from xml.sax.saxutils import unescape
 from copy import deepcopy
 
-import chem
-import chem.miller
-import chem.chemcalc
-import chem.chemtools
-import verifiers
-import verifiers.draganddrop
-
-import calc
 from .correctmap import CorrectMap
-import eia
 import inputtypes
 import customrender
 from .util import contextualize_text, convert_files_to_filenames
@@ -47,6 +33,7 @@ import xqueue_interface
 
 # to be replaced with auto-registering
 import responsetypes
+import safe_exec
 
 # dict of tagname, Response Class -- this should come from auto-registering
 response_tag_dict = dict([(x.response_tag, x) for x in responsetypes.__all__])
@@ -63,17 +50,6 @@ html_transforms = {'problem': {'tag': 'div'},
                    "math": {'tag': 'span'},
                    }
 
-global_context = {'random': random,
-                  'numpy': numpy,
-                  'math': math,
-                  'scipy': scipy,
-                  'calc': calc,
-                  'eia': eia,
-                  'chemcalc': chem.chemcalc,
-                  'chemtools': chem.chemtools,
-                  'miller': chem.miller,
-                  'draganddrop': verifiers.draganddrop}
-
 # These should be removed from HTML output, including all subelements
 html_problem_semantics = ["codeparam", "responseparam", "answer", "script", "hintgroup", "openendedparam", "openendedrubric"]
 
@@ -96,7 +72,7 @@ class LoncapaProblem(object):
 
          - problem_text (string): xml defining the problem
          - id           (string): identifier for this problem; often a filename (no spaces)
-         - seed         (int): random number generator seed (int) 
+         - seed         (int): random number generator seed (int)
          - state        (dict): containing the following keys:
                                 - 'seed' - (int) random number generator seed
                                 - 'student_answers' - (dict) maps input id to the stored answer for that input
@@ -115,23 +91,20 @@ class LoncapaProblem(object):
         if self.system is None:
             raise Exception()
 
-        state = state if state else {}
+        state = state or {}
 
         # Set seed according to the following priority:
         #       1. Contained in problem's state
         #       2. Passed into capa_problem via constructor
-        #       3. Assign from the OS's random number generator
         self.seed = state.get('seed', seed)
-        if self.seed is None:
-            self.seed = struct.unpack('i', os.urandom(4))[0]
+        assert self.seed is not None, "Seed must be provided for LoncapaProblem."
+
         self.student_answers = state.get('student_answers', {})
         if 'correct_map' in state:
             self.correct_map.set_dict(state['correct_map'])
         self.done = state.get('done', False)
         self.input_state = state.get('input_state', {})
 
-
-
         # Convert startouttext and endouttext to proper <text></text>
         problem_text = re.sub("startouttext\s*/", "text", problem_text)
         problem_text = re.sub("endouttext\s*/", "/text", problem_text)
@@ -144,7 +117,7 @@ class LoncapaProblem(object):
         self._process_includes()
 
         # construct script processor context (eg for customresponse problems)
-        self.context = self._extract_context(self.tree, seed=self.seed)
+        self.context = self._extract_context(self.tree)
 
         # Pre-parse the XML tree: modifies it to add ID's and perform some in-place
         # transformations.  This also creates the dict (self.responders) of Response
@@ -440,18 +413,23 @@ class LoncapaProblem(object):
         path = []
 
         for dir in raw_path:
-
             if not dir:
                 continue
 
             # path is an absolute path or a path relative to the data dir
             dir = os.path.join(self.system.filestore.root_path, dir)
+            # Check that we are within the filestore tree.
+            reldir = os.path.relpath(dir, self.system.filestore.root_path)
+            if ".." in reldir:
+                log.warning("Ignoring Python directory outside of course: %r" % dir)
+                continue
+
             abs_dir = os.path.normpath(dir)
             path.append(abs_dir)
 
         return path
 
-    def _extract_context(self, tree, seed=struct.unpack('i', os.urandom(4))[0]):  # private
+    def _extract_context(self, tree):
         '''
         Extract content of <script>...</script> from the problem.xml file, and exec it in the
         context of this problem.  Provides ability to randomize problems, and also set
@@ -459,55 +437,47 @@ class LoncapaProblem(object):
 
         Problem XML goes to Python execution context. Runs everything in script tags.
         '''
-        random.seed(self.seed)
-        # save global context in here also
-        context = {'global_context': global_context}
+        context = {}
+        context['seed'] = self.seed
+        all_code = ''
 
-        # initialize context to have stuff in global_context
-        context.update(global_context)
+        python_path = []
 
-        # put globals there also
-        context['__builtins__'] = globals()['__builtins__']
-
-        # pass instance of LoncapaProblem in
-        context['the_lcp'] = self
-        context['script_code'] = ''
-
-        self._execute_scripts(tree.findall('.//script'), context)
-
-        return context
-
-    def _execute_scripts(self, scripts, context):
-        '''
-        Executes scripts in the given context.
-        '''
-        original_path = sys.path
-
-        for script in scripts:
-            sys.path = original_path + self._extract_system_path(script)
+        for script in tree.findall('.//script'):
 
             stype = script.get('type')
-
             if stype:
                 if 'javascript' in stype:
                     continue    # skip javascript
                 if 'perl' in stype:
                     continue        # skip perl
             # TODO: evaluate only python
-            code = script.text
+
+            for d in self._extract_system_path(script):
+                if d not in python_path and os.path.exists(d):
+                    python_path.append(d)
+
             XMLESC = {"&apos;": "'", "&quot;": '"'}
-            code = unescape(code, XMLESC)
-            # store code source in context
-            context['script_code'] += code
+            code = unescape(script.text, XMLESC)
+            all_code += code
+
+        if all_code:
             try:
-                # use "context" for global context; thus defs in code are global within code
-                exec code in context, context
+                safe_exec.safe_exec(
+                    all_code,
+                    context,
+                    random_seed=self.seed,
+                    python_path=python_path,
+                    cache=self.system.cache,
+                )
             except Exception as err:
-                log.exception("Error while execing script code: " + code)
+                log.exception("Error while execing script code: " + all_code)
                 msg = "Error while executing script code: %s" % str(err).replace('<', '&lt;')
                 raise responsetypes.LoncapaProblemError(msg)
-            finally:
-                sys.path = original_path
+
+        # store code source in context
+        context['script_code'] = all_code
+        return context
 
 
 

common/lib/capa/capa/inputtypes.py

@@ -46,7 +46,7 @@ import sys
 import pyparsing
 
 from .registry import TagRegistry
-from capa.chem import chemcalc
+from chem import chemcalc
 import xqueue_interface
 from datetime import datetime
 

common/lib/capa/capa/safe_exec/README.rst

+Configuring Capa sandboxed execution
+====================================
+
+Capa problems can contain code authored by the course author.  We need to
+execute that code in a sandbox.  We use CodeJail as the sandboxing facility,
+but it needs to be configured specifically for Capa's use.
+
+As a developer, you don't have to do anything to configure sandboxing if you
+don't want to, and everything will operate properly, you just won't have
+protection on that code.
+
+If you want to configure sandboxing, you're going to use the `README from
+CodeJail`__, with a few customized tweaks.
+
+__ https://github.com/edx/codejail/blob/master/README.rst
+
+
+1. At the instruction to install packages into the sandboxed code, you'll 
+   need to install both `pre-sandbox-requirements.txt` and 
+   `sandbox-requirements.txt`::
+
+    $ sudo pip install -r pre-sandbox-requirements.txt
+    $ sudo pip install -r sandbox-requirements.txt
+
+2. At the instruction to create the AppArmor profile, you'll need a line in
+   the profile for the sandbox packages.  <EDXPLATFORM> is the full path to
+   your edx_platform repo::
+
+    <EDXPLATFORM>/common/lib/sandbox-packages/** r,
+
+3. You can configure resource limits in settings.py.  A CODE_JAIL setting is
+   available, a dictionary.  The "limits" key lets you adjust the limits for
+   CPU time, real time, and memory use.  Setting any of them to zero disables
+   that limit::
+
+    # in settings.py...
+    CODE_JAIL = {
+        # Configurable limits.
+        'limits': {
+            # How many CPU seconds can jailed code use?
+            'CPU': 1,
+            # How many real-time seconds will a sandbox survive?
+            'REALTIME': 1,
+            # How much memory (in bytes) can a sandbox use?
+            'VMEM': 30000000,
+        },
+    }
+
+
+That's it.  Once you've finished the CodeJail configuration instructions,
+your course-hosted Python code should be run securely.

common/lib/capa/capa/safe_exec/__init__.py

+"""Capa's specialized use of codejail.safe_exec."""
+
+from .safe_exec import safe_exec, update_hash

common/lib/capa/capa/safe_exec/lazymod.py

+"""A module proxy for delayed importing of modules.
+
+From http://barnesc.blogspot.com/2006/06/automatic-python-imports-with-autoimp.html,
+in the public domain.
+
+"""
+
+import sys
+
+class LazyModule(object):
+    """A lazy module proxy."""
+
+    def __init__(self, modname):
+        self.__dict__['__name__'] = modname
+        self._set_mod(None)
+
+    def _set_mod(self, mod):
+        if mod is not None:
+            self.__dict__ = mod.__dict__
+        self.__dict__['_lazymod_mod'] = mod
+
+    def _load_mod(self):
+        __import__(self.__name__)
+        self._set_mod(sys.modules[self.__name__])
+
+    def __getattr__(self, name):
+        if self.__dict__['_lazymod_mod'] is None:
+            self._load_mod()
+
+        mod = self.__dict__['_lazymod_mod']
+
+        if hasattr(mod, name):
+            return getattr(mod, name)
+        else:
+            try:
+                subname = '%s.%s' % (self.__name__, name)
+                __import__(subname)
+                submod = getattr(mod, name)
+            except ImportError:
+                raise AttributeError("'module' object has no attribute %r" % name)
+            self.__dict__[name] = LazyModule(subname, submod)
+            return self.__dict__[name]

common/lib/capa/capa/safe_exec/safe_exec.py

+"""Capa's specialized use of codejail.safe_exec."""
+
+from codejail.safe_exec import safe_exec as codejail_safe_exec
+from codejail.safe_exec import json_safe, SafeExecException
+from . import lazymod
+from statsd import statsd
+
+import hashlib
+
+# Establish the Python environment for Capa.
+# Capa assumes float-friendly division always.
+# The name "random" is a properly-seeded stand-in for the random module.
+CODE_PROLOG = """\
+from __future__ import division
+
+import random as random_module
+import sys
+random = random_module.Random(%r)
+random.Random = random_module.Random
+del random_module
+sys.modules['random'] = random
+"""
+
+ASSUMED_IMPORTS=[
+    ("numpy", "numpy"),
+    ("math", "math"),
+    ("scipy", "scipy"),
+    ("calc", "calc"),
+    ("eia", "eia"),
+    ("chemcalc", "chem.chemcalc"),
+    ("chemtools", "chem.chemtools"),
+    ("miller", "chem.miller"),
+    ("draganddrop", "verifiers.draganddrop"),
+]
+
+# We'll need the code from lazymod.py for use in safe_exec, so read it now.
+lazymod_py_file = lazymod.__file__
+if lazymod_py_file.endswith("c"):
+    lazymod_py_file = lazymod_py_file[:-1]
+
+lazymod_py = open(lazymod_py_file).read()
+
+LAZY_IMPORTS = [lazymod_py]
+for name, modname in ASSUMED_IMPORTS:
+    LAZY_IMPORTS.append("{} = LazyModule('{}')\n".format(name, modname))
+
+LAZY_IMPORTS = "".join(LAZY_IMPORTS)
+
+
+def update_hash(hasher, obj):
+    """
+    Update a `hashlib` hasher with a nested object.
+
+    To properly cache nested structures, we need to compute a hash from the
+    entire structure, canonicalizing at every level.
+
+    `hasher`'s `.update()` method is called a number of times, touching all of
+    `obj` in the process.  Only primitive JSON-safe types are supported.
+
+    """
+    hasher.update(str(type(obj)))
+    if isinstance(obj, (tuple, list)):
+        for e in obj:
+            update_hash(hasher, e)
+    elif isinstance(obj, dict):
+        for k in sorted(obj):
+            update_hash(hasher, k)
+            update_hash(hasher, obj[k])
+    else:
+        hasher.update(repr(obj))
+
+
+@statsd.timed('capa.safe_exec.time')
+def safe_exec(code, globals_dict, random_seed=None, python_path=None, cache=None):
+    """
+    Execute python code safely.
+
+    `code` is the Python code to execute.  It has access to the globals in `globals_dict`,
+    and any changes it makes to those globals are visible in `globals_dict` when this
+    function returns.
+
+    `random_seed` will be used to see the `random` module available to the code.
+
+    `python_path` is a list of directories to add to the Python path before execution.
+
+    `cache` is an object with .get(key) and .set(key, value) methods.  It will be used
+    to cache the execution, taking into account the code, the values of the globals,
+    and the random seed.
+
+    """
+    # Check the cache for a previous result.
+    if cache:
+        safe_globals = json_safe(globals_dict)
+        md5er = hashlib.md5()
+        md5er.update(repr(code))
+        update_hash(md5er, safe_globals)
+        key = "safe_exec.%r.%s" % (random_seed, md5er.hexdigest())
+        cached = cache.get(key)
+        if cached is not None:
+            # We have a cached result.  The result is a pair: the exception
+            # message, if any, else None; and the resulting globals dictionary.
+            emsg, cleaned_results = cached
+            globals_dict.update(cleaned_results)
+            if emsg:
+                raise SafeExecException(emsg)
+            return
+
+    # Create the complete code we'll run.
+    code_prolog = CODE_PROLOG % random_seed
+
+    # Run the code!  Results are side effects in globals_dict.
+    try:
+        codejail_safe_exec(
+            code_prolog + LAZY_IMPORTS + code, globals_dict,
+            python_path=python_path,
+        )
+    except SafeExecException as e:
+        emsg = e.message
+    else:
+        emsg = None
+
+    # Put the result back in the cache.  This is complicated by the fact that
+    # the globals dict might not be entirely serializable.
+    if cache:
+        cleaned_results = json_safe(globals_dict)
+        cache.set(key, (emsg, cleaned_results))
+
+    # If an exception happened, raise it now.
+    if emsg:
+        raise e

common/lib/capa/capa/safe_exec/tests/test_files/pylib/constant.py

+THE_CONST = 23

common/lib/capa/capa/safe_exec/tests/test_lazymod.py

+"""Test lazymod.py"""
+
+import sys
+import unittest
+
+from capa.safe_exec.lazymod import LazyModule
+
+
+class ModuleIsolation(object):
+    """
+    Manage changes to sys.modules so that we can roll back imported modules.
+
+    Create this object, it will snapshot the currently imported modules. When
+    you call `clean_up()`, it will delete any module imported since its creation.
+    """
+    def __init__(self):
+        # Save all the names of all the imported modules.
+        self.mods = set(sys.modules)
+
+    def clean_up(self):
+        # Get a list of modules that didn't exist when we were created
+        new_mods = [m for m in sys.modules if m not in self.mods]
+        # and delete them all so another import will run code for real again.
+        for m in new_mods:
+            del sys.modules[m]
+
+
+class TestLazyMod(unittest.TestCase):
+
+    def setUp(self):
+        # Each test will remove modules that it imported.
+        self.addCleanup(ModuleIsolation().clean_up)
+
+    def test_simple(self):
+        # Import some stdlib module that has not been imported before
+        self.assertNotIn("colorsys", sys.modules)
+        colorsys = LazyModule("colorsys")
+        hsv = colorsys.rgb_to_hsv(.3, .4, .2)
+        self.assertEqual(hsv[0], 0.25)
+
+    def test_dotted(self):
+        self.assertNotIn("email.utils", sys.modules)
+        email_utils = LazyModule("email.utils")
+        self.assertEqual(email_utils.quote('"hi"'), r'\"hi\"')

common/lib/capa/capa/safe_exec/tests/test_safe_exec.py

+"""Test safe_exec.py"""
+
+import hashlib
+import os.path
+import random
+import textwrap
+import unittest
+
+from capa.safe_exec import safe_exec, update_hash
+from codejail.safe_exec import SafeExecException
+
+
+class TestSafeExec(unittest.TestCase):
+    def test_set_values(self):
+        g = {}
+        safe_exec("a = 17", g)
+        self.assertEqual(g['a'], 17)
+
+    def test_division(self):
+        g = {}
+        # Future division: 1/2 is 0.5.
+        safe_exec("a = 1/2", g)
+        self.assertEqual(g['a'], 0.5)
+
+    def test_assumed_imports(self):
+        g = {}
+        # Math is always available.
+        safe_exec("a = int(math.pi)", g)
+        self.assertEqual(g['a'], 3)
+
+    def test_random_seeding(self):
+        g = {}
+        r = random.Random(17)
+        rnums = [r.randint(0, 999) for _ in xrange(100)]
+
+        # Without a seed, the results are unpredictable
+        safe_exec("rnums = [random.randint(0, 999) for _ in xrange(100)]", g)
+        self.assertNotEqual(g['rnums'], rnums)
+
+        # With a seed, the results are predictable
+        safe_exec("rnums = [random.randint(0, 999) for _ in xrange(100)]", g, random_seed=17)
+        self.assertEqual(g['rnums'], rnums)
+
+    def test_random_is_still_importable(self):
+        g = {}
+        r = random.Random(17)
+        rnums = [r.randint(0, 999) for _ in xrange(100)]
+
+        # With a seed, the results are predictable even from the random module
+        safe_exec(
+            "import random\n"
+            "rnums = [random.randint(0, 999) for _ in xrange(100)]\n",
+            g, random_seed=17)
+        self.assertEqual(g['rnums'], rnums)
+
+    def test_python_lib(self):
+        pylib = os.path.dirname(__file__) + "/test_files/pylib"
+        g = {}
+        safe_exec(
+            "import constant; a = constant.THE_CONST",
+            g, python_path=[pylib]
+        )
+
+    def test_raising_exceptions(self):
+        g = {}
+        with self.assertRaises(SafeExecException) as cm:
+            safe_exec("1/0", g)
+        self.assertIn("ZeroDivisionError", cm.exception.message)
+
+
+class DictCache(object):
+    """A cache implementation over a simple dict, for testing."""
+
+    def __init__(self, d):
+        self.cache = d
+
+    def get(self, key):
+        # Actual cache implementations have limits on key length
+        assert len(key) <= 250
+        return self.cache.get(key)
+
+    def set(self, key, value):
+        # Actual cache implementations have limits on key length
+        assert len(key) <= 250
+        self.cache[key] = value
+
+
+class TestSafeExecCaching(unittest.TestCase):
+    """Test that caching works on safe_exec."""
+
+    def test_cache_miss_then_hit(self):
+        g = {}
+        cache = {}
+
+        # Cache miss
+        safe_exec("a = int(math.pi)", g, cache=DictCache(cache))
+        self.assertEqual(g['a'], 3)
+        # A result has been cached
+        self.assertEqual(cache.values()[0], (None, {'a': 3}))
+
+        # Fiddle with the cache, then try it again.
+        cache[cache.keys()[0]] = (None, {'a': 17})
+
+        g = {}
+        safe_exec("a = int(math.pi)", g, cache=DictCache(cache))
+        self.assertEqual(g['a'], 17)
+
+    def test_cache_large_code_chunk(self):
+        # Caching used to die on memcache with more than 250 bytes of code.
+        # Check that it doesn't any more.
+        code = "a = 0\n" + ("a += 1\n" * 12345)
+
+        g = {}
+        cache = {}
+        safe_exec(code, g, cache=DictCache(cache))
+        self.assertEqual(g['a'], 12345)
+
+    def test_cache_exceptions(self):
+        # Used to be that running code that raised an exception didn't cache
+        # the result.  Check that now it does.
+        code = "1/0"
+        g = {}
+        cache = {}
+        with self.assertRaises(SafeExecException):
+            safe_exec(code, g, cache=DictCache(cache))
+
+        # The exception should be in the cache now.
+        self.assertEqual(len(cache), 1)
+        cache_exc_msg, cache_globals = cache.values()[0]
+        self.assertIn("ZeroDivisionError", cache_exc_msg)
+
+        # Change the value stored in the cache, the result should change.
+        cache[cache.keys()[0]] = ("Hey there!", {})
+
+        with self.assertRaises(SafeExecException):
+            safe_exec(code, g, cache=DictCache(cache))
+
+        self.assertEqual(len(cache), 1)
+        cache_exc_msg, cache_globals = cache.values()[0]
+        self.assertEqual("Hey there!", cache_exc_msg)
+
+        # Change it again, now no exception!
+        cache[cache.keys()[0]] = (None, {'a': 17})
+        safe_exec(code, g, cache=DictCache(cache))
+        self.assertEqual(g['a'], 17)
+
+    def test_unicode_submission(self):
+        # Check that using non-ASCII unicode does not raise an encoding error.
+        # Try several non-ASCII unicode characters
+        for code in [129, 500, 2**8 - 1, 2**16 - 1]:
+            code_with_unichr = unicode("# ") + unichr(code)
+            try:
+                safe_exec(code_with_unichr, {}, cache=DictCache({}))
+            except UnicodeEncodeError:
+                self.fail("Tried executing code with non-ASCII unicode: {0}".format(code))
+
+
+class TestUpdateHash(unittest.TestCase):
+    """Test the safe_exec.update_hash function to be sure it canonicalizes properly."""
+
+    def hash_obj(self, obj):
+        """Return the md5 hash that `update_hash` makes us."""
+        md5er = hashlib.md5()
+        update_hash(md5er, obj)
+        return md5er.hexdigest()
+
+    def equal_but_different_dicts(self):
+        """
+        Make two equal dicts with different key order.
+
+        Simple literals won't do it.  Filling one and then shrinking it will
+        make them different.
+
+        """
+        d1 = {k:1 for k in "abcdefghijklmnopqrstuvwxyz"}
+        d2 = dict(d1)
+        for i in xrange(10000):
+            d2[i] = 1
+        for i in xrange(10000):
+            del d2[i]
+
+        # Check that our dicts are equal, but with different key order.
+        self.assertEqual(d1, d2)
+        self.assertNotEqual(d1.keys(), d2.keys())
+
+        return d1, d2
+
+    def test_simple_cases(self):
+        h1 = self.hash_obj(1)
+        h10 = self.hash_obj(10)
+        hs1 = self.hash_obj("1")
+
+        self.assertNotEqual(h1, h10)
+        self.assertNotEqual(h1, hs1)
+
+    def test_list_ordering(self):
+        h1 = self.hash_obj({'a': [1,2,3]})
+        h2 = self.hash_obj({'a': [3,2,1]})
+        self.assertNotEqual(h1, h2)
+
+    def test_dict_ordering(self):
+        d1, d2 = self.equal_but_different_dicts()
+        h1 = self.hash_obj(d1)
+        h2 = self.hash_obj(d2)
+        self.assertEqual(h1, h2)
+
+    def test_deep_ordering(self):
+        d1, d2 = self.equal_but_different_dicts()
+        o1 = {'a':[1, 2, [d1], 3, 4]}
+        o2 = {'a':[1, 2, [d2], 3, 4]}
+        h1 = self.hash_obj(o1)
+        h2 = self.hash_obj(o2)
+        self.assertEqual(h1, h2)
+
+
+class TestRealProblems(unittest.TestCase):
+    def test_802x(self):
+        code = textwrap.dedent("""\
+            import math
+            import random
+            import numpy
+            e=1.602e-19 #C
+            me=9.1e-31  #kg
+            mp=1.672e-27 #kg
+            eps0=8.854e-12 #SI units
+            mu0=4e-7*math.pi #SI units
+
+            Rd1=random.randrange(1,30,1)
+            Rd2=random.randrange(30,50,1)
+            Rd3=random.randrange(50,70,1)
+            Rd4=random.randrange(70,100,1)
+            Rd5=random.randrange(100,120,1)
+
+            Vd1=random.randrange(1,20,1)
+            Vd2=random.randrange(20,40,1)
+            Vd3=random.randrange(40,60,1)
+
+            #R=[0,10,30,50,70,100] #Ohm
+            #V=[0,12,24,36] # Volt
+
+            R=[0,Rd1,Rd2,Rd3,Rd4,Rd5] #Ohms
+            V=[0,Vd1,Vd2,Vd3] #Volts
+            #here the currents IL and IR are defined as in figure ps3_p3_fig2
+            a=numpy.array([  [  R[1]+R[4]+R[5],R[4] ],[R[4], R[2]+R[3]+R[4] ] ])
+            b=numpy.array([V[1]-V[2],-V[3]-V[2]])
+            x=numpy.linalg.solve(a,b)
+            IL='%.2e' % x[0]
+            IR='%.2e' % x[1]
+            ILR='%.2e' % (x[0]+x[1])
+            def sign(x):
+                return abs(x)/x
+
+            RW="Rightwards"
+            LW="Leftwards"
+            UW="Upwards"
+            DW="Downwards"
+            I1='%.2e' % abs(x[0])
+            I1d=LW if sign(x[0])==1 else RW
+            I1not=LW if I1d==RW else RW
+            I2='%.2e' % abs(x[1])
+            I2d=RW if sign(x[1])==1 else LW
+            I2not=LW if I2d==RW else RW
+            I3='%.2e' % abs(x[1])
+            I3d=DW if sign(x[1])==1 else UW
+            I3not=DW if I3d==UW else UW
+            I4='%.2e' % abs(x[0]+x[1])
+            I4d=UW if sign(x[1]+x[0])==1 else DW
+            I4not=DW if I4d==UW else UW
+            I5='%.2e' % abs(x[0])
+            I5d=RW if sign(x[0])==1 else LW
+            I5not=LW if I5d==RW else RW
+            VAP=-x[0]*R[1]-(x[0]+x[1])*R[4]
+            VPN=-V[2]
+            VGD=+V[1]-x[0]*R[1]+V[3]+x[1]*R[2]
+            aVAP='%.2e' % VAP
+            aVPN='%.2e' % VPN
+            aVGD='%.2e' % VGD
+            """)
+        g = {}
+        safe_exec(code, g)
+        self.assertIn("aVAP", g)

common/lib/capa/capa/tests/__init__.py

-import fs
 import fs.osfs
-import os
+import os, os.path
 
+from capa.capa_problem import LoncapaProblem
 from mock import Mock, MagicMock
 
 import xml.sax.saxutils as saxutils
@@ -22,16 +22,28 @@ def calledback_url(dispatch = 'score_update'):
 xqueue_interface = MagicMock()
 xqueue_interface.send_to_queue.return_value = (0, 'Success!')
 
-test_system = Mock(
-    ajax_url='courses/course_id/modx/a_location',
-    track_function=Mock(),
-    get_module=Mock(),
-    render_template=tst_render_template,
-    replace_urls=Mock(),
-    user=Mock(),
-    filestore=fs.osfs.OSFS(os.path.join(TEST_DIR, "test_files")),
-    debug=True,
-    xqueue={'interface': xqueue_interface, 'construct_callback': calledback_url, 'default_queuename': 'testqueue', 'waittime': 10},
-    node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
-    anonymous_student_id='student'
-)
+def test_system():
+    """
+    Construct a mock ModuleSystem instance.
+
+    """
+    the_system = Mock(
+        ajax_url='courses/course_id/modx/a_location',
+        track_function=Mock(),
+        get_module=Mock(),
+        render_template=tst_render_template,
+        replace_urls=Mock(),
+        user=Mock(),
+        filestore=fs.osfs.OSFS(os.path.join(TEST_DIR, "test_files")),
+        debug=True,
+        xqueue={'interface': xqueue_interface, 'construct_callback': calledback_url, 'default_queuename': 'testqueue', 'waittime': 10},
+        node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
+        anonymous_student_id='student',
+        cache=None,
+        can_execute_unsafe_code=lambda: False,
+    )
+    return the_system
+
+def new_loncapa_problem(xml, system=None):
+    """Construct a `LoncapaProblem` suitable for unit tests."""
+    return LoncapaProblem(xml, id='1', seed=723, system=system or test_system())

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

@@ -221,6 +221,8 @@ class CustomResponseXMLFactory(ResponseXMLFactory):
         cfn = kwargs.get('cfn', None)
         expect = kwargs.get('expect', None)
         answer = kwargs.get('answer', None)
+        options = kwargs.get('options', None)
+        cfn_extra_args = kwargs.get('cfn_extra_args', None)
 
         # Create the response element
         response_element = etree.Element("customresponse")
@@ -235,6 +237,33 @@ class CustomResponseXMLFactory(ResponseXMLFactory):
             answer_element = etree.SubElement(response_element, "answer")
             answer_element.text = str(answer)
 
+        if options:
+            response_element.set('options', str(options))
+
+        if cfn_extra_args:
+            response_element.set('cfn_extra_args', str(cfn_extra_args))
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        return ResponseXMLFactory.textline_input_xml(**kwargs)
+
+
+class SymbolicResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for creating <symbolicresponse> XML trees """
+
+    def create_response_element(self, **kwargs):
+        cfn = kwargs.get('cfn', None)
+        answer = kwargs.get('answer', None)
+        options = kwargs.get('options', None)
+
+        response_element = etree.Element("symbolicresponse")
+        if cfn:
+            response_element.set('cfn', str(cfn))
+        if answer:
+            response_element.set('answer', str(answer))
+        if options:
+            response_element.set('options', str(options))
         return response_element
 
     def create_input_element(self, **kwargs):
@@ -638,12 +667,16 @@ class StringResponseXMLFactory(ResponseXMLFactory):
                 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.
+
+            *hintfn*: The name of a function in the script to use for hints.
+
         """
         # Retrieve the **kwargs
         answer = kwargs.get("answer", None)
         case_sensitive = kwargs.get("case_sensitive", True)
         hint_list = kwargs.get('hints', None)
-        assert(answer)
+        hint_fn = kwargs.get('hintfn', None)
+        assert answer
 
         # Create the <stringresponse> element
         response_element = etree.Element("stringresponse")
@@ -655,18 +688,24 @@ class StringResponseXMLFactory(ResponseXMLFactory):
         response_element.set("type", "cs" if case_sensitive else "ci")
 
         # Add the hints if specified
-        if hint_list:
+        if hint_list or hint_fn:
             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))
+            if hint_list:
+                assert not hint_fn
+                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))
+                    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)
 
-                hint_text_element = etree.SubElement(hintpart_element, "text")
-                hint_text_element.text = str(hint_text)
+            if hint_fn:
+                assert not hint_list
+                hintgroup_element.set("hintfn", hint_fn)
 
         return response_element
 
@@ -705,3 +744,38 @@ class AnnotationResponseXMLFactory(ResponseXMLFactory):
             option_element.text = description
 
         return input_element
+
+
+class SymbolicResponseXMLFactory(ResponseXMLFactory):
+    """ Factory for producing <symbolicresponse> xml """
+
+    def create_response_element(self, **kwargs):
+        """ Build the <symbolicresponse> XML element.
+
+        Uses **kwargs:
+
+        *expect*: The correct answer (a sympy string)
+
+        *options*: list of option strings to pass to symmath_check
+            (e.g. 'matrix', 'qbit', 'imaginary', 'numerical')"""
+
+        # Retrieve **kwargs
+        expect = kwargs.get('expect', '')
+        options = kwargs.get('options', [])
+
+        # Symmath check expects a string of options
+        options_str = ",".join(options)
+
+        # Construct the <symbolicresponse> element
+        response_element = etree.Element('symbolicresponse')
+
+        if expect:
+            response_element.set('expect', str(expect))
+
+        if options_str:
+            response_element.set('options', str(options_str))
+
+        return response_element
+
+    def create_input_element(self, **kwargs):
+        return ResponseXMLFactory.textline_input_xml(**kwargs)

common/lib/capa/capa/tests/test_customrender.py

@@ -26,7 +26,7 @@ class HelperTest(unittest.TestCase):
     Make sure that our helper function works!
     '''
     def check(self, d):
-        xml = etree.XML(test_system.render_template('blah', d))
+        xml = etree.XML(test_system().render_template('blah', d))
         self.assertEqual(d, extract_context(xml))
 
     def test_extract_context(self):
@@ -46,11 +46,11 @@ class SolutionRenderTest(unittest.TestCase):
         xml_str = """<solution id="solution_12">{s}</solution>""".format(s=solution)
         element = etree.fromstring(xml_str)
 
-        renderer = lookup_tag('solution')(test_system, element)
+        renderer = lookup_tag('solution')(test_system(), element)
 
         self.assertEqual(renderer.id, 'solution_12')
 
-        # our test_system "renders" templates to a div with the repr of the context
+        # Our test_system "renders" templates to a div with the repr of the context.
         xml = renderer.get_html()
         context = extract_context(xml)
         self.assertEqual(context, {'id': 'solution_12'})
@@ -65,7 +65,7 @@ class MathRenderTest(unittest.TestCase):
         xml_str = """<math>{tex}</math>""".format(tex=latex_in)
         element = etree.fromstring(xml_str)
 
-        renderer = lookup_tag('math')(test_system, element)
+        renderer = lookup_tag('math')(test_system(), element)
 
         self.assertEqual(renderer.mathstr, mathjax_out)
 

common/lib/capa/capa/tests/test_html_render.py

@@ -6,12 +6,15 @@ import json
 
 import mock
 
-from capa.capa_problem import LoncapaProblem
 from .response_xml_factory import StringResponseXMLFactory, CustomResponseXMLFactory
-from . import test_system
+from . import test_system, new_loncapa_problem
 
 class CapaHtmlRenderTest(unittest.TestCase):
 
+    def setUp(self):
+        super(CapaHtmlRenderTest, self).setUp()
+        self.system = test_system()
+
     def test_blank_problem(self):
         """
         It's important that blank problems don't break, since that's
@@ -20,7 +23,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         xml_str = "<problem> </problem>"
 
         # Create the problem
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str)
 
         # Render the HTML
         rendered_html = etree.XML(problem.get_html())
@@ -39,7 +42,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         """)
 
         # Create the problem
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str, system=self.system)
 
         # Render the HTML
         rendered_html = etree.XML(problem.get_html())
@@ -49,9 +52,6 @@ class CapaHtmlRenderTest(unittest.TestCase):
         self.assertEqual(test_element.tag, "test")
         self.assertEqual(test_element.text, "Test include")
 
-
-
-
     def test_process_outtext(self):
         # Generate some XML with <startouttext /> and <endouttext />
         xml_str = textwrap.dedent("""
@@ -61,7 +61,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         """)
 
         # Create the problem
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str)
 
         # Render the HTML
         rendered_html = etree.XML(problem.get_html())
@@ -80,7 +80,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         """)
 
         # Create the problem
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str)
 
         # Render the HTML
         rendered_html = etree.XML(problem.get_html())
@@ -98,7 +98,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         """)
 
         # Create the problem
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str)
 
         # Render the HTML
         rendered_html = etree.XML(problem.get_html())
@@ -117,11 +117,12 @@ class CapaHtmlRenderTest(unittest.TestCase):
         xml_str = StringResponseXMLFactory().build_xml(**kwargs)
 
         # Mock out the template renderer
-        test_system.render_template = mock.Mock()
-        test_system.render_template.return_value = "<div>Input Template Render</div>"
+        the_system = test_system()
+        the_system.render_template = mock.Mock()
+        the_system.render_template.return_value = "<div>Input Template Render</div>"
 
         # Create the problem and render the HTML
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str, system=the_system)
         rendered_html = etree.XML(problem.get_html())
 
         # Expect problem has been turned into a <div>
@@ -166,7 +167,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
                 mock.call('textline.html', expected_textline_context),
                 mock.call('solutionspan.html', expected_solution_context)]
 
-        self.assertEqual(test_system.render_template.call_args_list,
+        self.assertEqual(the_system.render_template.call_args_list,
                             expected_calls)
 
 
@@ -184,7 +185,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         xml_str = CustomResponseXMLFactory().build_xml(**kwargs)
 
         # Create the problem and render the html
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str)
 
         # Grade the problem
         correctmap = problem.grade_answers({'1_2_1': 'test'})
@@ -219,7 +220,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         """)
 
         # Create the problem and render the HTML
-        problem = LoncapaProblem(xml_str, '1', system=test_system)
+        problem = new_loncapa_problem(xml_str)
         rendered_html = etree.XML(problem.get_html())
 
         # Expect that the variable $test has been replaced with its value
@@ -227,7 +228,7 @@ class CapaHtmlRenderTest(unittest.TestCase):
         self.assertEqual(span_element.get('attr'), "TEST")
 
     def _create_test_file(self, path, content_str):
-        test_fp = test_system.filestore.open(path, "w")
+        test_fp = self.system.filestore.open(path, "w")
         test_fp.write(content_str)
         test_fp.close()
 

common/lib/capa/capa/tests/test_inputtypes.py

@@ -45,7 +45,7 @@ class OptionInputTest(unittest.TestCase):
         state = {'value': 'Down',
                  'id': 'sky_input',
                  'status': 'answered'}
-        option_input = lookup_tag('optioninput')(test_system, element, state)
+        option_input = lookup_tag('optioninput')(test_system(), element, state)
 
         context = option_input._get_render_context()
 
@@ -92,7 +92,7 @@ class ChoiceGroupTest(unittest.TestCase):
                  'id': 'sky_input',
                  'status': 'answered'}
 
-        the_input = lookup_tag(tag)(test_system, element, state)
+        the_input = lookup_tag(tag)(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -142,7 +142,7 @@ class JavascriptInputTest(unittest.TestCase):
         element = etree.fromstring(xml_str)
 
         state = {'value': '3', }
-        the_input = lookup_tag('javascriptinput')(test_system, element, state)
+        the_input = lookup_tag('javascriptinput')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -170,7 +170,7 @@ class TextLineTest(unittest.TestCase):
         element = etree.fromstring(xml_str)
 
         state = {'value': 'BumbleBee', }
-        the_input = lookup_tag('textline')(test_system, element, state)
+        the_input = lookup_tag('textline')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -198,7 +198,7 @@ class TextLineTest(unittest.TestCase):
         element = etree.fromstring(xml_str)
 
         state = {'value': 'BumbleBee', }
-        the_input = lookup_tag('textline')(test_system, element, state)
+        the_input = lookup_tag('textline')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -236,7 +236,7 @@ class TextLineTest(unittest.TestCase):
             element = etree.fromstring(xml_str)
 
             state = {'value': 'BumbleBee', }
-            the_input = lookup_tag('textline')(test_system, element, state)
+            the_input = lookup_tag('textline')(test_system(), element, state)
 
             context = the_input._get_render_context()
 
@@ -274,7 +274,7 @@ class FileSubmissionTest(unittest.TestCase):
                  'status': 'incomplete',
                  'feedback': {'message': '3'}, }
         input_class = lookup_tag('filesubmission')
-        the_input = input_class(test_system, element, state)
+        the_input = input_class(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -319,7 +319,7 @@ class CodeInputTest(unittest.TestCase):
                  'feedback': {'message': '3'}, }
 
         input_class = lookup_tag('codeinput')
-        the_input = input_class(test_system, element, state)
+        the_input = input_class(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -368,7 +368,7 @@ class MatlabTest(unittest.TestCase):
                  'feedback': {'message': '3'}, }
 
         self.input_class = lookup_tag('matlabinput')
-        self.the_input = self.input_class(test_system, elt, state)
+        self.the_input = self.input_class(test_system(), elt, state)
 
     def test_rendering(self):
         context = self.the_input._get_render_context()
@@ -396,7 +396,7 @@ class MatlabTest(unittest.TestCase):
                  'feedback': {'message': '3'}, }
         elt = etree.fromstring(self.xml)
 
-        the_input = self.input_class(test_system, elt, state)
+        the_input = self.input_class(test_system(), elt, state)
         context = the_input._get_render_context()
 
         expected = {'id': 'prob_1_2',
@@ -423,7 +423,7 @@ class MatlabTest(unittest.TestCase):
                      }
             elt = etree.fromstring(self.xml)
 
-            the_input = self.input_class(test_system, elt, state)
+            the_input = self.input_class(test_system(), elt, state)
             context = the_input._get_render_context()
             expected = {'id': 'prob_1_2',
                         'value': 'print "good evening"',
@@ -448,7 +448,7 @@ class MatlabTest(unittest.TestCase):
                  }
         elt = etree.fromstring(self.xml)
 
-        the_input = self.input_class(test_system, elt, state)
+        the_input = self.input_class(test_system(), elt, state)
         context = the_input._get_render_context()
         expected = {'id': 'prob_1_2',
                     'value': 'print "good evening"',
@@ -470,7 +470,7 @@ class MatlabTest(unittest.TestCase):
         get = {'submission': 'x = 1234;'}
         response = self.the_input.handle_ajax("plot", get)
 
-        test_system.xqueue['interface'].send_to_queue.assert_called_with(header=ANY, body=ANY)
+        test_system().xqueue['interface'].send_to_queue.assert_called_with(header=ANY, body=ANY)
 
         self.assertTrue(response['success'])
         self.assertTrue(self.the_input.input_state['queuekey'] is not None)
@@ -479,13 +479,12 @@ class MatlabTest(unittest.TestCase):
     def test_plot_data_failure(self):
         get = {'submission': 'x = 1234;'}
         error_message = 'Error message!'
-        test_system.xqueue['interface'].send_to_queue.return_value = (1, error_message)
+        test_system().xqueue['interface'].send_to_queue.return_value = (1, error_message)
         response = self.the_input.handle_ajax("plot", get)
         self.assertFalse(response['success'])
         self.assertEqual(response['message'], error_message)
         self.assertTrue('queuekey' not in self.the_input.input_state)
         self.assertTrue('queuestate' not in self.the_input.input_state)
-        test_system.xqueue['interface'].send_to_queue.return_value = (0, 'Success!')
 
     def test_ungraded_response_success(self):
         queuekey = 'abcd'
@@ -496,7 +495,7 @@ class MatlabTest(unittest.TestCase):
                  'feedback': {'message': '3'}, }
         elt = etree.fromstring(self.xml)
 
-        the_input = self.input_class(test_system, elt, state)
+        the_input = self.input_class(test_system(), elt, state)
         inner_msg = 'hello!'
         queue_msg = json.dumps({'msg': inner_msg})
 
@@ -514,7 +513,7 @@ class MatlabTest(unittest.TestCase):
                  'feedback': {'message': '3'}, }
         elt = etree.fromstring(self.xml)
 
-        the_input = self.input_class(test_system, elt, state)
+        the_input = self.input_class(test_system(), elt, state)
         inner_msg = 'hello!'
         queue_msg = json.dumps({'msg': inner_msg})
 
@@ -553,7 +552,7 @@ class SchematicTest(unittest.TestCase):
         state = {'value': value,
                  'status': 'unsubmitted'}
 
-        the_input = lookup_tag('schematic')(test_system, element, state)
+        the_input = lookup_tag('schematic')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -592,7 +591,7 @@ class ImageInputTest(unittest.TestCase):
         state = {'value': value,
                  'status': 'unsubmitted'}
 
-        the_input = lookup_tag('imageinput')(test_system, element, state)
+        the_input = lookup_tag('imageinput')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -643,7 +642,7 @@ class CrystallographyTest(unittest.TestCase):
         state = {'value': value,
                  'status': 'unsubmitted'}
 
-        the_input = lookup_tag('crystallography')(test_system, element, state)
+        the_input = lookup_tag('crystallography')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -681,7 +680,7 @@ class VseprTest(unittest.TestCase):
         state = {'value': value,
                  'status': 'unsubmitted'}
 
-        the_input = lookup_tag('vsepr_input')(test_system, element, state)
+        the_input = lookup_tag('vsepr_input')(test_system(), element, state)
 
         context = the_input._get_render_context()
 
@@ -708,7 +707,7 @@ class ChemicalEquationTest(unittest.TestCase):
         element = etree.fromstring(xml_str)
 
         state = {'value': 'H2OYeah', }
-        self.the_input = lookup_tag('chemicalequationinput')(test_system, element, state)
+        self.the_input = lookup_tag('chemicalequationinput')(test_system(), element, state)
 
     def test_rendering(self):
         ''' Verify that the render context matches the expected render context'''
@@ -783,7 +782,7 @@ class DragAndDropTest(unittest.TestCase):
                                     ]
                     }
 
-        the_input = lookup_tag('drag_and_drop_input')(test_system, element, state)
+        the_input = lookup_tag('drag_and_drop_input')(test_system(), element, state)
 
         context = the_input._get_render_context()
         expected = {'id': 'prob_1_2',
@@ -832,7 +831,7 @@ class AnnotationInputTest(unittest.TestCase):
 
         tag = 'annotationinput'
 
-        the_input = lookup_tag(tag)(test_system, element, state)
+        the_input = lookup_tag(tag)(test_system(), element, state)
 
         context = the_input._get_render_context()
 

common/lib/capa/capa/util.py

-from .calc import evaluator, UndefinedVariable
+from calc import evaluator, UndefinedVariable
 from cmath import isinf
 
 #-----------------------------------------------------------------------------

common/lib/capa/setup.py

@@ -4,5 +4,5 @@ setup(
     name="capa",
     version="0.1",
     packages=find_packages(exclude=["tests"]),
-    install_requires=['distribute==0.6.28', 'pyparsing==1.5.6'],
+    install_requires=["distribute==0.6.28"],
 )

lms/lib/symmath/formula.py → common/lib/capa/symmath/formula.py

@@ -736,4 +736,4 @@ def test6():		# imaginary numbers
   </mstyle>
 </math>
 '''
-    return formula(xmlstr, options='imaginaryi')
+    return formula(xmlstr, options='imaginary')

lms/lib/symmath/symmath_check.py → common/lib/capa/symmath/symmath_check.py

@@ -324,4 +324,5 @@ def symmath_check(expect, ans, dynamath=None, options=None, debug=None, xml=None
             msg += "<p>Difference: %s</p>" % to_latex(diff)
         msg += '<hr>'
 
-    return {'ok': False, 'msg': msg, 'ex': fexpect, 'got': fsym}
+    # Used to return more keys: 'ex': fexpect, 'got': fsym
+    return {'ok': False, 'msg': msg}

common/lib/chem/setup.py

+from setuptools import setup
+
+setup(
+    name="chem",
+    version="0.1",
+    packages=["chem"],
+    install_requires=[
+        "pyparsing==1.5.6",
+        "numpy",
+        "scipy",
+        "nltk==2.0.4",
+    ],
+)

common/lib/sandbox-packages/README

+This directory is in the Python path for sandboxed Python execution.

common/lib/sandbox-packages/setup.py

+from setuptools import setup
+
+setup(
+    name="sandbox-packages",
+    version="0.1",
+    packages=[
+        "verifiers",
+    ],
+    py_modules=[
+        "eia",
+    ],
+    install_requires=[
+    ],
+)

common/lib/xmodule/test_files/symbolicresponse.xml

@@ -13,13 +13,10 @@ real time, next to the input box.
 <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">
+       [mathjax]U=[/mathjax] <symbolicresponse cfn="symmath_check" answer="[[cos(theta),i*sin(theta)],[i*sin(theta),cos(theta)]]" options="matrix,imaginary" id="filenamedogi0VpEBOWedxsymmathresponse_1" state="unsubmitted">
           <textline size="80" math="1" response_id="2" answer_id="1" id="filenamedogi0VpEBOWedxsymmathresponse_2_1"/>
         </symbolicresponse>
       <br/>

common/lib/xmodule/xmodule/capa_module.py

@@ -3,7 +3,9 @@ import datetime
 import hashlib
 import json
 import logging
+import os
 import traceback
+import struct
 import sys
 
 from pkg_resources import resource_string
@@ -23,8 +25,10 @@ from xmodule.util.date_utils import time_to_datetime
 log = logging.getLogger("mitx.courseware")
 
 
-# Generated this many different variants of problems with rerandomize=per_student
+# Generate this many different variants of problems with rerandomize=per_student
 NUM_RANDOMIZATION_BINS = 20
+# Never produce more than this many different seeds, no matter what.
+MAX_RANDOMIZATION_BINS = 1000
 
 
 def randomization_bin(seed, problem_id):
@@ -109,11 +113,7 @@ class CapaModule(CapaFields, XModule):
             self.close_date = due_date
 
         if self.seed is None:
-            if self.rerandomize == 'never':
-                self.seed = 1
-            elif self.rerandomize == "per_student" and hasattr(self.system, 'seed'):
-                # see comment on randomization_bin
-                self.seed = randomization_bin(system.seed, self.location.url)
+            self.choose_new_seed()
 
         # Need the problem location in openendedresponse to send out.  Adding
         # it to the system here seems like the least clunky way to get it
@@ -157,6 +157,22 @@ class CapaModule(CapaFields, XModule):
 
             self.set_state_from_lcp()
 
+        assert self.seed is not None
+
+    def choose_new_seed(self):
+        """Choose a new seed."""
+        if self.rerandomize == 'never':
+            self.seed = 1
+        elif self.rerandomize == "per_student" and hasattr(self.system, 'seed'):
+            # see comment on randomization_bin
+            self.seed = randomization_bin(self.system.seed, self.location.url)
+        else:
+            self.seed = struct.unpack('i', os.urandom(4))[0]
+
+            # So that sandboxed code execution can be cached, but still have an interesting
+            # number of possibilities, cap the number of different random seeds.
+            self.seed %= MAX_RANDOMIZATION_BINS
+
     def new_lcp(self, state, text=None):
         if text is None:
             text = self.data
@@ -165,6 +181,7 @@ class CapaModule(CapaFields, XModule):
             problem_text=text,
             id=self.location.html_id(),
             state=state,
+            seed=self.seed,
             system=self.system,
         )
 
@@ -832,14 +849,11 @@ class CapaModule(CapaFields, XModule):
                     'error': "Refresh the page and make an attempt before resetting."}
 
         if self.rerandomize in ["always", "onreset"]:
-            # reset random number generator seed (note the self.lcp.get_state()
-            # in next line)
-            seed = None
-        else:
-            seed = self.lcp.seed
+            # Reset random number generator seed.
+            self.choose_new_seed()
 
         # Generate a new problem with either the previous seed or a new seed
-        self.lcp = self.new_lcp({'seed': seed})
+        self.lcp = self.new_lcp(None)
 
         # Pull in the new problem seed
         self.set_state_from_lcp()

common/lib/xmodule/xmodule/tests/__init__.py

@@ -14,7 +14,7 @@ import fs.osfs
 
 import numpy
 
-import capa.calc as calc
+import calc
 import xmodule
 from xmodule.x_module import ModuleSystem
 from mock import Mock
@@ -33,15 +33,14 @@ def test_system():
     """
     Construct a test ModuleSystem instance.
 
-    By default, the render_template() method simply returns
-    the context it is passed as a string.
-    You can override this behavior by monkey patching:
+    By default, the render_template() method simply returns the context it is
+    passed as a string.  You can override this behavior by monkey patching::
 
-    system = test_system()
-    system.render_template = my_render_func
+        system = test_system()
+        system.render_template = my_render_func
+
+    where `my_render_func` is a function of the form my_render_func(template, context).
 
-    where my_render_func is a function of the form
-    my_render_func(template, context)
     """
     return ModuleSystem(
         ajax_url='courses/course_id/modx/a_location',
@@ -86,10 +85,12 @@ class ModelsTest(unittest.TestCase):
         self.assertTrue(abs(calc.evaluator(variables, functions, "e^(j*pi)") + 1) < 0.00001)
         self.assertTrue(abs(calc.evaluator(variables, functions, "j||1") - 0.5 - 0.5j) < 0.00001)
         variables['t'] = 1.0
+        # Use self.assertAlmostEqual here...
         self.assertTrue(abs(calc.evaluator(variables, functions, "t") - 1.0) < 0.00001)
         self.assertTrue(abs(calc.evaluator(variables, functions, "T") - 1.0) < 0.00001)
         self.assertTrue(abs(calc.evaluator(variables, functions, "t", cs=True) - 1.0) < 0.00001)
         self.assertTrue(abs(calc.evaluator(variables, functions, "T", cs=True) - 298) < 0.2)
+        # Use self.assertRaises here...
         exception_happened = False
         try:
             calc.evaluator({}, {}, "5+7 QWSEKO")

common/lib/xmodule/xmodule/tests/test_capa_module.py

@@ -550,6 +550,7 @@ class CapaModuleTest(unittest.TestCase):
     def test_reset_problem(self):
         module = CapaFactory.create(done=True)
         module.new_lcp = Mock(wraps=module.new_lcp)
+        module.choose_new_seed = Mock(wraps=module.choose_new_seed)
 
         # Stub out HTML rendering
         with patch('xmodule.capa_module.CapaModule.get_problem_html') as mock_html:
@@ -567,7 +568,8 @@ class CapaModuleTest(unittest.TestCase):
         self.assertEqual(result['html'], "<div>Test HTML</div>")
 
         # Expect that the problem was reset
-        module.new_lcp.assert_called_once_with({'seed': None})
+        module.new_lcp.assert_called_once_with(None)
+        module.choose_new_seed.assert_called_once_with()
 
     def test_reset_problem_closed(self):
         module = CapaFactory.create()
@@ -1033,3 +1035,13 @@ class CapaModuleTest(unittest.TestCase):
                 self.assertTrue(module.seed is not None)
                 msg = 'Could not get a new seed from reset after 5 tries'
                 self.assertTrue(success, msg)
+
+    def test_random_seed_bins(self):
+        # Assert that we are limiting the number of possible seeds.
+
+        # Check the conditions that generate random seeds
+        for rerandomize in ['always', 'per_student', 'true', 'onreset']:
+            # Get a bunch of seeds, they should all be in 0-999.
+            for i in range(200):
+                module = CapaFactory.create(rerandomize=rerandomize)
+                assert 0 <= module.seed < 1000

common/lib/xmodule/xmodule/tests/test_progress.py

@@ -134,6 +134,6 @@ class ModuleProgressTest(unittest.TestCase):
     '''
     def test_xmodule_default(self):
         '''Make sure default get_progress exists, returns None'''
-        xm = x_module.XModule(test_system, 'a://b/c/d/e', None, {})
+        xm = x_module.XModule(test_system(), 'a://b/c/d/e', None, {})
         p = xm.get_progress()
         self.assertEqual(p, None)

common/lib/xmodule/xmodule/tests/test_randomize_module.py

@@ -14,7 +14,6 @@ START = '2013-01-01T01:00:00'
 
 
 from .test_course_module import DummySystem as DummyImportSystem
-from . import test_system
 
 
 class RandomizeModuleTestCase(unittest.TestCase):

common/lib/xmodule/xmodule/x_module.py

@@ -737,7 +737,10 @@ class ModuleSystem(object):
                  anonymous_student_id='',
                  course_id=None,
                  open_ended_grading_interface=None,
-                 s3_interface=None):
+                 s3_interface=None,
+                 cache=None,
+                 can_execute_unsafe_code=None,
+                ):
         '''
         Create a closure around the system environment.
 
@@ -779,6 +782,14 @@ class ModuleSystem(object):
 
         xblock_model_data - A dict-like object containing the all data available to this
             xblock
+
+        cache - A cache object with two methods:
+            .get(key) returns an object from the cache or None.
+            .set(key, value, timeout_secs=None) stores a value in the cache with a timeout.
+
+        can_execute_unsafe_code - A function returning a boolean, whether or
+            not to allow the execution of unsafe, unsandboxed code.
+
         '''
         self.ajax_url = ajax_url
         self.xqueue = xqueue
@@ -803,6 +814,9 @@ class ModuleSystem(object):
         self.open_ended_grading_interface = open_ended_grading_interface
         self.s3_interface = s3_interface
 
+        self.cache = cache or DoNothingCache()
+        self.can_execute_unsafe_code = can_execute_unsafe_code or (lambda: False)
+
     def get(self, attr):
         '''	provide uniform access to attributes (like etree).'''
         return self.__dict__.get(attr)
@@ -816,3 +830,12 @@ class ModuleSystem(object):
 
     def __str__(self):
         return str(self.__dict__)
+
+
+class DoNothingCache(object):
+    """A duck-compatible object to use in ModuleSystem when there's no cache."""
+    def get(self, key):
+        return None
+
+    def set(self, key, value, timeout=None):
+        pass

common/test/data/embedded_python/course.xml

+<course org="edX" course="embedded_python" url_name="2013_Spring"/>

common/test/data/embedded_python/course/2013_Spring.xml

+<course>
+  <chapter url_name="EmbeddedPythonChapter">
+
+    <vertical url_name="Homework1">
+      <problem url_name="schematic_problem">
+          <schematicresponse>
+            <center>
+                <schematic height="500" width="600" parts="g,n,s" analyses="dc,tran"
+                    submit_analyses="{&quot;tran&quot;:[[&quot;Z&quot;,0.0000004,0.0000009,0.0000014,0.0000019,0.0000024,0.0000029,0.0000034,0.000039]]}" 
+                    initial_value="[[&quot;w&quot;,[112,96,128,96]],[&quot;w&quot;,[256,96,240,96]],[&quot;w&quot;,[192,96,240,96]],[&quot;s&quot;,[240,96,0],{&quot;color&quot;:&quot;cyan&quot;,&quot;offset&quot;:&quot;&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:3},[&quot;Z&quot;]],[&quot;w&quot;,[32,224,192,224]],[&quot;w&quot;,[96,48,192,48]],[&quot;L&quot;,[256,96,3],{&quot;label&quot;:&quot;Z&quot;,&quot;_json_&quot;:6},[&quot;Z&quot;]],[&quot;r&quot;,[192,48,0],{&quot;name&quot;:&quot;Rpullup&quot;,&quot;r&quot;:&quot;10K&quot;,&quot;_json_&quot;:7},[&quot;1&quot;,&quot;Z&quot;]],[&quot;w&quot;,[32,144,32,192]],[&quot;w&quot;,[32,224,32,192]],[&quot;w&quot;,[48,192,32,192]],[&quot;w&quot;,[32,96,32,144]],[&quot;w&quot;,[48,144,32,144]],[&quot;w&quot;,[32,48,32,96]],[&quot;w&quot;,[48,96,32,96]],[&quot;w&quot;,[32,48,48,48]],[&quot;g&quot;,[32,224,0],{&quot;_json_&quot;:16},[&quot;0&quot;]],[&quot;v&quot;,[96,192,1],{&quot;name&quot;:&quot;VC&quot;,&quot;value&quot;:&quot;square(3,0,250K)&quot;,&quot;_json_&quot;:17},[&quot;C&quot;,&quot;0&quot;]],[&quot;v&quot;,[96,144,1],{&quot;name&quot;:&quot;VB&quot;,&quot;value&quot;:&quot;square(3,0,500K)&quot;,&quot;_json_&quot;:18},[&quot;B&quot;,&quot;0&quot;]],[&quot;v&quot;,[96,96,1],{&quot;name&quot;:&quot;VA&quot;,&quot;value&quot;:&quot;square(3,0,1000K)&quot;,&quot;_json_&quot;:19},[&quot;A&quot;,&quot;0&quot;]],[&quot;v&quot;,[96,48,1],{&quot;name&quot;:&quot;Vpwr&quot;,&quot;value&quot;:&quot;dc(3)&quot;,&quot;_json_&quot;:20},[&quot;1&quot;,&quot;0&quot;]],[&quot;L&quot;,[96,96,2],{&quot;label&quot;:&quot;A&quot;,&quot;_json_&quot;:21},[&quot;A&quot;]],[&quot;w&quot;,[96,96,104,96]],[&quot;L&quot;,[96,144,2],{&quot;label&quot;:&quot;B&quot;,&quot;_json_&quot;:23},[&quot;B&quot;]],[&quot;w&quot;,[96,144,104,144]],[&quot;L&quot;,[96,192,2],{&quot;label&quot;:&quot;C&quot;,&quot;_json_&quot;:25},[&quot;C&quot;]],[&quot;w&quot;,[96,192,104,192]],[&quot;w&quot;,[192,96,192,112]],[&quot;s&quot;,[112,96,0],{&quot;color&quot;:&quot;red&quot;,&quot;offset&quot;:&quot;15&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:28},[&quot;A&quot;]],[&quot;w&quot;,[104,96,112,96]],[&quot;s&quot;,[112,144,0],{&quot;color&quot;:&quot;green&quot;,&quot;offset&quot;:&quot;10&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:30},[&quot;B&quot;]],[&quot;w&quot;,[104,144,112,144]],[&quot;w&quot;,[128,144,112,144]],[&quot;s&quot;,[112,192,0],{&quot;color&quot;:&quot;blue&quot;,&quot;offset&quot;:&quot;5&quot;,&quot;plot offset&quot;:&quot;0&quot;,&quot;_json_&quot;:33},[&quot;C&quot;]],[&quot;w&quot;,[104,192,112,192]],[&quot;w&quot;,[128,192,112,192]],[&quot;view&quot;,0,0,2,&quot;5&quot;,&quot;10&quot;,&quot;10MEG&quot;,null,&quot;100&quot;,&quot;4us&quot;]]"
+                    />
+            </center>
+            <answer type="loncapa/python">
+# for a schematic response, submission[i] is the json representation
+# of the diagram and analysis results for the i-th schematic tag
+
+def get_tran(json,signal):
+  for element in json:
+    if element[0] == 'transient':
+      return element[1].get(signal,[])
+  return []
+
+def get_value(at,output):
+  for (t,v) in output:
+    if at == t: return v
+  return None
+
+output = get_tran(submission[0],'Z')
+okay = True
+
+# output should be 1, 1, 1, 1, 1, 0, 0, 0
+if get_value(0.0000004,output) &lt; 2.7: okay = False;
+if get_value(0.0000009,output) &lt; 2.7: okay = False;
+if get_value(0.0000014,output) &lt; 2.7: okay = False;
+if get_value(0.0000019,output) &lt; 2.7: okay = False;
+if get_value(0.0000024,output) &lt; 2.7: okay = False;
+if get_value(0.0000029,output) &gt; 0.25: okay = False;
+if get_value(0.0000034,output) &gt; 0.25: okay = False;
+if get_value(0.0000039,output) &gt; 0.25: okay = False;
+
+correct = ['correct' if okay else 'incorrect']
+
+</answer></schematicresponse>
+
+
+
+
+      </problem>
+
+
+
+<problem url_name="cfn_problem">
+  <text>
+    <script type="text/python" system_path="python_lib">
+def test_csv(expect, ans):
+   # Take out all spaces in expected answer
+   expect = [i.strip(' ') for i in str(expect).split(',')]
+   # Take out all spaces in student solution
+   ans = [i.strip(' ') for i in str(ans).split(',')]
+
+   def strip_q(x):
+      # Strip quotes around strings if students have entered them
+      stripped_ans = []
+      for item in x:
+         if item[0] == "'" and item[-1]=="'":
+            item = item.strip("'")
+         elif item[0] == '"' and item[-1] == '"':
+            item = item.strip('"')
+         stripped_ans.append(item)
+      return stripped_ans
+
+   return strip_q(expect) == strip_q(ans)
+</script>
+    <ol class="enumerate">
+      <li>
+        <pre>
+num = 0
+while num &lt;= 5:
+    print(num)
+    num += 1
+
+print("Outside of loop")
+print(num)
+ </pre>
+        <p>
+          <customresponse cfn="test_csv" expect="0, 1, 2, 3, 4, 5, 'Outside of loop', 6">
+            <textline size="50" correct_answer="0, 1, 2, 3, 4, 5, 'Outside of loop', 6"/>
+          </customresponse>
+        </p>
+      </li>
+    </ol>
+  </text>
+</problem>
+
+<problem url_name="computed_answer">
+
+  <customresponse>
+    <textline size="5" correct_answer="Xyzzy"/>
+    <answer type="loncapa/python">
+if submission[0] == "Xyzzy":
+    correct = ['correct']
+else:
+    correct = ['incorrect']
+    </answer>
+  </customresponse>
+
+</problem>
+
+    </vertical>
+  </chapter>
+</course>

common/test/data/embedded_python/roots/2013_Spring.xml

+<course org="edX" course="embedded_python" url_name="2013_Spring"/>

common/test/data/full/problem/test_files/symbolicresponse.xml

@@ -19,7 +19,7 @@ from symmath import *
   <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">
+       [mathjax]U=[/mathjax] <symbolicresponse cfn="symmath_check" answer="[[cos(theta),i*sin(theta)],[i*sin(theta),cos(theta)]]" options="matrix,imaginary" id="filenamedogi0VpEBOWedxsymmathresponse_1" state="unsubmitted">
           <textline size="80" math="1" response_id="2" answer_id="1" id="filenamedogi0VpEBOWedxsymmathresponse_2_1"/>
         </symbolicresponse>
       <br/>

lms/djangoapps/courseware/module_render.py

 import json
 import logging
 import pyparsing
+import re
 import sys
 import static_replace
 
@@ -8,6 +9,7 @@ from functools import partial
 
 from django.conf import settings
 from django.contrib.auth.models import User
+from django.core.cache import cache
 from django.core.exceptions import PermissionDenied
 from django.core.urlresolvers import reverse
 from django.http import Http404
@@ -273,6 +275,14 @@ def get_module_for_descriptor(user, request, descriptor, model_data_cache, cours
 
         statsd.increment("lms.courseware.question_answered", tags=tags)
 
+    def can_execute_unsafe_code():
+        # To decide if we can run unsafe code, we check the course id against
+        # a list of regexes configured on the server.
+        for regex in settings.COURSES_WITH_UNSAFE_CODE:
+            if re.match(regex, course_id):
+                return True
+        return False
+
     # TODO (cpennington): When modules are shared between courses, the static
     # prefix is going to have to be specific to the module, not the directory
     # that the xml was loaded from
@@ -299,6 +309,8 @@ def get_module_for_descriptor(user, request, descriptor, model_data_cache, cours
                           course_id=course_id,
                           open_ended_grading_interface=open_ended_grading_interface,
                           s3_interface=s3_interface,
+                          cache=cache,
+                          can_execute_unsafe_code=can_execute_unsafe_code,
                           )
     # pass position specified in URL to module through ModuleSystem
     system.set('position', position)

lms/djangoapps/courseware/tests/load_tests/README.md

+# Load Testing
+
+Scripts for load testing the courseware app, 
+mostly using [multimechanize](http://testutils.org/multi-mechanize/)

lms/djangoapps/courseware/tests/load_tests/custom_response/README.md

+# Custom Response Load Test
+
+## Optional Installations
+
+* [memcached](http://pypi.python.org/pypi/python-memcached/): Install this 
+and make sure it is running, or the Capa problem will not cache results.
+
+* [AppArmor](http://wiki.apparmor.net): Follow the instructions in
+`common/lib/codejail/README` to set up the Python sandbox environment.
+If you do not set up the sandbox, the tests will still execute code in the CustomResponse,
+so you can still run the tests.
+
+* [matplotlib](http://matplotlib.org): Multi-mechanize uses this to create graphs.
+
+
+## Running the Tests
+
+This test simulates student submissions for a custom response problem.
+
+First, clear the cache:
+
+   /etc/init.d/memcached restart 
+
+Then, run the test:
+
+    multimech-run custom_response
+
+You can configure the parameters in `customresponse/config.cfg`,
+and you can change the CustomResponse script and student submissions
+in `customresponse/test_scripts/v_user.py`.
+
+## Components Under Test
+
+Components under test:
+
+* Python sandbox (see `common/lib/codejail`), which uses `AppArmor`
+* Caching (see `common/lib/capa/capa/safe_exec/`), which uses `memcache` in production
+
+Components NOT under test:
+
+* Django views
+* `XModule`
+* gunicorn
+
+This allows us to avoid creating courses in mongo, logging in, using CSRF tokens,
+and other inconveniences.  Instead, we create a capa problem (from the capa package),
+pass it Django's memcache backend, and pass the problem student submissions.
+
+Even though the test uses `capa.capa_problem.LoncapaProblem` directly,
+the `capa` should not depend on Django.  For this reason, we put the
+test in the `courseware` Django app.

lms/djangoapps/courseware/tests/load_tests/custom_response/config.cfg

+
+[global]
+run_time = 240
+rampup = 30
+results_ts_interval = 10
+progress_bar = on
+console_logging = off
+xml_report = off
+
+
+[user_group-1]
+threads = 10
+script = v_user.py
+
+[user_group-2]
+threads = 10
+script = v_user.py
+
+[user_group-3]
+threads = 10
+script = v_user.py
+

lms/djangoapps/courseware/tests/load_tests/custom_response/test_scripts/v_user.py

+""" User script for load testing CustomResponse """
+
+from capa.tests.response_xml_factory import CustomResponseXMLFactory
+import capa.capa_problem as lcp
+from xmodule.x_module import ModuleSystem
+import mock
+import fs.osfs
+import random
+import textwrap
+
+# Use memcache running locally
+CACHE_SETTINGS = {
+    'default': {
+        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
+        'LOCATION': '127.0.0.1:11211'
+    },
+}
+
+# Configure settings so Django will let us import its cache wrapper
+# Caching is the only part of Django being tested
+from django.conf import settings 
+settings.configure(CACHES=CACHE_SETTINGS)
+
+from django.core.cache import cache
+
+# Script to install as the checker for the CustomResponse
+TEST_SCRIPT = textwrap.dedent("""
+        def check_func(expect, answer_given):
+            return {'ok': answer_given == expect, 'msg': 'Message text'}
+""")
+
+# Submissions submitted by the student
+TEST_SUBMISSIONS = [random.randint(-100, 100) for i in range(100)]
+
+class TestContext(object):
+    """ One-time set up for the test that is shared across transactions.
+    Uses a Singleton design pattern."""
+
+    SINGLETON = None
+    NUM_UNIQUE_SEEDS = 20
+
+    @classmethod
+    def singleton(cls):
+        """ Return the singleton, creating one if it does not already exist."""
+
+        # If we haven't created the singleton yet, create it now
+        if cls.SINGLETON is None:
+
+            # Create a mock ModuleSystem, installing our cache
+            system = mock.MagicMock(ModuleSystem)
+            system.render_template = lambda template, context: "<div>%s</div>" % template
+            system.cache = cache
+            system.filestore = mock.MagicMock(fs.osfs.OSFS)
+            system.filestore.root_path = ""
+            system.DEBUG = True
+
+            # Create a custom response problem
+            xml_factory = CustomResponseXMLFactory()
+            xml = xml_factory.build_xml(script=TEST_SCRIPT, cfn="check_func", expect="42")
+
+            # Create and store the context
+            cls.SINGLETON = cls(system, xml)
+
+        else:
+            pass
+
+        # Return the singleton
+        return cls.SINGLETON
+
+    def __init__(self, system, xml):
+        """ Store context needed for the test across transactions """
+        self.system = system
+        self.xml = xml
+
+        # Construct a small pool of unique seeds
+        # To keep our implementation in line with the one capa actually uses,
+        # construct the problems, then use the seeds they generate
+        self.seeds = [lcp.LoncapaProblem(self.xml, 'problem_id', system=self.system).seed
+                      for i in range(self.NUM_UNIQUE_SEEDS)]
+
+    def random_seed(self):
+        """ Return one of a small number of unique random seeds """
+        return random.choice(self.seeds)
+
+    def student_submission(self):
+        """ Return one of a small number of student submissions """
+        return random.choice(TEST_SUBMISSIONS)
+
+class Transaction(object):
+    """ User script that submits a response to a CustomResponse problem """
+
+    def __init__(self):
+        """ Create the problem """
+
+        # Get the context (re-used across transactions)
+        self.context = TestContext.singleton()
+
+        # Create a new custom response problem 
+        # using one of a small number of unique seeds
+        # We're assuming that the capa module is limiting the number
+        # of seeds (currently not the case for certain settings)
+        self.problem = lcp.LoncapaProblem(self.context.xml, 
+                                          '1', 
+                                          state=None, 
+                                          seed=self.context.random_seed(), 
+                                          system=self.context.system)
+
+    def run(self):
+        """ Submit a response to the CustomResponse problem """
+        answers = {'1_2_1': self.context.student_submission()}
+        self.problem.grade_answers(answers)
+
+if __name__ == '__main__':
+    trans = Transaction()
+    trans.run()

lms/djangoapps/debug/models.py

+from django.db import models
+
+# Create your models here.

lms/djangoapps/debug/views.py

+"""Views for debugging and diagnostics"""
+
+import pprint
+import traceback
+
+from django.http import Http404
+from django.contrib.auth.decorators import login_required
+from django_future.csrf import ensure_csrf_cookie, csrf_exempt
+from mitxmako.shortcuts import render_to_response
+
+from codejail.safe_exec import safe_exec
+
+@login_required
+@ensure_csrf_cookie
+def run_python(request):
+    """A page to allow testing the Python sandbox on a production server."""
+    if not request.user.is_staff:
+        raise Http404
+    c = {}
+    c['code'] = ''
+    c['results'] = None
+    if request.method == 'POST':
+        py_code = c['code'] = request.POST.get('code')
+        g = {}
+        try:
+            safe_exec(py_code, g)
+        except Exception as e:
+            c['results'] = traceback.format_exc()
+        else:
+            c['results'] = pprint.pformat(g)
+    return render_to_response("debug/run_python_form.html", c)

lms/envs/aws.py

@@ -92,6 +92,16 @@ CERT_QUEUE = ENV_TOKENS.get("CERT_QUEUE", 'test-pull')
 ZENDESK_URL = ENV_TOKENS.get("ZENDESK_URL")
 FEEDBACK_SUBMISSION_EMAIL = ENV_TOKENS.get("FEEDBACK_SUBMISSION_EMAIL")
 
+for name, value in ENV_TOKENS.get("CODE_JAIL", {}).items():
+    oldvalue = CODE_JAIL.get(name)
+    if isinstance(oldvalue, dict):
+        for subname, subvalue in value.items():
+            oldvalue[subname] = subvalue
+    else:
+        CODE_JAIL[name] = value
+
+COURSES_WITH_UNSAFE_CODE = ENV_TOKENS.get("COURSES_WITH_UNSAFE_CODE", [])
+
 ############################## SECURE AUTH ITEMS ###############
 # Secret things: passwords, access keys, etc.
 with open(ENV_ROOT / CONFIG_PREFIX + "auth.json") as auth_file:

lms/envs/common.py

@@ -97,6 +97,10 @@ MITX_FEATURES = {
 
     # Provide a UI to allow users to submit feedback from the LMS
     'ENABLE_FEEDBACK_SUBMISSION': False,
+
+    # Turn on a page that lets staff enter Python code to be run in the
+    # sandbox, for testing whether it's enabled properly.
+    'ENABLE_DEBUG_RUN_PYTHON': False,
 }
 
 # Used for A/B testing
@@ -246,6 +250,31 @@ MODULESTORE = {
 }
 CONTENTSTORE = None
 
+#################### Python sandbox ############################################
+
+CODE_JAIL = {
+    # Path to a sandboxed Python executable.  None means don't bother.
+    'python_bin': None,
+    # User to run as in the sandbox.
+    'user': 'sandbox',
+
+    # Configurable limits.
+    'limits': {
+        # How many CPU seconds can jailed code use?
+        'CPU': 1,
+    },
+}
+
+# Some courses are allowed to run unsafe code. This is a list of regexes, one
+# of them must match the course id for that course to run unsafe code.
+#
+# For example:
+#
+#   COURSES_WITH_UNSAFE_CODE = [
+#       r"Harvard/XY123.1/.*"
+#   ]
+COURSES_WITH_UNSAFE_CODE = []
+
 ############################ SIGNAL HANDLERS ################################
 # This is imported to register the exception signal handling that logs exceptions
 import monitoring.exceptions  # noqa
@@ -398,6 +427,7 @@ MIDDLEWARE_CLASSES = (
     # 'debug_toolbar.middleware.DebugToolbarMiddleware',
 
     'django_comment_client.utils.ViewNameMiddleware',
+    'codejail.django_integration.ConfigureCodeJailMiddleware',
 )
 
 ############################### Pipeline #######################################
@@ -601,6 +631,7 @@ INSTALLED_APPS = (
 
     # For testing
     'django.contrib.admin',   # only used in DEBUG mode
+    'debug',
 
     # Discussion forums
     'django_comment_client',

lms/templates/debug/run_python_form.html

+<html><body>
+<div>
+<p>Python:</p>
+<form method='post'>
+    <input type="hidden" name="csrfmiddlewaretoken" value="${ csrf_token }">
+    <div>
+        <textarea name='code' rows='20' cols='80'>${code|h}</textarea>
+    </div>
+    <input type='submit' value='Run it!'/>
+</form>
+</div>
+%if results:
+<div>
+    <p>Results:</p>
+    <pre>
+${results|h}
+</pre>
+</div>
+%endif

lms/urls.py

@@ -363,6 +363,11 @@ urlpatterns += (
     url(r'^comm/foldit_ops', 'foldit.views.foldit_ops', name="foldit_ops"),
 )
 
+if settings.MITX_FEATURES.get('ENABLE_DEBUG_RUN_PYTHON'):
+    urlpatterns += (
+        url(r'^debug/run_python', 'debug.views.run_python'),
+    )
+
 urlpatterns = patterns(*urlpatterns)
 
 if settings.DEBUG:

requirements/edx-sandbox/base.txt

+numpy==1.6.2

requirements/edx-sandbox/post.txt

+# Packages to install in the Python sandbox for secured execution.
+scipy==0.11.0
+lxml==3.0.1
+-e common/lib/calc
+-e common/lib/chem
+-e common/lib/sandbox-packages

requirements/edx/github.txt

@@ -9,3 +9,4 @@
 
 # Our libraries:
 -e git+https://github.com/edx/XBlock.git@483e0cb1#egg=XBlock
+-e git+https://github.com/edx/codejail.git@07494f1#egg=codejail

requirements/edx/local.txt

 # Python libraries to install that are local to the mitx repo
+-e common/lib/calc
 -e common/lib/capa
+-e common/lib/chem
 -e common/lib/xmodule
 -e .

scripts/runone.py

 #!/usr/bin/env python
-from django.core import management
 
 import argparse
 import os
@@ -42,21 +41,34 @@ def main(argv):
     test_py_path = find_full_path(test_py_path)
     test_spec = "%s:%s.%s" % (test_py_path, test_class, test_method)
 
+    settings = None
     if test_py_path.startswith('cms'):
         settings = 'cms.envs.test'
     elif test_py_path.startswith('lms'):
         settings = 'lms.envs.test'
-    else:
-        raise Exception("Couldn't determine settings to use!")
 
-    django_args = ["django-admin.py", "test", "--pythonpath=."]
-    django_args.append("--settings=%s" % settings)
-    if args.nocapture:
-        django_args.append("-s")
-    django_args.append(test_spec)
+    if settings:
+        # Run as a django test suite
+        from django.core import management
+
+        django_args = ["django-admin.py", "test", "--pythonpath=."]
+        django_args.append("--settings=%s" % settings)
+        if args.nocapture:
+            django_args.append("-s")
+        django_args.append(test_spec)
+
+        print " ".join(django_args)
+        management.execute_from_command_line(django_args)
+    else:
+        # Run as a nose test suite
+        import nose.core
+        nose_args = ["nosetests"]
+        if args.nocapture:
+            nose_args.append("-s")
+        nose_args.append(test_spec)
+        print " ".join(nose_args)
+        nose.core.main(argv=nose_args)
 
-    print " ".join(django_args)
-    management.execute_from_command_line(django_args)
 
 if __name__ == "__main__":
     main(sys.argv[1:])