deltacat 1.1.38__py3-none-any.whl → 2.0.0__py3-none-any.whl

deltacat/tests/compute/compact_partition_test_cases.py

@@ -20,11 +20,11 @@ from deltacat.utils.common import ReadKwargsProvider
 
 from deltacat.storage import (
     DeltaType,
+    EntryParams,
 )
 from deltacat.compute.compactor_v2.compaction_session import (
     compact_partition as compact_partition_v2,
 )
-from deltacat.storage import DeleteParameters
 
 from deltacat.compute.compactor.model.compactor_version import CompactorVersion
 
@@ -53,8 +53,8 @@ class BaseCompactorTestCase:
     Args:
         primary_keys: Set[str] - argument for the primary_keys parameter in compact_partition. Also needed for table/delta creation
         sort_keys: List[SortKey] - argument for the sort_keys parameter in compact_partition. Also needed for table/delta creation
-        partition_keys_param: List[PartitionKey] - argument for the partition_keys parameter. Needed for table/delta creation
-        partition_values_param: List[Optional[str]] - argument for the partition_valued parameter. Needed for table/delta creation
+        partition_keys: List[PartitionKey] - argument for the partition_keys parameter. Needed for table/delta creation
+        partition_values: List[Optional[str]] - argument for the partition_valued parameter. Needed for table/delta creation
         input_deltas: List[pa.Array] - argument required for delta creation during compact_partition test setup. Actual incoming deltas expressed as a PyArrow array (https://arrow.apache.org/docs/python/generated/pyarrow.array.html)
         input_deltas_delta_type: DeltaType - enumerated argument required for delta creation during compact_partition test setup. Available values are (DeltaType.APPEND, DeltaType.UPSERT, DeltaType.DELETE). DeltaType.APPEND is not supported by compactor v1 or v2
         expected_terminal_compact_partition_result: pa.Table - expected PyArrow table after compaction (i.e,. the state of the table after applying all row UPDATES/DELETES/INSERTS)
@@ -62,7 +62,7 @@ class BaseCompactorTestCase:
         expected_terminal_exception_message: Optional[str] - expected exception message if present.
         do_create_placement_group: bool - toggles whether to create a placement group (https://docs.ray.io/en/latest/ray-core/scheduling/placement-group.html) or not
         records_per_compacted_file: int - argument for the records_per_compacted_file parameter in compact_partition
-        hash_bucket_count_param: int - argument for the hash_bucket_count parameter in compact_partition
+        hash_bucket_count: int - argument for the hash_bucket_count parameter in compact_partition
         read_kwargs_provider: Optional[ReadKwargsProvider] - argument for read_kwargs_provider parameter in compact_partition. If None then no ReadKwargsProvider is provided to compact_partition_params
         drop_duplicates: bool - argument for drop_duplicates parameter in compact_partition. Only recognized by compactor v2.
         skip_enabled_compact_partition_drivers: List[CompactorVersion] - skip whatever enabled_compact_partition_drivers are included in this list
@@ -100,14 +100,7 @@ class IncrementalCompactionTestCaseParams(BaseCompactorTestCase):
     """
 
     is_inplace: bool
-    add_late_deltas: Optional[
-        List[Tuple[pa.Table, DeltaType, Optional[DeleteParameters]]]
-    ]
-
-
-@dataclass(frozen=True)
-class NoRCFOutputCompactionTestCaseParams(BaseCompactorTestCase):
-    pass
+    add_late_deltas: Optional[List[Tuple[pa.Table, DeltaType, Optional[EntryParams]]]]
 
 
 def with_compactor_version_func_test_param(
@@ -137,7 +130,7 @@ def with_compactor_version_func_test_param(
 
 
 INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
-    "1-incremental-pkstr-sknone-norcf": IncrementalCompactionTestCaseParams(
+    "1-incremental-pkstr-sknone-norci": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
         sort_keys=ZERO_VALUED_SORT_KEY,
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
@@ -163,7 +156,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
         skip_enabled_compact_partition_drivers=None,
         assert_compaction_audit=assert_compaction_audit,
     ),
-    "2-incremental-pkstr-skstr-norcf": IncrementalCompactionTestCaseParams(
+    "2-incremental-pkstr-skstr-norci": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
         sort_keys=ZERO_VALUED_SORT_KEY,
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
@@ -192,11 +185,11 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
         skip_enabled_compact_partition_drivers=None,
         assert_compaction_audit=assert_compaction_audit,
     ),
-    "3-incremental-pkstr-multiskstr-norcf": IncrementalCompactionTestCaseParams(
+    "3-incremental-pkstr-multiskstr-norci": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
         sort_keys=[
-            SortKey.of(key_name="sk_col_1"),
-            SortKey.of(key_name="sk_col_2"),
+            SortKey.of(key=["sk_col_1"]),
+            SortKey.of(key=["sk_col_2"]),
         ],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
@@ -233,8 +226,8 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     "4-incremental-duplicate-pk": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
         sort_keys=[
-            SortKey.of(key_name="sk_col_1"),
-            SortKey.of(key_name="sk_col_2"),
+            SortKey.of(key=["sk_col_1"]),
+            SortKey.of(key=["sk_col_2"]),
         ],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
@@ -269,7 +262,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "5-incremental-decimal-pk-simple": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -301,7 +294,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "6-incremental-integer-pk-simple": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -333,7 +326,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "7-incremental-timestamp-pk-simple": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -365,7 +358,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "8-incremental-decimal-timestamp-pk-multi": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1", "pk_col_2"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -399,7 +392,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "9-incremental-decimal-pk-multi-dup": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -431,7 +424,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "10-incremental-decimal-pk-partitionless": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=ZERO_VALUED_PARTITION_KEYS_PARAM,
         partition_values=ZERO_VALUED_PARTITION_VALUES_PARAM,
         input_deltas=pa.Table.from_arrays(
@@ -463,7 +456,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "11-incremental-decimal-hash-bucket-single": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=ZERO_VALUED_PARTITION_KEYS_PARAM,
         partition_values=ZERO_VALUED_PARTITION_VALUES_PARAM,
         input_deltas=pa.Table.from_arrays(
@@ -495,7 +488,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "12-incremental-decimal-single-hash-bucket": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=ZERO_VALUED_PARTITION_KEYS_PARAM,
         partition_values=ZERO_VALUED_PARTITION_VALUES_PARAM,
         input_deltas=pa.Table.from_arrays(
@@ -527,7 +520,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "13-incremental-pkstr-skexists-isinplacecompacted": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -571,7 +564,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "14-incremental-pkstr-skexists-unhappy-hash-bucket-count-not-present": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
         partition_values=["1"],
         input_deltas=pa.Table.from_arrays(
@@ -603,7 +596,7 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
     ),
     "15-incremental-empty-input-with-single-hash-bucket": IncrementalCompactionTestCaseParams(
         primary_keys={"pk_col_1"},
-        sort_keys=[SortKey.of(key_name="sk_col_1")],
+        sort_keys=[SortKey.of(key=["sk_col_1"])],
         partition_keys=ZERO_VALUED_PARTITION_KEYS_PARAM,
         partition_values=ZERO_VALUED_PARTITION_VALUES_PARAM,
         input_deltas=pa.Table.from_arrays(

deltacat/tests/compute/compactor/steps/test_repartition.py

@@ -5,7 +5,7 @@ from deltacat.compute.compactor.steps.repartition import repartition_range
 from deltacat.types.media import ContentType
 from deltacat.compute.compactor.model.repartition_result import RepartitionResult
 from deltacat.storage import (
-    PartitionLocator,
+    Partition,
 )
 
 """
@@ -46,10 +46,10 @@ class TestRepartitionRange(unittest.TestCase):
                 }
             ),
         ]
