Context: Manages binding of variables

This commit is contained in:
debugtalk
2017-06-26 00:38:00 +08:00
parent 4d9ca255cd
commit 75d06aecca
3 changed files with 256 additions and 0 deletions

74
ate/context.py Normal file
View File

@@ -0,0 +1,74 @@
import importlib
class Context(object):
""" Manages binding of variables
"""
def __init__(self):
self.functions = dict()
self.variables = dict() # Maps variable name to value
def import_requires(self, modules):
""" import required modules dynamicly
"""
for module_name in modules:
globals()[module_name] = importlib.import_module(module_name)
def bind_functions(self, function_binds):
""" Bind named functions within the context
This allows for passing in self-defined functions in testing.
e.g. function_binds:
{
"add_one": lambda x: x + 1,
"add_two_nums": "lambda x, y: x + y"
}
"""
for func_name, function in function_binds.items():
if isinstance(function, str):
function = eval(function)
self.functions[func_name] = function
def bind_variables(self, variable_binds):
""" Bind named variables to value within the context.
This allows for passing in variables or functions.
e.g. variable_binds:
[
{"TOKEN": "debugtalk"},
{"random": {"func": "gen_random_string", "args": [5]}},
{"json": {'name': 'user', 'password': '123456'}},
{"md5": {"func": "gen_md5", "args": ["$TOKEN", "$json", "$random"]}}
]
"""
for variable_bind_map in variable_binds:
for var_name, var_value in variable_bind_map.items():
self.variables[var_name] = self.get_eval_value(var_value)
def get_eval_value(self, data):
""" evaluate data recursively, each variable in data will be evaluated.
variable will always be a string started with $, such as $token
"""
if isinstance(data, str):
if data.startswith('$'):
# this is a variable, and will replace with its bind value
return self.variables.get(data[1:])
return data
if isinstance(data, list):
return [self.get_eval_value(item) for item in data]
if isinstance(data, dict):
if "func" in data:
# this is a function, e.g. {"func": "gen_random_string", "args": [5]}
# function marker: "func" key in dict
# the function will be called, and its return value will be binded to the variable.
func_name = data['func']
args = self.get_eval_value(data.get('args', []))
kargs = self.get_eval_value(data.get('kargs', {}))
return self.functions[func_name](*args, **kargs)
else:
evaluated_data = {}
for key, value in data.items():
evaluated_data[key] = self.get_eval_value(value)
return evaluated_data
return data

38
test/data/demo_binds.yml Normal file
View File

@@ -0,0 +1,38 @@
-
variable_binds:
- TOKEN: "debugtalk"
-
variable_binds:
- var: [1, 2, 3]
-
variable_binds:
- data: {'name': 'user', 'password': '123456'}
-
variable_binds:
- TOKEN: "debugtalk"
- token: $TOKEN
-
function_binds:
add_one: "lambda x: x + 1"
add_two_nums: "lambda x, y: x + y"
variable_binds:
- add1: {"func": "add_one", "args": [2]}
- sum2nums: {"func": "add_two_nums", "args": [2, 3]}
-
requires:
- random
- string
- hashlib
function_binds:
gen_random_string: "lambda str_len: ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(str_len))"
gen_md5: "lambda *str_args: hashlib.md5(''.join(str_args).encode('utf-8')).hexdigest()"
variable_binds:
- TOKEN: debugtalk
- random: {"func": "gen_random_string", "args": [5]}
- data: "{'name': 'user', 'password': '123456'}"
- authorization: {"func": "gen_md5", "args": [$TOKEN, $data, $random]}

144
test/test_context.py Normal file
View File

