refactor pipline

tests/test_api.py

@@ -2,7 +2,7 @@ import os
 import shutil
 import time
 
-from httprunner import HttpRunner, LocustRunner, loader
+from httprunner import HttpRunner, LocustRunner, api, loader, parser
 from locust import HttpLocust
 from tests.api_server import HTTPBIN_SERVER
 from tests.base import ApiServerUnittest
@@ -11,25 +11,22 @@ from tests.base import ApiServerUnittest
 class TestHttpRunner(ApiServerUnittest):
 
     def setUp(self):
-        self.testset_path = "tests/data/demo_testset_cli.yml"
+        self.testcase_cli_path = "tests/data/demo_testset_cli.yml"
         self.testcase_file_path_list = [
             os.path.join(
                 os.getcwd(), 'tests/data/demo_testset_hardcode.yml'),
             os.path.join(
                 os.getcwd(), 'tests/data/demo_testset_hardcode.json')
         ]
-        self.testcase = {
-            'name': 'testset description',
+        self.testcases = [{
             'config': {
-                'name': 'testset description',
+                'name': 'testcase description',
                 'request': {
                     'base_url': '',
                     'headers': {'User-Agent': 'python-requests/2.18.4'}
                 },
-                'variables': [],
-                'output': ['token']
+                'variables': []
             },
-            'api': {},
             'teststeps': [
                 {
                     'name': '/api/get-token',
@@ -63,7 +60,7 @@ class TestHttpRunner(ApiServerUnittest):
                     ]
                 }
             ]
-        }
+        }]
         self.reset_all()
 
     def reset_all(self):
@@ -72,46 +69,35 @@ class TestHttpRunner(ApiServerUnittest):
         return self.api_client.get(url, headers=headers)
 
     def test_text_run_times(self):
-        runner = HttpRunner().run(self.testset_path)
+        runner = HttpRunner().run(self.testcase_cli_path)
         self.assertEqual(runner.summary["stat"]["testsRun"], 10)
 
     def test_text_skip(self):
-        runner = HttpRunner().run(self.testset_path)
+        runner = HttpRunner().run(self.testcase_cli_path)
         self.assertEqual(runner.summary["stat"]["skipped"], 4)
 
     def test_html_report(self):
-        kwargs = {}
-        output_folder_name = os.path.basename(os.path.splitext(self.testset_path)[0])
-        runner = HttpRunner().run(self.testset_path)
+        runner = HttpRunner().run(self.testcase_cli_path)
         summary = runner.summary
         self.assertEqual(summary["stat"]["testsRun"], 10)
         self.assertEqual(summary["stat"]["skipped"], 4)
 
+        output_folder_name = "demo"
         runner.gen_html_report(html_report_name=output_folder_name)
-        report_save_dir = os.path.join(loader.project_working_directory, 'reports', output_folder_name)
+        report_save_dir = os.path.join(os.getcwd(), 'reports', output_folder_name)
         self.assertGreater(len(os.listdir(report_save_dir)), 0)
         shutil.rmtree(report_save_dir)
 
     def test_run_testcases(self):
-        testcases = [self.testcase]
-        runner = HttpRunner().run(testcases)
+        runner = HttpRunner().run_tests(self.testcases)
         summary = runner.summary
         self.assertTrue(summary["success"])
         self.assertEqual(summary["stat"]["testsRun"], 2)
         self.assertIn("details", summary)
         self.assertIn("records", summary["details"][0])
 
-    def test_run_testcase(self):
-        testcases = self.testcase
-        runner = HttpRunner().run(testcases)
-        summary = runner.summary
-        self.assertTrue(summary["success"])
-        self.assertEqual(summary["stat"]["testsRun"], 2)
-        self.assertIn("records", summary["details"][0])
-
     def test_run_yaml_upload(self):
-        testset_path = "tests/httpbin/upload.yml"
-        runner = HttpRunner().run(testset_path)
+        runner = HttpRunner().run("tests/httpbin/upload.yml")
         summary = runner.summary
         self.assertTrue(summary["success"])
         self.assertEqual(summary["stat"]["testsRun"], 1)
