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

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)

unit_tests/sources/streams/concurrent/test_thread_pool_manager.py

@@ -3,7 +3,7 @@
 #
 from concurrent.futures import Future, ThreadPoolExecutor
 from unittest import TestCase
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
 
 from airbyte_cdk.sources.concurrent_source.thread_pool_manager import ThreadPoolManager
 
@@ -23,23 +23,10 @@ class ThreadPoolManagerTest(TestCase):
 
         assert len(self._thread_pool_manager._futures) == 1
 
-    def test_submit_too_many_concurrent_tasks(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = None
-        future.done.side_effect = [False, True]
-
-        with patch("time.sleep") as sleep_mock:
-            self._thread_pool_manager._futures = [future]
-            self._thread_pool_manager.submit(self._fn, self._arg)
-            self._threadpool.submit.assert_called_with(self._fn, self._arg)
-            sleep_mock.assert_called_with(_SLEEP_TIME)
-
-            assert len(self._thread_pool_manager._futures) == 1
-
     def test_submit_task_previous_task_failed(self):
         future = Mock(spec=Future)
         future.exception.return_value = RuntimeError
-        future.done.side_effect = [False, True]
+        future.done.side_effect = [True, True]
 
         self._thread_pool_manager._futures = [future]
 

unit_tests/sources/streams/concurrent/test_throttled_queue.py

@@ -0,0 +1,65 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+from queue import Queue
+from unittest.mock import Mock
+
+import pytest
+from _queue import Empty
+from airbyte_cdk.sources.concurrent_source.throttler import Throttler
+from airbyte_cdk.sources.streams.concurrent.partitions.throttled_queue import ThrottledQueue
+
+_AN_ITEM = Mock()
+
+
+def test_new_throttled_queue_is_empty():
+    queue = Queue()
+    throttler = Mock(spec=Throttler)
+    timeout = 100
+    throttled_queue = ThrottledQueue(queue, throttler, timeout)
+
+    assert throttled_queue.empty()
+
+
+def test_throttled_queue_is_not_empty_after_putting_an_item():
+    queue = Queue()
+    throttler = Mock(spec=Throttler)
+    timeout = 100
+    throttled_queue = ThrottledQueue(queue, throttler, timeout)
+
+    throttled_queue.put(_AN_ITEM)
+
+    assert not throttled_queue.empty()
+
+
+def test_throttled_queue_get_returns_item_if_any():
+    queue = Queue()
+    throttler = Mock(spec=Throttler)
+    timeout = 100
+    throttled_queue = ThrottledQueue(queue, throttler, timeout)
+
+    throttled_queue.put(_AN_ITEM)
+    item = throttled_queue.get()
+
+    assert item == _AN_ITEM
+    assert throttled_queue.empty()
+
+
+def test_throttled_queue_blocks_for_timeout_seconds_if_no_items():
+    queue = Mock(spec=Queue)
+    throttler = Mock(spec=Throttler)
+    timeout = 100
+    throttled_queue = ThrottledQueue(queue, throttler, timeout)
+
+    throttled_queue.get()
+
+    assert queue.get.is_called_once_with(block=True, timeout=timeout)
+
+
+def test_throttled_queue_raises_an_error_if_no_items_after_timeout():
+    queue = Queue()
+    throttler = Mock(spec=Throttler)
+    timeout = 0.001
+    throttled_queue = ThrottledQueue(queue, throttler, timeout)
+
+    with pytest.raises(Empty):
+        throttled_queue.get()

unit_tests/sources/streams/concurrent/test_throttler.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+from unittest.mock import patch
+
+from airbyte_cdk.sources.concurrent_source.throttler import Throttler
+
+
+@patch('time.sleep', side_effect=lambda _: None)
+@patch('airbyte_cdk.sources.concurrent_source.throttler.len', side_effect=[1, 1, 0])
+def test_throttler(sleep_mock, len_mock):
+    throttler = Throttler([], 0.1, 1)
+    throttler.wait_and_acquire()
+    assert sleep_mock.call_count == 3