new feature: support parameters and data driven

httprunner/__init__.py

@@ -1 +1 @@
-__version__ = '0.9.1'
+__version__ = '0.9.2'

httprunner/task.py

@@ -49,13 +49,26 @@ def __init__(self, testset, variables_mapping=None, http_client_session=None):
         super(ApiTestSuite, self).__init__()
 
         self.config_dict = testset.get("config", {})
+
         variables = self.config_dict.get("variables", [])
         variables_mapping = variables_mapping or {}
         self.config_dict["variables"] = utils.override_variables_binds(variables, variables_mapping)
 
-        self.test_runner = runner.Runner(self.config_dict, http_client_session)
-        testcases = testset.get("testcases", [])
-        self._add_tests_to_suite(testcases)
+        parameters = self.config_dict.get("parameters", [])
+        cartesian_product_parameters = testcase.gen_cartesian_product_parameters(
+            parameters,
+            self.config_dict["path"]
+        ) or [{}]
+        for parameter_mapping in cartesian_product_parameters:
+            if parameter_mapping:
+                self.config_dict["variables"] = utils.override_variables_binds(
+                    self.config_dict["variables"],
+                    parameter_mapping
+                )
+
+            self.test_runner = runner.Runner(self.config_dict, http_client_session)
+            testcases = testset.get("testcases", [])
+            self._add_tests_to_suite(testcases)
 
     def _add_tests_to_suite(self, testcases):
         for testcase_dict in testcases:

httprunner/testcase.py

@@ -1,8 +1,10 @@
 import ast
 import io
+import itertools
 import json
 import logging
 import os
+import random
 import re
 from collections import OrderedDict
 
@@ -42,12 +44,70 @@ def _load_json_file(json_file):
         check_format(json_file, json_content)
         return json_content
 
+def _load_csv_file(csv_file):
+    """ load csv file and check file content format
+    @param
+        csv_file: csv file path
+        e.g. csv file content:
+            username,password
+            test1,111111
+            test2,222222
+            test3,333333
+    @return
+        list of parameter, each parameter is in dict format
+        e.g.
+        [
+            {'username': 'test1', 'password': '111111'},
+            {'username': 'test2', 'password': '222222'},
+            {'username': 'test3', 'password': '333333'}
+        ]
+    """
+    csv_content_list = []
+    parameter_list = None
+    collums_num = 0
+    with io.open(csv_file, encoding='utf-8') as data_file:
+        for line in data_file:
+            line_data = line.strip().split(",")
+            if line_data == [""]:
+                # ignore empty line
+                continue
+
+            if not parameter_list:
+                # first line will always be parameter name
+                expected_filename = "{}.csv".format("-".join(line_data))
+                if not csv_file.endswith(expected_filename):
+                    raise exception.FileFormatError("CSV file name does not match with headers: {}".format(csv_file))
+
+                parameter_list = line_data
+                collums_num = len(parameter_list)
+                continue
+
+            # from the second line
+            if len(line_data) != collums_num:
+                err_msg = "CSV file collums does match with headers.\n"
+                err_msg += "\tcsv file path: {}\n".format(csv_file)
+                err_msg += "\terror line content: {}".format(line_data)
+                raise exception.FileFormatError(err_msg)
+            else:
+                data = {}
+                for index, parameter_name in enumerate(parameter_list):
+                    data[parameter_name] = line_data[index]
+
+                csv_content_list.append(data)
+
+    return csv_content_list
+
 def load_file(file_path):
-    file_suffix = os.path.splitext(file_path)[1]
+    if not os.path.isfile(file_path):
+        raise exception.FileNotFoundError("{} does not exist.".format(file_path))
+
+    file_suffix = os.path.splitext(file_path)[1].lower()
     if file_suffix == '.json':
         return _load_json_file(file_path)
     elif file_suffix in ['.yaml', '.yml']:
         return _load_yaml_file(file_path)
+    elif file_suffix == ".csv":
+        return _load_csv_file(file_path)
     else:
         # '' or other suffix
         err_msg = u"file is not in YAML/JSON format: {}".format(file_path)
