voluptuous-openapi 0.0.4__tar.gz → 0.0.6__tar.gz

{voluptuous_openapi-0.0.4/voluptuous_openapi.egg-info → voluptuous_openapi-0.0.6}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: voluptuous-openapi
-Version: 0.0.4
+Version: 0.0.6
 Summary: Convert voluptuous schemas to OpenAPI Schema object
-Home-page: http://github.com/Shulyaka/voluptuous-openapi
+Home-page: https://github.com/home-assistant-libs/voluptuous-openapi
 Author: Denis Shulyaka
 Author-email: Shulyaka@gmail.com
 License: Apache License 2.0

{voluptuous_openapi-0.0.4 → voluptuous_openapi-0.0.6}/setup.py

@@ -2,9 +2,9 @@ from setuptools import setup
 
 setup(
     name="voluptuous-openapi",
-    version="0.0.4",
+    version="0.0.6",
     description="Convert voluptuous schemas to OpenAPI Schema object",
-    url="http://github.com/Shulyaka/voluptuous-openapi",
+    url="https://github.com/home-assistant-libs/voluptuous-openapi",
     author="Denis Shulyaka",
     author_email="Shulyaka@gmail.com",
     license="Apache License 2.0",

{voluptuous_openapi-0.0.4 → voluptuous_openapi-0.0.6}/tests/test_lib.py

@@ -1,9 +1,10 @@
 from enum import Enum
+from typing import Any, TypeVar
 
+import pytest
 import voluptuous as vol
-from typing import Any, TypeVar
 
-from voluptuous_openapi import UNSUPPORTED, convert
+from voluptuous_openapi import UNSUPPORTED, convert, convert_to_voluptuous
 
 
 def test_int_schema():
@@ -50,11 +51,18 @@ def test_datetime():
 
 
 def test_in():
-    assert {"enum": ["beer", "wine"]} == convert(vol.Schema(vol.In(["beer", "wine"])))
+    assert {"type": "string", "enum": ["beer", "wine"]} == convert(
+        vol.Schema(vol.In(["beer", "wine"]))
+    )
+
+
+def test_in_integer():
+    assert {"type": "integer", "enum": [1, 2]} == convert(vol.Schema(vol.In([1, 2])))
 
 
 def test_in_dict():
     assert {
+        "type": "string",
         "enum": ["en_US", "zh_CN"],
     } == convert(
         vol.Schema(
@@ -112,6 +120,19 @@ def test_dict():
         vol.Schema({})
     )
 
+    def string(x: str) -> str:
+        return x
+
+    assert {"type": "object", "additionalProperties": {"type": "string"}} == convert(
+        vol.Schema({string: string})
+    )
+    assert {"type": "object", "additionalProperties": True} == convert(
+        vol.Schema(object)
+    )
+    assert {"type": "object", "additionalProperties": True} == convert(
+        vol.Schema({string: object})
+    )
+
 
 def test_tuple():
     assert {"type": "array", "items": {"type": "string"}} == convert(vol.Schema(tuple))
@@ -221,17 +242,39 @@ def test_custom_serializer():
 
 
 def test_constant():
-    for value in True, False, "Hello", 1, None:
-        assert {"enum": [value]} == convert(vol.Schema(value))
-    assert {"enum": [None]} == convert(vol.Schema(type(None)))
+    assert {"type": "boolean", "enum": [True]} == convert(vol.Schema(True))
+    assert {"type": "boolean", "enum": [False]} == convert(vol.Schema(False))
+    assert {"type": "string", "enum": ["Hello"]} == convert(vol.Schema("Hello"))
+    assert {"type": "integer", "enum": [1]} == convert(vol.Schema(1))
+    assert {"type": "number", "enum": [1.5]} == convert(vol.Schema(1.5))
+    assert {
+        "type": "object",
+        "nullable": True,
+        "description": "Must be null",
+    } == convert(vol.Schema(None))
+    assert {
+        "type": "object",
+        "nullable": True,
+        "description": "Must be null",
+    } == convert(vol.Schema(type(None)))
 
 
 def test_enum():
-    class TestEnum(Enum):
+    class StringEnum(Enum):
         ONE = "one"
+        TWO = "two"
+
+    assert {"type": "string", "enum": ["one", "two"]} == convert(
+        vol.Schema(vol.Coerce(StringEnum))
+    )
+
+    class IntEnum(Enum):
+        ONE = 1
         TWO = 2
 
-    assert {"enum": ["one", 2]} == convert(vol.Schema(vol.Coerce(TestEnum)))
+    assert {"type": "integer", "enum": [1, 2]} == convert(
+        vol.Schema(vol.Coerce(IntEnum))
+    )
 
 
 def test_list():
@@ -256,12 +299,58 @@ def test_any_of():
         vol.Any(float, int)
     )
 
+    assert {"anyOf": [{"type": "number"}, {"type": "integer"}]} == convert(
+        vol.Any(float, int, float, int, int)
+    )
+
+    assert {"type": "object", "additionalProperties": True} == convert(
+        vol.Any(float, int, object)
+    )
+
+    assert {"type": "integer", "nullable": True, "enum": [1, 2]} == convert(
+        vol.Schema(vol.In([1, 2, None]))
+    )
+
+    assert {"type": "integer", "enum": [1, 2, 3]} == convert(
+        vol.Schema(vol.Any(1, 2, 3))
+    )
+
+    assert {
+        "anyOf": [{"type": "number"}, {"type": "integer"}, {"type": "string"}]
+    } == convert(
+        vol.Any(
+            vol.Any(float, int), vol.Any(int, float), vol.Any(float, vol.Any(int, str))
+        )
+    )
+
+    assert {
+        "anyOf": [{"type": "number"}, {"type": "integer"}],
+        "nullable": True,
+    } == convert(vol.Any(vol.Maybe(float), vol.Maybe(int)))
+
 
 def test_all_of():
     assert {"allOf": [{"minimum": 5}, {"minimum": 10}]} == convert(
         vol.All(vol.Range(min=5), vol.Range(min=10))
     )
 
+    assert {"type": "string"} == convert(vol.All(object, str))
+
+    assert {"type": "object", "additionalProperties": {"type": "string"}} == convert(
+        vol.All(object, {str: str})
+    )
+
+    assert {"maximum": 10, "minimum": 5, "type": "number"} == convert(
+        vol.All(vol.Range(min=5), vol.Range(max=10))
+    )
+
+    assert {"maximum": 10, "minimum": 5, "type": "number"} == convert(
+        vol.All(
+            vol.All(vol.Range(min=5), float),
+            vol.All(vol.All(vol.Range(max=10), float), float),
+        )
+    )
+
 
 def test_key_any():
     assert {
@@ -286,6 +375,24 @@ def test_key_any():
         )
     )
 
