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

edq/procedure/verify_exchanges.py

@@ -0,0 +1,85 @@
+"""
+Verify that exchanges sent to a given server have the same response.
+"""
+
+import glob
+import logging
+import os
+import typing
+import unittest
+
+import edq.testing.unittest
+import edq.util.net
+
+class ExchangeVerification(edq.testing.unittest.BaseTest):
+    """ Verify that exchanges match their content. """
+
+def run(paths: typing.List[str], server: str) -> int:
+    """ Run exchange verification. """
+
+    exchange_paths = _collect_exchange_paths(paths)
+
+    _attach_tests(exchange_paths, server)
+
+    runner = unittest.TextTestRunner(verbosity = 2)
+    tests = unittest.defaultTestLoader.loadTestsFromTestCase(ExchangeVerification)
+    results = runner.run(tests)
+
+    return len(results.errors) + len(results.failures)
+
+def _attach_tests(
+        paths: typing.List[str],
+        server: str,
+        extension: str = edq.util.net.DEFAULT_HTTP_EXCHANGE_EXTENSION,
+        ) -> None:
+    """ Create tests for each path and attach them to the ExchangeVerification class. """
+
+    common_prefix = os.path.commonprefix(paths)
+
+    for path in paths:
+        name = path.replace(common_prefix, '').replace(extension, '')
+        test_name = f"test_verify_exchange__{name}"
+
+        setattr(ExchangeVerification, test_name, _get_test_method(path, server))
+
+def _get_test_method(path: str, server: str,
+        match_options: typing.Union[typing.Dict[str, typing.Any], None] = None,
+        ) -> typing.Callable:
+    """ Create a test method for the given path. """
+
+    if (match_options is None):
+        match_options = {}
+
+    def __method(self: edq.testing.unittest.BaseTest) -> None:
+        exchange = edq.util.net.HTTPExchange.from_path(path)
+        response, body = exchange.make_request(server, raise_for_status = False, **match_options)
+
+        match, hint = exchange.match_response(response, override_body = body, **match_options)
+        if (not match):
+            raise AssertionError(f"Exchange does not match: '{hint}'.")
+
+    return __method
+
+def _collect_exchange_paths(
+        paths: typing.List[str],
+        extension: str = edq.util.net.DEFAULT_HTTP_EXCHANGE_EXTENSION,
+        ) -> typing.List[str]:
+    """ Collect exchange files by matching extensions and descending dirs. """
+
+    final_paths = []
+
+    for path in paths:
+        path = os.path.abspath(path)
+
+        if (os.path.isfile(path)):
+            if (path.endswith(extension)):
+                final_paths.append(path)
+            else:
+                logging.warning("Path does not look like an exchange file: '%s'.", path)
+        else:
+            dirent_paths = glob.glob(os.path.join(path, "**", f"*{extension}"), recursive = True)
+            for dirent_path in dirent_paths:
+                final_paths.append(dirent_path)
+
+    final_paths.sort()
+    return final_paths

edq/testing/asserts.py

@@ -37,7 +37,6 @@ class StringComparisonAssertion(typing.Protocol):
         Perform an assertion between expected and actual data.
         """
 
-
 def content_equals_raw(test: edq.testing.unittest.BaseTest, expected: str, actual: str, **kwargs: typing.Any) -> None:
     """ Check for equality using a simple string comparison. """
 

edq/testing/cli.py

@@ -9,6 +9,12 @@ and a second part which is the expected text output (stdout).
 For the keys of the JSON section, see the defaulted arguments to CLITestInfo.
 The options JSON will be splatted into CLITestInfo's constructor.
 
+If a test class implements a method with the signature `modify_cli_test_info(self, test_info: CLITestInfo) -> None`,
+then this method will be called with the test info right after the test info is read from disk.
+
+If a test class implements a class method with the signature `get_test_basename(cls, path: str) -> str`,
+then this method will be called to create the base name for the test case at the given path.
+
 The expected output or any argument can reference the test's current temp or data dirs with `__TEMP_DIR__()` or `__DATA_DIR__()`, respectively.
 An optional slash-separated path can be used as an argument to reference a path within those base directories.
 For example, `__DATA_DIR__(foo/bar.txt)` references `bar.txt` inside the `foo` directory inside the data directory.
@@ -30,6 +36,7 @@ import edq.util.pyimport
 
 TEST_CASE_SEP: str = '---'
 DATA_DIR_ID: str = '__DATA_DIR__'
+ABS_DATA_DIR_ID: str = '__ABS_DATA_DIR__'
 TEMP_DIR_ID: str = '__TEMP_DIR__'
 BASE_DIR_ID: str = '__BASE_DIR__'
 
@@ -175,6 +182,7 @@ class CLITestInfo:
             (DATA_DIR_ID, self.data_dir),
             (TEMP_DIR_ID, self.temp_dir),
             (BASE_DIR_ID, self.base_dir),
+            (ABS_DATA_DIR_ID, os.path.abspath(self.data_dir)),
         ]
 
         for (key, target_dir) in replacements:
@@ -251,6 +259,10 @@ def _get_test_method(test_name: str, path: str, data_dir: str) -> typing.Callabl
     def __method(self: edq.testing.unittest.BaseTest) -> None:
         test_info = CLITestInfo.load_path(path, test_name, getattr(self, BASE_TEMP_DIR_ATTR), data_dir)
 
+        # Allow the test class a chance to modify the test info before the test runs.
+        if (hasattr(self, 'modify_cli_test_info')):
+            self.modify_cli_test_info(test_info)
+
         if (test_info.should_skip()):
             self.skipTest(test_info.skip_message())
 
@@ -301,7 +313,11 @@ def add_test_paths(target_class: type, data_dir: str, paths: typing.List[str]) -
         setattr(target_class, BASE_TEMP_DIR_ATTR, edq.util.dirent.get_temp_path('edq_cli_test_'))
 
     for path in sorted(paths):
-        test_name = 'test_cli__' + os.path.splitext(os.path.basename(path))[0]
+        basename = os.path.splitext(os.path.basename(path))[0]
+        if (hasattr(target_class, 'get_test_basename')):
+            basename = getattr(target_class, 'get_test_basename')(path)
+
+        test_name = 'test_cli__' + basename
 
         try:
             setattr(target_class, test_name, _get_test_method(test_name, path, data_dir))