@@ -0,0 +1,144 @@
import os
import unittest
from ate import utils
from ate.context import Context
class VariableBindsUnittest(unittest.TestCase):
def setUp(self):
self.context = Context()
testcase_file_path = os.path.join(os.getcwd(), 'test/data/demo_binds.yml')
self.testcases = utils.load_testcases(testcase_file_path)
def test_context_variable_string(self):
# testcase in JSON format
testcase1 = {
"variable_binds": [
{"TOKEN": "debugtalk"}
]
}
# testcase in YAML format
testcase2 = self.testcases[0]
for testcase in [testcase1, testcase2]:
variable_binds = testcase['variable_binds']
self.context.bind_variables(variable_binds)
context_variables = self.context.variables
self.assertIn("TOKEN", context_variables)
self.assertEqual(context_variables["TOKEN"], "debugtalk")
def test_context_variable_list(self):
testcase1 = {
"variable_binds": [
{"var": [1, 2, 3]}
]
}
testcase2 = self.testcases[1]
for testcase in [testcase1, testcase2]:
variable_binds = testcase['variable_binds']
self.context.bind_variables(variable_binds)
context_variables = self.context.variables
self.assertIn("var", context_variables)
self.assertEqual(context_variables["var"], [1, 2, 3])
def test_context_variable_json(self):
testcase1 = {
"variable_binds": [
{"data": {'name': 'user', 'password': '123456'}}
]
}
testcase2 = self.testcases[2]
for testcase in [testcase1, testcase2]:
variable_binds = testcase['variable_binds']
self.context.bind_variables(variable_binds)
context_variables = self.context.variables
self.assertIn("data", context_variables)
self.assertEqual(
context_variables["data"],
{'name': 'user', 'password': '123456'}
)
def test_context_variable_variable(self):
testcase1 = {
"variable_binds": [
{"GLOBAL_TOKEN": "debugtalk"},
{"token": "$GLOBAL_TOKEN"}
]
}
testcase2 = self.testcases[3]
for testcase in [testcase1, testcase2]:
variable_binds = testcase['variable_binds']
self.context.bind_variables(variable_binds)
context_variables = self.context.variables
self.assertIn("GLOBAL_TOKEN", context_variables)
self.assertEqual(context_variables["GLOBAL_TOKEN"], "debugtalk")
self.assertIn("token", context_variables)
self.assertEqual(context_variables["token"], "debugtalk")
def test_context_variable_function_lambda(self):
testcase1 = {
"function_binds": {
"add_one": lambda x: x + 1,
"add_two_nums": lambda x, y: x + y
},
"variable_binds": [
{"add1": {"func": "add_one", "args": [2]}},
{"sum2nums": {"func": "add_two_nums", "args": [2, 3]}}
]
}
testcase2 = self.testcases[4]
for testcase in [testcase1, testcase2]:
function_binds = testcase.get('function_binds', {})
self.context.bind_functions(function_binds)
variable_binds = testcase['variable_binds']
self.context.bind_variables(variable_binds)
context_variables = self.context.variables
self.assertIn("add1", context_variables)
self.assertEqual(context_variables["add1"], 3)
self.assertIn("sum2nums", context_variables)
self.assertEqual(context_variables["sum2nums"], 5)
def test_context_variable_function_lambda_with_import(self):
testcase1 = {
"requires": ["random", "string", "hashlib"],
"function_binds": {
"gen_random_string": "lambda str_len: ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(str_len))",
"gen_md5": "lambda *str_args: hashlib.md5(''.join(str_args).encode('utf-8')).hexdigest()"
},
"variable_binds": [
{"TOKEN": "debugtalk"},
{"random": {"func": "gen_random_string", "args": [5]}},
{"data": "{'name': 'user', 'password': '123456'}"},
{"md5": {"func": "gen_md5", "args": ["$TOKEN", "$data", "$random"]}}
]
}
testcase2 = self.testcases[5]
for testcase in [testcase1, testcase2]:
requires = testcase.get('requires', [])
self.context.import_requires(requires)
function_binds = testcase.get('function_binds', {})
self.context.bind_functions(function_binds)
variable_binds = testcase['variable_binds']
self.context.bind_variables(variable_binds)
context_variables = self.context.variables
self.assertIn("random", context_variables)
self.assertIsInstance(context_variables["random"], str)
self.assertEqual(len(context_variables["random"]), 5)
self.assertIn("md5", context_variables)
self.assertEqual(len(context_variables["md5"]), 32)