chore: add tests, remove dead code

Author: regan-art

packages/google-cloud-bigquery-storage/google/cloud/bigquery_storage_v1/schema.py

@@ -56,42 +56,22 @@
 }
 
 
-def _is_proto_compatible(field_name: str) -> bool:
-    """Check if a field name is compatible with Protocol Buffer naming conventions.
-
-    Args:
-        field_name: The field name to check.
-
-    Returns:
-        True if the field name is proto-compatible, False otherwise.
-    """
-    if not field_name:
-        return False
-
-    # First character must be a letter or underscore
-    ch = field_name[0]
-    if not ((ch >= 'a' and ch <= 'z') or (ch >= 'A' and ch <= 'Z') or ch == '_'):
-        return False
-
-    # Remaining characters must be letters, digits, or underscores
-    for ch in field_name[1:]:
-        if not ((ch >= 'a' and ch <= 'z') or (ch >= 'A' and ch <= 'Z') or
-                ch == '_' or (ch >= '0' and ch <= '9')):
-            return False
-
-    return True
-
-
 def _sanitize_field_name(field_name: str) -> str:
     """Sanitize a field name to make it proto-compatible.
 
     Args:
         field_name: The original field name.
 
     Returns:
-        The sanitized field name (lowercased).
+        The sanitized field name.
     """
-    return field_name.lower()
+    # Replace invalid characters with underscores.
+    sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', field_name)
+    # If the first character is a digit, prepend an underscore.
+    if sanitized and sanitized[0].isdigit():
+        sanitized = '_' + sanitized
+    # As a convention, field names are lowercased.
+    return sanitized.lower()
 
 
 def _get_field_label(mode: types.TableFieldSchema.Mode) -> int:

packages/google-cloud-bigquery-storage/tests/unit/test_schema.py

@@ -487,6 +487,111 @@ def test_scope_based_naming_avoids_collisions(self):
         assert len(proto_descriptor.nested_type) == 1
         assert proto_descriptor.nested_type[0].name == "root__my_record"
 
+    def test_field_name_sanitization(self):
+        """Test that field names are sanitized to be proto-compatible."""
+        table_schema = types.TableSchema(
+            fields=[
+                types.TableFieldSchema(
+                    name="field-with-hyphens",
+                    type_=types.TableFieldSchema.Type.STRING,
+                ),
+                types.TableFieldSchema(
+                    name="field with spaces",
+                    type_=types.TableFieldSchema.Type.STRING,
+                ),
+                types.TableFieldSchema(
+                    name="123field",
+                    type_=types.TableFieldSchema.Type.STRING,
+                ),
+                types.TableFieldSchema(
+                    name="field@special#chars",
+                    type_=types.TableFieldSchema.Type.STRING,
+                ),
+                types.TableFieldSchema(
+                    name="ValidField",
+                    type_=types.TableFieldSchema.Type.STRING,
+                ),
+            ]
+        )
+
+        proto_descriptor = schema.table_schema_to_proto_descriptor(table_schema)
+
+        # Hyphens replaced with underscores
+        assert proto_descriptor.field[0].name == "field_with_hyphens"
+
+        # Spaces replaced with underscores
+        assert proto_descriptor.field[1].name == "field_with_spaces"
+
+        # Field starting with digit gets prepended underscore
+        assert proto_descriptor.field[2].name == "_123field"
+
+        # Special characters replaced with underscores
+        assert proto_descriptor.field[3].name == "field_special_chars"
+
+        # Valid field names are lowercased
+        assert proto_descriptor.field[4].name == "validfield"
+
+    def test_field_name_sanitization_in_nested_structs(self):
+        """Test that field name sanitization works in nested STRUCT fields."""
+        table_schema = types.TableSchema(
+            fields=[
+                types.TableFieldSchema(
+                    name="outer-struct",
+                    type_=types.TableFieldSchema.Type.STRUCT,
+                    fields=[
+                        types.TableFieldSchema(
+                            name="inner-field",
+                            type_=types.TableFieldSchema.Type.STRING,
+                        ),
+                        types.TableFieldSchema(
+                            name="123inner",
+                            type_=types.TableFieldSchema.Type.INT64,
+                        ),
+                    ],
+                ),
+            ]
+        )
+
+        proto_descriptor = schema.table_schema_to_proto_descriptor(table_schema)
+
+        # Outer struct field name sanitized
+        outer_field = proto_descriptor.field[0]
+        assert outer_field.name == "outer_struct"
+        assert outer_field.type_name == "root__outer_struct"
+
+        # Nested type name sanitized
+        nested_type = proto_descriptor.nested_type[0]
+        assert nested_type.name == "root__outer_struct"
+
+        # Inner fields sanitized
+        assert nested_type.field[0].name == "inner_field"
+        assert nested_type.field[1].name == "_123inner"
+
+    def test_field_name_sanitization_in_range_fields(self):
+        """Test that field name sanitization works for RANGE fields."""
+        table_schema = types.TableSchema(
+            fields=[
+                types.TableFieldSchema(
+                    name="date-range",
+                    type_=types.TableFieldSchema.Type.RANGE,
+                    range_element_type=types.TableFieldSchema.FieldElementType(
+                        type_=types.TableFieldSchema.Type.DATE
+                    ),
+                ),
+            ]
+        )
+
+        proto_descriptor = schema.table_schema_to_proto_descriptor(table_schema)
+
+        # Range field name sanitized
+        range_field = proto_descriptor.field[0]
+        assert range_field.name == "date_range"
+        assert range_field.type_name == "root__date_range"
+
+        # Range type name sanitized
+        range_type = proto_descriptor.nested_type[0]
+        assert range_type.name == "root__date_range"
+
 
 if __name__ == "__main__":
     pytest.main([__file__])