testdata-cli/tests/test_generators.py

"""Tests for JSON Schema Generator."""

import json

import pytest

from testdatagen.generators.json_schema_generator import JSONSchemaGenerator


class TestJSONSchemaGenerator:
    """Tests for JSONSchemaGenerator class."""

    def test_generate_simple_string(self):
        """Test generating a simple string field."""
        schema = {
            "type": "object",
            "properties": {
                "name": {"type": "string"}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert "name" in records[0]
        assert isinstance(records[0]["name"], str)

    def test_generate_string_with_format_email(self):
        """Test generating an email field."""
        schema = {
            "type": "object",
            "properties": {
                "email": {"type": "string", "format": "email"}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert "@" in records[0]["email"]
        assert "." in records[0]["email"]

    def test_generate_string_with_format_uuid(self):
        """Test generating a UUID field."""
        schema = {
            "type": "object",
            "properties": {
                "id": {"type": "string", "format": "uuid"}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert "-" in records[0]["id"]

    def test_generate_integer(self):
        """Test generating an integer field."""
        schema = {
            "type": "object",
            "properties": {
                "age": {"type": "integer"}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert isinstance(records[0]["age"], int)

    def test_generate_boolean(self):
        """Test generating a boolean field."""
        schema = {
            "type": "object",
            "properties": {
                "active": {"type": "boolean"}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert isinstance(records[0]["active"], bool)

    def test_generate_multiple_records(self):
        """Test generating multiple records."""
        schema = {
            "type": "object",
            "properties": {
                "name": {"type": "string"}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=5)
        
        assert len(records) == 5
        for record in records:
            assert "name" in record

    def test_generate_nested_object(self):
        """Test generating nested objects."""
        schema = {
            "type": "object",
            "properties": {
                "user": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "email": {"type": "string", "format": "email"}
                    }
                }
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert "user" in records[0]
        assert "name" in records[0]["user"]
        assert "email" in records[0]["user"]

    def test_generate_with_seed(self):
        """Test that seed produces reproducible results."""
        schema = {
            "type": "object",
            "properties": {
                "name": {"type": "string"}
            }
        }
        
        generator1 = JSONSchemaGenerator(seed=123)
        records1 = generator1.generate(schema, count=1)
        
        generator2 = JSONSchemaGenerator(seed=123)
        records2 = generator2.generate(schema, count=1)
        
        assert records1[0]["name"] == records2[0]["name"]

    def test_generate_array_of_strings(self):
        """Test generating array of strings."""
        schema = {
            "type": "object",
            "properties": {
                "tags": {
                    "type": "array",
                    "items": {"type": "string"}
                }
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=1)
        
        assert len(records) == 1
        assert isinstance(records[0]["tags"], list)

    def test_generate_with_enum(self):
        """Test generating with enum constraint."""
        schema = {
            "type": "object",
            "properties": {
                "status": {"type": "string", "enum": ["active", "inactive", "pending"]}
            }
        }
        generator = JSONSchemaGenerator(seed=42)
        records = generator.generate(schema, count=10)
        
        assert len(records) == 10
        for record in records:
            assert record["status"] in ["active", "inactive", "pending"]