mockapi/tests/unit/test_generators.py

"""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)
        assert "-" in result

    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 datetime 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": ["red", "green", "blue"]}
        result = gen.generate(schema)
        assert result in ["red", "green", "blue"]

    def test_generate_array(self):
        """Test generating arrays."""
        gen = DataGenerator(seed=42)
        schema = {"type": "array", "items": {"type": "string"}}
        result = gen.generate(schema)
        assert isinstance(result, list)
        assert len(result) > 0

    def test_generate_array_with_count(self):
        """Test generating arrays 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 objects."""
        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 objects with required fields."""
        gen = DataGenerator(seed=42)
        schema = {
            "type": "object",
            "properties": {
                "email": {"type": "string", "format": "email"},
                "name": {"type": "string"},
            },
            "required": ["email"],
        }
        result = gen.generate(schema)
        assert isinstance(result, dict)
        assert "email" in result

    def test_generate_nested_object(self):
        """Test generating nested objects."""
        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)

    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 generating with default values."""
        gen = DataGenerator(seed=42)
        schema = {"type": "string", "default": "default_value"}
        result = gen.generate(schema)
        assert result == "default_value"

    def test_generate_empty_schema(self):
        """Test generating with 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."""
        gen1 = DataGenerator(seed=12345)
        gen2 = DataGenerator(seed=12345)
        schema = {"type": "integer", "minimum": 1, "maximum": 1000}
        result1 = gen1.generate(schema)
        result2 = gen2.generate(schema)
        assert result1 == result2