test: enhance struct type support test coverage

Add comprehensive test cases for STRUCT type functionality:

- Add integration tests in test_base.py to verify struct type recognition
  - Update one_row_complex tests to expect AthenaStruct instead of String
  - Add tests for both struct<> and row<> type parsing in _get_column_type
- Expand converter tests with edge cases
  - Test empty strings, non-dict JSON, and invalid JSON handling
  - Document behavior with Athena's native struct format {a=1, b=2}
- Add compiler tests for error conditions and single field structs
- Add type tests for mixed field definitions and error handling

These tests ensure robust struct support and maintain backward compatibility
while providing comprehensive coverage of the new functionality.

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

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

Author: laughingman7743

tests/pyathena/sqlalchemy/test_base.py

@@ -275,7 +275,9 @@ def test_reflect_select(self, engine):
         assert isinstance(one_row_complex.c.col_binary.type, types.BINARY)
         assert isinstance(one_row_complex.c.col_array.type, types.String)
         assert isinstance(one_row_complex.c.col_map.type, types.String)
-        assert isinstance(one_row_complex.c.col_struct.type, types.String)
+        # With struct support, col_struct should now be recognized as AthenaStruct
+        from pyathena.sqlalchemy.types import AthenaStruct
+        assert isinstance(one_row_complex.c.col_struct.type, AthenaStruct)
         assert isinstance(
             one_row_complex.c.col_decimal.type,
             types.DECIMAL,
@@ -321,7 +323,10 @@ def test_get_column_type(self, engine):
         assert isinstance(dialect._get_column_type("binary"), types.BINARY)
         assert isinstance(dialect._get_column_type("array<integer>"), types.String)
         assert isinstance(dialect._get_column_type("map<int, int>"), types.String)
-        assert isinstance(dialect._get_column_type("struct<a: int, b: int>"), types.String)
+        # With struct support, struct types should be recognized as AthenaStruct
+        from pyathena.sqlalchemy.types import AthenaStruct
+        assert isinstance(dialect._get_column_type("struct<a: int, b: int>"), AthenaStruct)
+        assert isinstance(dialect._get_column_type("row<name: string, age: int>"), AthenaStruct)
         decimal_with_args = dialect._get_column_type("decimal(10,1)")
         assert isinstance(decimal_with_args, types.DECIMAL)
         assert decimal_with_args.precision == 10

tests/pyathena/sqlalchemy/test_compiler.py

@@ -31,3 +31,16 @@ def test_visit_struct_uppercase(self):
         assert "id INTEGER" in result
         assert "title STRING" in result or "title VARCHAR" in result
         assert result.endswith(")")
+
+    def test_visit_struct_no_fields_attribute(self):
+        # Test struct type without fields attribute
+        compiler = AthenaTypeCompiler()
+        struct_type = type('MockStruct', (), {})()
+        result = compiler.visit_struct(struct_type)
+        assert result == "ROW()"
+
+    def test_visit_struct_single_field(self):
+        compiler = AthenaTypeCompiler()
+        struct_type = AthenaStruct(("name", String))
+        result = compiler.visit_struct(struct_type)
+        assert result == "ROW(name STRING)" or result == "ROW(name VARCHAR)"

tests/pyathena/sqlalchemy/test_types.py

@@ -48,3 +48,19 @@ def test_visit_name(self):
     def test_struct_uppercase_visit_name(self):
         struct_type = STRUCT()
         assert struct_type.__visit_name__ == "STRUCT"
+
+    def test_empty_struct(self):
+        struct_type = AthenaStruct()
+        assert len(struct_type.fields) == 0
+
+    def test_mixed_field_definitions(self):
+        struct_type = AthenaStruct("name", ("age", Integer), ("active", String()))
+        assert len(struct_type.fields) == 3
+        assert isinstance(struct_type.fields["name"], sqltypes.String)
+        assert isinstance(struct_type.fields["age"], sqltypes.Integer)
+        assert isinstance(struct_type.fields["active"], sqltypes.String)
+
+    def test_field_access_nonexistent_key(self):
+        struct_type = AthenaStruct(("name", String))
+        with pytest.raises(KeyError):
+            struct_type["nonexistent"]

tests/pyathena/test_converter.py

@@ -28,6 +28,26 @@ def test_to_struct_invalid_json():
     assert result is None
 
 
+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)
+    assert result is None
+
+
 class TestDefaultTypeConverter:
     def test_struct_conversion(self):
         converter = DefaultTypeConverter()
@@ -40,3 +60,23 @@ 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}"""
+        converter = DefaultTypeConverter()
+        # This is how Athena actually returns struct data in some cases
+        # For now, our converter expects JSON format, but this test documents the behavior
+        result = converter.convert("row", "{a=1, b=2}")
+        # Currently returns None because it's not valid JSON
+        # This could be enhanced in the future to parse Athena's struct format
+        assert result is None