Merge pull request #17 from bcdev/forman-json_serializable

Refactoring: Introducting JsonSerializable

Author: forman

tests/cli/test_main.py

@@ -58,7 +58,7 @@ def xrlint(self, *args: tuple[str, ...]) -> click.testing.Result:
         runner = CliRunner()
         result = runner.invoke(main, args)
         if not isinstance(result.exception, SystemExit):
-            self.assertIsNone(None, result.exception)
+            self.assertIsNone(result.exception)
         return result
 
     def test_no_files_no_config(self):

tests/test_config.py

@@ -64,6 +64,37 @@ def test_from_value_ok(self):
             ),
         )
 
+    def test_to_json(self):
+        config = Config(
+            name="xXx",
+            files=["**/*.zarr", "**/*.nc"],
+            linter_options={"a": 4},
+            opener_options={"b": 5},
+            settings={"c": 6},
+            rules={
+                "hello/no-spaces-in-titles": RuleConfig(severity=2),
+                "hello/time-without-tz": RuleConfig(severity=0),
+                "hello/no-empty-units": RuleConfig(
+                    severity=1, args=(12,), kwargs={"indent": 4}
+                ),
+            },
+        )
+        self.assertEqual(
+            {
+                "name": "xXx",
+                "files": ["**/*.zarr", "**/*.nc"],
+                "linter_options": {"a": 4},
+                "opener_options": {"b": 5},
+                "settings": {"c": 6},
+                "rules": {
+                    "hello/no-empty-units": [1, 12, {"indent": 4}],
+                    "hello/no-spaces-in-titles": 2,
+                    "hello/time-without-tz": 0,
+                },
+            },
+            config.to_json(),
+        )
+
     def test_from_value_fails(self):
         with pytest.raises(
             TypeError,

tests/test_rule.py

@@ -50,10 +50,63 @@ class MyRule3(RuleOp):
 
         with pytest.raises(
             ValueError,
-            match="missing rule metadata, apply define_rule\\(\\) to class MyRule3",
+            match=r"missing rule metadata, apply define_rule\(\) to class MyRule3",
         ):
             Rule.from_value(MyRule3)
 
+    def test_to_json(self):
+        class MyRule3(RuleOp):
+            """This is my 3rd rule."""
+
+        rule = Rule.from_value("tests.test_rule")
+        self.assertEqual("tests.test_rule:export_rule", rule.to_json())
+
+        rule = Rule(meta=RuleMeta(name="r3", ref="mymod.rules:r3"), op_class=MyRule3)
+        self.assertEqual("mymod.rules:r3", rule.to_json())
+
+        rule = Rule(meta=RuleMeta(name="r3"), op_class=MyRule3)
+        self.assertEqual(
+            {
+                "meta": {"name": "r3", "version": "0.0.0", "type": "problem"},
+                "op_class": "<class"
+                " 'tests.test_rule.RuleTest.test_to_json.<locals>.MyRule3'>",
+            },
+            rule.to_json(),
+        )
+
+
+class RuleMetaTest(unittest.TestCase):
+    def test_from_value(self):
+        rule_meta = RuleMeta.from_value(
+            {
+                "name": "r-4",
+                "version": "2.0.1",
+                "type": "suggestion",
+                "description": "Be nice, always.",
+            }
+        )
+        self.assertEqual(
+            RuleMeta(
+                name="r-4",
+                version="2.0.1",
+                type="suggestion",
+                description="Be nice, always.",
+            ),
+            rule_meta,
+        )
+
+    def test_to_json(self):
+        rule_meta = RuleMeta(name="r1", version="0.1.2", description="Nice one.")
+        self.assertEqual(
+            {
+                "name": "r1",
+                "version": "0.1.2",
+                "type": "problem",
+                "description": "Nice one.",
+            },
+            rule_meta.to_json(),
+        )
+
 
 class DefineRuleTest(unittest.TestCase):
 
@@ -79,6 +132,18 @@ def test_with_registry(self):
         self.assertIs(rule1, registry["my-rule-1"])
         self.assertIs(rule2, registry["my-rule-2"])
 
+    # noinspection PyMethodMayBeStatic
+    def test_fail(self):
+        with pytest.raises(
+            TypeError,
+            match=(
+                r"component decorated by define_rule\(\)"
+                r" must be a subclass of RuleOp"
+            ),
+        ):
+            # noinspection PyTypeChecker
+            define_rule(op_class=DefineRuleTest)
+
 
 class RuleConfigTest(TestCase):
     def test_defaults(self):

tests/util/test_codec.py

@@ -9,6 +9,7 @@
     get_origin,
     Mapping,
     TYPE_CHECKING,
+    Literal,
 )
 from unittest import TestCase
 