-        self.destination_partition: PartitionLocator = MagicMock()
+        self.destination_partition: Partition = MagicMock()
         self.repartition_args = {"column": "last_updated", "ranges": [1678665487112747]}
         self.max_records_per_output_file = 2
-        self.s3_table_writer_kwargs = {}
+        self.table_writer_kwargs = {}
         self.repartitioned_file_content_type = ContentType.PARQUET
         self.deltacat_storage = MagicMock()
         self.deltacat_storage_kwargs = MagicMock()
@@ -60,7 +60,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,
@@ -87,7 +87,7 @@ class TestRepartitionRange(unittest.TestCase):
                 self.destination_partition,
                 self.repartition_args,
                 self.max_records_per_output_file,
-                self.s3_table_writer_kwargs,
+                self.table_writer_kwargs,
                 self.repartitioned_file_content_type,
                 self.deltacat_storage,
                 self.deltacat_storage_kwargs,
@@ -101,7 +101,7 @@ class TestRepartitionRange(unittest.TestCase):
                 self.destination_partition,
                 self.repartition_args,
                 self.max_records_per_output_file,
-                self.s3_table_writer_kwargs,
+                self.table_writer_kwargs,
                 self.repartitioned_file_content_type,
                 self.deltacat_storage,
                 self.deltacat_storage_kwargs,
@@ -114,7 +114,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,
@@ -128,7 +128,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,
@@ -143,7 +143,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,
@@ -158,7 +158,7 @@ class TestRepartitionRange(unittest.TestCase):
                 self.destination_partition,
                 self.repartition_args,
                 self.max_records_per_output_file,
-                self.s3_table_writer_kwargs,
+                self.table_writer_kwargs,
                 self.repartitioned_file_content_type,
                 self.deltacat_storage,
                 self.deltacat_storage_kwargs,
