- Added comprehensive unit tests for all codegen modules

Author: MS-32154

tests/test_gen_conftest.py

@@ -0,0 +1,54 @@
+"""
+Pytest configuration for codegen tests.
+"""
+
+import pytest
+import logging
+
+
+@pytest.fixture(scope="session", autouse=True)
+def configure_logging():
+    """Configure logging for tests."""
+    logging.basicConfig(
+        level=logging.WARNING,  # Reduce noise during tests
+        format="%(name)s - %(levelname)s - %(message)s",
+    )
+
+
+@pytest.fixture
+def sample_data():
+    """Sample JSON data for testing."""
+    return {
+        "user_id": 123,
+        "name": "John Doe",
+        "email": "[email protected]",
+        "active": True,
+        "score": 98.5,
+    }
+
+
+@pytest.fixture
+def nested_data():
+    """Sample nested JSON data."""
+    return {
+        "user": {
+            "id": 1,
+            "profile": {
+                "name": "John",
+                "age": 30,
+            },
+        }
+    }
+
+
+@pytest.fixture
+def array_data():
+    """Sample array JSON data."""
+    return {
+        "users": [
+            {"id": 1, "name": "John"},
+            {"id": 2, "name": "Jane"},
+        ],
+        "tags": ["python", "go", "rust"],
+        "scores": [95, 87, 92],
+    }

tests/test_gen_core_config.py

@@ -0,0 +1,92 @@
+"""
+Tests for core configuration.
+"""
+
+import pytest
+import tempfile
+import json
+from pathlib import Path
+from json_explorer.codegen.core.config import (
+    GeneratorConfig,
+    ConfigError,
+    load_config,
+    save_config,
+)
+
+
+class TestGeneratorConfig:
+    """Test GeneratorConfig dataclass."""
+
+    def test_default_config(self):
+        config = GeneratorConfig()
+        assert config.package_name == "main"
+        assert config.add_comments is True
+        assert config.indent_size == 4
+
+    def test_custom_config(self):
+        config = GeneratorConfig(
+            package_name="models",
+            add_comments=False,
+            indent_size=2,
+        )
+        assert config.package_name == "models"
+        assert config.add_comments is False
+        assert config.indent_size == 2
+
+    def test_config_language_specific(self):
+        config = GeneratorConfig(language_config={"custom_option": "value"})
+        assert config.language_config["custom_option"] == "value"
+
+    def test_validation_fails(self):
+        with pytest.raises(ConfigError):
+            GeneratorConfig(indent_size=0)
+
+    def test_merge_config(self):
+        config = GeneratorConfig(package_name="main")
+        merged = config.merge({"package_name": "models", "add_comments": False})
+
+        assert merged.package_name == "models"
+        assert merged.add_comments is False
+
+    def test_to_dict(self):
+        config = GeneratorConfig(package_name="test")
+        result = config.to_dict()
+
+        assert isinstance(result, dict)
+        assert result["package_name"] == "test"
+
+
+class TestConfigLoading:
+    """Test configuration loading."""
+
+    def test_load_from_dict(self):
+        config = load_config(custom_config={"package_name": "test"})
+        assert config.package_name == "test"
+
+    def test_load_from_file(self):
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump({"package_name": "file_test"}, f)
+            temp_path = f.name
+
+        try:
+            config = load_config(config_file=temp_path)
+            assert config.package_name == "file_test"
+        finally:
+            Path(temp_path).unlink()
+
+    def test_load_invalid_file(self):
+        with pytest.raises(ConfigError):
+            load_config(config_file="nonexistent.json")
+
+    def test_save_config(self):
+        config = GeneratorConfig(package_name="save_test")
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            temp_path = f.name
+
+        try:
+            save_config(config, temp_path)
+            loaded = load_config(config_file=temp_path)
+            assert loaded.package_name == "save_test"
+        finally:
+            Path(temp_path).unlink()

tests/test_gen_core_naming.py

@@ -0,0 +1,81 @@
+"""
+Tests for core naming utilities.
+"""
+
+from json_explorer.codegen.core.naming import (
+    to_snake_case,
+    to_camel_case,
+    to_pascal_case,
+    sanitize_name,
+    NameTracker,
+)
+
+
+class TestCaseConversion:
+    """Test case conversion functions."""
+
+    def test_to_snake_case(self):
+        assert to_snake_case("UserName") == "user_name"
+        assert to_snake_case("user-name") == "user_name"
+        assert to_snake_case("userName") == "user_name"
+
+    def test_to_camel_case(self):
+        assert to_camel_case("user_name") == "userName"
+        assert to_camel_case("UserName") == "userName"
+        assert to_camel_case("user-name") == "userName"
+
+    def test_to_pascal_case(self):
+        assert to_pascal_case("user_name") == "UserName"
+        assert to_pascal_case("userName") == "UserName"
+        assert to_pascal_case("user-name") == "UserName"
+
+
+class TestSanitizeName:
+    """Test name sanitization."""
+
+    def test_basic_sanitization(self):
+        result = sanitize_name("user-name", "snake")
+        assert result == "user_name"
+
+    def test_reserved_word_conflict(self):
+        reserved = {"class", "def"}
+        result = sanitize_name("class", "snake", reserved_words=reserved)
+        assert result == "class_"
+
+    def test_duplicate_name_conflict(self):
+        used = {"user"}
+        result = sanitize_name("user", "snake", used_names=used)
+        assert result == "user_1"
+
+    def test_invalid_characters(self):
+        result = sanitize_name("user@name!", "snake")
+        assert result == "user_name"
+
+    def test_starts_with_digit(self):
+        result = sanitize_name("123user", "snake")
+        assert result == "_123user"
+
+
+class TestNameTracker:
+    """Test NameTracker stateful sanitization."""
+
+    def test_tracks_used_names(self):
+        tracker = NameTracker()
+        name1 = tracker.sanitize("user", "snake")
+        name2 = tracker.sanitize("user", "snake")
+
+        assert name1 == "user"
+        assert name2 == "user_1"
+
+    def test_reserved_words(self):
+        tracker = NameTracker(reserved_words={"class"})
+        result = tracker.sanitize("class", "pascal")
+        assert result == "Class_"
+
+    def test_reset(self):
+        tracker = NameTracker()
+        tracker.sanitize("user", "snake")
+        tracker.reset()
+
+        result = tracker.sanitize("user", "snake")
+        assert result == "user"

