test: count table_metadata reads, not recomputes, in the hoist guard

The guard asserted that _MergeAppendFiles.__init__ triggers exactly one more
update_table_metadata call than its superclass. Recompute count is a proxy for
read count that the cache breaks: repeated reads of an unchanged state collapse
to one recompute, so an un-hoisting became invisible and the assertion had to be
relaxed to an upper bound.

Counting property reads directly restores the original assertion and makes the
guard orthogonal to caching. Verified both ways: it passes with and without the
cache, and un-hoisting __init__ back to three separate reads fails it (8 - 5).

Confidence: high
Not-tested: only the _MergeAppendFiles path was mutation-probed; the _summary()
assertions were left as-is beyond the oracle swap.

Author: devseunggwan

tests/table/test_snapshots.py

@@ -616,37 +616,46 @@ def test_snapshot_producer_bounded_metadata_access(table_v2: Table) -> None:
     """
     from unittest import mock
 
-    from pyiceberg.table.update import update_table_metadata
+    from pyiceberg.table import Transaction
+    from pyiceberg.table.metadata import TableMetadata
     from pyiceberg.table.update.snapshot import _FastAppendFiles, _MergeAppendFiles
 
     def make_file() -> DataFile:
         return DataFile.from_args(content=DataFileContent.DATA, record_count=1, file_size_in_bytes=1, partition=Record())
 
     txn = table_v2.transaction()
 
-    with mock.patch("pyiceberg.table.update_table_metadata", wraps=update_table_metadata) as spy:
+    # Counts property reads rather than update_table_metadata calls: hoisting removes reads,
+    # and a read that the cache serves is still a read the hoisting was meant to remove.
+    reads = [0]
+    fget = Transaction.__dict__["table_metadata"].fget
+
+    def counting(self: Transaction) -> TableMetadata:
+        reads[0] += 1
+        return fget(self)
+
+    with mock.patch.object(Transaction, "table_metadata", property(counting)):
         # _summary() cost must not scale with the number of data files
-        def summary_calls(n_files: int) -> int:
+        def summary_reads(n_files: int) -> int:
             append = _FastAppendFiles(operation=Operation.APPEND, transaction=txn, io=table_v2.io)
             for _ in range(n_files):
                 append.append_data_file(make_file())
-            spy.reset_mock()
+            reads[0] = 0
             append._summary()
-            return spy.call_count
+            return reads[0]
 
-        few, many = summary_calls(10), summary_calls(100)
-        assert few == many, f"_summary() update_table_metadata calls scale with file count ({few} vs {many})"
-        assert many <= 2, f"_summary() triggered {many} update_table_metadata calls; expected O(1)"
+        few, many = summary_reads(10), summary_reads(100)
+        assert few == many, f"_summary() table_metadata reads scale with file count ({few} vs {many})"
+        assert many <= 2, f"_summary() made {many} table_metadata reads; expected O(1)"
 
-        # _MergeAppendFiles.__init__ should add exactly one call over _FastAppendFiles.__init__
-        spy.reset_mock()
+        # _MergeAppendFiles.__init__ should add exactly one read over _FastAppendFiles.__init__
+        reads[0] = 0
         _FastAppendFiles(operation=Operation.APPEND, transaction=txn, io=table_v2.io)
-        fast_init = spy.call_count
-        spy.reset_mock()
+        fast_init = reads[0]
+        reads[0] = 0
         _MergeAppendFiles(operation=Operation.APPEND, transaction=txn, io=table_v2.io)
-        merge_init = spy.call_count
-        # Upper bound, not equality: the cache absorbs this access when the staged state is unchanged.
-        assert merge_init - fast_init <= 1, (
-            f"_MergeAppendFiles.__init__ made {merge_init - fast_init} extra update_table_metadata "
-            "calls over its superclass; expected at most 1"
+        merge_init = reads[0]
+        assert merge_init - fast_init == 1, (
+            f"_MergeAppendFiles.__init__ made {merge_init - fast_init} extra table_metadata "
+            "reads over its superclass; expected 1 (hoisted)"
         )