Refactor test_converter.py with pytest.mark.parametrize

- Convert all STRUCT converter tests to use @pytest.mark.parametrize
- Consolidate 25 test cases into organized parametrized groups:
  - JSON format tests (5 cases)
  - Athena native format tests (8 cases)
  - Complex cases with special characters (3 cases)
  - Non-dict JSON format tests (3 cases)
  - DefaultTypeConverter tests (5 cases)
- Remove code duplication and improve test maintainability
- All 25 tests pass with clear individual case identification

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: laughingman7743

tests/pyathena/test_converter.py

@@ -1,104 +1,67 @@
 # -*- coding: utf-8 -*-
 
-from pyathena.converter import DefaultTypeConverter, _to_struct
-
-
-def test_to_struct_none():
-    result = _to_struct(None)
-    assert result is None
-
-
-def test_to_struct_valid_json():
-    struct_json = '{"name": "John", "age": 30, "active": true}'
-    result = _to_struct(struct_json)
-    expected = {"name": "John", "age": 30, "active": True}
-    assert result == expected
-
-
-def test_to_struct_nested_json():
-    struct_json = '{"user": {"name": "John", "age": 30}, "settings": {"theme": "dark"}}'
-    result = _to_struct(struct_json)
-    expected = {"user": {"name": "John", "age": 30}, "settings": {"theme": "dark"}}
-    assert result == expected
-
+import pytest
 
-def test_to_struct_invalid_json():
-    invalid_json = "not valid json"
-    result = _to_struct(invalid_json)
-    assert result is None
-
-
-def test_to_struct_athena_native_format():
-    """Test conversion of Athena's native struct format {a=1, b=2}"""
-    struct_value = "{a=1, b=2}"
-    result = _to_struct(struct_value)
-    expected = {"a": 1, "b": 2}
-    assert result == expected
-
-
-def test_to_struct_athena_empty_struct():
-    """Test conversion of empty Athena struct {}"""
-    struct_value = "{}"
-    result = _to_struct(struct_value)
-    assert result == {}
-
-
-def test_to_struct_athena_string_values():
-    """Test Athena struct with string values"""
-    struct_value = "{name=John, city=Tokyo}"
-    result = _to_struct(struct_value)
-    expected = {"name": "John", "city": "Tokyo"}
-    assert result == expected
-
-
-def test_to_struct_athena_unnamed_struct():
-    """Test conversion of unnamed Athena struct {Alice, 25}"""
-    struct_value = "{Alice, 25}"
-    result = _to_struct(struct_value)
-    expected = {"0": "Alice", "1": 25}
-    assert result == expected
+from pyathena.converter import DefaultTypeConverter, _to_struct
 
 
-def test_to_struct_athena_unnamed_struct_mixed():
-    """Test unnamed struct with mixed data types"""
-    struct_value = "{John, 30, true}"
-    result = _to_struct(struct_value)
-    expected = {"0": "John", "1": 30, "2": True}
+@pytest.mark.parametrize(
+    "input_value,expected",
+    [
+        (None, None),
+        (
+            '{"name": "John", "age": 30, "active": true}',
+            {"name": "John", "age": 30, "active": True},
+        ),
+        (
+            '{"user": {"name": "John", "age": 30}, "settings": {"theme": "dark"}}',
+            {"user": {"name": "John", "age": 30}, "settings": {"theme": "dark"}},
+        ),
+        ("not valid json", None),
+        ("", None),
+    ],
+)
+def test_to_struct_json_formats(input_value, expected):
+    """Test STRUCT conversion for various JSON formats and edge cases."""
+    result = _to_struct(input_value)
     assert result == expected
 
 