@@ -27,6 +28,20 @@ class UselessContainer(ValueConstructible):
     pass
 
 
+@dataclass()
+class RequiredPropsContainer(MappingConstructible):
+    x: float
+    y: float
+    z: float
+
+
+class NoTypesContainer(MappingConstructible):
+    def __init__(self, u, v, w):
+        self.u = u
+        self.v = v
+        self.w = w
+
+
 @dataclass()
 class SimpleTypesContainer(MappingConstructible, JsonSerializable):
     a: Any = None
@@ -35,6 +50,7 @@ class SimpleTypesContainer(MappingConstructible, JsonSerializable):
     d: float = 0.0
     e: str = "abc"
     f: type = int
+    g: Literal[0, 1, True, False, "on", "off"] = 0
 
 
 @dataclass()
@@ -52,20 +68,6 @@ class UnionTypesContainer(MappingConstructible, JsonSerializable):
     m: SimpleTypesContainer | ComplexTypesContainer | None = None
 
 
-@dataclass()
-class RequiredPropsContainer(MappingConstructible, JsonSerializable):
-    x: float
-    y: float
-    z: float
-
-
-@dataclass()
-class NoTypesContainer(MappingConstructible, JsonSerializable):
-    u = 0
-    v = 0
-    w = 0
-
-
 if TYPE_CHECKING:
     # make IDEs and flake8 happy
     from xrlint.rule import RuleConfig
@@ -122,13 +124,29 @@ def test_assumptions(self):
 class JsonSerializableTest(TestCase):
     def test_simple_ok(self):
         self.assertEqual(
-            {"a": None, "b": False, "c": 0, "d": 0.0, "e": "abc", "f": "int"},
+            {
+                "a": None,
+                "b": False,
+                "c": 0,
+                "d": 0.0,
+                "e": "abc",
+                "f": "<class 'int'>",
+                "g": 0,
+            },
             SimpleTypesContainer().to_json(),
         )
         self.assertEqual(
-            {"a": "?", "b": True, "c": 12, "d": 34.56, "e": "uvw", "f": "bool"},
+            {
+                "a": "?",
+                "b": True,
+                "c": 12,
+                "d": 34.56,
+                "e": "uvw",
+                "f": "<class 'bool'>",
+                "g": "off",
+            },
             SimpleTypesContainer(
-                a="?", b=True, c=12, d=34.56, e="uvw", f=bool
+                a="?", b=True, c=12, d=34.56, e="uvw", f=bool, g="off"
             ).to_json(),
         )
 
