Restore testdata-cli with proper CI/CD and tests

tests/test_generators.py

@@ -0,0 +1,169 @@
+"""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"]