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

deltacat/tests/compute/compact_partition_test_cases.py

@@ -103,11 +103,6 @@ class IncrementalCompactionTestCaseParams(BaseCompactorTestCase):
     add_late_deltas: Optional[List[Tuple[pa.Table, DeltaType, Optional[EntryParams]]]]
 
 
-@dataclass(frozen=True)
-class NoRCFOutputCompactionTestCaseParams(BaseCompactorTestCase):
-    pass
-
-
 def with_compactor_version_func_test_param(
     test_cases: Dict[str, BaseCompactorTestCase] = None
 ):
@@ -135,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)],
@@ -161,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)],
@@ -190,7 +185,7 @@ 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=["sk_col_1"]),
@@ -599,6 +594,38 @@ INCREMENTAL_TEST_CASES: Dict[str, IncrementalCompactionTestCaseParams] = {
         skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
         assert_compaction_audit=None,
     ),
+    "15-incremental-empty-input-with-single-hash-bucket": IncrementalCompactionTestCaseParams(
+        primary_keys={"pk_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(
+            [
+                pa.array([]),
+                pa.array([]),
+            ],
+            names=["pk_col_1", "sk_col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([]),
+                pa.array([]),
+            ],
+            names=["pk_col_1", "sk_col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=1,
+        read_kwargs_provider=None,
+        drop_duplicates=True,
+        is_inplace=False,
+        add_late_deltas=None,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=assert_compaction_audit_no_hash_bucket,
+    ),
 }
 
 INCREMENTAL_TEST_CASES = with_compactor_version_func_test_param(INCREMENTAL_TEST_CASES)

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

@@ -49,7 +49,7 @@ class TestRepartitionRange(unittest.TestCase):
         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,131 +1,135 @@
-import unittest
+import pytest
 from unittest import mock
 
-from deltacat.tests.compute.conftest import (
-    create_local_deltacat_storage_file,
-    clean_up_local_deltacat_storage_file,
-)
 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 = create_local_deltacat_storage_file()
-
-        cls.COMPACTION_AUDIT = CompactionSessionAuditInfo("1.0", "2.3", "test")
-
-        super().setUpClass()
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.module_patcher.stop()
-        clean_up_local_deltacat_storage_file(cls.kwargs_for_local_deltacat_storage)
 
-    def test_sanity(self):
-        from deltacat.compute.compactor.utils import io
-        import deltacat.tests.local_deltacat_storage as ds
+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
 
-        (
-            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,
+            metastore,
+            main_deltacat_storage_kwargs,
         )
-
-        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,
-        )
-
-        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,
-            )

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