@@ -550,6 +610,67 @@ def check_format(file_path, content):
         logging.error(err_msg)
         raise exception.FileFormatError(err_msg)
 
+def gen_cartesian_product(*args):
+    """ generate cartesian product for lists
+    @param
+        (list) args
+            [{"a": 1}, {"a": 2}],
+            [
+                {"x": 111, "y": 112},
+                {"x": 121, "y": 122}
+            ]
+    @return
+        cartesian product in list
+        [
+            {'a': 1, 'x': 111, 'y': 112},
+            {'a': 1, 'x': 121, 'y': 122},
+            {'a': 2, 'x': 111, 'y': 112},
+            {'a': 2, 'x': 121, 'y': 122}
+        ]
+    """
+    if not args:
+        return []
+    elif len(args) == 1:
+        return args[0]
+
+    product_list = []
+    for product_item_tuple in itertools.product(*args):
+        product_item_dict = {}
+        for item in product_item_tuple:
+            product_item_dict.update(item)
+
+        product_list.append(product_item_dict)
+
+    return product_list
+
+def gen_cartesian_product_parameters(parameters, testset_path):
+    """ parse parameters and generate cartesian product
+    @params
+        (list) parameters: parameter name and fetch method
+            e.g.
+                [
+                    {"user_agent": "Random"},
+                    {"app_version": "Sequential"}
+                ]
+        (str) testset_path: testset file path, used for locating csv file
+    @return cartesian product in list
+    """
+    parameters_content_list = []
+    for parameter in parameters:
+        parameter_name, fetch_method = list(parameter.items())[0]
+        parameter_file_path = os.path.join(
+            os.path.dirname(testset_path),
+            "{}.csv".format(parameter_name)
+        )
+        csv_content_list = load_file(parameter_file_path)
+
+        if fetch_method.lower() == "random":
+            random.shuffle(csv_content_list)
+
+        parameters_content_list.append(csv_content_list)
+
+    return gen_cartesian_product(*parameters_content_list)
+
 
 class TestcaseParser(object):
 

tests/data/app_version.csv

@@ -0,0 +1,4 @@
+app_version
+2.8.5
+2.8.6
+

tests/data/demo_parameters.yml

@@ -0,0 +1,26 @@
+- config:
+    name: "user management testset."
+    parameters:
+        - user_agent: Random
+        - app_version: Sequential
+    variables:
+        - user_agent: 'iOS/10.3'
+        - device_sn: ${gen_random_string(15)}
+        - os_platform: 'ios'
+        - app_version: '2.8.6'
+    request:
+        base_url: $BASE_URL
+        headers:
+            Content-Type: application/json
+            device_sn: $device_sn
+    output:
+        - token
+
+- test:
+    name: get token with $user_agent and $app_version
+    api: get_token($user_agent, $device_sn, $os_platform, $app_version)
+    extract:
+        - token: content.token
+    validate:
+        - "eq": ["status_code", 200]
+        - "len_eq": ["content.token", 16]

tests/data/user_agent.csv

@@ -0,0 +1,4 @@
+user_agent
+iOS/10.1
+iOS/10.2
+iOS/10.3

tests/data/username-password.csv

@@ -0,0 +1,4 @@
+username,password
+test1,111111
+test2,222222
+test3,333333

tests/test_runner.py

@@ -158,3 +158,11 @@ def test_bugfix_type_match(self):
 
         test = testcases[2]["test"]
         self.assertTrue(self.test_runner._run_test(test))
+
+    def test_run_testset_with_parameters(self):
+        testcase_file_path = os.path.join(
+            os.getcwd(), 'tests/data/demo_parameters.yml')
+        result = run_suite_path(testcase_file_path)
+        self.assertTrue(result.success)
+        self.assertIn("token", result.output)
+        self.assertEqual(result.stat.total, 6)

tests/test_testcase.py

@@ -3,14 +3,16 @@
 import unittest
 
 from httprunner import testcase