tests/test_gen_core_schema.py

@@ -0,0 +1,161 @@
+"""
+Tests for core schema representation.
+"""
+
+from json_explorer.codegen.core.schema import (
+    Field,
+    FieldType,
+    Schema,
+    convert_analyzer_output,
+    extract_all_schemas,
+)
+
+
+class TestFieldType:
+    """Test FieldType enum."""
+
+    def test_field_types_exist(self):
+        assert FieldType.STRING.value == "string"
+        assert FieldType.INTEGER.value == "integer"
+        assert FieldType.ARRAY.value == "array"
+        assert FieldType.OBJECT.value == "object"
+
+
+class TestField:
+    """Test Field dataclass."""
+
+    def test_basic_field(self):
+        field = Field(
+            name="user_id",
+            original_name="userId",
+            type=FieldType.INTEGER,
+        )
+        assert field.name == "user_id"
+        assert field.type == FieldType.INTEGER
+        assert field.optional is False
+
+    def test_optional_field(self):
+        field = Field(
+            name="email",
+            original_name="email",
+            type=FieldType.STRING,
+            optional=True,
+        )
+        assert field.optional is True
+
+    def test_array_field(self):
+        field = Field(
+            name="tags",
+            original_name="tags",
+            type=FieldType.ARRAY,
+            array_element_type=FieldType.STRING,
+        )
+        assert field.type == FieldType.ARRAY
+        assert field.array_element_type == FieldType.STRING
+
+
+class TestSchema:
+    """Test Schema dataclass."""
+
+    def test_basic_schema(self):
+        schema = Schema(name="User", original_name="User")
+        assert schema.name == "User"
+        assert len(schema.fields) == 0
+
+    def test_add_field(self):
+        schema = Schema(name="User", original_name="User")
+        field = Field("id", "id", FieldType.INTEGER)
+
+        schema.add_field(field)
+        assert len(schema.fields) == 1
+        assert schema.fields[0].name == "id"
+
+    def test_get_field(self):
+        schema = Schema(name="User", original_name="User")
+        field = Field("id", "id", FieldType.INTEGER)
+        schema.add_field(field)
+
+        found = schema.get_field("id")
+        assert found is not None
+        assert found.name == "id"
+
+
+class TestConvertAnalyzerOutput:
+    """Test analyzer output conversion."""
+
+    def test_simple_object(self):
+        analyzer_result = {
+            "type": "object",
+            "children": {
+                "name": {"type": "str", "optional": False},
+                "age": {"type": "int", "optional": False},
+            },
+            "conflicts": {},
+        }
+
+        schema = convert_analyzer_output(analyzer_result, "User")
+
+        assert schema.name == "User"
+        assert len(schema.fields) == 2
+        assert schema.fields[0].type == FieldType.STRING
+        assert schema.fields[1].type == FieldType.INTEGER
+
+    def test_nested_object(self):
+        analyzer_result = {
+            "type": "object",
+            "children": {
+                "profile": {
+                    "type": "object",
+                    "children": {
+                        "age": {"type": "int", "optional": False},
+                    },
+                    "conflicts": {},
+                },
+            },
+            "conflicts": {},
+        }
+
+        schema = convert_analyzer_output(analyzer_result, "User")
+
+        assert len(schema.fields) == 1
+        assert schema.fields[0].type == FieldType.OBJECT
+        assert schema.fields[0].nested_schema is not None
+
+    def test_array_of_primitives(self):
+        analyzer_result = {
+            "type": "object",
+            "children": {
+                "tags": {
+                    "type": "list",
+                    "child_type": "str",
+                    "optional": False,
+                },
+            },
+            "conflicts": {},
+        }
+
+        schema = convert_analyzer_output(analyzer_result, "Data")
+
+        assert schema.fields[0].type == FieldType.ARRAY
+        assert schema.fields[0].array_element_type == FieldType.STRING
+
+    def test_extract_all_schemas(self):
+        analyzer_result = {
+            "type": "object",
+            "children": {
+                "profile": {
+                    "type": "object",
+                    "children": {
+                        "age": {"type": "int", "optional": False},
+                    },
+                    "conflicts": {},
+                },
+            },
+            "conflicts": {},
+        }
+
+        root_schema = convert_analyzer_output(analyzer_result, "User")
+        all_schemas = extract_all_schemas(root_schema)
+
+        assert len(all_schemas) == 2  # User + UserProfile
+        assert "User" in all_schemas