airbyte-cdk 0.58.9__py3-none-any.whl → 0.59.0__py3-none-any.whl

airbyte_cdk/sources/streams/concurrent/cursor.py

@@ -3,7 +3,8 @@
 #
 import functools
 from abc import ABC, abstractmethod
-from typing import Any, List, Mapping, Optional, Protocol, Tuple
+from datetime import datetime
+from typing import Any, List, Mapping, MutableMapping, Optional, Protocol, Tuple
 
 from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
 from airbyte_cdk.sources.message import MessageRepository
@@ -36,6 +37,11 @@ class CursorField:
 
 
 class Cursor(ABC):
+    @property
+    @abstractmethod
+    def state(self) -> MutableMapping[str, Any]:
+        ...
+
     @abstractmethod
     def observe(self, record: Record) -> None:
         """
@@ -52,6 +58,10 @@ class Cursor(ABC):
 
 
 class NoopCursor(Cursor):
+    @property
+    def state(self) -> MutableMapping[str, Any]:
+        return {}
+
     def observe(self, record: Record) -> None:
         pass
 
@@ -73,6 +83,7 @@ class ConcurrentCursor(Cursor):
         connector_state_converter: AbstractStreamStateConverter,
         cursor_field: CursorField,
         slice_boundary_fields: Optional[Tuple[str, str]],
+        start: Optional[Any],
     ) -> None:
         self._stream_name = stream_name
         self._stream_namespace = stream_namespace
@@ -82,9 +93,19 @@ class ConcurrentCursor(Cursor):
         self._cursor_field = cursor_field
         # To see some example where the slice boundaries might not be defined, check https://github.com/airbytehq/airbyte/blob/1ce84d6396e446e1ac2377362446e3fb94509461/airbyte-integrations/connectors/source-stripe/source_stripe/streams.py#L363-L379
         self._slice_boundary_fields = slice_boundary_fields if slice_boundary_fields else tuple()
+        self._start = start
         self._most_recent_record: Optional[Record] = None
         self._has_closed_at_least_one_slice = False
-        self.state = stream_state
+        self.start, self._concurrent_state = self._get_concurrent_state(stream_state)
+
+    @property
+    def state(self) -> MutableMapping[str, Any]:
+        return self._concurrent_state
+
+    def _get_concurrent_state(self, state: MutableMapping[str, Any]) -> Tuple[datetime, MutableMapping[str, Any]]:
+        if self._connector_state_converter.is_state_message_compatible(state):
+            return self._start or self._connector_state_converter.zero_value, self._connector_state_converter.deserialize(state)
+        return self._connector_state_converter.convert_from_sequential_state(self._cursor_field, state, self._start)
 
     def observe(self, record: Record) -> None:
         if self._slice_boundary_fields:
@@ -102,7 +123,7 @@ class ConcurrentCursor(Cursor):
     def close_partition(self, partition: Partition) -> None:
         slice_count_before = len(self.state.get("slices", []))
         self._add_slice_to_state(partition)
-        if slice_count_before < len(self.state["slices"]):
+        if slice_count_before < len(self.state["slices"]):  # only emit if at least one slice has been processed
             self._merge_partitions()
             self._emit_state_message()
         self._has_closed_at_least_one_slice = True
@@ -110,7 +131,9 @@ class ConcurrentCursor(Cursor):
     def _add_slice_to_state(self, partition: Partition) -> None:
         if self._slice_boundary_fields:
             if "slices" not in self.state:
-                self.state["slices"] = []
+                raise RuntimeError(
+                    f"The state for stream {self._stream_name} should have at least one slice to delineate the sync start time, but no slices are present. This is unexpected. Please contact Support."
+                )
             self.state["slices"].append(
                 {
                     "start": self._extract_from_slice(partition, self._slice_boundary_fields[self._START_BOUNDARY]),
@@ -126,10 +149,8 @@ class ConcurrentCursor(Cursor):
 
             self.state["slices"].append(
                 {
-                    # TODO: if we migrate stored state to the concurrent state format, we may want this to be the config start date
-                    #  instead of zero_value.
-                    "start": self._connector_state_converter.zero_value,
-                    "end": self._extract_cursor_value(self._most_recent_record),
+                    self._connector_state_converter.START_KEY: self.start,
+                    self._connector_state_converter.END_KEY: self._extract_cursor_value(self._most_recent_record),
                 }
             )
 

airbyte_cdk/sources/streams/concurrent/state_converters/abstract_stream_state_converter.py

@@ -4,7 +4,7 @@
 
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, List, MutableMapping, Optional
+from typing import TYPE_CHECKING, Any, List, MutableMapping, Tuple
 
 if TYPE_CHECKING:
     from airbyte_cdk.sources.streams.concurrent.cursor import CursorField
@@ -18,15 +18,6 @@ class AbstractStreamStateConverter(ABC):
     START_KEY = "start"
     END_KEY = "end"
 
-    def get_concurrent_stream_state(
-        self, cursor_field: Optional["CursorField"], state: MutableMapping[str, Any]
-    ) -> Optional[MutableMapping[str, Any]]:
-        if not cursor_field:
-            return None
-        if self.is_state_message_compatible(state):
-            return self.deserialize(state)
-        return self.convert_from_sequential_state(cursor_field, state)
-
     @abstractmethod
     def deserialize(self, state: MutableMapping[str, Any]) -> MutableMapping[str, Any]:
         """