@@ -175,7 +175,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,
@@ -189,7 +189,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,
@@ -206,7 +206,7 @@ class TestRepartitionRange(unittest.TestCase):
                 self.destination_partition,
                 self.repartition_args,
                 self.max_records_per_output_file,
-                self.s3_table_writer_kwargs,
+                self.table_writer_kwargs,
                 self.repartitioned_file_content_type,
                 self.deltacat_storage,
             ),
@@ -233,7 +233,7 @@ class TestRepartitionRange(unittest.TestCase):
             self.destination_partition,
             self.repartition_args,
             self.max_records_per_output_file,
-            self.s3_table_writer_kwargs,
+            self.table_writer_kwargs,
             self.repartitioned_file_content_type,
             self.deltacat_storage,
             self.deltacat_storage_kwargs,

deltacat/tests/compute/compactor/utils/test_io.py

@@ -1,133 +1,135 @@
-import unittest
+import pytest
 from unittest import mock
-from deltacat.tests.test_utils.constants import TEST_UPSERT_DELTA
-from typing import Any, Dict
-
-DATABASE_FILE_PATH_KEY, DATABASE_FILE_PATH_VALUE = (
-    "db_file_path",
-    "deltacat/tests/local_deltacat_storage/db_test.sqlite",
-)
 
+from deltacat.tests.test_utils.constants import TEST_UPSERT_DELTA
 
