format code

docs/CHANGELOG.md

@@ -1,10 +1,16 @@
 # Release History
 
-## 3.1.3 (2020-06-30)
+## 3.1.3 (2020-07-06)
+
+**Added**
+
+- feat: implement `parameters` feature
 
 **Fixed**
 
 - fix: validate with variable or function whose evaluation result is "" or not text
+- fix: raise TestCaseFormatError if teststep validate invalid
+- fix: raise TestCaseFormatError if ref testcase is invalid
 
 ## 3.1.2 (2020-06-29)
 

httprunner/parser.py

@@ -496,6 +496,7 @@ def parse_parameters(parameters, variables_mapping=None, functions_mapping=None)
 
     # load project_meta functions
     from httprunner.loader import load_project_meta
+
     project_meta = load_project_meta("")
     functions_mapping.update(project_meta.functions)
 
@@ -523,16 +524,15 @@ def parse_parameters(parameters, variables_mapping=None, functions_mapping=None)
         else:
             # (2) & (3)
             parsed_variables_mapping = parse_variables_mapping(
-                variables_mapping,
+                variables_mapping, functions_mapping
-                functions_mapping
             )
             parsed_parameter_content = parse_data(
-                parameter_content,
+                parameter_content, parsed_variables_mapping, functions_mapping
-                parsed_variables_mapping,
-                functions_mapping
             )
             if not isinstance(parsed_parameter_content, list):
-                raise exceptions.ParamsError(f"{parsed_parameter_content} parameters syntax error!")
+                raise exceptions.ParamsError(
+                    f"{parsed_parameter_content} parameters syntax error!"
+                )
 
             parameter_content_list = []
             for parameter_item in parsed_parameter_content:
@@ -545,17 +545,17 @@ def parse_parameters(parameters, variables_mapping=None, functions_mapping=None)
                     #       {"username": "user1", "password": "111111"},
                     #       {"username": "user2", "password": "222222"}
                     # ]
-                    parameter_dict = {key: parameter_item[key] for key in parameter_name_list}
+                    parameter_dict = {
-    #             elif isinstance(parameter_item, (list, tuple)):
+                        key: parameter_item[key] for key in parameter_name_list
-    #                 # {"username-password": "${get_account()}"}
+                    }
-    #                 # get_account() => [("user1", "111111"), ("user2", "222222")]
+                #             elif isinstance(parameter_item, (list, tuple)):
-    #                 parameter_dict = dict(zip(parameter_name_list, parameter_item))
+                #                 # {"username-password": "${get_account()}"}
+                #                 # get_account() => [("user1", "111111"), ("user2", "222222")]
+                #                 parameter_dict = dict(zip(parameter_name_list, parameter_item))
                 elif len(parameter_name_list) == 1:
                     # {"user_agent": "${get_user_agent()}"}
                     # get_user_agent() => ["iOS/10.1", "iOS/10.2"]
-                    parameter_dict = {
+                    parameter_dict = {parameter_name_list[0]: parameter_item}
-                        parameter_name_list[0]: parameter_item
-                    }
 
                 parameter_content_list.append(parameter_dict)
 

tests/make_test.py

@@ -9,7 +9,7 @@ from httprunner.make import (
     make_teststep_chain_style,
     pytest_files_run_set,
     ensure_file_abs_path_valid,
-    make_test_start_style
+    make_test_start_style,
 )
 from httprunner import loader
 
@@ -222,9 +222,7 @@ from request_methods.request_with_functions_test import (
             "username-password": "${parameterize(request_methods/account.csv)}",
             "app_version": "${get_app_version()}",
         }
