def test_interpreter_overrides(self):
# test overriding a parameter that gets set by the experiment
proc = Interpreter(self.compiled, self.interpreter_salt,
{'userid': 123454})
proc.set_overrides({'specific_goal': 0})
self.assertEqual(proc.get_params().get('specific_goal'), 0)
self.assertEqual(proc.get_params().get('ratings_goal'), None)
# test to make sure input data can also be overridden
proc = Interpreter(self.compiled, self.interpreter_salt,
{'userid': 123453})
proc.set_overrides({'userid': 123454})
self.assertEqual(proc.get_params().get('specific_goal'), 1)
def assign(self, params, **kwargs):
compiled = json.loads("""
{"op":"set",
"var":"foo",
"value":{
"choices":["a","b"],
"op":"uniformChoice",
"unit": {"op": "get", "var": "i"}
}
}
""")
proc = Interpreter(compiled, self.salt, kwargs)
params.update(proc.get_params())
def testPlanOutScript(script, inputs={}, overrides=None, assertions=None):
payload = {}
# make sure experiment runs with the given inputs
i = Interpreter(script, 'demo_salt', inputs)
if overrides:
i.set_overrides(overrides)
try:
results = dict(i.get_params()) # executes experiment
except Exception as err:
#message = "Error running experiment: %s" % traceback.format_exc(0)
message = "Error running experiment:\n%s" % err
payload['errors'] = [{"error_code": "runtime", "message": message}]
return payload
payload['results'] = results
# validate if input contains validation code
validation_errors = []
if assertions:
for (key, value) in assertions.iteritems():
if key not in results:
validation_errors.append({
"error_code": "assertion",
"message": {
"param": key
}
})
else:
if results[key] != value:
message = {
'param': key,
'expected': value,
'got': results[key]
}
validation_errors.append({
"error_code": "assertion",
"message": message
})
if validation_errors:
payload['errors'] = validation_errors
return payload
def return_runner(return_value):
config = {
"op":
"seq",
"seq": [{
"op": "set",
"var": "x",
"value": 2
}, {
"op": "return",
"value": return_value
}, {
"op": "set",
"var": "y",
"value": 4
}]
}
e = Interpreter(config, 'test_salt')
return e
def test_register_ops(self):
from planout.ops.base import PlanOutOpCommutative
class CustomOp(PlanOutOpCommutative):
def commutativeExecute(self, values):
return sum(values)
custom_op_script = {
"op":
"seq",
"seq": [{
"op": "set",
"var": "x",
"value": {
"values": [2, 4],
"op": "customOp"
}
}]
}
proc = Interpreter(custom_op_script, self.interpreter_salt,
{'userid': 123454})
proc.register_operators({'customOp': CustomOp})
self.assertEqual(proc.get_params().get('x'), 6)
def test_interpreter(self):
proc = Interpreter(self.compiled, self.interpreter_salt,
{'userid': 123454})
params = proc.get_params()
self.assertEqual(proc.get_params().get('specific_goal'), 1)
self.assertEqual(proc.get_params().get('ratings_goal'), 320)
def get_interpreter_instance(self, **kwargs):
return Interpreter(self.get_planout_dict(),
experiment_salt=self.salt,
**kwargs)
def runConfig(self, config, init={}):
e = None
e = Interpreter(config, 'test_salt', init)
return e.get_params()
def runConfig(self, config, init={}):
e = None
e = Interpreter(config, 'test_salt', init)
is_valid = Validator(config).validate()
self.assertTrue(is_valid)
return e.get_params()
def test_interpreter(self):
proc = Interpreter(self.compiled, 'foo', {'userid': 123456})
self.assertTrue(proc.get_params())
