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)

    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)