def import_module_items(self, imported_module):
""" import module functions and variables and bind to testset context
"""
module_mapping = loader.load_python_module(imported_module)
self.__update_context_functions_config("testset",
module_mapping["functions"])
self.bind_variables(module_mapping["variables"], "testset")
def test_get_module_item_variables(self):
from tests import confcustom
module_mapping = loader.load_python_module(confcustom)
SECRET_KEY = loader.get_module_item(module_mapping, 'variables',
'SECRET_KEY')
assert validator.is_variable(('SECRET_KEY', SECRET_KEY))
assert SECRET_KEY == 'MyHttpRunner'
def test_get_module_item_functions(self):
from httprunner import utils
module_mapping = loader.load_python_module(utils)
gen_md5 = loader.get_module_item(module_mapping, "functions", "gen_md5")
self.assertTrue(validator.is_function(("gen_md5", gen_md5)))
self.assertEqual(gen_md5("abc"), "900150983cd24fb0d6963f7d28e17f72")
with self.assertRaises(exceptions.FunctionNotFound):
loader.get_module_item(module_mapping, "functions", "gen_md4")
def test_get_module_item_variables(self):
from tests import debugtalk
module_mapping = loader.load_python_module(debugtalk)
SECRET_KEY = loader.get_module_item(module_mapping, "variables",
"SECRET_KEY")
self.assertTrue(validator.is_variable(("SECRET_KEY", SECRET_KEY)))
self.assertEqual(SECRET_KEY, "DebugTalk")
with self.assertRaises(exceptions.VariableNotFound):
loader.get_module_item(module_mapping, "variables", "SECRET_KEY2")
def test_get_module_item_functions(self):
from httprunner import utils
module_mapping = loader.load_python_module(utils)
get_uniform_comparator = loader.get_module_item(
module_mapping, 'functions', 'get_uniform_comparator')
assert validator.is_function(("get_uniform_comparator",
get_uniform_comparator))
assert get_uniform_comparator('==') == 'equals'
with pytest.raises(exceptions.FunctionNotFound):
loader.get_module_item(module_mapping, 'functions', 'gen_md4')
def test_get_module_item_functions(self):
from httprunner import utils
module_mapping = loader.load_python_module(utils)
get_uniform_comparator = loader.get_module_item(
module_mapping, "functions", "get_uniform_comparator")
self.assertTrue(
validator.is_function(
("get_uniform_comparator", get_uniform_comparator)))
self.assertEqual(get_uniform_comparator("=="), "equals")
with self.assertRaises(exceptions.FunctionNotFound):
loader.get_module_item(module_mapping, "functions", "gen_md4")
def test_get_module_item_variables(self):
dot_env_path = os.path.join(os.getcwd(), "tests", ".env")
loader.load_dot_env_file(dot_env_path)
from tests import debugtalk
module_mapping = loader.load_python_module(debugtalk)
SECRET_KEY = loader.get_module_item(module_mapping, "variables",
"SECRET_KEY")
self.assertTrue(validator.is_variable(("SECRET_KEY", SECRET_KEY)))
self.assertEqual(SECRET_KEY, "DebugTalk")
with self.assertRaises(exceptions.VariableNotFound):
loader.get_module_item(module_mapping, "variables", "SECRET_KEY2")
def test_parse_parameters_custom_function(self):
parameters = [{
"app_version": "${gen_app_version()}"
}, {
"username-password": "******"
}]
testset_path = os.path.join(os.getcwd(),
"tests/data/demo_parameters.yml")
from tests import debugtalk
debugtalk_module = loader.load_python_module(debugtalk)
cartesian_product_parameters = parser.parse_parameters(
parameters, debugtalk_module["variables"],
debugtalk_module["functions"])
self.assertEqual(len(cartesian_product_parameters), 2 * 2)
def current_validators(self):
from httprunner import built_in
module_mapping = loader.load_python_module(built_in)
functions_mapping = module_mapping["functions"]
functions_mapping["equals"](None, None)
functions_mapping["equals"](1, 1)
functions_mapping["equals"]("abc", "abc")
with self.assertRaises(AssertionError):
functions_mapping["equals"]("123", 123)
functions_mapping["less_than"](1, 2)
functions_mapping["less_than_or_equals"](2, 2)
functions_mapping["greater_than"](2, 1)
functions_mapping["greater_than_or_equals"](2, 2)
functions_mapping["not_equals"](123, "123")
functions_mapping["length_equals"]("123", 3)
functions_mapping["length_greater_than"]("123", 2)
functions_mapping["length_greater_than_or_equals"]("123", 3)
functions_mapping["contains"]("123abc456", "3ab")
functions_mapping["contains"](['1', '2'], "1")
functions_mapping["contains"]({'a':1, 'b':2}, "a")
functions_mapping["contained_by"]("3ab", "123abc456")
functions_mapping["regex_match"]("123abc456", "^123\w+456$")
with self.assertRaises(AssertionError):
functions_mapping["regex_match"]("123abc456", "^12b.*456$")
functions_mapping["startswith"]("abc123", "ab")
functions_mapping["startswith"]("123abc", 12)
functions_mapping["startswith"](12345, 123)
functions_mapping["endswith"]("abc123", 23)
functions_mapping["endswith"]("123abc", "abc")
functions_mapping["endswith"](12345, 45)
functions_mapping["type_match"](580509390, int)
functions_mapping["type_match"](580509390, "int")
functions_mapping["type_match"]([], list)
functions_mapping["type_match"]([], "list")
functions_mapping["type_match"]([1], "list")
functions_mapping["type_match"]({}, "dict")
functions_mapping["type_match"]({"a": 1}, "dict")
def parse_tests(self, testcases, variables_mapping=None):
""" parse testcases configs, including variables/parameters/name/request.
Args:
testcases (list): testcase list, with config unparsed.
variables_mapping (dict): if variables_mapping is specified, it will override variables in config block.
Returns:
list: parsed testcases list, with config variables/parameters/name/request parsed.
"""
self.exception_stage = "parse tests"
variables_mapping = variables_mapping or {}
parsed_testcases_list = []
for testcase in testcases:
# parse config parameters
config_parameters = testcase.setdefault("config",
{}).pop("parameters", [])
cartesian_product_parameters_list = parser.parse_parameters(
config_parameters,
self.project_mapping["debugtalk"]["variables"],
self.project_mapping["debugtalk"]["functions"]) or [{}]
for parameter_mapping in cartesian_product_parameters_list:
testcase_dict = testcase
config = testcase_dict.setdefault("config", {})
testcase_dict["config"]["functions"] = {}
# imported_module = importlib.reload(importlib.import_module('func_list.build_in'))
# testcase_dict["config"]["functions"].update(loader.load_python_module(imported_module)["functions"])
if config.get('import_module_functions'):
for f in config.get('import_module_functions'):
imported_module = importlib.reload(
importlib.import_module(f))
debugtalk_module = loader.load_python_module(
imported_module)
testcase_dict["config"]["functions"].update(
debugtalk_module["functions"])
testcase_dict["config"]["functions"].update(
self.project_mapping["debugtalk"]["functions"])
# self.project_mapping["debugtalk"]["functions"].update(debugtalk_module["functions"])
raw_config_variables = config.get("variables", [])
parsed_config_variables = parser.parse_data(
raw_config_variables,
self.project_mapping["debugtalk"]["variables"],
testcase_dict["config"]["functions"])
# priority: passed in > debugtalk.py > parameters > variables
# override variables mapping with parameters mapping
config_variables = utils.override_mapping_list(
parsed_config_variables, parameter_mapping)
# merge debugtalk.py module variables
config_variables.update(
self.project_mapping["debugtalk"]["variables"])
# override variables mapping with passed in variables_mapping
config_variables = utils.override_mapping_list(
config_variables, variables_mapping)
testcase_dict["config"]["variables"] = config_variables
# parse config name
testcase_dict["config"]["name"] = parser.parse_data(
testcase_dict["config"].get("name", ""), config_variables,
self.project_mapping["debugtalk"]["functions"])
# parse config request
testcase_dict["config"]["request"] = parser.parse_data(
testcase_dict["config"].get("request",
{}), config_variables,
self.project_mapping["debugtalk"]["functions"])
# put loaded project functions to config
# testcase_dict["config"]["functions"] = self.project_mapping["debugtalk"]["functions"]
parsed_testcases_list.append(testcase_dict)
return parsed_testcases_list
def test_filter_module_functions(self):
module_mapping = loader.load_python_module(loader)
functions_dict = module_mapping["functions"]
self.assertIn("load_python_module", functions_dict)
self.assertNotIn("is_py3", functions_dict)
def setUp(self):
module_mapping = loader.load_python_module(built_in)
self.functions_mapping = module_mapping["functions"]
def test_load_python_module(self):
pytest_module_items = loader.load_python_module(pytest)
assert 'mark' in pytest_module_items['variables']
assert 'skip' in pytest_module_items['functions']
def test_filter_module_functions(self):
module_mapping = loader.load_python_module(loader)
functions_dict = module_mapping['functions']
assert 'load_python_module' in functions_dict
assert 'is_py3' not in functions_dict