@@ -0,0 +1,254 @@
+from unittest.mock import Mock
+from deltacat.compute.compactor.utils.round_completion_reader import (
+    read_round_completion_info,
+)
+from deltacat.tests.compute.test_util_common import get_test_partition_locator
+from deltacat.compute.compactor import RoundCompletionInfo
+from deltacat.compute.compactor.model.pyarrow_write_result import PyArrowWriteResult
+from deltacat.storage.model.partition import Partition
+
+
+class TestRoundCompletionInfoInPartition:
+    def test_read_round_completion_info_from_partition_with_matching_source(self):
+        """
+        Test reading RoundCompletionInfo from partition metafile with matching source partition locator.
+        """
+        source_locator = get_test_partition_locator("source")
+        destination_locator = get_test_partition_locator("destination")
+
+        # Create a test RoundCompletionInfo with prev_source_partition_locator
+        pawr = PyArrowWriteResult.of(
+            file_count=1, pyarrow_bytes=1000, file_bytes=1000, record_count=100
+        )
+
+        expected_rci = RoundCompletionInfo.of(
+            high_watermark=122,
+            compacted_delta_locator=None,
+            compacted_pyarrow_write_result=pawr,
+            sort_keys_bit_width=12,
+            prev_source_partition_locator=source_locator,
+        )
+
+        # Create a partition with RoundCompletionInfo
+        partition = Partition.of(
+            locator=destination_locator,
+            content_types=None,
+            compaction_round_completion_info=expected_rci,
+        )
+
+        # Mock the storage
+        mock_storage = Mock()
+
+        # Test reading with partition provided (no storage call needed)
+        rci = read_round_completion_info(
+            source_partition_locator=source_locator,
+            destination_partition_locator=destination_locator,
+            deltacat_storage=mock_storage,
+            deltacat_storage_kwargs={},
+            destination_partition=partition,
+        )
+
+        assert rci is not None
+        assert rci == expected_rci
+        assert rci.high_watermark == 122
+        assert rci.sort_keys_bit_width == 12
+        assert (
+            rci.prev_source_partition_locator.partition_id
+            == source_locator.partition_id
+        )
+
+        # Verify storage was not called since partition was provided
+        mock_storage.get_partition.assert_not_called()
+
+    def test_read_round_completion_info_from_partition_with_mismatched_source(self):
+        """
+        Test reading RoundCompletionInfo from partition metafile with mismatched source partition locator.
+        Should return None and log a warning.
+        """
+        source_locator = get_test_partition_locator("source")
+        different_source_locator = get_test_partition_locator("different_source")
+        destination_locator = get_test_partition_locator("destination")
+
+        # Create a test RoundCompletionInfo with different prev_source_partition_locator
+        pawr = PyArrowWriteResult.of(
+            file_count=1, pyarrow_bytes=1000, file_bytes=1000, record_count=100
+        )
+
+        expected_rci = RoundCompletionInfo.of(
+            high_watermark=122,
+            compacted_delta_locator=None,
+            compacted_pyarrow_write_result=pawr,
+            sort_keys_bit_width=12,
+            prev_source_partition_locator=different_source_locator,  # Different from source_locator
+        )
+
+        # Create a partition with RoundCompletionInfo
+        partition = Partition.of(
+            locator=destination_locator,
+            content_types=None,
+            compaction_round_completion_info=expected_rci,
+        )
+
+        # Mock the storage
+        mock_storage = Mock()
+
+        # Test reading with mismatched source locator
+        rci = read_round_completion_info(
+            source_partition_locator=source_locator,  # Different from the one in RoundCompletionInfo
+            destination_partition_locator=destination_locator,
+            deltacat_storage=mock_storage,
+            deltacat_storage_kwargs={},
+            destination_partition=partition,
+        )
+
+        # Should return None due to mismatch
+        assert rci is None
+
+        # Verify storage was not called since partition was provided
+        mock_storage.get_partition.assert_not_called()
+
+    def test_read_round_completion_info_from_storage_when_partition_not_provided(self):
+        """
+        Test reading RoundCompletionInfo from storage when partition is not provided.
+        """
+        source_locator = get_test_partition_locator("source")
+        destination_locator = get_test_partition_locator("destination")
+
+        # Create a test RoundCompletionInfo
+        pawr = PyArrowWriteResult.of(
+            file_count=1, pyarrow_bytes=1000, file_bytes=1000, record_count=100
+        )
+
+        expected_rci = RoundCompletionInfo.of(
+            high_watermark=122,
+            compacted_delta_locator=None,
+            compacted_pyarrow_write_result=pawr,
+            sort_keys_bit_width=12,
+            prev_source_partition_locator=source_locator,
+        )
+
+        # Create a partition with RoundCompletionInfo
+        partition = Partition.of(
+            locator=destination_locator,
+            content_types=None,
+            compaction_round_completion_info=expected_rci,
+        )
+
+        # Mock the storage to return the partition
+        mock_storage = Mock()
+        mock_storage.get_partition.return_value = partition
+
+        # Test reading without partition provided (storage call needed)
+        rci = read_round_completion_info(
+            source_partition_locator=source_locator,
+            destination_partition_locator=destination_locator,
+            deltacat_storage=mock_storage,
+            deltacat_storage_kwargs={"test_arg": "test_value"},
+        )
+
+        assert rci is not None
+        assert rci == expected_rci
+        assert rci.high_watermark == 122
+
+        # Verify storage was called with correct parameters
+        mock_storage.get_partition.assert_called_once_with(
+            destination_locator.stream_locator,
+            destination_locator.partition_values,
+            test_arg="test_value",
+        )
+
+    def test_read_round_completion_info_when_partition_not_found(self):
+        """
+        Test reading RoundCompletionInfo when partition is not found in storage.
+        """
+        source_locator = get_test_partition_locator("source")
+        destination_locator = get_test_partition_locator("destination")
+
+        # Mock the storage to return None (partition not found)
+        mock_storage = Mock()
+        mock_storage.get_partition.return_value = None
+
+        # Test reading when partition not found
+        rci = read_round_completion_info(
+            source_partition_locator=source_locator,
+            destination_partition_locator=destination_locator,
+            deltacat_storage=mock_storage,
+            deltacat_storage_kwargs={},
+        )
+
+        # Should return None when partition not found
+        assert rci is None
+
+        # Verify storage was called
+        mock_storage.get_partition.assert_called_once()
+
+    def test_read_round_completion_info_when_no_completion_info_in_partition(self):
+        """
+        Test reading RoundCompletionInfo when partition exists but has no completion info.
+        """
+        source_locator = get_test_partition_locator("source")
+        destination_locator = get_test_partition_locator("destination")
+
+        # Create a partition without RoundCompletionInfo
+        partition = Partition.of(
+            locator=destination_locator,
+            content_types=None,
+            compaction_round_completion_info=None,
+        )
+
+        # Mock the storage to return the partition
+        mock_storage = Mock()
+        mock_storage.get_partition.return_value = partition
+
+        # Test reading when no completion info in partition
+        rci = read_round_completion_info(
+            source_partition_locator=source_locator,
+            destination_partition_locator=destination_locator,
+            deltacat_storage=mock_storage,
+            deltacat_storage_kwargs={},
+        )
+
+        # Should return None when no completion info
+        assert rci is None
+
+    def test_read_with_missing_prev_source_partition_locator_returns_none(self):
+        """
+        Test that reading with missing prev_source_partition_locator returns None.
+        """
+        source_locator = get_test_partition_locator("source")
+        destination_locator = get_test_partition_locator("destination")
+
+        # Create RoundCompletionInfo without prev_source_partition_locator
+        pawr = PyArrowWriteResult.of(
+            file_count=1, pyarrow_bytes=1000, file_bytes=1000, record_count=100
+        )
+
+        rcf = RoundCompletionInfo.of(
+            high_watermark=122,
+            compacted_delta_locator=None,
+            compacted_pyarrow_write_result=pawr,
+            sort_keys_bit_width=12,
+            prev_source_partition_locator=None,  # Missing
+        )
+
+        # Create a partition with RoundCompletionInfo
+        partition = Partition.of(
+            locator=destination_locator,
+            content_types=None,
+            compaction_round_completion_info=rcf,
+        )
+
+        # Mock the storage
+        mock_storage = Mock()
+
+        # Test reading should return None due to missing prev_source_partition_locator
+        result = read_round_completion_info(
+            source_partition_locator=source_locator,
+            destination_partition_locator=destination_locator,
+            deltacat_storage=mock_storage,
+            deltacat_storage_kwargs={},
+            destination_partition=partition,
+        )
+
+        # Should return None when prev_source_partition_locator is missing or mismatched
+        assert result is None