Better Type Parsing Interface

tests/test_schema_converter.py

@@ -1,4 +1,4 @@
-from jsonschema_pydantic import ModelSchemaBuilder
+from jsonschema_pydantic.schema_converter import SchemaConverter
 
 from pydantic import BaseModel
 
@@ -9,7 +9,7 @@ def is_pydantic_model(cls):
     return isinstance(cls, type) and issubclass(cls, BaseModel)
 
 
-class TestConversion(TestCase):
+class TestSchemaConverter(TestCase):
     def test_jsonschema_to_pydantic(self):
         schema = {
             "title": "Person",
@@ -22,7 +22,7 @@ class TestConversion(TestCase):
             "required": ["name"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         self.assertTrue(is_pydantic_model(model))
 
@@ -37,7 +37,7 @@ class TestConversion(TestCase):
             "required": ["name"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         self.assertEqual(model(name="John", age=30).name, "John")
 
@@ -52,7 +52,7 @@ class TestConversion(TestCase):
             "required": ["age"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         self.assertEqual(model(age=30).age, 30)
 
@@ -69,7 +69,7 @@ class TestConversion(TestCase):
             "required": ["age"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         self.assertEqual(model(age=30).age, 30.0)
 
@@ -86,7 +86,7 @@ class TestConversion(TestCase):
             "required": ["is_active"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         self.assertEqual(model(is_active=True).is_active, True)
 
@@ -103,7 +103,7 @@ class TestConversion(TestCase):
             "required": ["friends"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         self.assertEqual(model(friends=["John", "Jane"]).friends, ["John", "Jane"])
 
@@ -125,7 +125,7 @@ class TestConversion(TestCase):
             "required": ["address"],
         }
 
-        model = ModelSchemaBuilder.build(schema)
+        model = SchemaConverter.build(schema)
 
         obj = model(address={"street": "123 Main St", "city": "Springfield"})
 

tests/test_type_parser.py

@@ -0,0 +1,53 @@
+from jsonschema_pydantic.types import (
+    ArrayTypeParser,
+    FloatTypeParser,
+    GenericTypeParser,
+    IntTypeParser,
+    ObjectTypeParser,
+    StringTypeParser,
+)
+
+import unittest
+
+
+class TestTypeParser(unittest.TestCase):
+    def test_get_impl(self):
+        self.assertEqual(GenericTypeParser.get_impl("integer"), IntTypeParser)
+        self.assertEqual(GenericTypeParser.get_impl("string"), StringTypeParser)
+        self.assertEqual(GenericTypeParser.get_impl("number"), FloatTypeParser)
+        self.assertEqual(GenericTypeParser.get_impl("object"), ObjectTypeParser)
+        self.assertEqual(GenericTypeParser.get_impl("array"), ArrayTypeParser)
+
+    def test_int_parser(self):
+        parser = IntTypeParser()
+        expected_definition = (int, {})
+
+        self.assertEqual(parser.from_properties("placeholder", {}), expected_definition)
+
+    def test_float_parser(self):
+        parser = FloatTypeParser()
+        expected_definition = (float, {})
+
+        self.assertEqual(parser.from_properties("placeholder", {}), expected_definition)
+
+    def test_string_parser(self):
+        parser = StringTypeParser()
+        expected_definition = (str, {})
+
+        self.assertEqual(parser.from_properties("placeholder", {}), expected_definition)
+
+    def test_object_parser(self):
+        parser = ObjectTypeParser()
+        expected_definition = (object, {})
+
+        self.assertEqual(parser.from_properties("placeholder", {}), expected_definition)
+
+    def test_array_parser(self):
+        parser = ArrayTypeParser()
+        expected_definition = (list[str], {})
+
+        properties = {"items": {"type": "string"}}
+
+        self.assertEqual(
+            parser.from_properties("placeholder", properties), expected_definition
+        )