deltacat 2.0.0b10__py3-none-any.whl → 2.0.0b12__py3-none-any.whl

deltacat/tests/storage/model/test_metafile_io.py

@@ -20,6 +20,12 @@ from deltacat import (
     NullOrder,
     LifecycleState,
 )
+from deltacat.exceptions import (
+    ObjectAlreadyExistsError,
+    ConcurrentModificationError,
+    ObjectDeletedError,
+    ObjectNotFoundError,
+)
 from deltacat.storage import (
     BucketTransform,
     BucketTransformParameters,
@@ -47,7 +53,6 @@ from deltacat.storage import (
     TableVersion,
     Transaction,
     TransactionOperation,
-    TransactionType,
     TransactionOperationType,
     TruncateTransform,
     TruncateTransformParameters,
@@ -92,7 +97,6 @@ def _commit_single_delta_table(temp_dir: str) -> List[Tuple[Metafile, Metafile,
         for meta in meta_to_create
     ]
     transaction = Transaction.of(
-        txn_type=TransactionType.APPEND,
         txn_operations=txn_operations,
     )
     write_paths, txn_log_path = transaction.commit(temp_dir)
@@ -116,7 +120,7 @@ def _commit_concurrent_transaction(
 ) -> None:
     try:
         return transaction.commit(catalog_root)
-    except (RuntimeError, ValueError) as e:
+    except (ObjectAlreadyExistsError, ConcurrentModificationError) as e:
         return e
 
 
@@ -133,7 +137,6 @@ class TestMetafileIO:
             description="test table description",
         )
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -158,9 +161,8 @@ class TestMetafileIO:
                 results = [future.get() for future in futures]
                 conflict_exception_count = 0
                 for result in results:
-                    # TODO(pdames): Add new concurrent conflict exception types.
-                    if isinstance(result, RuntimeError) or isinstance(
-                        result, ValueError
+                    if isinstance(result, ConcurrentModificationError) or isinstance(
+                        result, ObjectAlreadyExistsError
                     ):
                         conflict_exception_count += 1
                     else:
@@ -174,7 +176,6 @@ class TestMetafileIO:
         namespace = Namespace.of(locator=namespace_locator)
         # given a transaction that creates a single namespace
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -213,7 +214,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=txn_operations,
         )
         # expect the bad timestamp to be detected and its commit to fail
@@ -274,7 +274,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=txn_operations,
         )
         # expect the commit to fail due to a concurrent modification error
@@ -304,7 +303,6 @@ class TestMetafileIO:
         original_delta = Delta.read(orig_delta_write_path)
         new_delta = Delta.update_for(original_delta)
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.UPDATE,
@@ -314,10 +312,10 @@ class TestMetafileIO:
             ],
         )
         # expect the commit to fail due to a concurrent modification error
-        with pytest.raises(RuntimeError):
+        with pytest.raises(ConcurrentModificationError):
             transaction.commit(temp_dir)
         # expect a commit retry to also fail
-        with pytest.raises(RuntimeError):
+        with pytest.raises(ConcurrentModificationError):
             transaction.commit(temp_dir)
 
     def test_append_multiple_deltas(self, temp_dir):
@@ -342,7 +340,6 @@ class TestMetafileIO:
                 )
             )
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -387,7 +384,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -415,10 +411,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect subsequent deletes of the deleted delta to fail
@@ -429,10 +424,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
     def test_replace_delta(self, temp_dir):
@@ -452,13 +446,12 @@ class TestMetafileIO:
 
         txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_delta,
                 src_metafile=original_delta,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -483,16 +476,15 @@ class TestMetafileIO:
         # expect a subsequent replace of the original delta to fail
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_delta,
                 src_metafile=original_delta,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect deletes of the original delta to fail
@@ -503,10 +495,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
     def test_delete_partition(self, temp_dir):
@@ -522,7 +513,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -562,16 +552,15 @@ class TestMetafileIO:
         )
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_partition,
                 src_metafile=original_partition,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect subsequent deletes of the deleted partition to fail