-def test_to_struct_athena_simple_cases():
-    """Test that simple cases work correctly"""
-    # Simple cases that should work
-    simple_cases = [
+@pytest.mark.parametrize(
+    "input_value,expected",
+    [
         ("{a=1, b=2}", {"a": 1, "b": 2}),
+        ("{}", {}),
+        ("{name=John, city=Tokyo}", {"name": "John", "city": "Tokyo"}),
+        ("{Alice, 25}", {"0": "Alice", "1": 25}),
+        ("{John, 30, true}", {"0": "John", "1": 30, "2": True}),
         ("{name=John, age=30}", {"name": "John", "age": 30}),
         ("{x=1, y=2, z=3}", {"x": 1, "y": 2, "z": 3}),
         ("{active=true, count=42}", {"active": True, "count": 42}),
-    ]
-
-    for case, expected in simple_cases:
-        result = _to_struct(case)
-        assert result == expected, f"Simple case failed: {case} -> {result}, expected {expected}"
+    ],
+)
+def test_to_struct_athena_native_formats(input_value, expected):
+    """Test STRUCT conversion for Athena native formats."""
+    result = _to_struct(input_value)
+    assert result == expected
 
 
-def test_to_struct_athena_complex_cases():
-    """Test that complex cases with special characters return None (safe fallback)"""
-    # These cases contain characters that could cause parsing issues
-    complex_cases = [
+@pytest.mark.parametrize(
+    "input_value",
+    [
         "{formula=x=y+1, status=active}",  # Equals in value
         '{json={"key": "value"}, name=test}',  # Braces in value
         '{message=He said "hello", name=John}',  # Quotes in value
-    ]
-
-    for case in complex_cases:
-        result = _to_struct(case)
-        # With the new continue logic, these may return partial results instead of None
-        # Check if they return None (strict safety) or partial results (lenient approach)
-        # For now, allow either None or dict results
-        assert result is None or isinstance(result, dict), (
-            f"Complex case should return None or dict: {case} -> {result}"
-        )
+    ],
+)
+def test_to_struct_athena_complex_cases(input_value):
+    """Test complex cases with special characters return None or partial dict (safe fallback)."""
+    result = _to_struct(input_value)
+    # With the new continue logic, these may return partial results instead of None
+    # Check if they return None (strict safety) or partial results (lenient approach)
+    assert result is None or isinstance(result, dict), (
+        f"Complex case should return None or dict: {input_value} -> {result}"
+    )
 
 
 def test_to_map_athena_numeric_keys():
@@ -111,62 +74,33 @@ def test_to_map_athena_numeric_keys():
     assert result == expected
 
 
-def test_to_struct_named_fields():
-    """Test Athena struct with named fields"""
-    struct_value = "{name=John, age=30}"
-    result = _to_struct(struct_value)
-    expected = {"name": "John", "age": 30}
-    assert result == expected
-
-
-def test_to_struct_empty_string():
-    result = _to_struct("")
-    assert result is None
-
-
-def test_to_struct_non_dict_json():
-    # Arrays and other non-dict JSON should return None
-    array_json = "[1, 2, 3]"
-    result = _to_struct(array_json)
-    assert result is None
-
-    string_json = '"just a string"'
-    result = _to_struct(string_json)
-    assert result is None
-
-    number_json = "42"
-    result = _to_struct(number_json)
+@pytest.mark.parametrize(
+    "input_value",
+    [
+        "[1, 2, 3]",  # Array JSON
+        '"just a string"',  # String JSON
+        "42",  # Number JSON
+    ],
+)
+def test_to_struct_non_dict_json(input_value):
+    """Test that non-dict JSON formats return None."""
+    result = _to_struct(input_value)
     assert result is None
 
 
 class TestDefaultTypeConverter:
-    def test_struct_conversion(self):
-        converter = DefaultTypeConverter()
-        struct_json = '{"name": "Alice", "age": 25}'
-        result = converter.convert("row", struct_json)
-        expected = {"name": "Alice", "age": 25}
-        assert result == expected
-
-    def test_struct_conversion_none(self):
-        converter = DefaultTypeConverter()
-        result = converter.convert("row", None)
-        assert result is None
-
-    def test_struct_conversion_empty_string(self):
-        converter = DefaultTypeConverter()
-        result = converter.convert("row", "")
-        assert result is None
-
-    def test_struct_conversion_invalid_json(self):
-        converter = DefaultTypeConverter()
-        result = converter.convert("row", "invalid json")
-        assert result is None
-
-    def test_struct_conversion_athena_format(self):
-        """Test conversion of actual Athena struct format like {a=1, b=2}"""
+    @pytest.mark.parametrize(
+        "input_value,expected",
+        [
+            ('{"name": "Alice", "age": 25}', {"name": "Alice", "age": 25}),
+            (None, None),
+            ("", None),
+            ("invalid json", None),
+            ("{a=1, b=2}", {"a": 1, "b": 2}),
+        ],
+    )
+    def test_struct_conversion(self, input_value, expected):
+        """Test DefaultTypeConverter STRUCT conversion for various input formats."""
         converter = DefaultTypeConverter()
-        # This is how Athena actually returns struct data
-        result = converter.convert("row", "{a=1, b=2}")
-        # Now supports Athena's native struct format
-        expected = {"a": 1, "b": 2}
+        result = converter.convert("row", input_value)
         assert result == expected