@@ -121,7 +107,14 @@ class TestHttpRunner(ApiServerUnittest):
     def test_run_post_data(self):
         testcases = [
             {
-                "name": "post data",
+                "config": {
+                    'name': "post data",
+                    'request': {
+                        'base_url': '',
+                        'headers': {'User-Agent': 'python-requests/2.18.4'}
+                    },
+                    'variables': []
+                },
                 "teststeps": [
                     {
                         "name": "post data",
@@ -141,25 +134,23 @@ class TestHttpRunner(ApiServerUnittest):
                 ]
             }
         ]
-        runner = HttpRunner().run(testcases)
+        runner = HttpRunner().run_tests(testcases)
         summary = runner.summary
         self.assertTrue(summary["success"])
         self.assertEqual(summary["stat"]["testsRun"], 1)
         self.assertEqual(summary["details"][0]["records"][0]["meta_data"]["response"]["json"]["data"], "abc")
 
     def test_html_report_repsonse_image(self):
-        testset_path = "tests/httpbin/load_image.yml"
-        runner = HttpRunner().run(testset_path)
+        runner = HttpRunner().run("tests/httpbin/load_image.yml")
         summary = runner.summary
-        output_folder_name = os.path.basename(os.path.splitext(testset_path)[0])
+        output_folder_name = "demo"
         report = runner.gen_html_report(html_report_name=output_folder_name)
         self.assertTrue(os.path.isfile(report))
-        report_save_dir = os.path.join(loader.project_working_directory, 'reports', output_folder_name)
+        report_save_dir = os.path.join(os.getcwd(), 'reports', output_folder_name)
         shutil.rmtree(report_save_dir)
 
     def test_testcase_layer(self):
-        testcase_path = "tests/testcases/smoketest.yml"
-        runner = HttpRunner(failfast=True).run(testcase_path)
+        runner = HttpRunner(failfast=True).run("tests/testcases/smoketest.yml")
         summary = runner.summary
         self.assertTrue(summary["success"])
         self.assertEqual(summary["stat"]["testsRun"], 8)
@@ -167,7 +158,6 @@ class TestHttpRunner(ApiServerUnittest):
     def test_run_httprunner_with_hooks(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/httpbin/hooks.yml')
-
         start_time = time.time()
         runner = HttpRunner().run(testcase_file_path)
         end_time = time.time()
@@ -180,7 +170,7 @@ class TestHttpRunner(ApiServerUnittest):
             {
                 "config": {
                     "name": "test teardown hooks",
-                    "path": "tests/httpbin/hooks.yml"
+                    "refs": loader.load_project_tests("tests")
                 },
                 "teststeps": [
                     {
@@ -207,16 +197,15 @@ class TestHttpRunner(ApiServerUnittest):
                 ]
             }
         ]
-        runner = HttpRunner().run(testcases)
+        runner = HttpRunner().run_tests(testcases)
         summary = runner.summary
         self.assertTrue(summary["success"])
 
     def test_run_httprunner_with_teardown_hooks_not_exist_attribute(self):
         testcases = [
             {
-                "name": "test teardown hooks",
                 "config": {
-                    "path": "tests/httpbin/hooks.yml"
+                    "name": "test teardown hooks"
                 },
                 "teststeps": [
                     {
@@ -236,7 +225,7 @@ class TestHttpRunner(ApiServerUnittest):
                 ]
             }
         ]
-        runner = HttpRunner().run(testcases)
+        runner = HttpRunner().run_tests(testcases)
         summary = runner.summary
         self.assertFalse(summary["success"])
         self.assertEqual(summary["stat"]["errors"], 1)
@@ -244,8 +233,9 @@ class TestHttpRunner(ApiServerUnittest):
     def test_run_httprunner_with_teardown_hooks_error(self):
         testcases = [
             {
-                "name": "test teardown hooks",
-                "config": {},
+                "config": {
+                    "name": "test teardown hooks"
+                },
                 "teststeps": [
                     {
                         "name": "test teardown hooks",
@@ -261,7 +251,7 @@ class TestHttpRunner(ApiServerUnittest):
                 ]
             }
         ]
-        runner = HttpRunner().run(testcases)
+        runner = HttpRunner().run_tests(testcases)
         summary = runner.summary
         self.assertFalse(summary["success"])
         self.assertEqual(summary["stat"]["errors"], 1)
@@ -269,30 +259,34 @@ class TestHttpRunner(ApiServerUnittest):
     def test_run_testcase_hardcode(self):
         for testcase_file_path in self.testcase_file_path_list:
             runner = HttpRunner().run(testcase_file_path)
-            self.assertTrue(runner.summary["success"])
+            summary = runner.summary
+            self.assertTrue(summary["success"])
+            self.assertEqual(summary["stat"]["testsRun"], 3)
+            self.assertEqual(summary["stat"]["successes"], 3)
 
     def test_run_testcases_hardcode(self):
         runner = HttpRunner().run(self.testcase_file_path_list)
         summary = runner.summary
         self.assertTrue(summary["success"])
+        self.assertTrue(summary["success"])
         self.assertEqual(summary["stat"]["testsRun"], 6)
         self.assertEqual(summary["stat"]["successes"], 6)
 
-    def test_run_testset_template_variables(self):
+    def test_run_testcase_template_variables(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/data/demo_testset_variables.yml')
         runner = HttpRunner().run(testcase_file_path)
         summary = runner.summary
         self.assertTrue(summary["success"])
 
-    def test_run_testset_template_import_functions(self):
+    def test_run_testcase_template_import_functions(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/data/demo_testset_functions.yml')
         runner = HttpRunner().run(testcase_file_path)
         summary = runner.summary
         self.assertTrue(summary["success"])
 
-    def test_run_testset_layered(self):
+    def test_run_testcase_layered(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/data/demo_testset_layer.yml')
         runner = HttpRunner().run(testcase_file_path)
@@ -347,10 +341,10 @@ class TestHttpRunner(ApiServerUnittest):
     def test_run_testcase_with_parameters_name(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/data/demo_parameters.yml')
+        testcases = loader.load_tests(testcase_file_path)
+        parsed_testcases = api.parse_tests(testcases)
         runner = HttpRunner()
-        testcases = runner.load_tests(testcase_file_path)
-        parsed_testcases = runner.parse_tests(testcases)
-        test_suite = runner.add_tests(parsed_testcases)
+        test_suite = runner._add_tests(parsed_testcases)
 
         self.assertEqual(
             test_suite._tests[0].teststeps[0]['name'],
@@ -377,28 +371,17 @@ class TestHttpRunner(ApiServerUnittest):
             'get token with iOS/10.3 and test2'
         )
 
-    def test_load_tests(self):
+    def test_validate_response_content(self):
         testcase_file_path = os.path.join(
-            os.getcwd(), 'tests/data/demo_testcase.yml')
-        runner = HttpRunner()
-        testcases = runner.load_tests(testcase_file_path)
-        self.assertIsInstance(testcases, list)
-        self.assertEqual(
-            testcases[0]["config"]["request"],
-            '$demo_default_request'
-        )
-        self.assertEqual(testcases[0]["config"]["name"], '123$var_a')
-        self.assertIn(
-            "sum_two",
-            runner.project_mapping["debugtalk"]["functions"]
-        )
+            os.getcwd(), 'tests/httpbin/basic.yml')
+        runner = HttpRunner().run(testcase_file_path)
+        self.assertTrue(runner.summary["success"])
 
     def test_parse_tests(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/data/demo_testcase.yml')
-        runner = HttpRunner()
-        testcases = runner.load_tests(testcase_file_path)
-        parsed_testcases = runner.parse_tests(testcases)
+        testcases = loader.load_tests(testcase_file_path)
+        parsed_testcases = api.parse_tests(testcases)
         self.assertEqual(parsed_testcases[0]["config"]["variables"]["var_c"], 3)
         self.assertEqual(len(parsed_testcases), 2 * 2)
         self.assertEqual(
@@ -412,12 +395,6 @@ class TestHttpRunner(ApiServerUnittest):
         self.assertIsInstance(parsed_testcases, list)
         self.assertEqual(parsed_testcases[0]["config"]["name"], '12311')
 
-    def test_validate_response_content(self):
-        testcase_file_path = os.path.join(
-            os.getcwd(), 'tests/httpbin/basic.yml')
-        runner = HttpRunner().run(testcase_file_path)
-        self.assertTrue(runner.summary["success"])
-
 
 class TestLocustRunner(ApiServerUnittest):
 

tests/test_context.py

@@ -9,8 +9,8 @@ from tests.base import ApiServerUnittest
 class TestContext(ApiServerUnittest):
 
     def setUp(self):
-        loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
-        self.debugtalk_module = loader.project_mapping["debugtalk"]
+        project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
+        self.debugtalk_module = project_mapping["debugtalk"]
 
         self.context = context.Context(
             self.debugtalk_module["variables"],
@@ -22,7 +22,6 @@ class TestContext(ApiServerUnittest):
     def test_init_context_functions(self):
         context_functions = self.context.TESTCASE_SHARED_FUNCTIONS_MAPPING
         self.assertIn("gen_md5", context_functions)
-        self.assertIn("equals", context_functions)
 
     def test_init_context_variables(self):
         self.assertEqual(

tests/test_loader.py

@@ -133,29 +133,28 @@ class TestFileLoader(unittest.TestCase):
         self.assertEqual([], files)
 
     def test_load_dot_env_file(self):
-        loader.project_working_directory = os.path.join(
-            os.getcwd(), "tests",
+        dot_env_path = os.path.join(
+            os.getcwd(), "tests", ".env"
         )
-        env_variables_mapping = loader.load_dot_env_file()
+        env_variables_mapping = loader.load_dot_env_file(dot_env_path)
         self.assertIn("PROJECT_KEY", env_variables_mapping)
         self.assertEqual(env_variables_mapping["UserName"], "debugtalk")
 
     def test_load_custom_dot_env_file(self):
-        loader.project_working_directory = os.path.join(
-            os.getcwd(), "tests",
+        dot_env_path = os.path.join(
+            os.getcwd(), "tests", "data", "test.env"
         )
-        loader.dot_env_path = "tests/data/test.env"
-        env_variables_mapping = loader.load_dot_env_file()
+        env_variables_mapping = loader.load_dot_env_file(dot_env_path)
         self.assertIn("PROJECT_KEY", env_variables_mapping)
         self.assertEqual(env_variables_mapping["UserName"], "test")
         self.assertEqual(env_variables_mapping["content_type"], "application/json; charset=UTF-8")
-        loader.dot_env_path = None
 
     def test_load_env_path_not_exist(self):
-        loader.project_working_directory = os.path.join(
+        dot_env_path = os.path.join(
             os.getcwd(), "tests", "data",
         )
-        loader.load_dot_env_file()
+        with self.assertRaises(exceptions.FileNotFound):
+            loader.load_dot_env_file(dot_env_path)
 
     def test_locate_file(self):
         with self.assertRaises(exceptions.FileNotFound):
@@ -198,14 +197,13 @@ class TestModuleLoader(unittest.TestCase):
         self.assertNotIn("is_py3", functions_dict)
 
     def test_load_debugtalk_module(self):
-        loader.load_project_tests(os.path.join(os.getcwd(), "httprunner"))
-        imported_module_items = loader.project_mapping["debugtalk"]
-        self.assertIn("equals", imported_module_items["functions"])
+        project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "httprunner"))
+        imported_module_items = project_mapping["debugtalk"]
         self.assertNotIn("SECRET_KEY", imported_module_items["variables"])
         self.assertNotIn("alter_response", imported_module_items["functions"])
 
-        loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
-        imported_module_items = loader.project_mapping["debugtalk"]
+        project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
+        imported_module_items = project_mapping["debugtalk"]
         self.assertEqual(
             imported_module_items["variables"]["SECRET_KEY"],
             "DebugTalk"
@@ -229,6 +227,11 @@ class TestModuleLoader(unittest.TestCase):
             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)
 
@@ -258,15 +261,30 @@ class TestModuleLoader(unittest.TestCase):
             None
         )
 
+    def test_load_tests(self):
+        testcase_file_path = os.path.join(
+            os.getcwd(), 'tests/data/demo_testcase.yml')
+        testcases = loader.load_tests(testcase_file_path)
+        self.assertIsInstance(testcases, list)
+        self.assertEqual(
+            testcases[0]["config"]["request"],
+            '$demo_default_request'
+        )
+        self.assertEqual(testcases[0]["config"]["name"], '123$var_a')
+        self.assertIn(
+            "sum_two",
+            testcases[0]["config"]["refs"]["debugtalk"]["functions"]
+        )
+
 
 class TestSuiteLoader(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
+        cls.project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
 
     def test_load_test_file_testcase(self):
-        testcase = loader._load_test_file("tests/testcases/smoketest.yml")
+        testcase = loader._load_test_file("tests/testcases/smoketest.yml", self.project_mapping)
         self.assertEqual(testcase["config"]["name"], "smoketest")
         self.assertIn("device_sn", testcase["config"]["variables"][0])
         self.assertEqual(len(testcase["teststeps"]), 8)
@@ -274,7 +292,7 @@ class TestSuiteLoader(unittest.TestCase):
 
     def test_get_block_by_name(self):
         ref_call = "get_user($uid, $token)"
-        block = loader._get_block_by_name(ref_call, "def-api")
+        block = loader._get_block_by_name(ref_call, "def-api", self.project_mapping)
         self.assertEqual(block["request"]["url"], "/api/users/$uid")
         self.assertEqual(block["function_meta"]["func_name"], "get_user")
         self.assertEqual(block["function_meta"]["args"], ['$uid', '$token'])
@@ -282,11 +300,14 @@ class TestSuiteLoader(unittest.TestCase):
     def test_get_block_by_name_args_mismatch(self):
         ref_call = "get_user($uid, $token, $var)"
         with self.assertRaises(exceptions.ParamsError):
-            loader._get_block_by_name(ref_call, "def-api")
+            loader._get_block_by_name(ref_call, "def-api", self.project_mapping)
 
     def test_override_block(self):
         def_block = loader._get_block_by_name(
-            "get_token($user_agent, $device_sn, $os_platform, $app_version)", "def-api")
+            "get_token($user_agent, $device_sn, $os_platform, $app_version)",
+            "def-api",
+            self.project_mapping
+        )
         test_block = {
             "name": "override block",
             "variables": [
@@ -306,20 +327,20 @@ class TestSuiteLoader(unittest.TestCase):
         self.assertIn({'check': 'content.token', 'comparator': 'len_eq', 'expect': 32}, test_block["validate"])
 
     def test_get_test_definition_api(self):
-        api_def = loader._get_test_definition("get_headers", "def-api")
+        api_def = loader._get_test_definition("get_headers", "def-api", self.project_mapping)
         self.assertEqual(api_def["request"]["url"], "/headers")
         self.assertEqual(len(api_def["setup_hooks"]), 2)
         self.assertEqual(len(api_def["teardown_hooks"]), 1)
 
         with self.assertRaises(exceptions.ApiNotFound):
-            loader._get_test_definition("get_token_XXX", "def-api")
+            loader._get_test_definition("get_token_XXX", "def-api", self.project_mapping)
 
     def test_get_test_definition_suite(self):
-        api_def = loader._get_test_definition("create_and_check", "def-testcase")
+        api_def = loader._get_test_definition("create_and_check", "def-testcase", self.project_mapping)
         self.assertEqual(api_def["config"]["name"], "create user and check result.")
 
         with self.assertRaises(exceptions.TestcaseNotFound):
-            loader._get_test_definition("create_and_check_XXX", "def-testcase")
+            loader._get_test_definition("create_and_check_XXX", "def-testcase", self.project_mapping)
 
     def test_merge_validator(self):
         def_validators = [
@@ -379,51 +400,59 @@ class TestSuiteLoader(unittest.TestCase):
         )
 
     def test_load_testcases_by_path_files(self):
-        testsets_list = []
+        testcases_list = []
 
         # absolute file path
         path = os.path.join(
             os.getcwd(), 'tests/data/demo_testset_hardcode.json')
-        testset_list = loader.load_testcases(path)
-        self.assertEqual(len(testset_list), 1)
-        self.assertEqual(len(testset_list[0]["teststeps"]), 3)
-        testsets_list.extend(testset_list)
+        testcases_list = loader.load_tests(path)
+        self.assertEqual(len(testcases_list), 1)
+        self.assertEqual(len(testcases_list[0]["teststeps"]), 3)
+        self.assertEqual(
+            testcases_list[0]["config"]["refs"]["debugtalk"]["variables"]["SECRET_KEY"],
+            "DebugTalk"
+        )
+        self.assertIn("get_sign", testcases_list[0]["config"]["refs"]["debugtalk"]["functions"])
 
         # relative file path
         path = 'tests/data/demo_testset_hardcode.yml'
-        testset_list = loader.load_testcases(path)
-        self.assertEqual(len(testset_list), 1)
-        self.assertEqual(len(testset_list[0]["teststeps"]), 3)
-        testsets_list.extend(testset_list)
+        testcases_list = loader.load_tests(path)
+        self.assertEqual(len(testcases_list), 1)
+        self.assertEqual(len(testcases_list[0]["teststeps"]), 3)
+        self.assertEqual(
+            testcases_list[0]["config"]["refs"]["debugtalk"]["variables"]["SECRET_KEY"],
+            "DebugTalk"
+        )
+        self.assertIn("get_sign", testcases_list[0]["config"]["refs"]["debugtalk"]["functions"])
 
         # list/set container with file(s)
         path = [
             os.path.join(os.getcwd(), 'tests/data/demo_testset_hardcode.json'),
             'tests/data/demo_testset_hardcode.yml'
         ]
-        testset_list = loader.load_testcases(path)
-        self.assertEqual(len(testset_list), 2)
-        self.assertEqual(len(testset_list[0]["teststeps"]), 3)
-        self.assertEqual(len(testset_list[1]["teststeps"]), 3)
-        testsets_list.extend(testset_list)
-        self.assertEqual(len(testsets_list), 4)
+        testcases_list = loader.load_tests(path)
+        self.assertEqual(len(testcases_list), 2)
+        self.assertEqual(len(testcases_list[0]["teststeps"]), 3)
+        self.assertEqual(len(testcases_list[1]["teststeps"]), 3)
+        testcases_list.extend(testcases_list)
+        self.assertEqual(len(testcases_list), 4)
 
-        for testset in testsets_list:
-            for test in testset["teststeps"]:
-                self.assertIn('name', test)
-                self.assertIn('request', test)
-                self.assertIn('url', test['request'])
-                self.assertIn('method', test['request'])
+        for testcase in testcases_list:
+            for teststep in testcase["teststeps"]:
+                self.assertIn('name', teststep)
+                self.assertIn('request', teststep)
+                self.assertIn('url', teststep['request'])
+                self.assertIn('method', teststep['request'])
 
     def test_load_testcases_by_path_folder(self):
         # absolute folder path
         path = os.path.join(os.getcwd(), 'tests/data')
-        testset_list_1 = loader.load_testcases(path)
+        testset_list_1 = loader.load_tests(path)
         self.assertGreater(len(testset_list_1), 4)
 
         # relative folder path
         path = 'tests/data/'
-        testset_list_2 = loader.load_testcases(path)
+        testset_list_2 = loader.load_tests(path)
         self.assertEqual(len(testset_list_1), len(testset_list_2))
 
         # list/set container with file(s)
@@ -431,19 +460,19 @@ class TestSuiteLoader(unittest.TestCase):
             os.path.join(os.getcwd(), 'tests/data'),
             'tests/data/'
         ]
-        testset_list_3 = loader.load_testcases(path)
+        testset_list_3 = loader.load_tests(path)
         self.assertEqual(len(testset_list_3), 2 * len(testset_list_1))
 
     def test_load_testcases_by_path_not_exist(self):
         # absolute folder path
         path = os.path.join(os.getcwd(), 'tests/data_not_exist')
         with self.assertRaises(exceptions.FileNotFound):
-            loader.load_testcases(path)
+            loader.load_tests(path)
 
         # relative folder path
         path = 'tests/data_not_exist'
         with self.assertRaises(exceptions.FileNotFound):
-            loader.load_testcases(path)
+            loader.load_tests(path)
 
         # list/set container with file(s)
         path = [
@@ -451,17 +480,17 @@ class TestSuiteLoader(unittest.TestCase):
             'tests/data_not_exist/'
         ]
         with self.assertRaises(exceptions.FileNotFound):
-            loader.load_testcases(path)
+            loader.load_tests(path)
 
     def test_load_testcases_by_path_layered(self):
         path = os.path.join(
             os.getcwd(), 'tests/data/demo_testset_layer.yml')
-        testsets_list = loader.load_testcases(path)
-        self.assertIn("variables", testsets_list[0]["config"])
-        self.assertIn("request", testsets_list[0]["config"])
-        self.assertIn("request", testsets_list[0]["teststeps"][0])
-        self.assertIn("url", testsets_list[0]["teststeps"][0]["request"])
-        self.assertIn("validate", testsets_list[0]["teststeps"][0])
+        testcases_list = loader.load_tests(path)
+        self.assertIn("variables", testcases_list[0]["config"])
+        self.assertIn("request", testcases_list[0]["config"])
+        self.assertIn("request", testcases_list[0]["teststeps"][0])
+        self.assertIn("url", testcases_list[0]["teststeps"][0]["request"])
+        self.assertIn("validate", testcases_list[0]["teststeps"][0])
 
     def test_load_folder_content(self):
         path = os.path.join(os.getcwd(), "tests", "api")
@@ -507,8 +536,7 @@ class TestSuiteLoader(unittest.TestCase):
         )
 
     def test_load_project_tests(self):
-        loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
-        project_mapping = loader.project_mapping
+        project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
         self.assertEqual(project_mapping["debugtalk"]["variables"]["SECRET_KEY"], "DebugTalk")
         self.assertIn("get_token", project_mapping["def-api"])
         self.assertIn("setup_and_reset", project_mapping["def-testcase"])

tests/test_parser.py

@@ -384,6 +384,10 @@ class TestParser(unittest.TestCase):
             os.getcwd(),
             "tests/data/demo_parameters.yml"
         )
+        dot_env_path = os.path.join(
+            os.getcwd(), "tests", ".env"
+        )
+        loader.load_dot_env_file(dot_env_path)
         from tests import debugtalk
         debugtalk_module = loader.load_python_module(debugtalk)
         cartesian_product_parameters = parser.parse_parameters(
@@ -412,8 +416,7 @@ class TestParser(unittest.TestCase):
         )
 
     def test_parse_parameters_mix(self):
-        loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
-        project_mapping = loader.project_mapping
+        project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
 
         parameters = [
             {"user_agent": ["iOS/10.1", "iOS/10.2", "iOS/10.3"]},

tests/test_runner.py

@@ -10,8 +10,8 @@ from tests.base import ApiServerUnittest
 class TestRunner(ApiServerUnittest):
 
     def setUp(self):
-        loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
-        self.debugtalk_module = loader.project_mapping["debugtalk"]
+        project_mapping = loader.load_project_tests(os.path.join(os.getcwd(), "tests"))
+        self.debugtalk_module = project_mapping["debugtalk"]
         config_dict = {
             "variables": self.debugtalk_module["variables"],
             "functions": self.debugtalk_module["functions"]
@@ -226,7 +226,7 @@ class TestRunner(ApiServerUnittest):
     def test_run_testcase_with_empty_header(self):
         testcase_file_path = os.path.join(
             os.getcwd(), 'tests/data/test_bugfix.yml')
-        testsets = loader.load_testcases(testcase_file_path)
+        testsets = loader.load_tests(testcase_file_path)
         testset = testsets[0]
         config_dict_headers = testset["config"]["request"]["headers"]
         test_dict_headers = testset["teststeps"][0]["request"]["headers"]