@@ -582,10 +571,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the deleted partition to fail
@@ -597,10 +585,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_replace_partition(self, temp_dir):
@@ -620,13 +607,12 @@ class TestMetafileIO:
 
         txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_partition,
                 src_metafile=original_partition,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -679,16 +665,15 @@ class TestMetafileIO:
         # expect a subsequent replace of the original partition to fail
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_partition,
                 src_metafile=original_partition,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect deletes of the original partition to fail
@@ -699,10 +684,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the old partition to fail
@@ -714,10 +698,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_delete_stream(self, temp_dir):
@@ -733,7 +716,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -776,16 +758,15 @@ class TestMetafileIO:
         )
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_stream,
                 src_metafile=original_stream,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect subsequent deletes of the deleted stream to fail
@@ -796,10 +777,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the deleted stream to fail
@@ -811,10 +791,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_replace_stream(self, temp_dir):
@@ -834,13 +813,12 @@ class TestMetafileIO:
 
         txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_stream,
                 src_metafile=original_stream,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -896,16 +874,15 @@ class TestMetafileIO:
         # expect a subsequent replace of the original stream to fail
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_stream,
                 src_metafile=original_stream,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect deletes of the original stream to fail
@@ -916,10 +893,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the old stream to fail
@@ -931,10 +907,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_delete_table_version(self, temp_dir):
@@ -950,7 +925,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -996,16 +970,15 @@ class TestMetafileIO:
         )
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_table_version,
                 src_metafile=original_table_version,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect subsequent deletes of the deleted table version to fail
@@ -1016,10 +989,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the deleted table version to fail
@@ -1031,10 +1003,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_replace_table_version(self, temp_dir):
@@ -1054,13 +1025,12 @@ class TestMetafileIO:
 
         txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_table_version,
                 src_metafile=original_table_version,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -1120,16 +1090,15 @@ class TestMetafileIO:
         # expect a subsequent replace of the original table version to fail
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_table_version,
                 src_metafile=original_table_version,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect deletes of the original table version to fail
@@ -1140,10 +1109,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the old table version to fail
@@ -1155,10 +1123,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_delete_table(self, temp_dir):
@@ -1174,7 +1141,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -1220,16 +1186,15 @@ class TestMetafileIO:
         replacement_table: Table = Table.based_on(original_table)
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_table,
                 src_metafile=original_table,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect subsequent deletes of the deleted table to fail
@@ -1240,10 +1205,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the deleted table to fail
@@ -1255,10 +1219,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_replace_table(self, temp_dir):
@@ -1277,13 +1240,12 @@ class TestMetafileIO:
 
         txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_table,
                 src_metafile=original_table,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -1345,16 +1307,15 @@ class TestMetafileIO:
         # expect a subsequent table replace of the original table to fail
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_table,
                 src_metafile=original_table,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect table deletes of the original table to fail
@@ -1365,10 +1326,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the old table to fail
@@ -1380,10 +1340,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_delete_namespace(self, temp_dir):
@@ -1399,7 +1358,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -1448,16 +1406,15 @@ class TestMetafileIO:
         replacement_namespace: Namespace = Namespace.based_on(original_namespace)
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_namespace,
                 src_metafile=original_namespace,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect subsequent deletes of the deleted namespace to fail