-class TestFitInputDeltas(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.module_patcher = mock.patch.dict("sys.modules", {"ray": mock.MagicMock()})
-        cls.module_patcher.start()
 
-        from deltacat.compute.compactor.model.compaction_session_audit_info import (
-            CompactionSessionAuditInfo,
+@pytest.fixture(scope="module", autouse=True)
+def mock_ray():
+    """Mock ray module for all tests in this module"""
+    module_patcher = mock.patch.dict("sys.modules", {"ray": mock.MagicMock()})
+    module_patcher.start()
+    yield
+    module_patcher.stop()
+
+
+@pytest.fixture
+def compaction_audit():
+    """Fixture for CompactionSessionAuditInfo"""
+    from deltacat.compute.compactor.model.compaction_session_audit_info import (
+        CompactionSessionAuditInfo,
+    )
+
+    return CompactionSessionAuditInfo("1.0", "2.3", "test")
+
+
+def test_sanity(main_deltacat_storage_kwargs, compaction_audit):
+    from deltacat.compute.compactor.utils import io
+    from deltacat.storage import metastore
+
+    (
+        delta_list,
+        hash_bucket_count,
+        high_watermark,
+        require_multiple_rounds,
+    ) = io.fit_input_deltas(
+        [TEST_UPSERT_DELTA],
+        {"CPU": 1, "memory": 20000000},
+        compaction_audit,
+        None,
+        metastore,
+        main_deltacat_storage_kwargs,
+    )
+
+    assert hash_bucket_count is not None
+    assert len(delta_list) == 1
+    assert high_watermark is not None
+    assert require_multiple_rounds is False
+    assert compaction_audit.hash_bucket_count is not None
+    assert compaction_audit.input_file_count is not None
+    assert compaction_audit.input_size_bytes is not None
+    assert compaction_audit.total_cluster_memory_bytes is not None
+
+
+def test_when_hash_bucket_count_overridden(
+    main_deltacat_storage_kwargs, compaction_audit
+):
+    from deltacat.compute.compactor.utils import io
+    from deltacat.storage import metastore
+
+    (
+        delta_list,
+        hash_bucket_count,
+        high_watermark,
+        require_multiple_rounds,
+    ) = io.fit_input_deltas(
+        [TEST_UPSERT_DELTA],
+        {"CPU": 1, "memory": 20000000},
+        compaction_audit,
+        20,
+        metastore,
+        main_deltacat_storage_kwargs,
+    )
+
+    assert hash_bucket_count == 20
+    assert len(delta_list) == 1
+    assert high_watermark is not None
+    assert require_multiple_rounds is False
+
+
+def test_when_not_enough_memory_splits_manifest_entries(
+    main_deltacat_storage_kwargs, compaction_audit
+):
+    from deltacat.compute.compactor.utils import io
+    from deltacat.storage import metastore
+
+    (
+        delta_list,
+        hash_bucket_count,
+        high_watermark,
+        require_multiple_rounds,
+    ) = io.fit_input_deltas(
+        [TEST_UPSERT_DELTA],
+        {"CPU": 2, "memory": 10},
+        compaction_audit,
+        20,
+        metastore,
+        main_deltacat_storage_kwargs,
+    )
+
+    assert hash_bucket_count is not None
+    assert len(delta_list) == 2
+    assert high_watermark is not None
+    assert require_multiple_rounds is False
+
+
+def test_when_no_input_deltas(main_deltacat_storage_kwargs, compaction_audit):
+    from deltacat.compute.compactor.utils import io
+    from deltacat.storage import metastore
+
+    with pytest.raises(AssertionError):
+        io.fit_input_deltas(
+            [],
+            {"CPU": 100, "memory": 20000.0},
+            compaction_audit,
+            None,
+            metastore,
+            main_deltacat_storage_kwargs,
         )
 
-        cls.kwargs_for_local_deltacat_storage: Dict[str, Any] = {
-            DATABASE_FILE_PATH_KEY: DATABASE_FILE_PATH_VALUE,
-        }
-
-        cls.COMPACTION_AUDIT = CompactionSessionAuditInfo("1.0", "2.3", "test")
-
-        super().setUpClass()
 
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.module_patcher.stop()
+def test_when_cpu_resources_is_not_passed(
+    main_deltacat_storage_kwargs, compaction_audit
+):
+    from deltacat.compute.compactor.utils import io
+    from deltacat.storage import metastore
 
-    def test_sanity(self):
-        from deltacat.compute.compactor.utils import io
-        import deltacat.tests.local_deltacat_storage as ds
-
-        (
-            delta_list,
-            hash_bucket_count,
-            high_watermark,
-            require_multiple_rounds,
-        ) = io.fit_input_deltas(
-            [TEST_UPSERT_DELTA],
-            {"CPU": 1, "memory": 20000000},
-            self.COMPACTION_AUDIT,
+    with pytest.raises(KeyError):
+        io.fit_input_deltas(
+            [],
+            {},
+            compaction_audit,
             None,
-            ds,
-            self.kwargs_for_local_deltacat_storage,
-        )
-
-        self.assertIsNotNone(hash_bucket_count)
-        self.assertTrue(1, len(delta_list))
-        self.assertIsNotNone(high_watermark)
-        self.assertFalse(require_multiple_rounds)
-        self.assertIsNotNone(hash_bucket_count, self.COMPACTION_AUDIT.hash_bucket_count)
-        self.assertIsNotNone(self.COMPACTION_AUDIT.input_file_count)
-        self.assertIsNotNone(self.COMPACTION_AUDIT.input_size_bytes)
-        self.assertIsNotNone(self.COMPACTION_AUDIT.total_cluster_memory_bytes)
-
-    def test_when_hash_bucket_count_overridden(self):
-        from deltacat.compute.compactor.utils import io
-        import deltacat.tests.local_deltacat_storage as ds
-
-        (
-            delta_list,
-            hash_bucket_count,
-            high_watermark,
-            require_multiple_rounds,
-        ) = io.fit_input_deltas(
-            [TEST_UPSERT_DELTA],
-            {"CPU": 1, "memory": 20000000},
-            self.COMPACTION_AUDIT,
-            20,
-            ds,
-            self.kwargs_for_local_deltacat_storage,
+            metastore,
+            main_deltacat_storage_kwargs,
         )
-
-        self.assertEqual(20, hash_bucket_count)
-        self.assertEqual(1, len(delta_list))
-        self.assertIsNotNone(high_watermark)
-        self.assertFalse(require_multiple_rounds)
-
-    def test_when_not_enough_memory_splits_manifest_entries(self):
-        from deltacat.compute.compactor.utils import io
-        import deltacat.tests.local_deltacat_storage as ds
-
-        (
-            delta_list,
-            hash_bucket_count,
-            high_watermark,
-            require_multiple_rounds,
-        ) = io.fit_input_deltas(
-            [TEST_UPSERT_DELTA],
-            {"CPU": 2, "memory": 10},
-            self.COMPACTION_AUDIT,
-            20,
-            ds,
-            self.kwargs_for_local_deltacat_storage,
-        )
-
-        self.assertIsNotNone(hash_bucket_count)
-        self.assertTrue(2, len(delta_list))
-        self.assertIsNotNone(high_watermark)
-        self.assertFalse(require_multiple_rounds)
-
-    def test_when_no_input_deltas(self):
-        from deltacat.compute.compactor.utils import io
-        import deltacat.tests.local_deltacat_storage as ds
-
-        with self.assertRaises(AssertionError):
-            io.fit_input_deltas(
-                [],
-                {"CPU": 100, "memory": 20000.0},
-                self.COMPACTION_AUDIT,
-                None,
-                ds,
-                self.kwargs_for_local_deltacat_storage,
-            )
-
-    def test_when_cpu_resources_is_not_passed(self):
-        from deltacat.compute.compactor.utils import io
-        import deltacat.tests.local_deltacat_storage as ds
-
-        with self.assertRaises(KeyError):
-            io.fit_input_deltas(
-                [],
-                {},
-                self.COMPACTION_AUDIT,
-                None,
-                ds,
-                self.kwargs_for_local_deltacat_storage,
-            )