@@ -144,7 +162,15 @@ def test_complex_ok(self):
         )
         self.assertEqual(
             {
-                "p": {"a": None, "b": False, "c": 0, "d": 0.0, "e": "abc", "f": "int"},
+                "p": {
+                    "a": None,
+                    "b": False,
+                    "c": 0,
+                    "d": 0.0,
+                    "e": "abc",
+                    "f": "<class 'int'>",
+                    "g": 0,
+                },
                 "q": {"p": True, "q": False},
                 "r": {
                     "u": {
@@ -153,27 +179,38 @@ def test_complex_ok(self):
                         "c": 0,
                         "d": 0.0,
                         "e": "abc",
-                        "f": "int",
+                        "f": "<class 'int'>",
+                        "g": 0,
                     },
                     "v": {
                         "a": None,
                         "b": False,
                         "c": 0,
                         "d": 0.0,
                         "e": "abc",
-                        "f": "int",
+                        "f": "<class 'int'>",
+                        "g": 0,
                     },
                 },
                 "s": [1, 2, 3],
                 "t": [
-                    {"a": None, "b": False, "c": 5, "d": 6.7, "e": "abc", "f": "int"},
+                    {
+                        "a": None,
+                        "b": False,
+                        "c": 5,
+                        "d": 6.7,
+                        "e": "abc",
+                        "f": "<class 'int'>",
+                        "g": 0,
+                    },
                     {
                         "a": None,
                         "b": False,
                         "c": 8,
                         "d": 9.1,
                         "e": "abc",
-                        "f": "SimpleTypesContainer",
+                        "f": "<class 'tests.util.test_codec.SimpleTypesContainer'>",
+                        "g": 0,
                     },
                 ],
                 "u": None,
@@ -193,7 +230,7 @@ class Problematic(JsonSerializable):
                 " None|bool|int|float|str|dict|list|tuple, but got object"
             ),
         ):
-            Problematic(data=object()).to_json(name="problematic")
+            Problematic(data=object()).to_json(value_name="problematic")
 
 
 class ValueConstructibleTest(TestCase):
@@ -263,11 +300,32 @@ def test_useless_fail(self):
         ):
             UselessContainer.from_value(UselessContainer, value_name="utc")
 
+    def test_required_props_ok(self):
+        rpc = RequiredPropsContainer.from_value({"x": 12.0, "y": 23.0, "z": 34.0})
+        self.assertEqual(RequiredPropsContainer(x=12.0, y=23.0, z=34.0), rpc)
+
+    # noinspection PyMethodMayBeStatic
+    def test_required_props_fail(self):
+        with pytest.raises(
+            TypeError,
+            match=(
+                r"missing value for required property rpc.y"
+                r" of type RequiredPropsContainer \| dict\[str, Any\]"
+            ),
+        ):
+            RequiredPropsContainer.from_value({"x": 12.0, "z": 34.0}, "rpc")
+
+    def test_no_types_ok(self):
+        ntc = NoTypesContainer.from_value(dict(u=True, v=654, w="abc"))
+        self.assertEqual(True, ntc.u)
+        self.assertEqual(654, ntc.v)
+        self.assertEqual("abc", ntc.w)
+
 
 class MappingConstructibleTest(TestCase):
 
     def test_simple_ok(self):
-        kwargs = dict(a="?", b=True, c=12, d=34.56, e="uvw", f=bytes)
+        kwargs = dict(a="?", b=True, c=12, d=34.56, e="uvw", f=bytes, g="on")
         container = SimpleTypesContainer(**kwargs)
         self.assertEqual(container, SimpleTypesContainer.from_value(kwargs))
         self.assertIs(container, SimpleTypesContainer.from_value(container))
@@ -339,6 +397,12 @@ def test_simple_fail(self):
         ):
             SimpleTypesContainer.from_value({"b": None}, value_name="stc")
 
+        with pytest.raises(
+            TypeError,
+            match=r"stc.g must be one of 0, 1, True, False, 'on', 'off', but got 74",
+        ):
+            SimpleTypesContainer.from_value({"g": 74}, value_name="stc")
+
         with pytest.raises(
             TypeError, match="x is not a member of stc of type SimpleTypesContainer"
         ):
@@ -439,6 +503,7 @@ def test_resolves_types(self):
                 "d",
                 "e",
                 "f",
+                "g",
                 "p",
                 "q",
                 "r",

tests/util/test_todict.py

@@ -136,7 +136,7 @@ def print_config_for_file(self, file_path: str) -> None:
             file_path: A file path.
         """
         config = self.get_config_for_file(file_path)
-        config_json_obj = config.to_dict() if config is not None else None
+        config_json_obj = config.to_json() if config is not None else None
         click.echo(json.dumps(config_json_obj, indent=2))
 
     def verify_datasets(self, files: Iterable[str]) -> Iterator[Result]: