edq-utils 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

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

@@ -0,0 +1,11 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/a.txt",
+            "name": "foo.txt"
+        }
+    ],
+    "response_body": "simple_file_name"
+}

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

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

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

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

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

@@ -0,0 +1,8 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "headers": {
+        "a": "1"
+    },
+    "response_body": "simple_headers"
+}

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

@@ -0,0 +1,7 @@
+{
+    "method": "GET",
+    "url": "simple/jsonresponse/dict",
+    "response_body": {
+        "a": 1
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+    "method": "GET",
+    "url": "simple/jsonresponse/list",
+    "response_body": [
+        {
+            "a": 1
+        }
+    ]
+}

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

@@ -0,0 +1,9 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "parameters": {
+        "a": "1",
+        "b": "2"
+    },
+    "response_body": "simple_params"
+}

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

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

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

@@ -0,0 +1,9 @@
+{
+    "method": "POST",
+    "url": "simple",
+    "parameters": {
+        "a": "1",
+        "b": "2"
+    },
+    "response_body": "simple_post_params"
+}

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

@@ -0,0 +1,5 @@
+{
+    "method": "POST",
+    "url": "simple?c=3&d=4",
+    "response_body": "simple_post_urlparams"
+}

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

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple?c=3&d=4",
+    "response_body": "simple_urlparams"
+}

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

@@ -0,0 +1,8 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "parameters": {
+        "a": ["1", "2"]
+    },
+    "response_body": "specialcase_listparams_explicit"
+}

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

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple?b=1&b=2",
+    "response_body": "specialcase_listparams_url"
+}

edq/testing/unittest.py

@@ -14,25 +14,45 @@ class BaseTest(unittest.TestCase):
     maxDiff = None
     """ Don't limit the size of diffs. """
 
-    def assertJSONDictEqual(self, a: typing.Dict[str, typing.Any], b: typing.Dict[str, typing.Any]) -> None:  # pylint: disable=invalid-name
+    def assertJSONDictEqual(self, a: typing.Any, b: typing.Any, message: typing.Union[str, None] = None) -> None:  # pylint: disable=invalid-name
         """
-        Call assertDictEqual(), but supply a message containing the full JSON representation of the arguments.
+        Like unittest.TestCase.assertDictEqual(),
+        but will try to convert each comparison argument to a dict if it is not already,
+        and uses a default assertion message containing the full JSON representation of the arguments.
         """
 
+        if (not isinstance(a, dict)):
+            if (isinstance(a, edq.util.json.DictConverter)):
+                a = a.to_dict()
+            else:
+                a = vars(a)
+
+        if (not isinstance(b, dict)):
+            if (isinstance(b, edq.util.json.DictConverter)):
+                b = b.to_dict()
+            else:
+                b = vars(b)
+
         a_json = edq.util.json.dumps(a, indent = 4)
         b_json = edq.util.json.dumps(b, indent = 4)
 
-        super().assertDictEqual(a, b, FORMAT_STR % (a_json, b_json))
+        if (message is None):
+            message = FORMAT_STR % (a_json, b_json)
 
-    def assertJSONListEqual(self, a: typing.List[typing.Any], b: typing.List[typing.Any]) -> None:  # pylint: disable=invalid-name
+        super().assertDictEqual(a, b, msg = message)
+
+    def assertJSONListEqual(self, a: typing.List[typing.Any], b: typing.List[typing.Any], message: typing.Union[str, None] = None) -> None:  # pylint: disable=invalid-name
         """
-        Call assertListEqual(), but supply a message containing the full JSON representation of the arguments.
+        Call assertDictEqual(), but supply a default message containing the full JSON representation of the arguments.
         """
 
         a_json = edq.util.json.dumps(a, indent = 4)
         b_json = edq.util.json.dumps(b, indent = 4)
 
