edq-utils 0.1.9__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

@@ -0,0 +1,142 @@
+"""
+Discover and run unit tests (via Python's unittest package)
+that live in this project's base package
+(the parent of this package).
+"""
+
+import argparse
+import os
+import re
+import sys
+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]:
+    """
+    Collect and return tests (unittest.TestCase) from the target directory.
+    """
+
+    if (isinstance(suite, unittest.TestCase)):
+        return [suite]
+
+    if (not isinstance(suite, unittest.suite.TestSuite)):
+        raise ValueError(f"Unknown test type: '{str(type(suite))}'.")
+
+    test_cases = []
+    for test_object in suite:
+        test_cases += _collect_tests(test_object)
+
+    return test_cases
+
+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 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.get('path_additions', None) is not None):
+        for path in args['path_additions']:
+            sys.path.append(path)
+
+    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 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
+
+        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.)
+        return max(1, min(faults, 100))
+
+    return 0
+
+def main() -> int:
+    """ Parse the CLI arguments and run tests. """
+
+    args = _get_parser().parse_args()
+    return run(args)
+
+def _get_parser() -> argparse.ArgumentParser:
+    """ Build a parser for CLI arguments. """
+
+    parser = argparse.ArgumentParser(description = 'Run unit tests discovered in this project.')
+
+    parser.add_argument('--work-dir', dest = 'work_dir',
+        action = 'store', type = str, default = os.getcwd(),
+        help = 'Set the working directory when running tests, defaults to the current working directory (%(default)s).')
+
+    parser.add_argument('--tests-dir', dest = 'test_dirs',
+        action = 'append',
+        help = 'Discover tests from these directories. Defaults to the current directory.')
+
+    parser.add_argument('--add-path', dest = 'path_additions',
+        action = 'append',
+        help = 'If supplied, add this path the sys.path before running tests.')
+
+    parser.add_argument('--filename-pattern', dest = 'filename_pattern',
+        action = 'store', type = str, default = DEFAULT_TEST_FILENAME_PATTERN,
+        help = 'The pattern to use to find test files (default: %(default)s).')
+
+    parser.add_argument('pattern',
+        action = 'store', type = str, default = None, nargs = '?',
+        help = 'If supplied, only tests with names matching this pattern will be run. This pattern is used directly in re.search().')
+
+    return parser
+
+if __name__ == '__main__':
+    sys.exit(main())

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/cli/tests/help_base.txt

@@ -0,0 +1,9 @@
+{
+    "cli": "edq.cli.version",
+    "arguments": [
+        '--help'
+    ],
+    "error": true
+}
+---
+builtins.SystemExit: 0

edq/testing/testdata/cli/tests/platform_skip.txt

@@ -0,0 +1,5 @@
+{
+    "cli": "package.that.does.not.exist.and.should.never.be.called",
+    "platform_skip": ".*"
+}
+---

edq/testing/testdata/cli/tests/version_base.txt

@@ -0,0 +1,6 @@
+{
+    "cli": "edq.cli.version",
+    "arguments": [],
+}
+---
+<VERSION>

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

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