@@ -40,8 +31,11 @@ class AbstractStreamStateConverter(ABC):
 
     @abstractmethod
     def convert_from_sequential_state(
-        self, cursor_field: "CursorField", stream_state: MutableMapping[str, Any]
-    ) -> MutableMapping[str, Any]:
+        self,
+        cursor_field: "CursorField",
+        stream_state: MutableMapping[str, Any],
+        start: Any,
+    ) -> Tuple[Any, MutableMapping[str, Any]]:
         """
         Convert the state message to the format required by the ConcurrentCursor.
 

airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py

@@ -4,7 +4,7 @@
 
 from abc import abstractmethod
 from datetime import datetime, timedelta
-from typing import Any, List, MutableMapping, Optional
+from typing import Any, List, MutableMapping, Optional, Tuple
 
 import pendulum
 from airbyte_cdk.sources.streams.concurrent.cursor import CursorField
@@ -16,9 +16,6 @@ from pendulum.datetime import DateTime
 
 
 class DateTimeStreamStateConverter(AbstractStreamStateConverter):
-    START_KEY = "start"
-    END_KEY = "end"
-
     @property
     @abstractmethod
     def _zero_value(self) -> Any:
@@ -62,7 +59,7 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
         for interval in sorted_intervals[1:]:
             last_end_time = merged_intervals[-1][self.END_KEY]
             current_start_time = interval[self.START_KEY]
-            if self.compare_intervals(last_end_time, current_start_time):
+            if self._compare_intervals(last_end_time, current_start_time):
                 merged_end_time = max(last_end_time, interval[self.END_KEY])
                 merged_intervals[-1][self.END_KEY] = merged_end_time
             else:
@@ -70,10 +67,12 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
 
         return merged_intervals
 
-    def compare_intervals(self, end_time: Any, start_time: Any) -> bool:
+    def _compare_intervals(self, end_time: Any, start_time: Any) -> bool:
         return bool(self.increment(end_time) >= start_time)
 
-    def convert_from_sequential_state(self, cursor_field: CursorField, stream_state: MutableMapping[str, Any]) -> MutableMapping[str, Any]:
+    def convert_from_sequential_state(
+        self, cursor_field: CursorField, stream_state: MutableMapping[str, Any], start: datetime
+    ) -> Tuple[datetime, MutableMapping[str, Any]]:
         """
         Convert the state message to the format required by the ConcurrentCursor.
 
@@ -82,28 +81,35 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
             "state_type": ConcurrencyCompatibleStateType.date_range.value,
             "metadata": { … },
             "slices": [
-                {starts: 0, end: "2021-01-18T21:18:20.000+00:00", finished_processing: true}]
+                {"start": "2021-01-18T21:18:20.000+00:00", "end": "2021-01-18T21:18:20.000+00:00"},
+            ]
         }
         """
+        sync_start = self._get_sync_start(cursor_field, stream_state, start)
         if self.is_state_message_compatible(stream_state):
-            return stream_state
-        if cursor_field.cursor_field_key in stream_state:
-            slices = [
-                {
-                    # TODO: if we migrate stored state to the concurrent state format, we may want this to be the config start date
-                    # instead of `zero_value`
-                    self.START_KEY: self.zero_value,
-                    self.END_KEY: self.parse_timestamp(stream_state[cursor_field.cursor_field_key]),
-                },
-            ]
-        else:
-            slices = []
-        return {
+            return sync_start, stream_state
+
+        # Create a slice to represent the records synced during prior syncs.
+        # The start and end are the same to avoid confusion as to whether the records for this slice
+        # were actually synced
+        slices = [{self.START_KEY: sync_start, self.END_KEY: sync_start}]
+
+        return sync_start, {
             "state_type": ConcurrencyCompatibleStateType.date_range.value,
             "slices": slices,
             "legacy": stream_state,
         }
 
+    def _get_sync_start(self, cursor_field: CursorField, stream_state: MutableMapping[str, Any], start: Optional[Any]) -> datetime:
+        sync_start = self.parse_timestamp(start) if start is not None else self.zero_value
+        prev_sync_low_water_mark = (
+            self.parse_timestamp(stream_state[cursor_field.cursor_field_key]) if cursor_field.cursor_field_key in stream_state else None
+        )
+        if prev_sync_low_water_mark and prev_sync_low_water_mark >= sync_start:
+            return prev_sync_low_water_mark
+        else:
+            return sync_start
+
     def convert_to_sequential_state(self, cursor_field: CursorField, stream_state: MutableMapping[str, Any]) -> MutableMapping[str, Any]:
         """
         Convert the state message from the concurrency-compatible format to the stream's original format.