+    assert {
+        "properties": {
+            "conversation_command": {"type": "string"},
+            "hours": {"type": "integer"},
+            "minutes": {"type": "integer"},
+            "name": {"type": "string"},
+            "seconds": {"type": "integer"},
+        },
+        "required": [],
+        "type": "object",
+    } == convert(
+        {
+            vol.Required(vol.Any("hours", "minutes", "seconds")): int,
+            vol.Optional("name"): str,
+            vol.Optional("conversation_command"): str,
+        }
+    )
+
 
 def test_function():
     def validator(data):
@@ -376,3 +483,99 @@ def test_function():
     assert {"type": "object", "additionalProperties": {"type": "integer"}} == convert(
         validator_dict_int
     )
+
+
+def test_nested_in_list():
+    assert {
+        "properties": {
+            "drink": {
+                "type": "array",
+                "items": {"type": "string", "enum": ["beer", "wine"]},
+            },
+        },
+        "required": [],
+        "type": "object",
+    } == convert(vol.Schema({vol.Optional("drink"): [vol.In(["beer", "wine"])]}))
+
+    assert {"type": "integer", "enum": [1, 2, 3]} == convert(
+        vol.Schema(vol.In([1, 2, 3]))
+    )
+
+
+def test_reverse_int_schema():
+    assert convert_to_voluptuous({"type": "integer"}) == int
+
+
+def test_reverse_str_schema():
+    assert convert_to_voluptuous({"type": "string"}) == str
+
+
+def test_reverse_float_schema():
+    assert convert_to_voluptuous({"type": "number"}) == float
+
+
+def test_reverse_bool_schema():
+    assert convert_to_voluptuous({"type": "boolean"}) == bool
+
+
+def test_reverse_datetime():
+    validator = convert_to_voluptuous(
+        {
+            "type": "string",
+            "format": "date-time",
+        }
+    )
+    validator("2025-01-01T12:32:55.11Z")
+
+    with pytest.raises(vol.Invalid):
+        validator("2021-01-01")
+    with pytest.raises(vol.Invalid):
+        validator("abc")
+
+
+def test_reverse_unknown_type():
+    with pytest.raises(ValueError):
+        convert_to_voluptuous({})
+
+    with pytest.raises(ValueError):
+        convert_to_voluptuous({"type": "unknown"})
+
+
+def test_convert_to_voluptuous_wrong_type() -> None:
+    """Test calling with the wrong type"""
+
+    with pytest.raises(ValueError):
+        convert_to_voluptuous({"oneOf": ["integer"]})
+
+    with pytest.raises(ValueError):
+        convert_to_voluptuous({"oneOf": "integer"})
+
+    with pytest.raises(ValueError):
+        convert_to_voluptuous("a")
+
+
+def test_unsupported_features() -> None:
+    """Test converting a mixed aray type."""
+
+    with pytest.raises(ValueError):
+        convert_to_voluptuous({"type": "integer", "multipleOf": 2})
+
+    with pytest.raises(ValueError):
+        convert_to_voluptuous({"type": "array", "items": {"minItems": 1}})
+
+
+def test_mixed_type_list() -> None:
+    """Test converting a mixed aray type."""
+    validator = convert_to_voluptuous(
+        {"type": "array", "items": {"oneOf": [{"type": "string"}, {"type": "integer"}]}}
+    )
+
+    validator(["a", "b"])
+    validator([1, 2])
+    validator(["a", 1, "b", 2])
+
+    with pytest.raises(vol.Invalid):
+        validator("abc")
+
+    with pytest.raises(vol.Invalid):
+        validator(123)