-from httprunner.exception import ApiNotFound, FileFormatError, ParamsError
+from httprunner.exception import (ApiNotFound, FileFormatError,
+                                  FileNotFoundError, ParamsError)
 
 
 class TestcaseParserUnittest(unittest.TestCase):
 
     def test_load_testcases_bad_filepath(self):
         testcase_file_path = os.path.join(os.getcwd(), 'tests/data/demo')
-        self.assertEqual(testcase.load_file(testcase_file_path), [])
+        with self.assertRaises(FileNotFoundError):
+            testcase.load_file(testcase_file_path)
 
     def test_load_json_testcases(self):
         testcase_file_path = os.path.join(
@@ -34,6 +36,111 @@ def test_load_yaml_testcases(self):
         self.assertIn('url', test['request'])
         self.assertIn('method', test['request'])
 
+    def test_load_csv_file_one_parameter(self):
+        csv_file_path = os.path.join(
+            os.getcwd(), 'tests/data/user_agent.csv')
+        csv_content = testcase.load_file(csv_file_path)
+        self.assertEqual(
+            csv_content,
+            [
+                {'user_agent': 'iOS/10.1'},
+                {'user_agent': 'iOS/10.2'},
+                {'user_agent': 'iOS/10.3'}
+            ]
+        )
+
+    def test_load_csv_file_multiple_parameters(self):
+        csv_file_path = os.path.join(
+            os.getcwd(), 'tests/data/username-password.csv')
+        csv_content = testcase.load_file(csv_file_path)
+        self.assertEqual(
+            csv_content,
+            [
+                {'username': 'test1', 'password': '111111'},
+                {'username': 'test2', 'password': '222222'},
+                {'username': 'test3', 'password': '333333'}
+            ]
+        )
+
+    def test_cartesian_product_one(self):
+        parameters_content_list = [
+            [
+                {"a": 1},
+                {"a": 2}
+            ]
+        ]
+        product_list = testcase.gen_cartesian_product(*parameters_content_list)
+        self.assertEqual(
+            product_list,
+            [
+                {"a": 1},
+                {"a": 2}
+            ]
+        )
+
+    def test_cartesian_product_multiple(self):
+        parameters_content_list = [
+            [
+                {"a": 1},
+                {"a": 2}
+            ],
+            [
+                {"x": 111, "y": 112},
+                {"x": 121, "y": 122}
+            ]
+        ]
+        product_list = testcase.gen_cartesian_product(*parameters_content_list)
+        self.assertEqual(
+            product_list,
+            [
+                {'a': 1, 'x': 111, 'y': 112},
+                {'a': 1, 'x': 121, 'y': 122},
+                {'a': 2, 'x': 111, 'y': 112},
+                {'a': 2, 'x': 121, 'y': 122}
+            ]
+        )
+
+    def test_cartesian_product_empty(self):
+        parameters_content_list = []
+        product_list = testcase.gen_cartesian_product(*parameters_content_list)
+        self.assertEqual(product_list, [])
+
+    def test_gen_cartesian_product_parameters_one_to_one(self):
+        parameters = [
+            {"user_agent": "random"},
+            {"app_version": "sequential"}
+        ]
+        testset_path = os.path.join(
+            os.getcwd(),
+            "tests/data/demo_parameters.yml"
+        )
+        cartesian_product_parameters = testcase.gen_cartesian_product_parameters(
+            parameters,
+            testset_path
+        )
+        self.assertEqual(
+            len(cartesian_product_parameters),
+            6
+        )
+
+    def test_gen_cartesian_product_parameters_one_to_multiple(self):
+        parameters = [
+            {"user_agent": "random"},
+            {"username-password": "sequential"}
+        ]
+        testset_path = os.path.join(
+            os.getcwd(),
+            "tests/data/demo_parameters.yml"
+        )
+        cartesian_product_parameters = testcase.gen_cartesian_product_parameters(
+            parameters,
+            testset_path
+        )
+        self.assertEqual(
+            len(cartesian_product_parameters),
+            9
+        )
+
     def test_load_yaml_file_file_format_error(self):
         yaml_tmp_file = "tests/data/tmp.yml"
         # create empty yaml file