fix: add type guards and fix test_token_200_w_oauth2_server_uri URL bug

- Add `assert ... is not None` guards in test files to help mypy narrow
  TableMetadata union types (reduces attr-defined errors vs main)
- Add type annotations in test_pyarrow_visitor.py to satisfy mypy
- Fix test_token_200_w_oauth2_server_uri: was passing OAUTH2_SERVER_URI
  constant as the value instead of TEST_OAUTH2_SERVER_URI URL
- Remove duplicate assert in test_metadata.py
- Minor formatting fixes (blank lines, import spacing)

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

Author: 2 people

tests/catalog/integration_test_dynamodb.py

@@ -112,6 +112,8 @@ def test_load_table(test_catalog: Catalog, table_schema_nested: Schema, database
     loaded_table = test_catalog.load_table(identifier)
     assert table.name() == loaded_table.name()
     assert table.metadata_location == loaded_table.metadata_location
+    assert table.metadata is not None
+    assert loaded_table.metadata is not None
     assert table.metadata == loaded_table.metadata
 
 

tests/catalog/integration_test_glue.py

@@ -392,6 +392,7 @@ def test_commit_table_update_schema(
     identifier = (database_name, table_name)
     test_catalog.create_namespace(namespace=database_name)
     table = test_catalog.create_table(identifier, table_schema_nested)
+    assert table.metadata is not None
     original_table_metadata = table.metadata
 
     assert MetastoreCatalog._parse_metadata_version(table.metadata_location) == 0
@@ -417,6 +418,7 @@ def test_commit_table_update_schema(
     update.commit()
     transaction.commit_transaction()
 
+    assert table.metadata is not None
     updated_table_metadata = table.metadata
 
     assert MetastoreCatalog._parse_metadata_version(table.metadata_location) == 1
@@ -485,6 +487,7 @@ def test_commit_table_properties(
     transaction.commit_transaction()
 
     updated_table_metadata = table.metadata
+    assert updated_table_metadata is not None
     assert MetastoreCatalog._parse_metadata_version(table.metadata_location) == 1
     assert updated_table_metadata.properties == {"Description": "test_description", "test_a": "test_aa", "test_c": "test_c"}
 

tests/catalog/test_rest.py

@@ -334,7 +334,7 @@ def test_token_200_w_oauth2_server_uri(rest_mock: Mocker) -> None:
         status_code=200,
         request_headers=OAUTH_TEST_HEADERS,
     )
-    catalog = RestCatalog("rest", uri=TEST_URI, credential=TEST_CREDENTIALS, **{OAUTH2_SERVER_URI: OAUTH2_SERVER_URI})
+    catalog = RestCatalog("rest", uri=TEST_URI, credential=TEST_CREDENTIALS, **{OAUTH2_SERVER_URI: TEST_OAUTH2_SERVER_URI})
     req = Request("GET", "http://example.com")
     prepped = catalog._session.prepare_request(req)
     assert prepped.headers["Authorization"] == f"Bearer {TEST_TOKEN}"
@@ -3164,11 +3164,11 @@ def test_load_table_without_storage_credentials(
     assert actual == expected
 
 
-
 # Tests for issue #3422: REST catalog auth cannot be configured via environment
 # variables unless auth JSON strings are decoded.
 
 import json
+
 import pytest
 
 

tests/io/test_pyarrow_visitor.py

@@ -71,80 +71,80 @@
 
 
 def test_pyarrow_binary_to_iceberg() -> None:
-    length = 23
-    pyarrow_type = pa.binary(length)
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    length: int = 23
+    pyarrow_type: pa.DataType = pa.binary(length)
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == FixedType(length)
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_decimal128_to_iceberg() -> None:
-    precision = 26
-    scale = 20
-    pyarrow_type = pa.decimal128(precision, scale)
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    precision: int = 26
+    scale: int = 20
+    pyarrow_type: pa.DataType = pa.decimal128(precision, scale)
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == DecimalType(precision, scale)
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_decimal256_to_iceberg() -> None:
-    precision = 26
-    scale = 20
-    pyarrow_type = pa.decimal256(precision, scale)
+    precision: int = 26
+    scale: int = 20
+    pyarrow_type: pa.DataType = pa.decimal256(precision, scale)
     with pytest.raises(TypeError, match=re.escape("Unsupported type: decimal256(26, 20)")):
         visit_pyarrow(pyarrow_type, _ConvertToIceberg())
 
 
 def test_pyarrow_boolean_to_iceberg() -> None:
-    pyarrow_type = pa.bool_()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.bool_()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == BooleanType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_int8_to_iceberg() -> None:
-    pyarrow_type = pa.int8()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.int8()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == IntegerType()
 
 
 def test_pyarrow_int16_to_iceberg() -> None:
-    pyarrow_type = pa.int16()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.int16()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == IntegerType()
 
 
 def test_pyarrow_int32_to_iceberg() -> None:
-    pyarrow_type = pa.int32()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.int32()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == IntegerType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_int64_to_iceberg() -> None:
-    pyarrow_type = pa.int64()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.int64()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == LongType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_float32_to_iceberg() -> None:
-    pyarrow_type = pa.float32()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.float32()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == FloatType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_float64_to_iceberg() -> None:
-    pyarrow_type = pa.float64()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.float64()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == DoubleType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
 
 def test_pyarrow_date32_to_iceberg() -> None:
-    pyarrow_type = pa.date32()
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.date32()
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == DateType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
@@ -165,8 +165,8 @@ def test_pyarrow_time32_to_iceberg() -> None:
 
 
 def test_pyarrow_time64_us_to_iceberg() -> None:
-    pyarrow_type = pa.time64("us")
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.time64("us")
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == TimeType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
 
@@ -179,8 +179,8 @@ def test_pyarrow_time64_ns_to_iceberg() -> None:
 
 @pytest.mark.parametrize("precision", ["s", "ms", "us", "ns"])
 def test_pyarrow_timestamp_to_iceberg(precision: str) -> None:
-    pyarrow_type = pa.timestamp(unit=precision)
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg(downcast_ns_timestamp_to_us=True))
+    pyarrow_type: pa.DataType = pa.timestamp(unit=precision)
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg(downcast_ns_timestamp_to_us=True))
     assert converted_iceberg_type == TimestampType()
     # all timestamp types are converted to 'us' precision
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pa.timestamp(unit="us")
@@ -199,10 +199,10 @@ def test_pyarrow_timestamp_invalid_units() -> None:
 
 
 def test_pyarrow_timestamp_tz_to_iceberg() -> None:
-    pyarrow_type = pa.timestamp(unit="us", tz="UTC")
-    pyarrow_type_zero_offset = pa.timestamp(unit="us", tz="+00:00")
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
-    converted_iceberg_type_zero_offset = visit_pyarrow(pyarrow_type_zero_offset, _ConvertToIceberg())
+    pyarrow_type: pa.DataType = pa.timestamp(unit="us", tz="UTC")
+    pyarrow_type_zero_offset: pa.DataType = pa.timestamp(unit="us", tz="+00:00")
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    converted_iceberg_type_zero_offset: IcebergType = visit_pyarrow(pyarrow_type_zero_offset, _ConvertToIceberg())
     assert converted_iceberg_type == TimestamptzType()
     assert converted_iceberg_type_zero_offset == TimestamptzType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pyarrow_type
@@ -234,21 +234,21 @@ def test_pyarrow_timestamp_ns_tz_invalid_tz() -> None:
 
 
 def test_pyarrow_timestamp_ns_no_tz_accepted() -> None:
-    pyarrow_type = pa.timestamp(unit="ns")
-    converted = visit_pyarrow(pyarrow_type, _ConvertToIceberg(format_version=3))
+    pyarrow_type: pa.DataType = pa.timestamp(unit="ns")
+    converted: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg(format_version=3))
     assert converted == TimestampNanoType()
 
 
 @pytest.mark.parametrize("pyarrow_type", [pa.string(), pa.large_string(), pa.string_view()])
 def test_pyarrow_string_to_iceberg(pyarrow_type: pa.DataType) -> None:
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == StringType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pa.large_string()
 
 
 @pytest.mark.parametrize("pyarrow_type", [pa.binary(), pa.large_binary(), pa.binary_view()])
 def test_pyarrow_variable_binary_to_iceberg(pyarrow_type: pa.DataType) -> None:
-    converted_iceberg_type = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
+    converted_iceberg_type: IcebergType = visit_pyarrow(pyarrow_type, _ConvertToIceberg())
     assert converted_iceberg_type == BinaryType()
     assert visit(converted_iceberg_type, _ConvertToArrowSchema()) == pa.large_binary()
 

tests/table/test_delete_file_index.py

@@ -14,6 +14,8 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+
+
 import pytest
 
 from pyiceberg.manifest import DataFile, DataFileContent, FileFormat, ManifestEntry, ManifestEntryStatus

tests/table/test_init.py

@@ -341,12 +341,16 @@ def test_table_scan_projection_unknown_column(table_v2: Table) -> None:
 def test_static_table_same_as_table(table_v2: Table, metadata_location: str) -> None:
     static_table = StaticTable.from_metadata(metadata_location)
     assert isinstance(static_table, Table)
+    assert static_table.metadata is not None
+    assert table_v2.metadata is not None
     assert static_table.metadata == table_v2.metadata
 
 
 def test_static_table_gz_same_as_table(table_v2: Table, metadata_location_gz: str) -> None:
     static_table = StaticTable.from_metadata(metadata_location_gz)
     assert isinstance(static_table, Table)
+    assert static_table.metadata is not None
+    assert table_v2.metadata is not None
     assert static_table.metadata == table_v2.metadata
 
 
@@ -363,6 +367,8 @@ def test_static_table_version_hint_same_as_table(
     ]:
         static_table = StaticTable.from_metadata(table_location)
         assert isinstance(static_table, Table)
+        assert static_table.metadata is not None
+        assert table_v2.metadata is not None
         assert static_table.metadata == table_v2.metadata
 
 
@@ -723,18 +729,22 @@ def test_update_nested_list_in_struct_required(table_v2: Table) -> None:
 
 def test_apply_set_properties_update(table_v2: Table) -> None:
     base_metadata = table_v2.metadata
+    assert base_metadata is not None
 
     new_metadata_no_update = update_table_metadata(base_metadata, (SetPropertiesUpdate(updates={}),))
+    assert new_metadata_no_update is not None
     assert new_metadata_no_update == base_metadata
 
     new_metadata = update_table_metadata(
         base_metadata, (SetPropertiesUpdate(updates={"read.split.target.size": "123", "test_a": "test_a", "test_b": "test_b"}),)
     )
+    assert new_metadata is not None
 
     assert base_metadata.properties == {"read.split.target.size": "134217728"}
     assert new_metadata.properties == {"read.split.target.size": "123", "test_a": "test_a", "test_b": "test_b"}
 
     new_metadata_add_only = update_table_metadata(new_metadata, (SetPropertiesUpdate(updates={"test_c": "test_c"}),))
+    assert new_metadata_add_only is not None
 
     assert new_metadata_add_only.properties == {
         "read.split.target.size": "123",

tests/table/test_metadata.py

@@ -256,6 +256,7 @@ def test_new_table_metadata_with_explicit_v1_format() -> None:
         order_id=1,
     )
 
+    assert actual is not None
     expected = TableMetadataV1(
         location="s3://some_v1_location/",
         table_uuid=actual.table_uuid,
@@ -686,6 +687,7 @@ def test_make_metadata_fresh() -> None:
         schema=schema, partition_spec=partition_spec, sort_order=sort_order, location="s3://", properties={}
     )
 
+    assert actual is not None
     expected = TableMetadataV2(
         location="s3://",
         table_uuid=actual.table_uuid,
@@ -843,6 +845,7 @@ def test_new_table_metadata_with_v3_schema() -> None:
         format_version=3,
     )
 
+    assert actual is not None
     assert actual.model_dump() == expected.model_dump()
     assert actual.schemas == [expected_schema]
     assert actual.partition_specs == [expected_spec]

tests/test_serializers.py

@@ -39,6 +39,7 @@ def test_legacy_current_snapshot_id(
     metadata = TableMetadataV1(**example_table_metadata_no_snapshot_v1)
     ToOutputFile.table_metadata(metadata, PyArrowFileIO().new_output(location=metadata_location), overwrite=True)
     static_table = StaticTable.from_metadata(metadata_location)
+    assert static_table.metadata is not None
     assert static_table.metadata.current_snapshot_id is None
 
     mocker.patch.dict(os.environ, values={"PYICEBERG_LEGACY_CURRENT_SNAPSHOT_ID": "True"})
@@ -48,6 +49,7 @@ def test_legacy_current_snapshot_id(
         metadata_json_bytes = input_stream.read()
     assert json.loads(metadata_json_bytes)["current-snapshot-id"] == -1
     backwards_compatible_static_table = StaticTable.from_metadata(metadata_location)
+    assert backwards_compatible_static_table.metadata is not None
     assert backwards_compatible_static_table.metadata.current_snapshot_id is None
     assert backwards_compatible_static_table.metadata == static_table.metadata