Initial commit: Add OpenAPI Mock Server project

.tests/test_data_generator.py

@@ -0,0 +1,203 @@
+"""Tests for the data generator module."""
+
+import pytest
+
+from openapi_mock.generators.data_generator import (
+    DataGenerator,
+    generate_mock_data,
+    FakerMapping,
+    UnsupportedTypeError,
+)
+
+
+class TestFakerMapping:
+    """Tests for FakerMapping class."""
+
+    def test_get_faker_method_by_format(self):
+        """Test getting Faker method by format."""
+        schema = {"type": "string", "format": "email"}
+        method = FakerMapping.get_faker_method(schema)
+        assert method == "email"
+
+    def test_get_faker_method_by_type(self):
+        """Test getting Faker method by type."""
+        schema = {"type": "integer"}
+        method = FakerMapping.get_faker_method(schema)
+        assert method == "random_int"
+
+    def test_get_faker_method_default(self):
+        """Test getting default Faker method."""
+        schema = {"type": "unknown"}
+        method = FakerMapping.get_faker_method(schema)
+        assert method == "word"
+
+
+class TestDataGenerator:
+    """Tests for DataGenerator class."""
+
+    def test_generate_string(self):
+        """Test generating a string."""
+        generator = DataGenerator()
+        schema = {"type": "string"}
+        result = generator.generate(schema)
+        assert isinstance(result, str)
+
+    def test_generate_integer(self):
+        """Test generating an integer."""
+        generator = DataGenerator()
+        schema = {"type": "integer"}
+        result = generator.generate(schema)
+        assert isinstance(result, int)
+
+    def test_generate_boolean(self):
+        """Test generating a boolean."""
+        generator = DataGenerator()
+        schema = {"type": "boolean"}
+        result = generator.generate(schema)
+        assert isinstance(result, bool)
+
+    def test_generate_number(self):
+        """Test generating a number."""
+        generator = DataGenerator()
+        schema = {"type": "number"}
+        result = generator.generate(schema)
+        assert isinstance(result, float)
+
+    def test_generate_string_with_format_email(self):
+        """Test generating an email."""
+        generator = DataGenerator()
+        schema = {"type": "string", "format": "email"}
+        result = generator.generate(schema)
+        assert isinstance(result, str)
+        assert "@" in result
+
+    def test_generate_string_with_format_uuid(self):
+        """Test generating a UUID."""
+        generator = DataGenerator()
+        schema = {"type": "string", "format": "uuid"}
+        result = generator.generate(schema)
+        assert isinstance(result, str)
+
+    def test_generate_string_with_format_date_time(self):
+        """Test generating a date-time."""
+        generator = DataGenerator()
+        schema = {"type": "string", "format": "date-time"}
+        result = generator.generate(schema)
+        assert isinstance(result, str)
+
+    def test_generate_string_with_enum(self):
+        """Test generating from enum values."""
+        generator = DataGenerator()
+        schema = {"type": "string", "enum": ["red", "green", "blue"]}
+        result = generator.generate(schema)
+        assert result in ["red", "green", "blue"]
+
+    def test_generate_string_with_min_max_length(self):
+        """Test generating string with length constraints."""
+        generator = DataGenerator()
+        schema = {"type": "string", "minLength": 10, "maxLength": 20}
+        result = generator.generate(schema)
+        assert len(result) >= 10
+        assert len(result) <= 20
+
+    def test_generate_integer_with_min_max(self):
+        """Test generating integer with min/max."""
+        generator = DataGenerator()
+        schema = {"type": "integer", "minimum": 10, "maximum": 20}
+        result = generator.generate(schema)
+        assert result >= 10
+        assert result <= 20
+
+    def test_generate_integer_with_multiple_of(self):
+        """Test generating integer with multipleOf."""
+        generator = DataGenerator()
+        schema = {"type": "integer", "minimum": 0, "maximum": 100, "multipleOf": 5}
+        result = generator.generate(schema)
+        assert result % 5 == 0
+
+    def test_generate_object(self):
+        """Test generating an object."""
+        generator = DataGenerator()
+        schema = {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "age": {"type": "integer"}
+            }
+        }
+        result = generator.generate(schema)
+        assert isinstance(result, dict)
+        assert "name" in result or "age" in result
+
+    def test_generate_array(self):
+        """Test generating an array."""
+        generator = DataGenerator()
+        schema = {
+            "type": "array",
+            "items": {"type": "string"},
+            "minItems": 2,
+            "maxItems": 5
+        }
+        result = generator.generate(schema)
+        assert isinstance(result, list)
+        assert len(result) >= 2
+        assert len(result) <= 5
+
+    def test_generate_with_ref(self, sample_openapi_spec):
+        """Test generating with $ref."""
+        generator = DataGenerator()
+        schemas = sample_openapi_spec["components"]["schemas"]
+        generator.set_ref_cache(schemas)
+
+        schema = {"$ref": "#/components/schemas/User"}
+        result = generator.generate(schema)
+        assert isinstance(result, dict)
+
+    def test_generate_null(self):
+        """Test generating null value."""
+        generator = DataGenerator()
+        schema = {"type": "null"}
+        result = generator.generate(schema)
+        assert result is None
+
+    def test_generate_nullable(self):
+        """Test generating nullable field."""
+        generator = DataGenerator()
+        schema = {"type": "string", "nullable": True}
+        result = generator.generate(schema)
+        assert result is None or isinstance(result, str)
+
+
+class TestGenerateMockData:
+    """Tests for the convenience function."""
+
+    def test_generate_mock_data_simple(self):
+        """Test generating mock data with convenience function."""
+        schema = {"type": "string", "format": "email"}
+        result = generate_mock_data(schema)
+        assert isinstance(result, str)
+        assert "@" in result
+
+    def test_generate_mock_data_with_schemas(self, sample_openapi_spec):
+        """Test generating mock data with schemas."""
+        schemas = sample_openapi_spec["components"]["schemas"]
+        schema = {"$ref": "#/components/schemas/User"}
+        result = generate_mock_data(schema, schemas=schemas)
+        assert isinstance(result, dict)
+
+    def test_generate_nested_object(self):
+        """Test generating nested object."""
+        schema = {
+            "type": "object",
+            "properties": {
+                "user": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "email": {"type": "string", "format": "email"}
+                    }
+                }
+            }
+        }
+        result = generate_mock_data(schema)
+        assert isinstance(result, dict)