@@ -1468,10 +1425,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the deleted namespace to fail
@@ -1483,10 +1439,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_replace_namespace(self, temp_dir):
@@ -1505,13 +1460,12 @@ class TestMetafileIO:
 
         txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_namespace,
                 src_metafile=original_namespace,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -1576,16 +1530,15 @@ class TestMetafileIO:
         # expect a subsequent namespace replace of the original namespace to fail
         bad_txn_operations = [
             TransactionOperation.of(
-                operation_type=TransactionOperationType.UPDATE,
+                operation_type=TransactionOperationType.REPLACE,
                 dest_metafile=replacement_namespace,
                 src_metafile=original_namespace,
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.OVERWRITE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect namespace deletes of the original namespace to fail
@@ -1596,10 +1549,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect new child metafile creation under the old namespace to fail
@@ -1611,10 +1563,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_create_stream_bad_order_txn_op_chaining(self, temp_dir):
@@ -1650,16 +1601,14 @@ class TestMetafileIO:
             ),
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=txn_operations,
         )
         # when the transaction is committed,
         # expect stream creation to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectNotFoundError):
             transaction.commit(temp_dir)
         # when a transaction with the operations reversed is committed,
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=list(reversed(txn_operations)),
         )
         # expect table version and stream creation to succeed
@@ -1699,16 +1648,14 @@ class TestMetafileIO:
             ),
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=txn_operations,
         )
         # when the transaction is committed,
         # expect the transaction to fail due to incorrect operation order
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectNotFoundError):
             transaction.commit(temp_dir)
         # when a transaction with the operations reversed is committed,
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=list(reversed(txn_operations)),
         )
         # expect table and table version creation to succeed
@@ -1721,7 +1668,6 @@ class TestMetafileIO:
         # given serial transaction that try to create two namespaces with
         # the same name
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     TransactionOperationType.CREATE,
@@ -1734,7 +1680,7 @@ class TestMetafileIO:
         deserialized_namespace = Namespace.read(write_paths.pop())
         assert namespace.equivalent_to(deserialized_namespace)
         # but expect the second transaction to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectAlreadyExistsError):
             transaction.commit(temp_dir)
 
     def test_create_duplicate_namespace_txn_op_chaining(self, temp_dir):
@@ -1742,7 +1688,6 @@ class TestMetafileIO:
         namespace = Namespace.of(locator=namespace_locator)
         # given a transaction that tries to create the same namespace twice
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     TransactionOperationType.CREATE,
@@ -1756,7 +1701,7 @@ class TestMetafileIO:
         )
         # when the transaction is committed,
         # expect duplicate namespace creation to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectAlreadyExistsError):
             transaction.commit(temp_dir)
 
     def test_create_stream_in_missing_table_version(self, temp_dir):
@@ -1772,7 +1717,6 @@ class TestMetafileIO:
         )
         new_stream.table_version_locator.table_version = "missing_table_version.0"
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     TransactionOperationType.CREATE,
@@ -1782,7 +1726,7 @@ class TestMetafileIO:
         )
         # when the transaction is committed,
         # expect stream creation to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectNotFoundError):
             transaction.commit(temp_dir)
 
     def test_create_table_version_in_missing_namespace(self, temp_dir):
@@ -1798,7 +1742,6 @@ class TestMetafileIO:
         )
         new_table_version.namespace_locator.namespace = "missing_namespace"
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     TransactionOperationType.CREATE,
@@ -1808,7 +1751,7 @@ class TestMetafileIO:
         )
         # when the transaction is committed,
         # expect table version creation to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectNotFoundError):
             transaction.commit(temp_dir)
 
     def test_create_table_version_in_missing_table(self, temp_dir):
@@ -1824,7 +1767,6 @@ class TestMetafileIO:
         )
         new_table_version.table_locator.table_name = "missing_table"
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     TransactionOperationType.CREATE,
@@ -1834,7 +1776,7 @@ class TestMetafileIO:
         )
         # when the transaction is committed,
         # expect table version creation to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectNotFoundError):
             transaction.commit(temp_dir)
 
     def test_create_table_in_missing_namespace(self, temp_dir):
@@ -1849,7 +1791,6 @@ class TestMetafileIO:
         # given a transaction that tries to create a single table in a
         # namespace that doesn't exist
         transaction = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     TransactionOperationType.CREATE,
