remove unecessary test

Author: maxime.c

unit_tests/sources/declarative/incremental/test_per_partition_cursor_integration.py

@@ -422,142 +422,6 @@ def test_substream_without_input_state():
         ]
 
 
-def test_switch_to_global_limit(caplog):
-    """
-    Test that when the number of partitions exceeds the limit to switch to global state.
-
-    In this test, we set the maximum number of partitions to 1 (not 2 because we evaluate this before generating a
-    partition and the limit is not inclusive) and provide 3 partitions.
-    We verify that the state switch to global.
-    """
-    stream_name = "Rates"
-
-    partition_slices = [
-        StreamSlice(partition={"partition_field": "1"}, cursor_slice={}),
-        StreamSlice(partition={"partition_field": "2"}, cursor_slice={}),
-        StreamSlice(partition={"partition_field": "3"}, cursor_slice={}),
-    ]
-
-    records_list = [
-        [
-            Record(
-                data={"a record key": "a record value", CURSOR_FIELD: "2022-01-15"},
-                associated_slice=partition_slices[0],
-                stream_name=stream_name,
-            ),
-            Record(
-                data={"a record key": "a record value", CURSOR_FIELD: "2022-01-16"},
-                associated_slice=partition_slices[0],
-                stream_name=stream_name,
-            ),
-        ],
-        [
-            Record(
-                data={"a record key": "a record value", CURSOR_FIELD: "2022-02-15"},
-                associated_slice=partition_slices[0],
-                stream_name=stream_name,
-            )
-        ],
-        [
-            Record(
-                data={"a record key": "a record value", CURSOR_FIELD: "2022-01-16"},
-                associated_slice=partition_slices[1],
-                stream_name=stream_name,
-            )
-        ],
-        [],
-        [],
-        [
-            Record(
-                data={"a record key": "a record value", CURSOR_FIELD: "2022-02-17"},
-                associated_slice=partition_slices[2],
-                stream_name=stream_name,
-            )
-        ],
-    ]
-
-    configured_stream = ConfiguredAirbyteStream(
-        stream=AirbyteStream(
-            name="Rates",
-            json_schema={},
-            supported_sync_modes=[SyncMode.full_refresh, SyncMode.incremental],
-        ),
-        sync_mode=SyncMode.incremental,
-        destination_sync_mode=DestinationSyncMode.append,
-    )
-    catalog = ConfiguredAirbyteCatalog(streams=[configured_stream])
-
-    initial_state = [
-        AirbyteStateMessage(
-            type=AirbyteStateType.STREAM,
-            stream=AirbyteStreamState(
-                stream_descriptor=StreamDescriptor(name="post_comment_votes", namespace=None),
-                stream_state=AirbyteStateBlob(
-                    {
-                        "states": [
-                            {
-                                "partition": {"partition_field": "1"},
-                                "cursor": {CURSOR_FIELD: "2022-01-01"},
-                            },
-                            {
-                                "partition": {"partition_field": "2"},
-                                "cursor": {CURSOR_FIELD: "2022-01-02"},
-                            },
-                            {
-                                "partition": {"partition_field": "3"},
-                                "cursor": {CURSOR_FIELD: "2022-01-03"},
-                            },
-                        ]
-                    }
-                ),
-            ),
-        )
-    ]
-    logger = MagicMock()
-
-    source = ConcurrentDeclarativeSource(
-        source_config=ManifestBuilder()
-        .with_list_partition_router(
-            stream_name=stream_name, cursor_field="partition_field", partitions=["1", "2", "3"]
-        )
-        .with_incremental_sync(
-            stream_name=stream_name,
-            start_datetime="2022-01-01",
-            end_datetime="2022-02-28",
-            datetime_format="%Y-%m-%d",
-            cursor_field=CURSOR_FIELD,
-            step="P1M",
-            cursor_granularity="P1D",
-        )
-        .build(),
-        config={},
-        catalog=catalog,
-        state=initial_state,
-    )
-
-    # Use caplog to capture logs
-    with caplog.at_level(logging.INFO, logger="airbyte"):
-        with patch.object(SimpleRetriever, "_read_pages", side_effect=records_list):
-            with patch.object(ConcurrentPerPartitionCursor, "SWITCH_TO_GLOBAL_LIMIT", 1):
-                output = list(source.read(logger, {}, catalog, initial_state))
-
-    # Check if the warning was logged
-    logged_messages = [record.message for record in caplog.records if record.levelname == "INFO"]
-    warning_message = "Exceeded the 'SWITCH_TO_GLOBAL_LIMIT' of"
-    assert any(map(lambda message: warning_message in message, logged_messages))
-
-    final_state = [
-        orjson.loads(orjson.dumps(message.state.stream.stream_state))
-        for message in output
-        if message.state
-    ]
-    assert final_state[-1] == {
-        "lookback_window": 1,
-        "state": {"cursor_field": "2022-02-17"},
-        "use_global_cursor": True,
-    }
-
-
 def test_perpartition_with_fallback(caplog):
     """
     Test that when the number of partitions exceeds the limit in PerPartitionCursor,