diff --git a/tests/unit/test_generators.py b/tests/unit/test_generators.py
new file mode 100644
index 0000000..9e96b98
--- /dev/null
+++ b/tests/unit/test_generators.py
@@ -0,0 +1,191 @@
+"""Tests for data generators."""
+
+import pytest
+
+from mockapi.core.generators import DataGenerator
+
+
+class TestDataGenerator:
+    """Test cases for DataGenerator."""
+
+    def test_generate_boolean_true(self):
+        """Test generating boolean values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "boolean"}
+        result = gen.generate(schema)
+        assert isinstance(result, bool)
+
+    def test_generate_integer(self):
+        """Test generating integer values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "integer"}
+        result = gen.generate(schema)
+        assert isinstance(result, int)
+
+    def test_generate_integer_with_bounds(self):
+        """Test generating integers with min/max bounds."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "integer", "minimum": 10, "maximum": 20}
+        result = gen.generate(schema)
+        assert isinstance(result, int)
+        assert 10 <= result <= 20
+
+    def test_generate_number(self):
+        """Test generating number values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "number"}
+        result = gen.generate(schema)
+        assert isinstance(result, float)
+
+    def test_generate_string(self):
+        """Test generating string values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "string"}
+        result = gen.generate(schema)
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_generate_string_with_format_email(self):
+        """Test generating email format strings."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "string", "format": "email"}
+        result = gen.generate(schema)
+        assert isinstance(result, str)
+        assert "@" in result
+
+    def test_generate_string_with_format_uuid(self):
+        """Test generating UUID format strings."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "string", "format": "uuid"}
+        result = gen.generate(schema)
+        assert isinstance(result, str)
+
+    def test_generate_string_with_format_uri(self):
+        """Test generating URI format strings."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "string", "format": "uri"}
+        result = gen.generate(schema)
+        assert isinstance(result, str)
+
+    def test_generate_string_with_format_datetime(self):
+        """Test generating date-time format strings."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "string", "format": "date-time"}
+        result = gen.generate(schema)
+        assert isinstance(result, str)
+
+    def test_generate_enum(self):
+        """Test generating enum values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "string", "enum": ["pending", "processing", "completed"]}
+        result = gen.generate(schema)
+        assert result in ["pending", "processing", "completed"]
+
+    def test_generate_array(self):
+        """Test generating array values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "array", "items": {"type": "string"}}
+        result = gen.generate(schema)
+        assert isinstance(result, list)
+        assert len(result) > 0
+        assert all(isinstance(item, str) for item in result)
+
+    def test_generate_array_with_count(self):
+        """Test generating array with specific item count."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "array", "items": {"type": "integer"}, "minItems": 3, "maxItems": 3}
+        result = gen.generate(schema)
+        assert isinstance(result, list)
+        assert len(result) == 3
+
+    def test_generate_object(self):
+        """Test generating object values."""
+        gen = DataGenerator(seed=42)
+        schema = {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "age": {"type": "integer"},
+            },
+        }
+        result = gen.generate(schema)
+        assert isinstance(result, dict)
+        assert "name" in result
+        assert "age" in result
+
+    def test_generate_object_with_required(self):
+        """Test generating object with required fields."""
+        gen = DataGenerator(seed=42)
+        schema = {
+            "type": "object",
+            "required": ["email", "name"],
+            "properties": {
+                "email": {"type": "string", "format": "email"},
+                "name": {"type": "string"},
+                "age": {"type": "integer"},
+            },
+        }
+        result = gen.generate(schema)
+        assert isinstance(result, dict)
+        assert "email" in result
+        assert "name" in result
+
+    def test_generate_nested_object(self):
+        """Test generating nested object structures."""
+        gen = DataGenerator(seed=42)
+        schema = {
+            "type": "object",
+            "properties": {
+                "user": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "email": {"type": "string", "format": "email"},
+                    },
+                },
+            },
+        }
+        result = gen.generate(schema)
+        assert isinstance(result, dict)
+        assert "user" in result
+        assert isinstance(result["user"], dict)
+        assert "name" in result["user"]
+        assert "email" in result["user"]
+
+    def test_generate_null(self):
+        """Test generating null values."""
+        gen = DataGenerator(seed=42)
+        schema = {"type": "null"}
+        result = gen.generate(schema)
+        assert result is None
+
+    def test_generate_with_default(self):
+        """Test that required fields use defaults."""
+        gen = DataGenerator(seed=42)
+        schema = {
+            "type": "object",
+            "required": ["name"],
+            "properties": {
+                "name": {"type": "string", "default": "John Doe"},
+            },
+        }
+        result = gen.generate(schema)
+        assert result.get("name") is not None
+
+    def test_generate_empty_schema(self):
+        """Test generating from empty schema."""
+        gen = DataGenerator(seed=42)
+        result = gen.generate({})
+        assert result is None
+
+    def test_generate_with_seed_reproducibility(self):
+        """Test that same seed produces same results within a single generator."""
+        gen = DataGenerator(seed=12345)
+
+        schema = {"type": "integer", "minimum": 0, "maximum": 1000}
+
+        result1 = gen.generate(schema)
+        result2 = gen.generate(schema)
+
+        assert isinstance(result1, int)
+        assert isinstance(result2, int)