voluptuous_openapi-0.0.6/tests/test_validation.py

@@ -0,0 +1,387 @@
+"""Tests for voluptuous schema and openapi schemas that exercise validation code.
+
+Each test in this file defines an equivalent schema in both `openapi` and
+`voluptuous` formats. The schema is then converted to the other format and
+validation code is run against all variations of schema types.
+
+The motivation is because voluptuous schemas cannot be introspected directly
+and are tested by exercising with both valid and invalid data.
+"""
+
+from collections.abc import Callable, Generator
+import datetime
+
+import pytest
+import voluptuous as vol
+import openapi_schema_validator
+from typing import Any
+import logging
+
+from voluptuous_openapi import convert, convert_to_voluptuous
+from jsonschema.exceptions import ValidationError
+
+
+_LOGGER = logging.getLogger(__name__)
+
+# Validator type used to represent a validation function for a specific schema type
+Validator = Callable[[Any], Any]
+
+
+class InvalidFormat(Exception):
+    """Validation exception thrown on invalid input test data."""
+
+
+def voluptuous_validator(schema: vol.Schema) -> Validator:
+    """Create a Validator for a voluptuous schema."""
+
+    def validator(data: Any) -> Any:
+        try:
+            _LOGGER.debug("Validating %s with schema %s", data, schema)
+            return schema(data)
+        except (vol.Invalid, ValueError) as e:
+            raise InvalidFormat(str(e))
+
+    return validator
+
+
+def openapi_validator(schema: dict) -> Any:
+    """Create a Validator for an OpenAPI schema."""
+
+    def validator(data: Any) -> Any:
+        try:
+            _LOGGER.debug("Validating %s with schema %s", data, schema)
+            openapi_schema_validator.validate(data, schema)
+            return data
+        except ValidationError as e:
+            raise InvalidFormat(str(e))
+
+    return validator
+
+
+# Order of id created by `generate_validators`
+TEST_IDS = ["openapi", "voluptuous", "voluptuous_to_openapi", "openapi_to_voluptuous"]
+
+
+def generate_validators(
+    openapi_schema: dict, voluptuous_schema: vol.Schema
+) -> Generator[Validator]:
+    """Create validation functions for the various schema types."""
+
+    # Native schema validations
+    yield openapi_validator(openapi_schema)
+    yield voluptuous_validator(voluptuous_schema)
+
+    # Converted schema validations
+    yield openapi_validator(convert(voluptuous_schema))
+    yield voluptuous_validator(convert_to_voluptuous(openapi_schema))
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "string"},
+        str,
+    ),
+    ids=TEST_IDS,
+)
+def test_string(validator: Validator) -> None:
+    """Test string schema."""
+
+    validator("hello")
+    validator("A" * 10)
+    validator("A" * 12)
+    validator("123")
+    # Note voluptuos coerces everything to string but openapi does not,
+    # so not validated here.
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "string", "minLength": 1, "maxLength": 10},
+        vol.All(str, vol.Length(min=1, max=10)),
+    ),
+    ids=TEST_IDS,
+)
+def test_string_min_max_length(validator: Validator) -> None:
+    """Test string min and max length."""
+
+    validator("hello")
+    validator("A" * 10)
+
+    with pytest.raises(InvalidFormat):
+        validator(123)
+
+    with pytest.raises(InvalidFormat):
+        validator("")
+
+    with pytest.raises(InvalidFormat):
+        validator("A" * 12)
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "integer"},
+        int,
+    ),
+    ids=TEST_IDS,
+)
+def test_int(validator: Validator) -> None:
+    """Test int schema."""
+
+    validator(1)
+    validator(10)
+    validator(0)
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "integer", "minimum": 1, "maximum": 10},
+        vol.All(int, vol.Range(min=1, max=10)),
+    ),
+    ids=TEST_IDS,
+)
+def test_int_range(validator: Validator) -> None:
+    """Test an int range"""
+
+    validator(1)
+    validator(10)
+
+    with pytest.raises(InvalidFormat):
+        validator(0)
+
+    with pytest.raises(InvalidFormat):
+        validator(11)
+
+    with pytest.raises(InvalidFormat):
+        validator(5.5)
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "number"},
+        float,
+    ),
+    ids=TEST_IDS,
+)
+def test_float(validator: Validator) -> None:
+    """Test float schema."""
+
+    validator(1.0)
+    validator(5.5)
+    validator(10.0)
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "number", "minimum": 1, "maximum": 10},
+        vol.All(float, vol.Range(min=1, max=10)),
+    ),
+    ids=TEST_IDS,
+)
+def test_float_range(validator: Validator) -> None:
+    """Test float range schema."""
+
+    validator(1.0)
+    validator(5.5)
+    validator(10.0)
+
+    with pytest.raises(InvalidFormat):
+        validator(0.0)
+
+    with pytest.raises(InvalidFormat):
+        validator(10.1)
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "string", "pattern": r"^\d{3}-\d{2}-\d{4}$"},
+        vol.All(str, vol.Match(r"^\d{3}-\d{2}-\d{4}$")),
+    ),
+    ids=TEST_IDS,
+)
+def test_match_pattern(validator: Validator) -> None:
+    """Test matching a regular expression pattern."""
+
+    validator("555-10-2020")
+
+    with pytest.raises(InvalidFormat):
+        validator("555-1-2020")
+
+    with pytest.raises(InvalidFormat):
+        validator("555")
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"type": "array", "items": {"type": "string"}},
+        vol.All([str]),
+    ),
+    ids=TEST_IDS,
+)
+def test_string_list(validator: Validator) -> None:
+    """Test a list of strings."""
+
+    validator(["a"])
+    validator(["a", "b"])
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+    with pytest.raises(InvalidFormat):
+        validator(123)
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {
+            "type": "object",
+            "properties": {"id": {"type": "integer"}, "name": {"type": "string"}},
+            "required": ["id"],
+        },
+        vol.Schema({vol.Required("id"): int, vol.Optional("name"): str}),
+    ),
+    ids=TEST_IDS,
+)
+def test_object(validator: Validator) -> None:
+    """Test an object."""
+    validator({"id": 1, "name": "hello"})
+    validator({"id": 1})
+
+    with pytest.raises(InvalidFormat):
+        validator({"id": "abc", "name": "hello"})
+
+    with pytest.raises(InvalidFormat):
+        validator({"name": "hello"})
+
+    with pytest.raises(InvalidFormat):
+        validator("abc")
+
+    with pytest.raises(InvalidFormat):
+        validator(123)
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {
+            "type": "object",
+            "properties": {
+                "id": {"type": "integer"},
+                "content": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                    },
+                },
+            },
+        },
+        vol.Schema(
+            {
+                vol.Required("id"): int,
+                vol.Optional("content"): vol.Schema({vol.Optional("name"): str}),
+            }
+        ),
+    ),
+    ids=TEST_IDS,
+)
+def test_nested_object(validator: Validator) -> None:
+    """Test an object nested in an object."""
+    validator({"id": 1, "content": {"name": "hello"}})
+    validator({"id": 1, "content": {}})
+    validator({"id": 1})
+
+    with pytest.raises(InvalidFormat):
+        validator({"id": 1, "content": {"name": 1234}})
+
+    with pytest.raises(InvalidFormat):
+        validator(123)
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {
+            "type": "object",
+            "properties": {"id": {"type": "integer"}},
+            "additionalProperties": True,
+        },
+        vol.Schema(
+            {vol.Required("id"): int, vol.Optional("name"): str}, extra=vol.ALLOW_EXTRA
+        ),
+    ),
+    ids=TEST_IDS,
+)
+def test_allow_extra(validator: Validator) -> None:
+    """Test additional properties are allowed."""
+    validator({"id": 1})
+    validator({"id": 1, "extra-key": "hello"})
+
+    with pytest.raises(InvalidFormat):
+        validator(123)
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {
+            "type": "object",
+            "properties": {"id": {"type": "integer"}},
+            "additionalProperties": False,
+        },
+        vol.Schema({vol.Required("id"): int, vol.Optional("name"): str}),
+    ),
+    ids=TEST_IDS,
+)
+def test_no_extra(validator: Validator) -> None:
+    """Test additional properties are not allowed."""
+    validator({"id": 1})
+
+    # TODO: Note this does not currently fail when converting from openapi to voluptuous because
+    # additionalProperties: False is not set. Fix that then uncomment here.
+    # with pytest.raises(InvalidFormat):
+    #    validator({"id": 1, "extra-key": "hello"})
+
+    with pytest.raises(InvalidFormat):
+        validator(123)
+
+
+@pytest.mark.parametrize(
+    "validator",
+    generate_validators(
+        {"oneOf": [{"type": "string"}, {"type": "integer"}]},
+        vol.Any(str, int),
+    ),
+    ids=TEST_IDS,
+)
+def test_one_of(validator: Validator) -> None:
+    """Test oneOf multiple types."""
+
+    validator(1)
+    validator(10)
+    validator("hello")
+
+    with pytest.raises(InvalidFormat):
+        validator(1.4)