relocate test suite loader

httprunner/utils.py

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+import collections
 import copy
 import hashlib
 import hmac
@@ -13,8 +14,9 @@ import string
 import types
 from datetime import datetime
 
-from httprunner import exceptions, logger
-from httprunner.compat import OrderedDict, basestring, is_py2, is_py3, str
+from httprunner import exceptions, logger, parser
+from httprunner.compat import (OrderedDict, basestring, builtin_str, is_py2,
+                               is_py3, numeric_types, str)
 from requests.structures import CaseInsensitiveDict
 
 SECRET_KEY = "DebugTalk"
@@ -84,6 +86,205 @@ def query_json(json_content, query, delimiter='.'):
 
     return json_content
 
+
+def substitute_variables_with_mapping(content, mapping):
+    """ substitute variables in content with mapping
+    e.g.
+    @params
+        content = {
+            'request': {
+                'url': '/api/users/$uid',
+                'headers': {'token': '$token'}
+            }
+        }
+        mapping = {"$uid": 1000}
+    @return
+        {
+            'request': {
+                'url': '/api/users/1000',
+                'headers': {'token': '$token'}
+            }
+        }
+    """
+    # TODO: refactor type check
+    if isinstance(content, bool):
+        return content
+
+    if isinstance(content, (numeric_types, type)):
+        return content
+
+    if not content:
+        return content
+
+    if isinstance(content, (list, set, tuple)):
+        return [
+            substitute_variables_with_mapping(item, mapping)
+            for item in content
+        ]
+
+    if isinstance(content, dict):
+        substituted_data = {}
+        for key, value in content.items():
+            eval_key = substitute_variables_with_mapping(key, mapping)
+            eval_value = substitute_variables_with_mapping(value, mapping)
+            substituted_data[eval_key] = eval_value
+
+        return substituted_data
+
+    # content is in string format here
+    for var, value in mapping.items():
+        if content == var:
+            # content is a variable
+            content = value
+        else:
+            if not isinstance(value, str):
+                value = builtin_str(value)
+            content = content.replace(var, value)
+
+    return content
+
+
+def _get_validators_mapping(validators):
+    """ get validators mapping from api or test validators
+    @param (list) validators:
+        [
+            {"check": "v1", "expect": 201, "comparator": "eq"},
+            {"check": {"b": 1}, "expect": 200, "comparator": "eq"}
+        ]
+    @return
+        {
+            ("v1", "eq"): {"check": "v1", "expect": 201, "comparator": "eq"},
+            ('{"b": 1}', "eq"): {"check": {"b": 1}, "expect": 200, "comparator": "eq"}
+        }
+    """
+    validators_mapping = {}
+
+    for validator in validators:
+        validator = parser.parse_validator(validator)
+
+        if not isinstance(validator["check"], collections.Hashable):
+            check = json.dumps(validator["check"])
+        else:
+            check = validator["check"]
+
+        key = (check, validator["comparator"])
+        validators_mapping[key] = validator
+
+    return validators_mapping
+
+
+def _merge_validator(def_validators, current_validators):
+    """ merge def_validators with current_validators
+    @params:
+        def_validators: [{'eq': ['v1', 200]}, {"check": "s2", "expect": 16, "comparator": "len_eq"}]
+        current_validators: [{"check": "v1", "expect": 201}, {'len_eq': ['s3', 12]}]
+    @return:
+        [
+            {"check": "v1", "expect": 201, "comparator": "eq"},
+            {"check": "s2", "expect": 16, "comparator": "len_eq"},
+            {"check": "s3", "expect": 12, "comparator": "len_eq"}
+        ]
+    """
+    if not def_validators:
+        return current_validators
+
+    elif not current_validators:
+        return def_validators
+
+    else:
+        api_validators_mapping = _get_validators_mapping(def_validators)
+        test_validators_mapping = _get_validators_mapping(current_validators)
+
+        api_validators_mapping.update(test_validators_mapping)
+        return list(api_validators_mapping.values())
+
+
+def _merge_extractor(def_extrators, current_extractors):
+    """ merge def_extrators with current_extractors
+    @params:
+        def_extrators: [{"var1": "val1"}, {"var2": "val2"}]
+        current_extractors: [{"var1": "val111"}, {"var3": "val3"}]
+    @return:
+        [
+            {"var1": "val111"},
+            {"var2": "val2"},
+            {"var3": "val3"}
+        ]
+    """
+    if not def_extrators:
+        return current_extractors
+
+    elif not current_extractors:
+        return def_extrators
+
+    else:
+        extractor_dict = OrderedDict()
+        for api_extrator in def_extrators:
+            if len(api_extrator) != 1:
+                logger.log_warning("incorrect extractor: {}".format(api_extrator))
+                continue
+
+            var_name = list(api_extrator.keys())[0]
+            extractor_dict[var_name] = api_extrator[var_name]
+
+        for test_extrator in current_extractors:
+            if len(test_extrator) != 1:
+                logger.log_warning("incorrect extractor: {}".format(test_extrator))
+                continue
+
+            var_name = list(test_extrator.keys())[0]
+            extractor_dict[var_name] = test_extrator[var_name]
+
+        extractor_list = []
+        for key, value in extractor_dict.items():
+            extractor_list.append({key: value})
+
+        return extractor_list
+
+
+def _override_block(def_block, current_block):
+    """ override def_block with current_block
+    @param def_block:
+        {
+            "name": "get token",
+            "request": {...},
+            "validate": [{'eq': ['status_code', 200]}]
+        }
+    @param current_block:
+        {
+            "name": "get token",
+            "extract": [{"token": "content.token"}],
+            "validate": [{'eq': ['status_code', 201]}, {'len_eq': ['content.token', 16]}]
+        }
+    @return
+        {
+            "name": "get token",
+            "request": {...},
+            "extract": [{"token": "content.token"}],
+            "validate": [{'eq': ['status_code', 201]}, {'len_eq': ['content.token', 16]}]
+        }
+    """
+    def_validators = def_block.get("validate") or def_block.get("validators", [])
+    current_validators = current_block.get("validate") or current_block.get("validators", [])
+
+    def_extrators = def_block.get("extract") \
+        or def_block.get("extractors") \
+        or def_block.get("extract_binds", [])
+    current_extractors = current_block.get("extract") \
+        or current_block.get("extractors") \
+        or current_block.get("extract_binds", [])
+
+    current_block.update(def_block)
+    current_block["validate"] = _merge_validator(
+        def_validators,
+        current_validators
+    )
+    current_block["extract"] = _merge_extractor(
+        def_extrators,
+        current_extractors
+    )
+
+
 def get_uniform_comparator(comparator):
     """ convert comparator alias to uniform name
     """