-        config = {
+        config = {"parameters": params}
-            "parameters": params
-        }
         self.assertEqual(
             make_test_start_style(config),
             f"""
@@ -236,5 +234,5 @@ from request_methods.request_with_functions_test import (
     @pytest.mark.parametrize('parametrize', parse_parameters(param))
     def test_start(self, parametrize):
         super().test_start(parametrize)
-        """
+        """,
         )

tests/parser_test.py

@@ -467,15 +467,79 @@ class TestParserBasic(unittest.TestCase):
         ]
 
         functions = {
-            "add_two_nums": lambda a, b=1: [a + b, b-a],
+            "add_two_nums": lambda a, b=1: [a + b, b - a],
         }
 
         parsed_params = parser.parse_parameters(param, variables, functions)
-        self.assertIn({'username': 'test1', 'password': '111111', 'user_agent': 'iOS/10.1', 'sum': 3}, parsed_params)
+        self.assertIn(
-        self.assertIn({'username': 'test1', 'password': '111111', 'user_agent': 'iOS/10.1', 'sum': 1}, parsed_params)
+            {
-        self.assertIn({'username': 'test1', 'password': '111111', 'user_agent': 'iOS/10.2', 'sum': 3}, parsed_params)
+                "username": "test1",
-        self.assertIn({'username': 'test1', 'password': '111111', 'user_agent': 'iOS/10.2', 'sum': 1}, parsed_params)
+                "password": "111111",
-        self.assertIn({'username': 'test2', 'password': '222222', 'user_agent': 'iOS/10.1', 'sum': 3}, parsed_params)
+                "user_agent": "iOS/10.1",
-        self.assertIn({'username': 'test2', 'password': '222222', 'user_agent': 'iOS/10.1', 'sum': 1}, parsed_params)
+                "sum": 3,
-        self.assertIn({'username': 'test2', 'password': '222222', 'user_agent': 'iOS/10.2', 'sum': 3}, parsed_params)
+            },
-        self.assertIn({'username': 'test2', 'password': '222222', 'user_agent': 'iOS/10.2', 'sum': 1}, parsed_params)
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test1",
+                "password": "111111",
+                "user_agent": "iOS/10.1",
+                "sum": 1,
+            },
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test1",
+                "password": "111111",
+                "user_agent": "iOS/10.2",
+                "sum": 3,
+            },
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test1",
+                "password": "111111",
+                "user_agent": "iOS/10.2",
+                "sum": 1,
+            },
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test2",
+                "password": "222222",
+                "user_agent": "iOS/10.1",
+                "sum": 3,
+            },
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test2",
+                "password": "222222",
+                "user_agent": "iOS/10.1",
+                "sum": 1,
+            },
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test2",
+                "password": "222222",
+                "user_agent": "iOS/10.2",
+                "sum": 3,
+            },
+            parsed_params,
+        )
+        self.assertIn(
+            {
+                "username": "test2",
+                "password": "222222",
+                "user_agent": "iOS/10.2",
+                "sum": 1,
+            },
+            parsed_params,
+        )

tests/utils_test.py

@@ -127,50 +127,30 @@ class TestUtils(unittest.TestCase):
         )
 
     def test_ensure_mapping_format(self):
-        map_list = [
+        map_list = [{"a": 1}, {"b": 2}]
-            {"a": 1},
-            {"b": 2}
-        ]
         ordered_dict = utils.ensure_mapping_format(map_list)
         self.assertIsInstance(ordered_dict, dict)
         self.assertIn("a", ordered_dict)
 
     def test_cartesian_product_one(self):
-        parameters_content_list = [
+        parameters_content_list = [[{"a": 1}, {"a": 2}]]
-            [
-                {"a": 1},
-                {"a": 2}
-            ]
-        ]
         product_list = utils.gen_cartesian_product(*parameters_content_list)
-        self.assertEqual(
+        self.assertEqual(product_list, [{"a": 1}, {"a": 2}])
-            product_list,
-            [
-                {"a": 1},
-                {"a": 2}
-            ]
-        )
 
     def test_cartesian_product_multiple(self):
         parameters_content_list = [
-            [
+            [{"a": 1}, {"a": 2}],
-                {"a": 1},
+            [{"x": 111, "y": 112}, {"x": 121, "y": 122}],
-                {"a": 2}
-            ],
-            [
-                {"x": 111, "y": 112},
-                {"x": 121, "y": 122}
-            ]
         ]
         product_list = utils.gen_cartesian_product(*parameters_content_list)
         self.assertEqual(
             product_list,
             [
-                {'a': 1, 'x': 111, 'y': 112},
+                {"a": 1, "x": 111, "y": 112},
-                {'a': 1, 'x': 121, 'y': 122},
+                {"a": 1, "x": 121, "y": 122},
-                {'a': 2, 'x': 111, 'y': 112},
+                {"a": 2, "x": 111, "y": 112},
-                {'a': 2, 'x': 121, 'y': 122}
+                {"a": 2, "x": 121, "y": 122},
-            ]
+            ],
         )
 
     def test_cartesian_product_empty(self):