Add test files: conftest, parser tests, generator tests

tests/test_generator.py

@@ -0,0 +1,226 @@
+"""Tests for Response Generator."""
+
+import pytest
+from src.core.generator import ResponseGenerator, UnsupportedSchemaType
+
+
+class TestResponseGenerator:
+    """Tests for ResponseGenerator class."""
+
+    def test_generate_string(self):
+        """Test string generation."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "string"}
+        result = generator.generate(schema)
+
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_generate_string_with_min_length(self):
+        """Test string generation with minLength constraint."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "string", "minLength": 50}
+        result = generator.generate(schema)
+
+        assert isinstance(result, str)
+        assert len(result) >= 50
+
+    def test_generate_string_with_max_length(self):
+        """Test string generation with maxLength constraint."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "string", "maxLength": 10}
+        result = generator.generate(schema)
+
+        assert isinstance(result, str)
+        assert len(result) <= 10
+
+    def test_generate_string_with_enum(self):
+        """Test string generation with enum constraint."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "string", "enum": ["apple", "banana", "cherry"]}
+        result = generator.generate(schema)
+
+        assert result in ["apple", "banana", "cherry"]
+
+    def test_generate_string_with_format_email(self):
+        """Test string generation with email format."""
+        generator = ResponseGenerator(seed=42)
+
+        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 string generation with UUID format."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "string", "format": "uuid"}
+        result = generator.generate(schema)
+
+        assert isinstance(result, str)
+
+    def test_generate_integer(self):
+        """Test integer generation."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "integer"}
+        result = generator.generate(schema)
+
+        assert isinstance(result, int)
+
+    def test_generate_integer_with_bounds(self):
+        """Test integer generation with minimum and maximum."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "integer", "minimum": 10, "maximum": 20}
+        result = generator.generate(schema)
+
+        assert isinstance(result, int)
+        assert 10 <= result <= 20
+
+    def test_generate_integer_with_multiple_of(self):
+        """Test integer generation with multipleOf constraint."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "integer", "minimum": 0, "maximum": 100, "multipleOf": 5}
+        result = generator.generate(schema)
+
+        assert isinstance(result, int)
+        assert result % 5 == 0
+
+    def test_generate_number(self):
+        """Test number generation."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "number"}
+        result = generator.generate(schema)
+
+        assert isinstance(result, float)
+
+    def test_generate_boolean(self):
+        """Test boolean generation."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "boolean"}
+        result = generator.generate(schema)
+
+        assert isinstance(result, bool)
+
+    def test_generate_object(self):
+        """Test object generation."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {
+            "type": "object",
+            "properties": {
+                "id": {"type": "integer"},
+                "name": {"type": "string"},
+                "email": {"type": "string", "format": "email"}
+            },
+            "required": ["id", "name"]
+        }
+        result = generator.generate(schema)
+
+        assert isinstance(result, dict)
+        assert "id" in result
+        assert "name" in result
+        assert isinstance(result["id"], int)
+        assert isinstance(result["name"], str)
+
+    def test_generate_object_with_nested_properties(self):
+        """Test object generation with nested properties."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {
+            "type": "object",
+            "properties": {
+                "user": {
+                    "type": "object",
+                    "properties": {
+                        "id": {"type": "integer"},
+                        "name": {"type": "string"}
+                    }
+                }
+            }
+        }
+        result = generator.generate(schema)
+
+        assert isinstance(result, dict)
+        assert "user" in result
+        assert isinstance(result["user"], dict)
+        assert "id" in result["user"]
+        assert "name" in result["user"]
+
+    def test_generate_null(self):
+        """Test null generation."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "null"}
+        result = generator.generate(schema)
+
+        assert result is None
+
+    def test_generate_empty_schema(self):
+        """Test handling of empty schema."""
+        generator = ResponseGenerator(seed=42)
+
+        result = generator.generate({})
+
+        assert result is None
+
+    def test_generate_none_schema(self):
+        """Test handling of None schema."""
+        generator = ResponseGenerator(seed=42)
+
+        result = generator.generate(None)
+
+        assert result is None
+
+    def test_generate_response(self):
+        """Test generating a complete response."""
+        generator = ResponseGenerator(seed=42)
+
+        schema = {"type": "object", "properties": {"id": {"type": "integer"}, "name": {"type": "string"}}}
+        response = generator.generate_response(schema, status_code=200, headers={"Content-Type": "application/json"})
+
+        assert response["status_code"] == 200
+        assert response["body"] is not None
+        assert response["headers"]["Content-Type"] == "application/json"
+
+    def test_generate_list_response(self):
+        """Test generating a list response."""
+        generator = ResponseGenerator(seed=42)
+
+        item_schema = {"type": "object", "properties": {"id": {"type": "integer"}, "name": {"type": "string"}}}
+        response = generator.generate_list_response(item_schema, count=5)
+
+        assert response["status_code"] == 200
+        assert isinstance(response["body"], list)
+        assert len(response["body"]) == 5
+
+    def test_generate_error_response(self):
+        """Test generating an error response."""
+        generator = ResponseGenerator(seed=42)
+
+        response = generator.generate_error_response("Not found", status_code=404, error_type="Not Found")
+
+        assert response["status_code"] == 404
+        assert response["body"]["error"]["type"] == "Not Found"
+        assert response["body"]["error"]["message"] == "Not found"
+
+
+class TestResponseGeneratorErrors:
+    """Tests for response generator error handling."""
+
+    def test_unsupported_schema_type(self):
+        """Test handling of unsupported schema type."""
+        generator = ResponseGenerator(seed=42)
+
+        with pytest.raises(UnsupportedSchemaType):
+            generator.generate({"type": "unsupported_type"})