@@ -113,10 +119,9 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
         """
         if self.is_state_message_compatible(stream_state):
             legacy_state = stream_state.get("legacy", {})
-            if slices := stream_state.pop("slices", None):
-                latest_complete_time = self._get_latest_complete_time(slices)
-                if latest_complete_time:
-                    legacy_state.update({cursor_field.cursor_field_key: self.output_format(latest_complete_time)})
+            latest_complete_time = self._get_latest_complete_time(stream_state.get("slices", []))
+            if latest_complete_time is not None:
+                legacy_state.update({cursor_field.cursor_field_key: self.output_format(latest_complete_time)})
             return legacy_state or {}
         else:
             return stream_state
@@ -125,11 +130,12 @@ class DateTimeStreamStateConverter(AbstractStreamStateConverter):
         """
         Get the latest time before which all records have been processed.
         """
-        if slices:
-            first_interval = self.merge_intervals(slices)[0][self.END_KEY]
-            return first_interval
-        else:
-            return None
+        if not slices:
+            raise RuntimeError("Expected at least one slice but there were none. This is unexpected; please contact Support.")
+
+        merged_intervals = self.merge_intervals(slices)
+        first_interval = merged_intervals[0]
+        return first_interval[self.END_KEY]
 
 
 class EpochValueConcurrentStreamStateConverter(DateTimeStreamStateConverter):

{airbyte_cdk-0.58.9.dist-info → airbyte_cdk-0.59.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 0.58.9
+Version: 0.59.0
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://github.com/airbytehq/airbyte
 Author: Airbyte

{airbyte_cdk-0.58.9.dist-info → airbyte_cdk-0.59.0.dist-info}/RECORD

@@ -202,7 +202,7 @@ airbyte_cdk/sources/streams/concurrent/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuY
 airbyte_cdk/sources/streams/concurrent/abstract_stream.py,sha256=W7WEz6FrfAjb0o_msnMBIESSVO1qJC2_A8ocYg55Rw4,3579
 airbyte_cdk/sources/streams/concurrent/adapters.py,sha256=f48kLzOHYNeD7Tfsdy7WaZ__hB24SfCTcW5WpQedqTc,18648
 airbyte_cdk/sources/streams/concurrent/availability_strategy.py,sha256=8xDRpfktnARBbRi_RwznvKuoGrpPF2b6tQyloMwogkM,2013
-airbyte_cdk/sources/streams/concurrent/cursor.py,sha256=GnSRDkEEvg2GNy_fEc9cWFoYI1oEfvzwg1vhRrusqWg,7105
+airbyte_cdk/sources/streams/concurrent/cursor.py,sha256=_mAbnJILeiGOGBNXeeXrSSoz7rveEBMoL97569EPEBY,8106
 airbyte_cdk/sources/streams/concurrent/default_stream.py,sha256=w83pvFbw9vjfhbovw-LrCFiwQMO8hfo1Vm-1CB1SeXQ,2777
 airbyte_cdk/sources/streams/concurrent/exceptions.py,sha256=-WETGIY5_QFmVeDFiqm4WhRJ_nNCkfcDwOQqx6cSqrI,365
 airbyte_cdk/sources/streams/concurrent/partition_enqueuer.py,sha256=TicEVRyLt5Y85xa8bXsrGzjmNMJAulBLqe1LfBLnHmk,1540
@@ -214,8 +214,8 @@ airbyte_cdk/sources/streams/concurrent/partitions/record.py,sha256=-Q3zLex3CHOXi
 airbyte_cdk/sources/streams/concurrent/partitions/throttled_queue.py,sha256=P6KrMb4GtcDUbMcx7pVb7dfF_igeW9Utn2MFoVHkH6o,1589
 airbyte_cdk/sources/streams/concurrent/partitions/types.py,sha256=iVARnsGOSdvlSCqAf-yxc4_PUT3oOR9B6cyVNcLTjY8,932
 airbyte_cdk/sources/streams/concurrent/state_converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-airbyte_cdk/sources/streams/concurrent/state_converters/abstract_stream_state_converter.py,sha256=8_97TvqOSn5jxmHsNMmnFi_A4XxGtMrX5GG6eNOyLtA,2954
-airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py,sha256=4K_Fa0nviG3L3Mu4YX3oEs1cAfE0QqzrKkkdJsL21M4,7002
+airbyte_cdk/sources/streams/concurrent/state_converters/abstract_stream_state_converter.py,sha256=jeVP3V9uDM_aCMh1G3kZNKafjopy1rZzIAJ8sU-69KU,2613
+airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py,sha256=BvVwPiVHE-R7mWDjcqhsKnZyD6OcpmAYaih7pcmOUvo,7589
 airbyte_cdk/sources/streams/http/__init__.py,sha256=cTP2d7Wf0hYXaN20U0dtxKa1pFZ9rI-lBbkQ0UM1apQ,261
 airbyte_cdk/sources/streams/http/availability_strategy.py,sha256=MHgW42gwaevaCVnNLrUSE6WJHT4reeZ417nMWrmbC7o,6884
 airbyte_cdk/sources/streams/http/exceptions.py,sha256=OokLDI7W8hZvq9e15sL3em2AdwmzmcAl72Ms-i5l0Nw,1334
@@ -411,8 +411,8 @@ unit_tests/sources/streams/concurrent/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYC
 unit_tests/sources/streams/concurrent/test_adapters.py,sha256=Y_c1vKCtGKEzrUSncmpgp0lgFnArmBrIrmLFaOIAxRg,15439
 unit_tests/sources/streams/concurrent/test_concurrent_partition_generator.py,sha256=a5JWWWc20zeEGmMzYzzk-_6XwfDEZOGgW287dVgft_8,1339
 unit_tests/sources/streams/concurrent/test_concurrent_read_processor.py,sha256=Dc7PGfQge1ymxnaTlPKGMVOLCV81JCXoK1ciJPwHIhg,26347
-unit_tests/sources/streams/concurrent/test_cursor.py,sha256=ere6x4nhhtSmEdvDoksLvLJTFkcl29N7VI7Mj6jin-I,5385
-unit_tests/sources/streams/concurrent/test_datetime_state_converter.py,sha256=mzlm8JL5AuYmNX4r9VViLKNaU1zUyBvBQ3lIdChW9pU,19153
+unit_tests/sources/streams/concurrent/test_cursor.py,sha256=0nFp9xauWxDVxJmFQLedvnxWKDoAlk9ChDkd0Mmrhm4,5951
+unit_tests/sources/streams/concurrent/test_datetime_state_converter.py,sha256=vx-oPmGSzSfBM37ZXN_wXLeTOlozErqQoa5sc5zP42o,13287
 unit_tests/sources/streams/concurrent/test_default_stream.py,sha256=VLF46ESoRqcoALYCdrdZ2NDl5s2T1fRRWsYAy2-IwYw,6502
 unit_tests/sources/streams/concurrent/test_partition_reader.py,sha256=2uj7uV3ie0BMb--aa3MUru-f4jLiYUR-Nl0r3EhwxLQ,951
 unit_tests/sources/streams/concurrent/test_thread_pool_manager.py,sha256=UzlMhXTgXAuqqPrESGjkDG9JLj4UdPo2bx3T9oLCFpA,3140
@@ -420,7 +420,7 @@ unit_tests/sources/streams/concurrent/test_throttled_queue.py,sha256=05NgNkx5c5r
 unit_tests/sources/streams/concurrent/test_throttler.py,sha256=y1cWUdKZP5iy4FKWmGdgEk4e_0WY0VNgRvzmlU114NY,448
 unit_tests/sources/streams/concurrent/scenarios/__init__.py,sha256=4Hw-PX1-VgESLF16cDdvuYCzGJtHntThLF4qIiULWeo,61
 unit_tests/sources/streams/concurrent/scenarios/incremental_scenarios.py,sha256=TH4vzdHNWvw4JsF0v4n6wrR1Rnr-WfU3R6nnOwGLNwg,9751
-unit_tests/sources/streams/concurrent/scenarios/stream_facade_builder.py,sha256=cFqcfrk-P4Gz-5yUFjTXIZ5U0zhzg3jayZiF6W79oPc,5880
+unit_tests/sources/streams/concurrent/scenarios/stream_facade_builder.py,sha256=BGqaYgU_ow4PsuhDjFwAFkU1VCkUuromvTAUV5tOaJ8,5816
 unit_tests/sources/streams/concurrent/scenarios/stream_facade_scenarios.py,sha256=kDKKV0ApASyS5c2HYkKvYohSkT--46TqALirqU8POjg,13804
 unit_tests/sources/streams/concurrent/scenarios/test_concurrent_scenarios.py,sha256=Z_4-ClsxBupmN7Pbl8lF9bkSA9wnjLtrgA9WR_8VRi8,3757
 unit_tests/sources/streams/concurrent/scenarios/thread_based_concurrent_stream_scenarios.py,sha256=KqCLsXB_9rV4hNdSPrNynK3G-UIsipqsZT6X0Z-iM5E,13175
@@ -448,8 +448,8 @@ unit_tests/utils/test_schema_inferrer.py,sha256=Z2jHBZ540wnYkylIdV_2xr75Vtwlxuyg
 unit_tests/utils/test_secret_utils.py,sha256=XKe0f1RHYii8iwE6ATmBr5JGDI1pzzrnZUGdUSMJQP4,4886
 unit_tests/utils/test_stream_status_utils.py,sha256=Xr8MZ2HWgTVIyMbywDvuYkRaUF4RZLQOT8-JjvcfR24,2970
 unit_tests/utils/test_traced_exception.py,sha256=bDFP5zMBizFenz6V2WvEZTRCKGB5ijh3DBezjbfoYIs,4198
-airbyte_cdk-0.58.9.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
-airbyte_cdk-0.58.9.dist-info/METADATA,sha256=c-ydl9BXY_-L2loNF2hjCcrt3PukOwp228pA6DRSk84,11073
-airbyte_cdk-0.58.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-airbyte_cdk-0.58.9.dist-info/top_level.txt,sha256=edvsDKTnE6sD2wfCUaeTfKf5gQIL6CPVMwVL2sWZzqo,51
-airbyte_cdk-0.58.9.dist-info/RECORD,,
+airbyte_cdk-0.59.0.dist-info/LICENSE.txt,sha256=Wfe61S4BaGPj404v8lrAbvhjYR68SHlkzeYrg3_bbuM,1051
+airbyte_cdk-0.59.0.dist-info/METADATA,sha256=5wiAdalwK0NUdE--8UKtiGbRy9ccsaY1T255M_Ei850,11073
+airbyte_cdk-0.59.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+airbyte_cdk-0.59.0.dist-info/top_level.txt,sha256=edvsDKTnE6sD2wfCUaeTfKf5gQIL6CPVMwVL2sWZzqo,51
+airbyte_cdk-0.59.0.dist-info/RECORD,,

unit_tests/sources/streams/concurrent/scenarios/stream_facade_builder.py

@@ -52,8 +52,7 @@ class StreamFacadeSource(ConcurrentSourceAdapter):
     def streams(self, config: Mapping[str, Any]) -> List[Stream]:
         state_manager = ConnectorStateManager(stream_instance_map={s.name: s for s in self._streams}, state=self._state)
         state_converter = StreamFacadeConcurrentConnectorStateConverter()
-        stream_states = [state_converter.get_concurrent_stream_state(self._cursor_field, state_manager.get_stream_state(stream.name, stream.namespace))
-                         for stream in self._streams]
+        stream_states = [state_manager.get_stream_state(stream.name, stream.namespace) for stream in self._streams]
         return [
             StreamFacade.create_from_stream(
                 stream,
@@ -69,6 +68,7 @@ class StreamFacadeSource(ConcurrentSourceAdapter):
                     state_converter,
                     self._cursor_field,
                     self._cursor_boundaries,
+                    None,
                 )
                 if self._cursor_field
                 else NoopCursor(),

unit_tests/sources/streams/concurrent/test_cursor.py

@@ -45,33 +45,50 @@ class ConcurrentCursorTest(TestCase):
         return ConcurrentCursor(
             _A_STREAM_NAME,
             _A_STREAM_NAMESPACE,
-            self._state_converter.get_concurrent_stream_state(CursorField(_A_CURSOR_FIELD_KEY), {}),
+            {},
             self._message_repository,
             self._state_manager,
             self._state_converter,
             CursorField(_A_CURSOR_FIELD_KEY),
             _SLICE_BOUNDARY_FIELDS,
+            None,
         )
 
     def _cursor_without_slice_boundary_fields(self) -> ConcurrentCursor:
         return ConcurrentCursor(
             _A_STREAM_NAME,
             _A_STREAM_NAMESPACE,
-            self._state_converter.get_concurrent_stream_state(CursorField(_A_CURSOR_FIELD_KEY), {}),
+            {},
             self._message_repository,
             self._state_manager,
             self._state_converter,
             CursorField(_A_CURSOR_FIELD_KEY),
             None,
+            None,
         )
 
     def test_given_boundary_fields_when_close_partition_then_emit_state(self) -> None:
-        self._cursor_with_slice_boundary_fields().close_partition(
+        cursor = self._cursor_with_slice_boundary_fields()
+        cursor.close_partition(
             _partition(
                 {_LOWER_SLICE_BOUNDARY_FIELD: 12, _UPPER_SLICE_BOUNDARY_FIELD: 30},
             )
         )
 
+        self._message_repository.emit_message.assert_called_once_with(self._state_manager.create_state_message.return_value)
+        self._state_manager.update_state_for_stream.assert_called_once_with(
+            _A_STREAM_NAME,
+            _A_STREAM_NAMESPACE,
+            {_A_CURSOR_FIELD_KEY: 0},  # State message is updated to the legacy format before being emitted
+        )
+
+    def test_given_boundary_fields_when_close_partition_then_emit_updated_state(self) -> None:
+        self._cursor_with_slice_boundary_fields().close_partition(
+            _partition(
+                {_LOWER_SLICE_BOUNDARY_FIELD: 0, _UPPER_SLICE_BOUNDARY_FIELD: 30},
+            )
+        )
+
         self._message_repository.emit_message.assert_called_once_with(self._state_manager.create_state_message.return_value)
         self._state_manager.update_state_for_stream.assert_called_once_with(
             _A_STREAM_NAME,

unit_tests/sources/streams/concurrent/test_datetime_state_converter.py

@@ -5,16 +5,6 @@
 from datetime import datetime, timezone
 
 import pytest
-from airbyte_cdk.models import (
-    AirbyteStateBlob,
-    AirbyteStateMessage,
-    AirbyteStateType,
-    AirbyteStream,
-    AirbyteStreamState,
-    StreamDescriptor,
-    SyncMode,
-)
-from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
 from airbyte_cdk.sources.streams.concurrent.cursor import CursorField
 from airbyte_cdk.sources.streams.concurrent.state_converters.abstract_stream_state_converter import ConcurrencyCompatibleStateType
 from airbyte_cdk.sources.streams.concurrent.state_converters.datetime_stream_state_converter import (
@@ -23,115 +13,12 @@ from airbyte_cdk.sources.streams.concurrent.state_converters.datetime_stream_sta
 )
 
 
-@pytest.mark.parametrize(
-    "converter, stream, input_state, expected_output_state",
-    [
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            [],
-            {'legacy': {}, 'slices': [], 'state_type': 'date-range'},
-            id="no-input-state-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="stream1", namespace=None),
-                        stream_state=AirbyteStateBlob.parse_obj({"created_at": 1703020837}),
-                    ),
-                ),
-            ],
-            {
-                "legacy": {"created_at": 1703020837},
-                "slices": [{"end": datetime(2023, 12, 19, 21, 20, 37, tzinfo=timezone.utc),
-                            "start": datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc)}],
-                "state_type": ConcurrencyCompatibleStateType.date_range.value,
-            },
-            id="incompatible-input-state-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="stream1", namespace=None),
-                        stream_state=AirbyteStateBlob.parse_obj(
-                            {
-                                "created_at": 1703020837,
-                                "state_type": ConcurrencyCompatibleStateType.date_range.value,
-                            },
-                        ),
-                    ),
-                ),
-            ],
-            {"created_at": 1703020837, "state_type": ConcurrencyCompatibleStateType.date_range.value},
-            id="compatible-input-state-epoch",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            [],
-            {'legacy': {}, 'slices': [], 'state_type': 'date-range'},
-            id="no-input-state-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="stream1", namespace=None),
-                        stream_state=AirbyteStateBlob.parse_obj({"created_at": "2021-01-18T21:18:20.000Z"}),
-                    ),
-                ),
-            ],
-            {
-                "legacy": {"created_at": "2021-01-18T21:18:20.000Z"},
-                "slices": [{"end": datetime(2021, 1, 18, 21, 18, 20, tzinfo=timezone.utc),
-                            "start": datetime(1, 1, 1, 0, 0, 0, tzinfo=timezone.utc)}],
-                "state_type": ConcurrencyCompatibleStateType.date_range.value},
-            id="incompatible-input-state-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="stream1", namespace=None),
-                        stream_state=AirbyteStateBlob.parse_obj(
-                            {
-                                "created_at": "2021-01-18T21:18:20.000Z",
-                                "state_type": ConcurrencyCompatibleStateType.date_range.value,
-                            },
-                        ),
-                    ),
-                ),
-            ],
-            {"created_at": "2021-01-18T21:18:20.000Z", "state_type": ConcurrencyCompatibleStateType.date_range.value},
-            id="compatible-input-state-isomillis",
-        ),
-    ],
-)
-def test_concurrent_connector_state_manager_get_stream_state(converter, stream, input_state, expected_output_state):
-    state_manager = ConnectorStateManager({"stream1": stream}, input_state)
-    assert converter.get_concurrent_stream_state(CursorField("created_at"), state_manager.get_stream_state("stream1", None)) == expected_output_state
-
-
 @pytest.mark.parametrize(
     "converter, input_state, is_compatible",
     [
         pytest.param(
             EpochValueConcurrentStreamStateConverter(),
-            {'state_type': 'date-range'},
+            {"state_type": "date-range"},
             True,
             id="no-input-state-is-compatible-epoch",
         ),
@@ -163,7 +50,7 @@ def test_concurrent_connector_state_manager_get_stream_state(converter, stream,
         ),
         pytest.param(
             IsoMillisConcurrentStreamStateConverter(),
-            {'state_type': 'date-range'},
+            {"state_type": "date-range"},
             True,
             id="no-input-state-is-compatible-isomillis",
         ),
@@ -200,22 +87,106 @@ def test_concurrent_stream_state_converter_is_state_message_compatible(converter
 
 
 @pytest.mark.parametrize(
-    "converter, stream, sequential_state, expected_output_state",
+    "converter,start,state,expected_start",
+    [
+        pytest.param(
+            EpochValueConcurrentStreamStateConverter(),
+            None,
+            {},
+            EpochValueConcurrentStreamStateConverter().zero_value,
+            id="epoch-converter-no-state-no-start-start-is-zero-value"
+        ),
+        pytest.param(
+            EpochValueConcurrentStreamStateConverter(),
+            1617030403,
+            {},
+            datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc),
+            id="epoch-converter-no-state-with-start-start-is-start"
+        ),
+        pytest.param(
+            EpochValueConcurrentStreamStateConverter(),
+            None,
+            {"created_at": 1617030404},
+            datetime(2021, 3, 29, 15, 6, 44, tzinfo=timezone.utc),
+            id="epoch-converter-state-without-start-start-is-from-state"
+        ),
+        pytest.param(
+            EpochValueConcurrentStreamStateConverter(),
+            1617030404,
+            {"created_at": 1617030403},
+            datetime(2021, 3, 29, 15, 6, 44, tzinfo=timezone.utc),
+            id="epoch-converter-state-before-start-start-is-start"
+        ),
+        pytest.param(
+            EpochValueConcurrentStreamStateConverter(),
+            1617030403,
+            {"created_at": 1617030404},
+            datetime(2021, 3, 29, 15, 6, 44, tzinfo=timezone.utc),
+            id="epoch-converter-state-after-start-start-is-from-state"
+        ),
+        pytest.param(
+            IsoMillisConcurrentStreamStateConverter(),
+            None,
+            {},
+            IsoMillisConcurrentStreamStateConverter().zero_value,
+            id="isomillis-converter-no-state-no-start-start-is-zero-value"
+        ),
+        pytest.param(
+            IsoMillisConcurrentStreamStateConverter(),
+            "2021-08-22T05:03:27.000Z",
+            {},
+            datetime(2021, 8, 22, 5, 3, 27, tzinfo=timezone.utc),
+            id="isomillis-converter-no-state-with-start-start-is-start"
+        ),
+        pytest.param(
+            IsoMillisConcurrentStreamStateConverter(),
+            None,
+            {"created_at": "2021-08-22T05:03:27.000Z"},
+            datetime(2021, 8, 22, 5, 3, 27, tzinfo=timezone.utc),
+            id="isomillis-converter-state-without-start-start-is-from-state"
+        ),
+        pytest.param(
+            IsoMillisConcurrentStreamStateConverter(),
+            "2022-08-22T05:03:27.000Z",
+            {"created_at": "2021-08-22T05:03:27.000Z"},
+            datetime(2022, 8, 22, 5, 3, 27, tzinfo=timezone.utc),
+            id="isomillis-converter-state-before-start-start-is-start"
+        ),
+        pytest.param(
+            IsoMillisConcurrentStreamStateConverter(),
+            "2022-08-22T05:03:27.000Z",
+            {"created_at": "2023-08-22T05:03:27.000Z"},
+            datetime(2023, 8, 22, 5, 3, 27, tzinfo=timezone.utc),
+            id="isomillis-converter-state-after-start-start-is-from-state"
+        ),
+    ]
+)
+def test_get_sync_start(converter, start, state, expected_start):
+    assert converter._get_sync_start(CursorField("created_at"), state, start) == expected_start
+
+
+@pytest.mark.parametrize(
+    "converter, start, sequential_state, expected_output_state",
     [
         pytest.param(
             EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
+            0,
             {},
-            {'legacy': {}, 'slices': [], 'state_type': 'date-range'},
+            {
+                "legacy": {},
+                "slices": [{"start": EpochValueConcurrentStreamStateConverter().zero_value,
+                            "end": EpochValueConcurrentStreamStateConverter().zero_value}],
+                "state_type": "date-range",
+            },
             id="empty-input-state-epoch",
         ),
         pytest.param(
             EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
+            1617030403,
             {"created": 1617030403},
             {
                 "state_type": "date-range",
-                "slices": [{"start": datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                "slices": [{"start": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc),
                             "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
                 "legacy": {"created": 1617030403},
             },
@@ -223,18 +194,11 @@ def test_concurrent_stream_state_converter_is_state_message_compatible(converter
         ),
         pytest.param(
             IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            {},
-            {'legacy': {}, 'slices': [], 'state_type': 'date-range'},
-            id="empty-input-state-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
+            "2020-01-01T00:00:00.000Z",
             {"created": "2021-08-22T05:03:27.000Z"},
             {
                 "state_type": "date-range",
-                "slices": [{"start": datetime(1, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                "slices": [{"start": datetime(2021, 8, 22, 5, 3, 27, tzinfo=timezone.utc),
                             "end": datetime(2021, 8, 22, 5, 3, 27, tzinfo=timezone.utc)}],
                 "legacy": {"created": "2021-08-22T05:03:27.000Z"},
             },
@@ -242,186 +206,120 @@ def test_concurrent_stream_state_converter_is_state_message_compatible(converter
         ),
     ],
 )
-def test_convert_from_sequential_state(converter, stream, sequential_state, expected_output_state):
+def test_convert_from_sequential_state(converter, start, sequential_state, expected_output_state):
     comparison_format = "%Y-%m-%dT%H:%M:%S.%f"
     if expected_output_state["slices"]:
-        conversion = converter.convert_from_sequential_state(CursorField("created"), sequential_state)
+        _, conversion = converter.convert_from_sequential_state(CursorField("created"), sequential_state, start)
         assert conversion["state_type"] == expected_output_state["state_type"]
         assert conversion["legacy"] == expected_output_state["legacy"]
         for actual, expected in zip(conversion["slices"], expected_output_state["slices"]):
             assert actual["start"].strftime(comparison_format) == expected["start"].strftime(comparison_format)
             assert actual["end"].strftime(comparison_format) == expected["end"].strftime(comparison_format)
     else:
-        assert converter.convert_from_sequential_state(CursorField("created"), sequential_state) == expected_output_state
+        _, conversion = converter.convert_from_sequential_state(CursorField("created"), sequential_state, start)
+        assert conversion == expected_output_state
 
 
 @pytest.mark.parametrize(
-    "converter, stream, concurrent_state, expected_output_state",
+    "converter, concurrent_state, expected_output_state",
     [
         pytest.param(
             EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            {"state_type": ConcurrencyCompatibleStateType.date_range.value},
-            {},
-            id="empty-input-state-epoch",
+            {
+                "state_type": "date-range",
+                "slices": [{"start": datetime(1970, 1, 3, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
+            },
+            {"created": 1617030403},
+            id="epoch-single-slice",
         ),
         pytest.param(
             EpochValueConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
             {
                 "state_type": "date-range",
-                "slices": [{"start": datetime(1, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
-                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}]},
+                "slices": [{"start": datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)},
+                           {"start": datetime(2020, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2022, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
+            },
+            {"created": 1648566403},
+            id="epoch-overlapping-slices",
+        ),
+        pytest.param(
+            EpochValueConcurrentStreamStateConverter(),
+            {
+                "state_type": "date-range",
+                "slices": [{"start": datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)},
+                           {"start": datetime(2022, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                           "end": datetime(2023, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
+            },
             {"created": 1617030403},
-            id="with-input-state-epoch",
+            id="epoch-multiple-slices",
         ),
         pytest.param(
             IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
-            {"state_type": ConcurrencyCompatibleStateType.date_range.value},
-            {},
-            id="empty-input-state-isomillis",
+            {
+                "state_type": "date-range",
+                "slices": [{"start": datetime(1970, 1, 3, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
+            },
+            {"created": "2021-03-29T15:06:43.000Z"},
+            id="isomillis-single-slice",
         ),
         pytest.param(
             IsoMillisConcurrentStreamStateConverter(),
-            AirbyteStream(name="stream1", json_schema={}, supported_sync_modes=[SyncMode.incremental]),
             {
                 "state_type": "date-range",
-                "slices": [{"start": datetime(1, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
-                            "end": datetime(2021, 8, 22, 5, 3, 27, tzinfo=timezone.utc)}]},
-            {"created": "2021-08-22T05:03:27.000Z"},
-            id="with-input-state-isomillis",
+                "slices": [{"start": datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)},
+                           {"start": datetime(2020, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2022, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
+            },
+            {"created": "2022-03-29T15:06:43.000Z"},
+            id="isomillis-overlapping-slices",
+        ),
+        pytest.param(
+            IsoMillisConcurrentStreamStateConverter(),
+            {
+                "state_type": "date-range",
+                "slices": [{"start": datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                            "end": datetime(2021, 3, 29, 15, 6, 43, tzinfo=timezone.utc)},
+                           {"start": datetime(2022, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                           "end": datetime(2023, 3, 29, 15, 6, 43, tzinfo=timezone.utc)}],
+            },
+            {"created": "2021-03-29T15:06:43.000Z"},
+            id="isomillis-multiple-slices",
         ),
     ],
 )
-def test_convert_to_sequential_state(converter, stream, concurrent_state, expected_output_state):
+def test_convert_to_sequential_state(converter, concurrent_state, expected_output_state):
     assert converter.convert_to_sequential_state(CursorField("created"), concurrent_state) == expected_output_state
 
 
 @pytest.mark.parametrize(
-    "converter, input_intervals, expected_merged_intervals",
+    "converter, concurrent_state, expected_output_state",
     [
         pytest.param(
             EpochValueConcurrentStreamStateConverter(),
-            [],
-            [],
-            id="no-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 0, "end": 1}],
-            [{"start": 0, "end": 1}],
-            id="single-interval-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 0, "end": 1}, {"start": 0, "end": 1}],
-            [{"start": 0, "end": 1}],
-            id="duplicate-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 0, "end": 1}, {"start": 0, "end": 2}],
-            [{"start": 0, "end": 2}],
-            id="overlapping-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 0, "end": 3}, {"start": 1, "end": 2}],
-            [{"start": 0, "end": 3}],
-            id="enclosed-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 1, "end": 2}, {"start": 0, "end": 1}],
-            [{"start": 0, "end": 2}],
-            id="unordered-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 0, "end": 1}, {"start": 2, "end": 3}],
-            [{"start": 0, "end": 3}],
-            id="adjacent-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 3, "end": 4}, {"start": 0, "end": 1}],
-            [{"start": 0, "end": 1}, {"start": 3, "end": 4}],
-            id="nonoverlapping-intervals-epoch",
-        ),
-        pytest.param(
-            EpochValueConcurrentStreamStateConverter(),
-            [{"start": 0, "end": 1}, {"start": 2, "end": 3}, {"start": 10, "end": 11}, {"start": 1, "end": 4}],
-            [{"start": 0, "end": 4}, {"start": 10, "end": 11}],
-            id="overlapping-and-nonoverlapping-intervals-epoch",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [],
-            [],
-            id="no-intervals-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            id="single-interval-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"},
-             {"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            id="duplicate-intervals-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2023-08-22T05:03:27.000Z"},
-             {"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2023-08-22T05:03:27.000Z"}],
-            id="overlapping-intervals-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2024-08-22T05:03:27.000Z"},
-             {"start": "2022-08-22T05:03:27.000Z", "end": "2023-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2024-08-22T05:03:27.000Z"}],
-            id="enclosed-intervals-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2023-08-22T05:03:27.000Z", "end": "2024-08-22T05:03:27.000Z"},
-             {"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            [{"start": 0, "end": 2}],
-            id="unordered-intervals-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"},
-             {"start": "2022-08-22T05:03:27.001Z", "end": "2023-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2023-08-22T05:03:27.000Z"}],
-            id="adjacent-intervals-isomillis",
-        ),
-        pytest.param(
-            IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2023-08-22T05:03:27.000Z", "end": "2024-08-22T05:03:27.000Z"},
-             {"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"},
-             {"start": "2023-08-22T05:03:27.000Z", "end": "2024-08-22T05:03:27.000Z"}],
-            id="nonoverlapping-intervals-isomillis",
+            {
+                "state_type": ConcurrencyCompatibleStateType.date_range.value,
+                "start": EpochValueConcurrentStreamStateConverter().zero_value,
+            },
+            {"created": 0},
+            id="empty-slices-epoch",
         ),
         pytest.param(
             IsoMillisConcurrentStreamStateConverter(),
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2022-08-22T05:03:27.000Z"},
-             {"start": "2022-08-22T05:03:27.001Z", "end": "2023-08-22T05:03:27.000Z"},
-             {"start": "2027-08-22T05:03:27.000Z", "end": "2028-08-22T05:03:27.000Z"},
-             {"start": "2022-08-22T05:03:27.000Z", "end": "2025-08-22T05:03:27.000Z"}],
-            [{"start": "2021-08-22T05:03:27.000Z", "end": "2025-08-22T05:03:27.000Z"},
-             {"start": "2027-08-22T05:03:27.000Z", "end": "2028-08-22T05:03:27.000Z"}],
-            id="overlapping-and-nonoverlapping-intervals-isomillis",
+            {
+                "state_type": ConcurrencyCompatibleStateType.date_range.value,
+                "start": datetime(2021, 8, 22, 5, 3, 27, tzinfo=timezone.utc),
+            },
+            {"created": "2021-08-22T05:03:27.000Z"},
+            id="empty-slices-isomillis",
         ),
     ],
 )
-def test_merge_intervals(converter, input_intervals, expected_merged_intervals):
-    parsed_intervals = [{"start": converter.parse_timestamp(i["start"]), "end": converter.parse_timestamp(i["end"])} for i in input_intervals]
-    return converter.merge_intervals(parsed_intervals) == expected_merged_intervals
+def test_convert_to_sequential_state_no_slices_returns_legacy_state(converter, concurrent_state, expected_output_state):
+    with pytest.raises(RuntimeError):
+        converter.convert_to_sequential_state(CursorField("created"), concurrent_state)