-        super().assertListEqual(a, b, FORMAT_STR % (a_json, b_json))
+        if (message is None):
+            message = FORMAT_STR % (a_json, b_json)
+
+        super().assertListEqual(a, b, msg = message)
 
     def format_error_string(self, ex: typing.Union[BaseException, None]) -> str:
         """

edq/util/dirent.py

@@ -41,6 +41,8 @@ def get_temp_path(prefix: str = '', suffix: str = '', rm: bool = True) -> str:
     while ((path is None) or exists(path)):
         path = os.path.join(tempfile.gettempdir(), prefix + str(uuid.uuid4()) + suffix)
 
+    path = os.path.realpath(path)
+
     if (rm):
         atexit.register(remove, path)
 

edq/util/dirent_test.py

@@ -3,32 +3,51 @@ import os
 import edq.testing.unittest
 import edq.util.dirent
 
-THIS_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
-TEST_BASE_DIR = os.path.join(THIS_DIR, 'testdata', 'dirent-operations')
-"""
-This test data directory is laid out as:
-.
-├── a.txt
-├── dir_1
-│   ├── b.txt
-│   └── dir_2
-│       └── c.txt
-├── dir_empty
-├── file_empty
-├── symlink_a.txt -> a.txt
-├── symlink_dir_1 -> dir_1
-├── symlink_dir_empty -> dir_empty
-└── symlink_file_empty -> file_empty
-
-Where non-empty files are filled with their filename (without the extension).
-dir_empty will not exist in the repository (since it is an empty directory),
-but it will be created by _prep_temp_dir().
-"""
-
 DIRENT_TYPE_DIR = 'dir'
 DIRENT_TYPE_FILE = 'file'
 DIRENT_TYPE_BROKEN_SYMLINK = 'broken_symlink'
 
+def create_test_dir(temp_dir_prefix: str) -> str:
+    """
+    Create a temp dir and populate it with dirents for testing.
+
+    This test data directory is laid out as:
+    .
+    ├── a.txt
+    ├── dir_1
+    │   ├── b.txt
+    │   └── dir_2
+    │       └── c.txt
+    ├── dir_empty
+    ├── file_empty
+    ├── symlink_a.txt -> a.txt
+    ├── symlink_dir_1 -> dir_1
+    ├── symlink_dir_empty -> dir_empty
+    └── symlink_file_empty -> file_empty
+
+    Where non-empty files are filled with their filename (without the extension).
+    """
+
+    temp_dir = edq.util.dirent.get_temp_dir(prefix = temp_dir_prefix)
+
+    # Dirs
+    edq.util.dirent.mkdir(os.path.join(temp_dir, 'dir_1', 'dir_2'))
+    edq.util.dirent.mkdir(os.path.join(temp_dir, 'dir_empty'))
+
+    # Files
+    edq.util.dirent.write_file(os.path.join(temp_dir, 'a.txt'), 'a')
+    edq.util.dirent.write_file(os.path.join(temp_dir, 'file_empty'), '')
+    edq.util.dirent.write_file(os.path.join(temp_dir, 'dir_1', 'b.txt'), 'b')
+    edq.util.dirent.write_file(os.path.join(temp_dir, 'dir_1', 'dir_2', 'c.txt'), 'c')
+
+    # Links
+    os.symlink('a.txt', os.path.join(temp_dir, 'symlink_a.txt'))
+    os.symlink('dir_1', os.path.join(temp_dir, 'symlink_dir_1'))
+    os.symlink('dir_empty', os.path.join(temp_dir, 'symlink_dir_empty'))
+    os.symlink('file_empty', os.path.join(temp_dir, 'symlink_file_empty'))
+
+    return temp_dir
+
 class TestDirent(edq.testing.unittest.BaseTest):
     """ Test basic operations on dirents. """
 
@@ -363,10 +382,7 @@ class TestDirent(edq.testing.unittest.BaseTest):
                 self.assertEqual(expected_contents, actual_contents)
 
     def test_copy_contents_base(self):
-        """
-        Test copying the contents of a dirent.
-        Note that the base functionality of copy_contents() is tested by test_setup().
-        """
+        """ Test copying the contents of a dirent. """
 
         # [(source, dest, no clobber?, error substring), ...]
         test_cases = [
@@ -877,12 +893,7 @@ class TestDirent(edq.testing.unittest.BaseTest):
         self._check_existing_paths(temp_dir, expected_paths)
 
     def _prep_temp_dir(self):
-        temp_dir = edq.util.dirent.get_temp_dir(prefix = 'edq_test_dirent_')
-
-        edq.util.dirent.mkdir(os.path.join(temp_dir, 'dir_empty'))
-        edq.util.dirent.copy_contents(TEST_BASE_DIR, temp_dir)
-
-        return temp_dir
+        return create_test_dir('edq_test_dirent_')
 
     def _check_existing_paths(self, base_dir, raw_paths):
         """

edq/util/json.py

@@ -4,37 +4,45 @@ Specifically, we try to be flexible when reading (using JSON5),
 and strict when writing (using vanilla JSON).
 """
 
-import abc
 import enum
 import json
+import os
 import typing
 
 import json5
 
 import edq.util.dirent
 
-class DictConverter(abc.ABC):
+class DictConverter():
     """
     A base class for class that can represent (serialize) and reconstruct (deserialize) themselves as/from a dict.
     The intention is that the dict can then be cleanly converted to/from JSON.
+
+    General (but inefficient) implementations of several core Python equality, comparison, and representation methods are provided.
     """
 
-    @abc.abstractmethod
     def to_dict(self) -> typing.Dict[str, typing.Any]:
         """
         Return a dict that can be used to represent this object.
         If the dict is passed to from_dict(), an identical object should be reconstructed.
+
+        A general (but inefficient) implementation is provided by default.
         """
 
+        return vars(self).copy()
+
     @classmethod
-    @abc.abstractmethod
     # Note that `typing.Self` is returned, but that is introduced in Python 3.12.
     def from_dict(cls, data: typing.Dict[str, typing.Any]) -> typing.Any:
         """
         Return an instance of this subclass created using the given dict.
         If the dict came from to_dict(), the returned object should be identical to the original.
+
+        A general (but inefficient) implementation is provided by default.
         """
 
+        return cls(**data)
+
     def __eq__(self, other: object) -> bool:
         """
         Check for equality.
@@ -49,6 +57,12 @@ class DictConverter(abc.ABC):
 
         return bool(self.to_dict() == other.to_dict())  # type: ignore[attr-defined]
 
+    def __lt__(self, other: 'DictConverter') -> bool:
+        return dumps(self) < dumps(other)
+
+    def __hash__(self) -> int:
+        return hash(dumps(self))
+
     def __str__(self) -> str:
         return dumps(self)
 
@@ -107,6 +121,9 @@ def load_path(
     otherwise use JSON5.
     """
 
+    if (os.path.isdir(path)):
+        raise IsADirectoryError(f"Cannot open JSON file, expected a file but got a directory at '{path}'.")
+
     try:
         with open(path, 'r', encoding = encoding) as file:
             return load(file, strict = strict, **kwargs)