@@ -1859,7 +1800,7 @@ class TestMetafileIO:
         )
         # when the transaction is committed,
         # expect table creation to fail
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectNotFoundError):
             transaction.commit(temp_dir)
 
     def test_rename_table_txn_op_chaining(self, temp_dir):
@@ -1932,7 +1873,6 @@ class TestMetafileIO:
             ),
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -1986,7 +1926,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -2038,10 +1977,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.RESTATE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect table deletes of the old table name fail
@@ -2052,10 +1990,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect child metafile creation under the old table name to fail
@@ -2067,10 +2004,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_rename_namespace(self, temp_dir):
@@ -2091,7 +2027,6 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=txn_operations,
         )
         # when the transaction is committed
@@ -2146,10 +2081,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.ALTER,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect namespace deletes of the old namespace name fail
@@ -2160,10 +2094,9 @@ class TestMetafileIO:
             )
         ]
         transaction = Transaction.of(
-            txn_type=TransactionType.DELETE,
             txn_operations=bad_txn_operations,
         )
-        with pytest.raises(ValueError):
+        with pytest.raises(ObjectDeletedError):
             transaction.commit(temp_dir)
 
         # expect child metafile creation under the old namespace to fail
@@ -2175,10 +2108,9 @@ class TestMetafileIO:
                 )
             ]
             transaction = Transaction.of(
-                txn_type=TransactionType.APPEND,
                 txn_operations=bad_txn_operations,
             )
-            with pytest.raises(ValueError):
+            with pytest.raises(ObjectAlreadyExistsError):
                 transaction.commit(temp_dir)
 
     def test_e2e_serde(self, temp_dir):
@@ -2195,7 +2127,6 @@ class TestMetafileIO:
         namespace = Namespace.of(locator=namespace_locator)
         # given a transaction that creates a single namespace
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -2219,7 +2150,6 @@ class TestMetafileIO:
         )
         # given a transaction that creates a single table
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -2267,7 +2197,7 @@ class TestMetafileIO:
             PartitionKey.of(
                 key=["some_string", "some_int32"],
                 name="test_partition_key",
-                field_id="test_field_id",
+                field_id=1,
                 transform=bucket_transform,
             )
         ]
@@ -2307,7 +2237,6 @@ class TestMetafileIO:
         )
         # given a transaction that creates a single table version
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -2338,7 +2267,7 @@ class TestMetafileIO:
             PartitionKey.of(
                 key=["some_string", "some_int32"],
                 name="test_partition_key",
-                field_id="test_field_id",
+                field_id=1,
                 transform=bucket_transform,
             )
         ]
@@ -2356,7 +2285,6 @@ class TestMetafileIO:
         )
         # given a transaction that creates a single stream
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -2379,28 +2307,8 @@ class TestMetafileIO:
             partition_values=["a", 1],
             partition_id="test_partition_id",
         )
-        schema = Schema.of(
-            [
-                Field.of(
-                    field=pa.field("some_string", pa.string(), nullable=False),
-                    field_id=1,
-                    is_merge_key=True,
-                ),
-                Field.of(
-                    field=pa.field("some_int32", pa.int32(), nullable=False),
-                    field_id=2,
-                    is_merge_key=True,
-                ),
-                Field.of(
-                    field=pa.field("some_float64", pa.float64()),
-                    field_id=3,
-                    is_merge_key=False,
-                ),
-            ]
-        )
         partition = Partition.of(
             locator=partition_locator,
-            schema=schema,
             content_types=[ContentType.PARQUET],
             state=CommitState.STAGED,
             previous_stream_position=0,
@@ -2410,7 +2318,6 @@ class TestMetafileIO:
         )
         # given a transaction that creates a single partition
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -2472,7 +2379,6 @@ class TestMetafileIO:
         )
         # given a transaction that creates a single delta
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,
@@ -2511,7 +2417,6 @@ class TestMetafileIO:
         )
         # when a transaction commits this table
         write_paths, txn_log_path = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=[
                 TransactionOperation.of(
                     operation_type=TransactionOperationType.CREATE,