literal dict validator tests

tests/unit/validators/test_dict_validator.py

@@ -2,33 +2,34 @@ import pytest
 
 from ytdl_subscribe.validators.base.validators import BoolValidator
 from ytdl_subscribe.validators.base.validators import DictValidator
+from ytdl_subscribe.validators.base.validators import LiteralDictValidator
 from ytdl_subscribe.validators.base.validators import StringValidator
 from ytdl_subscribe.validators.exceptions import ValidationException
 
 
-@pytest.mark.parametrize(
+class TestDictValidator:
+    @pytest.mark.parametrize(
         "value", [{}, {"key": "value"}, {"b": {}, "a": "keys_out_of_order"}]
-)
+    )
-def test_dict_validator(value):
+    def test_dict_validator(self, value):
         dict_validator = DictValidator(name="good_dict_validator", value=value)
         assert dict_validator._name == "good_dict_validator"
         assert dict_validator._value == value
         assert dict_validator._dict == value
         assert dict_validator._keys == sorted(list(value.keys()))
 
-
+    @pytest.mark.parametrize("value", [None, "a", {"set"}, 0])
-@pytest.mark.parametrize("value", [None, "a", {"set"}, 0])
+    def test_dict_validator_fails_bad_value(self, value):
-def test_dict_validator_fails_bad_value(value):
         with pytest.raises(
-        ValidationException, match="Validation error in fail: should be of type object"
+            ValidationException,
+            match="Validation error in fail: should be of type object",
         ):
             _ = DictValidator(name="fail", value=value)
 
-
+    @pytest.mark.parametrize(
-@pytest.mark.parametrize(
         "value, validator_class", [("string", StringValidator), (False, BoolValidator)]
-)
+    )
-def test_dict_validator_validate_key(value, validator_class):
+    def test_dict_validator_validate_key(self, value, validator_class):
         dict_validator = DictValidator(name="validate_key", value={"key_name": value})
         validated_key = dict_validator._validate_key(
             key="key_name", validator=validator_class
@@ -37,8 +38,7 @@ def test_dict_validator_validate_key(value, validator_class):
         assert isinstance(validated_key, validator_class)
         assert validated_key.value == value
 
-
+    def test_dict_validator_validate_key_errors_missing(self):
-def test_dict_validator_validate_key_errors_missing():
         dict_validator = DictValidator(name="validate_key", value={"key": None})
         with pytest.raises(
             ValidationException,
@@ -46,9 +46,8 @@ def test_dict_validator_validate_key_errors_missing():
         ):
             _ = dict_validator._validate_key(key="key_name", validator=StringValidator)
 
-
+    @pytest.mark.parametrize("bad_value", [True, None, {}])
-@pytest.mark.parametrize("bad_value", [True, None, {}])
+    def test_dict_validator_validate_key_errors_bad_validation(self, bad_value):
-def test_dict_validator_validate_key_errors_bad_validation(bad_value):
         dict_validator = DictValidator(name="parent", value={"child": bad_value})
         with pytest.raises(
             ValidationException,
@@ -56,11 +55,10 @@ def test_dict_validator_validate_key_errors_bad_validation(bad_value):
         ):
             _ = dict_validator._validate_key(key="child", validator=StringValidator)
 
-
+    @pytest.mark.parametrize(
-@pytest.mark.parametrize(
         "value, validator_class", [("string", StringValidator), (False, BoolValidator)]
-)
+    )
-def test_dict_validator_validate_key_if_present(value, validator_class):
+    def test_dict_validator_validate_key_if_present(self, value, validator_class):
         dict_validator = DictValidator(name="validate_key", value={"key_name": value})
         validated_key = dict_validator._validate_key_if_present(
             key="key_name", validator=validator_class
@@ -69,8 +67,7 @@ def test_dict_validator_validate_key_if_present(value, validator_class):
         assert isinstance(validated_key, validator_class)
         assert validated_key.value == value
 
-
+    def test_dict_validator_validate_key_if_present_is_missing(self):
-def test_dict_validator_validate_key_if_present_is_missing():
         dict_validator = DictValidator(name="validate_key", value={"key_name": None})
         out = dict_validator._validate_key_if_present(
             key="non_existent_key", validator=StringValidator
@@ -78,8 +75,7 @@ def test_dict_validator_validate_key_if_present_is_missing():
 
         assert out is None
 
-
+    def test_dict_validator_validate_key_if_present_is_missing_with_default(self):
-def test_dict_validator_validate_key_if_present_is_missing_with_default():
         dict_validator = DictValidator(name="validate_key", value={"key_name": None})
         out = dict_validator._validate_key_if_present(
             key="non_existent_key", validator=StringValidator, default="default"
@@ -88,12 +84,26 @@ def test_dict_validator_validate_key_if_present_is_missing_with_default():
         assert isinstance(out, StringValidator)
         assert out.value == "default"
 
-
+    @pytest.mark.parametrize("bad_value", [True, None, {}])
-@pytest.mark.parametrize("bad_value", [True, None, {}])
+    def test_dict_validator_validate_key_errors_none_bad_validation(self, bad_value):
-def test_dict_validator_validate_key_errors_none_bad_validation(bad_value):
         dict_validator = DictValidator(name="parent", value={"child": bad_value})
         with pytest.raises(
             ValidationException,
             match="Validation error in parent.child: should be of type string",
         ):
             _ = dict_validator._validate_key(key="child", validator=StringValidator)
+
+
+class TestLiteralDictValidator:
+    @pytest.mark.parametrize(
+        "value", [{}, {"key": "value"}, {"b": {}, "a": "keys_out_of_order"}]
+    )
+    def test_literal_dict_validator_dict_and_keys(self, value):
+        dict_validator = LiteralDictValidator(name="good_dict_validator", value=value)
+        assert dict_validator._name == "good_dict_validator"
+        assert dict_validator._value == value
+        assert dict_validator._dict == value
+        assert dict_validator._keys == sorted(list(value.keys()))
+
+        assert dict_validator.keys == dict_validator._keys
+        assert dict_validator.dict == dict_validator._dict