edq-utils 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

edq/testing/httpserver_test.py

@@ -0,0 +1,424 @@
+import os
+
+import edq.testing.httpserver
+import edq.util.net
+
+THIS_DIR: str = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
+TEST_EXCHANGES_DIR: str = os.path.join(THIS_DIR, "testdata", "http", 'exchanges')
+
+class HTTPTestServerTest(edq.testing.httpserver.HTTPServerTest):
+    """ Test the HTTP test server. """
+
+    @classmethod
+    def setup_server(cls, server: edq.testing.httpserver.HTTPTestServer) -> None:
+        edq.testing.httpserver.HTTPServerTest.setup_server(server)
+        server.load_exchanges_dir(TEST_EXCHANGES_DIR)
+
+    def test_exchange_validation(self):
+        """ Test validation of exchanges. """
+
+        # [(kwargs, expected, error substring), ...]
+        test_cases = [
+            # Base
+
+            (
+                {
+                    'method': 'GET',
+                    'url': 'simple',
+                },
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                ),
+                None,
+            ),
+
+            (
+                {
+                    'method': 'ZZZ',
+                    'url': 'simple',
+                },
+                None,
+                'unknown/disallowed method',
+            ),
+
+            (
+                {
+                },
+                None,
+                'URL path cannot be empty',
+            ),
+
+            # URL Components
+
+            (
+                {
+                    'url': 'foo?a=b#c',
+                },
+                edq.util.net.HTTPExchange(
+                    url_path = 'foo',
+                    url_anchor = 'c',
+                    parameters = {
+                        'a': 'b',
+                    },
+                ),
+                None,
+            ),
+
+            (
+                {
+                    'url': 'for',
+                    'url_path': 'bar',
+                },
+                None,
+                'Mismatched URL paths',
+            ),
+
+            (
+                {
+                    'url': 'for#a',
+                    'url_anchor': 'b',
+                },
+                None,
+                'Mismatched URL anchors',
+            ),
+
+            # Files
+
+            (
+                {
+                    'url': 'foo',
+                    'files': [
+                        {
+                            'path': 'test.txt',
+                        }
+                    ],
+                },
+                edq.util.net.HTTPExchange(
+                    url_path = 'foo',
+                    files = [
+                        edq.util.net.FileInfo(name = 'test.txt', path = 'test.txt'),
+                    ]
+                ),
+                None,
+            ),
+
+            (
+                {
+                    'url': 'foo',
+                    'files': [
+                        {
+                            'content': '',
+                        }
+                    ],
+                },
+                None,
+                'No name was provided for file',
+            ),
+
+            (
+                {
+                    'url': 'foo',
+                    'files': [
+                        {
+                            'name': 'foo.txt',
+                        }
+                    ],
+                },
+                None,
+                'File must have either path or content',
+            ),
+
+            # JSON Response Body
+
+            (
+                {
+                    'url': 'foo',
+                    'response_body': {
+                        'a': 1,
+                    }
+                },
+                edq.util.net.HTTPExchange(
+                    url_path = 'foo',
+                    json_body = True,
+                    response_body = '{"a": 1}',
+                ),
+                None,
+            ),
+
+            (
+                {
+                    'url': 'foo',
+                    'response_body': [{
+                        'a': 1,
+                    }]
+                },
+                edq.util.net.HTTPExchange(
+                    url_path = 'foo',
+                    json_body = True,
+                    response_body = '[{"a": 1}]',
+                ),
+                None,
+            ),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (kwargs, expected, error_substring) = test_case
+
+            with self.subTest(msg = f"Case {i}:"):
+                try:
+                    actual = edq.util.net.HTTPExchange(**kwargs)
+                except Exception as ex:
+                    error_string = self.format_error_string(ex)
+                    if (error_substring is None):
+                        self.fail(f"Unexpected error: '{error_string}'.")
+
+                    self.assertIn(error_substring, error_string, 'Error is not as expected.')
+
+                    continue
+
+                if (error_substring is not None):
+                    self.fail(f"Did not get expected error: '{error_substring}'.")
+
+                self.assertJSONDictEqual(expected, actual)
+
+    def test_exchange_matching_base(self):
+        """ Test matching exchanges against queries. """
+
+        # {<file basename no ext>: exchange, ...}
+        exchanges = {}
+        for exchange in self.get_server().get_exchanges():
+            key = os.path.basename(exchange.source_path).replace(edq.util.net.DEFAULT_HTTP_EXCHANGE_EXTENSION, '')
+            exchanges[key] = exchange
+
+        # [(target, query, match?, hint substring), ...]
+        test_cases = [
+            # Base
+            (
+                exchanges['simple'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                ),
+                {},
+                True,
+                None,
+            ),
+
+            # Params
+            (
+                exchanges['simple_params'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                    parameters = {
+                        'a': '1',
+                        'b': '2',
+                    },
+                ),
+                {},
+                True,
+                None,
+            ),
+
+            # Params, skip missing.
+            (
+                exchanges['simple'],
+                exchanges['simple_params'],
+                {
+                    'params_to_skip': ['a', 'b'],
+                },
+                True,
+                None,
+            ),
+
+            # Headers, skip missing.
+            (
+                exchanges['simple'],
+                exchanges['simple_headers'],
+                {
+                    'headers_to_skip': ['a'],
+                },
+                True,
+                None,
+            ),
+
+            # Param, skip unmatching.
+            (
+                exchanges['simple_params'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                    parameters = {
+                        'a': '1',
+                        'b': 'ZZZ',
+                    },
+                ),
+                {
+                    'params_to_skip': ['b'],
+                },
+                True,
+                None,
+            ),
+
+            (
+                exchanges['simple'],
+                exchanges['simple_headers'],
+                {
+                    'match_headers': False,
+                },
+                True,
+                None,
+            ),
+
+            # Misses
+
+            # Missed method.
+            (
+                exchanges['simple'],
+                edq.util.net.HTTPExchange(
+                    method = 'POST',
+                    url = 'simple',
+                ),
+                {},
+                False,
+                'method does not match',
+            ),
+            (
+                exchanges['simple'],
+                exchanges['simple_post'],
+                {},
+                False,
+                'method does not match',
+            ),
+
+            # Missed URL path.
+            (
+                exchanges['simple'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'ZZZ',
+                ),
+                {},
+                False,
+                'URL path does not match',
+            ),
+
+            # Missed URL anchor.
+            (
+                exchanges['simple'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple#1',
+                ),
+                {},
+                False,
+                'URL anchor does not match',
+            ),
+
+            # Missed number of params.
+            (
+                exchanges['simple'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                    parameters = {'a': '1'},
+                ),
+                {},
+                False,
+                'Parameter keys do not match',
+            ),
+            (
+                exchanges['simple_post'],
+                exchanges['simple_post_params'],
+                {},
+                False,
+                'Parameter keys do not match',
+            ),
+            (
+                exchanges['simple_post'],
+                exchanges['simple_post_urlparams'],
+                {},
+                False,
+                'Parameter keys do not match',
+            ),
+
+            # Missed param value.
+            (
+                exchanges['simple_params'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                    parameters = {
+                        'a': '1',
+                        'b': 'ZZZ',
+                    },
+                ),
+                {},
+                False,
+                "Parameter 'b' has a non-matching value",
+            ),
+
+            # Missed number of headers.
+            (
+                exchanges['simple'],
+                exchanges['simple_headers'],
+                {
+                    'match_headers': True,
+                },
+                False,
+                'Header keys do not match',
+            ),
+
+            # Missed header value.
+            (
+                exchanges['simple_headers'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                    headers = {
+                        'a': 'ZZZ',
+                    },
+                ),
+                {
+                    'match_headers': True,
+                },
+                False,
+                "Header 'a' has a non-matching value",
+            ),
+
+            # Param, with skip.
+            (
+                exchanges['simple_params'],
+                edq.util.net.HTTPExchange(
+                    method = 'GET',
+                    url = 'simple',
+                    parameters = {
+                        'a': '1',
+                        'b': 'ZZZ',
+                    },
+                ),
+                {
+                    'params_to_skip': ['a'],
+                },
+                False,
+                "Parameter 'b' has a non-matching value",
+            ),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (target, query, match_options, expected_match, hint_substring) = test_case
+            base_name = os.path.basename(target.source_path).replace(edq.util.net.DEFAULT_HTTP_EXCHANGE_EXTENSION, '')
+
+            with self.subTest(msg = f"Case {i} ('{base_name}'):"):
+                actual_match, hint = target.match(query, **match_options)
+
+                self.assertEqual(expected_match, actual_match, f"Match status does not agree (hint: '{hint}').")
+
+                if (hint is not None):
+                    if (hint_substring is None):
+                        self.fail(f"Unexpected hint: '{hint}'.")
+
+                    self.assertIn(hint_substring, hint, 'Hint is not as expected.')
+                elif (hint_substring is not None):
+                    self.fail(f"Did not get expected hint: '{hint_substring}'.")

edq/testing/run.py

@@ -12,6 +12,13 @@ import typing
 import unittest
 
 DEFAULT_TEST_FILENAME_PATTERN: str = '*_test.py'
+""" The default pattern for test files. """
+
+CLEANUP_FUNC_NAME: str = 'suite_cleanup'
+"""
+If a test class has a function with this name,
+then the function will be run after the test suite finishes.
+"""
 
 def _collect_tests(suite: typing.Union[unittest.TestCase, unittest.suite.TestSuite]) -> typing.List[unittest.TestCase]:
     """
@@ -30,44 +37,67 @@ def _collect_tests(suite: typing.Union[unittest.TestCase, unittest.suite.TestSui
 
     return test_cases
 
-def run(args: argparse.Namespace) -> int:
+def run(args: typing.Union[argparse.Namespace, typing.Dict[str, typing.Any], None] = None) -> int:
     """
     Discover and run unit tests.
     This function may change your working directory.
     Will raise if tests fail to load (e.g. syntax errors) and a suggested exit code otherwise.
     """
 
-    if (args.work_dir is not None):
-        os.chdir(args.work_dir)
+    if (args is None):
+        args = {}
+
+    if (not isinstance(args, dict)):
+        args = vars(args)
+
+    if (args.get('work_dir', None) is not None):
+        os.chdir(args['work_dir'])
 
-    if (args.path_additions is not None):
-        for path in args.path_additions:
+    if (args.get('path_additions', None) is not None):
+        for path in args['path_additions']:
             sys.path.append(path)
 
-    if (args.test_dirs is None):
-        args.test_dirs = ['.']
+    test_dirs = args.get('test_dirs', None)
+    if (test_dirs is None):
+        test_dirs = []
+
+    if (len(test_dirs) == 0):
+        test_dirs.append('.')
 
     runner = unittest.TextTestRunner(verbosity = 3)
     test_cases = []
 
-    for test_dir in args.test_dirs:
-        discovered_suite = unittest.TestLoader().discover(test_dir, pattern = args.filename_pattern)
+    for test_dir in test_dirs:
+        discovered_suite = unittest.TestLoader().discover(test_dir, pattern = args.get('filename_pattern', DEFAULT_TEST_FILENAME_PATTERN))
         test_cases += _collect_tests(discovered_suite)
 
+    # Cleanup class functions from test classes.
+    # {class: function, ...}
+    cleanup_funcs = {}
+
     tests = unittest.suite.TestSuite()
 
     for test_case in test_cases:
         if (isinstance(test_case, unittest.loader._FailedTest)):  # type: ignore[attr-defined]
             raise ValueError(f"Failed to load test: '{test_case.id()}'.") from test_case._exception
 
-        if (args.pattern is None or re.search(args.pattern, test_case.id())):
+        pattern = args.get('pattern', None)
+        if ((pattern is None) or re.search(pattern, test_case.id())):
             tests.addTest(test_case)
+
+            # Check for a cleanup function.
+            if (hasattr(test_case.__class__, CLEANUP_FUNC_NAME)):
+                cleanup_funcs[test_case.__class__] = getattr(test_case.__class__, CLEANUP_FUNC_NAME)
         else:
             print(f"Skipping {test_case.id()} because of match pattern.")
 
     result = runner.run(tests)
     faults = len(result.errors) + len(result.failures)
 
+    # Perform any cleanup.
+    for cleanup_func in cleanup_funcs.values():
+        cleanup_func()
+
     if (not result.wasSuccessful()):
         # This value will be used as an exit status, so it should not be larger than a byte.
         # (Some higher values are used specially, so just keep it at a round number.)

edq/testing/testdata/cli/data/configs/empty/edq-config.json

@@ -0,0 +1 @@
+{}

edq/testing/testdata/cli/data/configs/simple-1/edq-config.json

@@ -0,0 +1,4 @@
+{
+    "user": "user@test.edulinq.org",
+}
+

edq/testing/testdata/cli/data/configs/simple-2/edq-config.json

@@ -0,0 +1,3 @@
+{
+    "api-key": "KEY-1234567890",
+}

edq/testing/testdata/cli/data/configs/value-number/edq-config.json

@@ -0,0 +1,3 @@
+{
+  "timeout": 60
+}

edq/testing/testdata/cli/tests/config/list/config_list_base.txt

@@ -0,0 +1,16 @@
+{
+    "cli": "edq.cli.config.list",
+    "arguments": [
+        "--config-global", "__DATA_DIR__(configs/empty/edq-config.json)",
+        "--config-file", "__DATA_DIR__(configs/simple-1/edq-config.json)",
+        "--config-file", "__DATA_DIR__(configs/simple-2/edq-config.json)",
+        "--config", "pass=password1234",
+        "--config", "server=http://test.edulinq.org"
+    ],
+}
+---
+Key	Value
+api-key	KEY-1234567890
+pass	password1234
+server	http://test.edulinq.org
+user	user@test.edulinq.org

edq/testing/testdata/cli/tests/config/list/config_list_config_value_number.txt

@@ -0,0 +1,10 @@
+{
+    "cli": "edq.cli.config.list",
+    "arguments": [
+        "--config-global", "__DATA_DIR__(configs/empty/edq-config.json)",
+        "--config-file", "__DATA_DIR__(configs/value-number/edq-config.json)",
+    ],
+}
+---
+Key	Value
+timeout	60

edq/testing/testdata/cli/tests/config/list/config_list_ignore_config.txt

@@ -0,0 +1,14 @@
+{
+    "cli": "edq.cli.config.list",
+    "arguments": [
+        "--ignore-config-option", "pass",
+        "--ignore-config-option", "api-key",
+        "--config-global", "__DATA_DIR__(configs/empty/edq-config.json)",
+        "--config-file", "__DATA_DIR__(configs/simple-1/edq-config.json)",
+        "--config-file", "__DATA_DIR__(configs/simple-2/edq-config.json)",
+        "--config", "pass=password1234",
+    ],
+}
+---
+Key	Value
+user	user@test.edulinq.org

edq/testing/testdata/cli/tests/config/list/config_list_no_config.txt

@@ -0,0 +1,8 @@
+{
+    "cli": "edq.cli.config.list",
+    "arguments": [
+        "--config-global", "__DATA_DIR__(configs/empty/edq-config.json)",
+    ],
+}
+---
+Key	Value

edq/testing/testdata/cli/tests/config/list/config_list_show_origin.txt

@@ -0,0 +1,13 @@
+{
+    "cli": "edq.cli.config.list",
+    "arguments": [
+        "--config-file", "__DATA_DIR__(configs/simple-1/edq-config.json)",
+        "--config-global", "__DATA_DIR__(configs/empty/edq-config.json)",
+        "--config", "pass=password1234",
+        "--show-origin",
+    ],
+}
+---
+Key	Value	Origin
+pass	password1234	<cli argument>
+user	user@test.edulinq.org	__ABS_DATA_DIR__(configs/simple-1/edq-config.json)

edq/testing/testdata/cli/tests/config/list/config_list_skip_header.txt

@@ -0,0 +1,10 @@
+{
+    "cli": "edq.cli.config.list",
+    "arguments": [
+        "--config-global", "__DATA_DIR__(configs/empty/edq-config.json)",
+        "--config", "user=user@test.edulinq.org",
+        "--skip-header",
+    ],
+}
+---
+user	user@test.edulinq.org

edq/testing/testdata/http/exchanges/simple.httpex.json

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "response_body": "simple"
+}

edq/testing/testdata/http/exchanges/simple_anchor.httpex.json

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple#a",
+    "response_body": "simple_anchor"
+}

edq/testing/testdata/http/exchanges/simple_file.httpex.json

@@ -0,0 +1,10 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/a.txt"
+        }
+    ],
+    "response_body": "simple_file"
+}

edq/testing/testdata/http/exchanges/simple_file_binary.httpex.json

@@ -0,0 +1,10 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/tiny.png"
+        }
+    ],
+    "response_body": "simple_file_binary"
+}

edq/testing/testdata/http/exchanges/simple_file_get_params.httpex.json

@@ -0,0 +1,14 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "parameters": {
+        "a": "1",
+        "b": "2"
+    },
+    "files": [
+        {
+            "path": "../files/a.txt"
+        }
+    ],
+    "response_body": "simple_file_get_params"
+}

edq/testing/testdata/http/exchanges/simple_file_multiple.httpex.json

@@ -0,0 +1,13 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/a.txt"
+        },
+        {
+            "path": "../files/tiny.png"
+        }
+    ],
+    "response_body": "simple_file_multiple"
+}