better xrlint.rule coverage, support Literal annotation

Author: forman

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
 
@@ -49,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()
@@ -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,
@@ -288,7 +325,7 @@ def test_no_types_ok(self):
 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))
@@ -360,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"
         ):
@@ -460,6 +503,7 @@ def test_resolves_types(self):
                 "d",
                 "e",
                 "f",
+                "g",
                 "p",
                 "q",
                 "r",

xrlint/rule.py

@@ -12,7 +12,11 @@
 )
 from xrlint.node import DatasetNode, DataArrayNode, AttrsNode, AttrNode
 from xrlint.result import Suggestion
-from xrlint.util.codec import MappingConstructible, ValueConstructible, JsonSerializable
+from xrlint.util.codec import (
+    MappingConstructible,
+    ValueConstructible,
+    JsonSerializable,
+)
 from xrlint.util.formatting import format_message_one_of
 from xrlint.util.importutil import import_value
 from xrlint.util.naming import to_kebab_case
@@ -186,6 +190,13 @@ class RuleMeta(MappingConstructible, JsonSerializable):
     def _get_value_type_name(cls) -> str:
         return "RuleMeta | dict"
 
+    def to_dict(self, value_name: str | None = None) -> dict[str, str]:
+        return {
+            k: v
+            for k, v in super().to_dict(value_name=value_name).items()
+            if v is not None
+        }
+
 
 @dataclass(frozen=True)
 class Rule(MappingConstructible, JsonSerializable):
@@ -239,7 +250,7 @@ def _get_value_type_name(cls) -> str:
     def to_json(self, value_name: str | None = None) -> str:
         if self.meta.ref:
             return self.meta.ref
-        return repr(self)
+        return super().to_json(value_name=value_name)
 
 
 @dataclass(frozen=True)

xrlint/util/codec.py

@@ -14,15 +14,15 @@
     get_args,
     get_type_hints,
     Optional,
+    Literal,
 )
 
-from xrlint.util.formatting import format_message_type_of
-
+from xrlint.util.formatting import format_message_type_of, format_message_one_of
 
 JSON_VALUE_TYPE_NAME = "None | bool | int | float | str | dict | list"
 
 JsonValue: TypeAlias = (
-    NoneType | bool | int | float | str | dict[str, "JsonValue"] | list["JsonValue"]
+    None | bool | int | float | str | dict[str, "JsonValue"] | list["JsonValue"]
 )
 
 T = TypeVar("T")
@@ -198,6 +198,12 @@ def _convert_value(cls, value: Any, type_annotation: Any, value_name: str) -> An
             # therefore return the value as-is
             return value
 
+        if type_origin is Literal:
+            # Value must be one of literal arguments
+            if value not in type_args:
+                raise TypeError(format_message_one_of(value_name, value, type_args))
+            return value
+
         if type_origin is Union:
             # For unions try converting the alternatives.
             # Return the first successfully converted value.
@@ -480,7 +486,6 @@ def to_dict(self, value_name: str | None = None) -> dict[str, JsonValue]:
     @classmethod
     def _value_to_json(cls, value: Any, value_name: str) -> JsonValue:
         if value is None:
-            # noinspection PyTypeChecker
             return None
         if isinstance(value, JsonSerializable):
             return value.to_json(value_name=value_name)
@@ -497,7 +502,7 @@ def _value_to_json(cls, value: Any, value_name: str) -> JsonValue:
         if isinstance(value, Sequence):
             return cls._sequence_to_json(value, value_name)
         if isinstance(value, type):
-            return value.__name__
+            return repr(value)
         raise TypeError(format_message_type_of(value_name, value, JSON_VALUE_TYPE_NAME))
 
     @classmethod