Add test files

tests/test_typescript.py

@@ -0,0 +1,84 @@
+"""Tests for TypeScript generator."""
+
+import pytest
+
+from config_converter.generators import TypeScriptGenerator
+from config_converter.validators.schema import SchemaType
+
+
+class TestTypeScriptGenerator:
+    """Tests for TypeScript interface generation."""
+
+    def test_generate_simple_interface(self) -> None:
+        """Test generating simple interface."""
+        generator = TypeScriptGenerator(interface_name="TestConfig")
+        data = {"name": "test", "value": 42}
+        result = generator.generate(data)
+        assert "export interface TestConfig" in result
+        assert "name: string" in result
+        assert "value: number" in result
+
+    def test_generate_with_boolean(self) -> None:
+        """Test generating interface with boolean property."""
+        generator = TypeScriptGenerator()
+        data = {"active": True, "disabled": False}
+        result = generator.generate(data)
+        assert "active: boolean" in result
+        assert "disabled: boolean" in result
+
+    def test_generate_with_nested_object(self) -> None:
+        """Test generating interface with nested object."""
+        generator = TypeScriptGenerator()
+        data = {"config": {"setting": "value"}}
+        result = generator.generate(data)
+        assert "export interface Config" in result
+        assert "setting: string" in result
+
+    def test_generate_with_array(self) -> None:
+        """Test generating interface with array."""
+        generator = TypeScriptGenerator()
+        data = {"items": [1, 2, 3]}
+        result = generator.generate(data)
+        assert "items: Array<number>" in result
+
+    def test_generate_with_array_of_objects(self) -> None:
+        """Test generating interface with array of objects."""
+        generator = TypeScriptGenerator()
+        data = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
+        result = generator.generate(data)
+        assert "users: UsersItem[]" in result or "Array<" in result
+
+    def test_generate_from_schema(self) -> None:
+        """Test generating from inferred schema."""
+        from config_converter.validators import SchemaInferrer
+
+        generator = TypeScriptGenerator()
+        data = {"name": "test", "count": 5}
+        inferrer = SchemaInferrer()
+        schema = inferrer.infer(data)
+        result = generator.generate_from_schema(schema, "GeneratedConfig")
+        assert "export interface GeneratedConfig" in result
+
+    def test_python_to_ts_mapping(self) -> None:
+        """Test Python to TypeScript type mapping."""
+        generator = TypeScriptGenerator()
+        mapping = generator.PYTHON_TO_TS
+        assert mapping[SchemaType.STRING] == "string"
+        assert mapping[SchemaType.NUMBER] == "number"
+        assert mapping[SchemaType.INTEGER] == "number"
+        assert mapping[SchemaType.BOOLEAN] == "boolean"
+        assert mapping[SchemaType.NULL] == "null"
+
+    def test_generate_custom_interface_name(self) -> None:
+        """Test generating with custom interface name."""
+        generator = TypeScriptGenerator(interface_name="CustomName")
+        result = generator.generate({"key": "value"})
+        assert "export interface CustomName" in result
+
+    def test_generate_from_json_string(self) -> None:
+        """Test generating TypeScript from JSON string."""
+        generator = TypeScriptGenerator()
+        json_str = '{"name": "test", "value": 42}'
+        result = generator.generate_from_json(json_str)
+        assert "export interface Config" in result
+        assert "name: string" in result