airbyte-cdk 0.72.1__py3-none-any.whl → 6.17.1.dev0__py3-none-any.whl

unit_tests/sources/declarative/parsers/testing_components.py

@@ -1,36 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from dataclasses import dataclass
-from typing import List, Optional
-
-from airbyte_cdk.sources.declarative.extractors import DpathExtractor
-from airbyte_cdk.sources.declarative.partition_routers import SubstreamPartitionRouter
-from airbyte_cdk.sources.declarative.requesters import RequestOption
-from airbyte_cdk.sources.declarative.requesters.error_handlers import DefaultErrorHandler
-from airbyte_cdk.sources.declarative.requesters.paginators import DefaultPaginator, PaginationStrategy
-
-
-@dataclass
-class TestingSomeComponent(DefaultErrorHandler):
-    """
-    A basic test class with various field permutations used to test manifests with custom components
-    """
-
-    subcomponent_field_with_hint: DpathExtractor = DpathExtractor(field_path=[], config={}, parameters={})
-    basic_field: str = ""
-    optional_subcomponent_field: Optional[RequestOption] = None
-    list_of_subcomponents: List[RequestOption] = None
-    without_hint = None
-    paginator: DefaultPaginator = None
-
-
-@dataclass
-class TestingCustomSubstreamPartitionRouter(SubstreamPartitionRouter):
-    """
-    A test class based on a SubstreamPartitionRouter used for testing manifests that use custom components.
-    """
-
-    custom_field: str
-    custom_pagination_strategy: PaginationStrategy

unit_tests/sources/declarative/partition_routers/__init__.py

@@ -1,3 +0,0 @@
-#
-# Copyright (c) 2022 Airbyte, Inc., all rights reserved.
-#

unit_tests/sources/declarative/partition_routers/test_list_partition_router.py

@@ -1,155 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-import pytest as pytest
-from airbyte_cdk.sources.declarative.partition_routers.list_partition_router import ListPartitionRouter
-from airbyte_cdk.sources.declarative.requesters.request_option import RequestOption, RequestOptionType
-from airbyte_cdk.sources.declarative.types import StreamSlice
-
-partition_values = ["customer", "store", "subscription"]
-cursor_field = "owner_resource"
-parameters = {"cursor_field": "owner_resource"}
-
-
-@pytest.mark.parametrize(
-    "partition_values, cursor_field, expected_slices",
-    [
-        (
-            ["customer", "store", "subscription"],
-            "owner_resource",
-            [StreamSlice(partition={"owner_resource": "customer"}, cursor_slice={}),
-             StreamSlice(partition={"owner_resource": "store"}, cursor_slice={}),
-             StreamSlice(partition={"owner_resource": "subscription"}, cursor_slice={})],
-        ),
-        (
-            '["customer", "store", "subscription"]',
-            "owner_resource",
-            [StreamSlice(partition={"owner_resource": "customer"}, cursor_slice={}),
-             StreamSlice(partition={"owner_resource": "store"}, cursor_slice={}),
-             StreamSlice(partition={"owner_resource": "subscription"}, cursor_slice={})],
-        ),
-        (
-            '["customer", "store", "subscription"]',
-            "{{ parameters['cursor_field'] }}",
-            [StreamSlice(partition={"owner_resource": "customer"}, cursor_slice={}),
-             StreamSlice(partition={"owner_resource": "store"}, cursor_slice={}),
-                StreamSlice(partition={"owner_resource": "subscription"}, cursor_slice={})],
-        ),
-    ],
-    ids=[
-        "test_single_element",
-        "test_input_list_is_string",
-        "test_using_cursor_from_parameters",
-    ],
-)
-def test_list_partition_router(partition_values, cursor_field, expected_slices):
-    slicer = ListPartitionRouter(values=partition_values, cursor_field=cursor_field, config={}, parameters=parameters)
-    slices = [s for s in slicer.stream_slices()]
-    assert slices == expected_slices
-    assert all(isinstance(s, StreamSlice) for s in slices)
-
-
-@pytest.mark.parametrize(
-    "request_option, expected_req_params, expected_headers, expected_body_json, expected_body_data",
-    [
-        (
-            RequestOption(inject_into=RequestOptionType.request_parameter, parameters={}, field_name="owner_resource"),
-            {"owner_resource": "customer"},
-            {},
-            {},
-            {},
-        ),
-        (
-            RequestOption(inject_into=RequestOptionType.header, parameters={}, field_name="owner_resource"),
-            {},
-            {"owner_resource": "customer"},
-            {},
-            {},
-        ),
-        (
-            RequestOption(inject_into=RequestOptionType.body_json, parameters={}, field_name="owner_resource"),
-            {},
-            {},
-            {"owner_resource": "customer"},
-            {},
-        ),
-        (
-            RequestOption(inject_into=RequestOptionType.body_data, parameters={}, field_name="owner_resource"),
-            {},
-            {},
-            {},
-            {"owner_resource": "customer"},
-        ),
-    ],
-    ids=[
-        "test_inject_into_req_param",
-        "test_pass_by_header",
-        "test_inject_into_body_json",
-        "test_inject_into_body_data",
-    ],
-)
-def test_request_option(request_option, expected_req_params, expected_headers, expected_body_json, expected_body_data):
-    partition_router = ListPartitionRouter(
-        values=partition_values, cursor_field=cursor_field, config={}, request_option=request_option, parameters={}
-    )
-    stream_slice = {cursor_field: "customer"}
-
-    assert expected_req_params == partition_router.get_request_params(stream_slice=stream_slice)
-    assert expected_headers == partition_router.get_request_headers(stream_slice=stream_slice)
-    assert expected_body_json == partition_router.get_request_body_json(stream_slice=stream_slice)
-    assert expected_body_data == partition_router.get_request_body_data(stream_slice=stream_slice)
-
-
-@pytest.mark.parametrize(
-    "stream_slice",
-    [
-        pytest.param({}, id="test_request_option_is_empty_if_empty_stream_slice"),
-        pytest.param({"not the cursor": "value"}, id="test_request_option_is_empty_if_the_stream_slice_does_not_have_cursor_field"),
-        pytest.param(None, id="test_request_option_is_empty_if_no_stream_slice")
-    ]
-)
-def test_request_option_is_empty_if_no_stream_slice(stream_slice):
-    request_option = RequestOption(inject_into=RequestOptionType.body_data, parameters={}, field_name="owner_resource")
-    partition_router = ListPartitionRouter(
-        values=partition_values, cursor_field=cursor_field, config={}, request_option=request_option, parameters={}
-    )
-    assert {} == partition_router.get_request_body_data(stream_slice=stream_slice)
-
-
-@pytest.mark.parametrize(
-    "field_name_interpolation, expected_request_params",
-    [
-        ("{{parameters['partition_name']}}", {"parameters_partition": "customer"}),
-        ("{{config['partition_name']}}", {"config_partition": "customer"}),
-    ],
-    ids=[
-        "parameters_interpolation",
-        "config_interpolation",
-    ],
-)
-def test_request_options_interpolation(field_name_interpolation: str, expected_request_params: dict):
-    config = {"partition_name": "config_partition"}
-    parameters = {"partition_name": "parameters_partition"}
-    request_option = RequestOption(
-        inject_into=RequestOptionType.request_parameter, parameters=parameters, field_name=field_name_interpolation
-    )
-    partition_router = ListPartitionRouter(
-        values=partition_values, cursor_field=cursor_field, config=config, request_option=request_option, parameters=parameters
-    )
-    stream_slice = {cursor_field: "customer"}
-
-    assert expected_request_params == partition_router.get_request_params(stream_slice=stream_slice)
-
-
-def test_request_option_before_updating_cursor():
-    request_option = RequestOption(inject_into=RequestOptionType.request_parameter, parameters={}, field_name="owner_resource")
-    partition_router = ListPartitionRouter(
-        values=partition_values, cursor_field=cursor_field, config={}, request_option=request_option, parameters={}
-    )
-    stream_slice = {cursor_field: "customer"}
-
-    assert {} == partition_router.get_request_params(stream_slice)
-    assert {} == partition_router.get_request_headers()
-    assert {} == partition_router.get_request_body_json()
-    assert {} == partition_router.get_request_body_data()

unit_tests/sources/declarative/partition_routers/test_single_partition_router.py

@@ -1,14 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from airbyte_cdk.sources.declarative.partition_routers.single_partition_router import SinglePartitionRouter
-from airbyte_cdk.sources.declarative.types import StreamSlice
-
-
-def test():
-    iterator = SinglePartitionRouter(parameters={})
-
-    stream_slices = iterator.stream_slices()
-    next_slice = next(stream_slices)
-    assert next_slice == StreamSlice(partition={}, cursor_slice={})

unit_tests/sources/declarative/partition_routers/test_substream_partition_router.py

@@ -1,404 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from typing import Any, Iterable, List, Mapping, Optional, Union
-
-import pytest as pytest
-from airbyte_cdk.models import AirbyteMessage, AirbyteRecordMessage, SyncMode, Type
-from airbyte_cdk.sources.declarative.declarative_stream import DeclarativeStream
-from airbyte_cdk.sources.declarative.incremental.per_partition_cursor import StreamSlice
-from airbyte_cdk.sources.declarative.partition_routers.substream_partition_router import ParentStreamConfig, SubstreamPartitionRouter
-from airbyte_cdk.sources.declarative.requesters.request_option import RequestOption, RequestOptionType
-from airbyte_cdk.sources.declarative.types import Record
-
-parent_records = [{"id": 1, "data": "data1"}, {"id": 2, "data": "data2"}]
-more_records = [{"id": 10, "data": "data10", "slice": "second_parent"}, {"id": 20, "data": "data20", "slice": "second_parent"}]
-
-data_first_parent_slice = [{"id": 0, "slice": "first", "data": "A"}, {"id": 1, "slice": "first", "data": "B"}]
-data_second_parent_slice = [{"id": 2, "slice": "second", "data": "C"}]
-data_third_parent_slice = []
-all_parent_data = data_first_parent_slice + data_second_parent_slice + data_third_parent_slice
-parent_slices = [{"slice": "first"}, {"slice": "second"}, {"slice": "third"}]
-second_parent_stream_slice = [StreamSlice(partition={"slice": "second_parent"}, cursor_slice={})]
-
-
-class MockStream(DeclarativeStream):
-    def __init__(self, slices, records, name):
-        self._slices = slices
-        self._records = records
-        self._name = name
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def primary_key(self) -> Optional[Union[str, List[str], List[List[str]]]]:
-        return "id"
-
-    def stream_slices(
-        self, *, sync_mode: SyncMode, cursor_field: List[str] = None, stream_state: Mapping[str, Any] = None
-    ) -> Iterable[Optional[StreamSlice]]:
-        for s in self._slices:
-            if isinstance(s, StreamSlice):
-                yield s
-            else:
-                yield StreamSlice(partition=s, cursor_slice={})
-
-    def read_records(
-        self,
-        sync_mode: SyncMode,
-        cursor_field: List[str] = None,
-        stream_slice: Mapping[str, Any] = None,
-        stream_state: Mapping[str, Any] = None,
-    ) -> Iterable[Mapping[str, Any]]:
-        # The parent stream's records should always be read as full refresh
-        assert sync_mode == SyncMode.full_refresh
-        if not stream_slice:
-            yield from self._records
-        else:
-            yield from [r for r in self._records if r["slice"] == stream_slice["slice"]]
-
-
-@pytest.mark.parametrize(
-    "parent_stream_configs, expected_slices",
-    [
-        ([], None),
-        (
-            [
-                ParentStreamConfig(
-                    stream=MockStream([{}], [], "first_stream"),
-                    parent_key="id",
-                    partition_field="first_stream_id",
-                    parameters={},
-                    config={},
-                )
-            ],
-            [],
-        ),
-        (
-            [
-                ParentStreamConfig(
-                    stream=MockStream([{}], parent_records, "first_stream"),
-                    parent_key="id",
-                    partition_field="first_stream_id",
-                    parameters={},
-                    config={},
-                )
-            ],
-            [{"first_stream_id": 1, "parent_slice": {}}, {"first_stream_id": 2, "parent_slice": {}}],
-        ),
-        (
-            [
-                ParentStreamConfig(
-                    stream=MockStream(parent_slices, all_parent_data, "first_stream"),
-                    parent_key="id",
-                    partition_field="first_stream_id",
-                    parameters={},
-                    config={},
-                )
-            ],
-            [
-                {"parent_slice": {"slice": "first"}, "first_stream_id": 0},
-                {"parent_slice": {"slice": "first"}, "first_stream_id": 1},
-                {"parent_slice": {"slice": "second"}, "first_stream_id": 2},
-            ],
-        ),
-        (
-                [
-                    ParentStreamConfig(
-                        stream=MockStream([StreamSlice(partition=p, cursor_slice={"start": 0, "end": 1}) for p in parent_slices], all_parent_data, "first_stream"),
-                        parent_key="id",
-                        partition_field="first_stream_id",
-                        parameters={},
-                        config={},
-                    )
-                ],
-                [
-                    {"parent_slice": {"slice": "first"}, "first_stream_id": 0},
-                    {"parent_slice": {"slice": "first"}, "first_stream_id": 1},
-                    {"parent_slice": {"slice": "second"}, "first_stream_id": 2},
-                ],
-        ),
-        (
-            [
-                ParentStreamConfig(
-                    stream=MockStream(parent_slices, data_first_parent_slice + data_second_parent_slice, "first_stream"),
-                    parent_key="id",
-                    partition_field="first_stream_id",
-                    parameters={},
-                    config={},
-                ),
-                ParentStreamConfig(
-                    stream=MockStream(second_parent_stream_slice, more_records, "second_stream"),
-                    parent_key="id",
-                    partition_field="second_stream_id",
-                    parameters={},
-                    config={},
-                ),
-            ],
-            [
-                {"parent_slice": {"slice": "first"}, "first_stream_id": 0},
-                {"parent_slice": {"slice": "first"}, "first_stream_id": 1},
-                {"parent_slice": {"slice": "second"}, "first_stream_id": 2},
-                {"parent_slice": {"slice": "second_parent"}, "second_stream_id": 10},
-                {"parent_slice": {"slice": "second_parent"}, "second_stream_id": 20},
-            ],
-        ),
-        (
-            [
-                ParentStreamConfig(
-                    stream=MockStream([{}], [{"id": 0}, {"id": 1}, {"_id": 2}, {"id": 3}], "first_stream"),
-                    parent_key="id",
-                    partition_field="first_stream_id",
-                    parameters={},
-                    config={},
-                )
-            ],
-            [
-                {"first_stream_id": 0, "parent_slice": {}},
-                {"first_stream_id": 1, "parent_slice": {}},
-                {"first_stream_id": 3, "parent_slice": {}},
-            ],
-        ),
-        (
-            [
-                ParentStreamConfig(
-                    stream=MockStream([{}], [{"a": {"b": 0}}, {"a": {"b": 1}}, {"a": {"c": 2}}, {"a": {"b": 3}}], "first_stream"),
-                    parent_key="a/b",
-                    partition_field="first_stream_id",
-                    parameters={},
-                    config={},
-                )
-            ],
-            [
-                {"first_stream_id": 0, "parent_slice": {}},
-                {"first_stream_id": 1, "parent_slice": {}},
-                {"first_stream_id": 3, "parent_slice": {}},
-            ],
-        ),
-    ],
-    ids=[
-        "test_no_parents",
-        "test_single_parent_slices_no_records",
-        "test_single_parent_slices_with_records",
-        "test_with_parent_slices_and_records",
-        "test_multiple_parent_streams",
-        "test_cursor_values_are_removed_from_parent_slices",
-        "test_missed_parent_key",
-        "test_dpath_extraction",
-    ],
-)
-def test_substream_slicer(parent_stream_configs, expected_slices):
-    if expected_slices is None:
-        try:
-            SubstreamPartitionRouter(parent_stream_configs=parent_stream_configs, parameters={}, config={})
-            assert False
-        except ValueError:
-            return
-    partition_router = SubstreamPartitionRouter(parent_stream_configs=parent_stream_configs, parameters={}, config={})
-    slices = [s for s in partition_router.stream_slices()]
-    assert slices == expected_slices
-
-
-@pytest.mark.parametrize(
-    "parent_stream_request_parameters, expected_req_params, expected_headers, expected_body_json, expected_body_data",
-    [
-        (
-            [
-                RequestOption(inject_into=RequestOptionType.request_parameter, parameters={}, field_name="first_stream"),
-                RequestOption(inject_into=RequestOptionType.request_parameter, parameters={}, field_name="second_stream"),
-            ],
-            {"first_stream": "1234", "second_stream": "4567"},
-            {},
-            {},
-            {},
-        ),
-        (
-            [
-                RequestOption(inject_into=RequestOptionType.header, parameters={}, field_name="first_stream"),
-                RequestOption(inject_into=RequestOptionType.header, parameters={}, field_name="second_stream"),
-            ],
-            {},
-            {"first_stream": "1234", "second_stream": "4567"},
-            {},
-            {},
-        ),
-        (
-            [
-                RequestOption(inject_into=RequestOptionType.request_parameter, parameters={}, field_name="first_stream"),
-                RequestOption(inject_into=RequestOptionType.header, parameters={}, field_name="second_stream"),
-            ],
-            {"first_stream": "1234"},
-            {"second_stream": "4567"},
-            {},
-            {},
-        ),
-        (
-            [
-                RequestOption(inject_into=RequestOptionType.body_json, parameters={}, field_name="first_stream"),
-                RequestOption(inject_into=RequestOptionType.body_json, parameters={}, field_name="second_stream"),
-            ],
-            {},
-            {},
-            {"first_stream": "1234", "second_stream": "4567"},
-            {},
-        ),
-        (
-            [
-                RequestOption(inject_into=RequestOptionType.body_data, parameters={}, field_name="first_stream"),
-                RequestOption(inject_into=RequestOptionType.body_data, parameters={}, field_name="second_stream"),
-            ],
-            {},
-            {},
-            {},
-            {"first_stream": "1234", "second_stream": "4567"},
-        ),
-    ],
-    ids=[
-        "test_request_option_in_request_param",
-        "test_request_option_in_header",
-        "test_request_option_in_param_and_header",
-        "test_request_option_in_body_json",
-        "test_request_option_in_body_data",
-    ],
-)
-def test_request_option(
-    parent_stream_request_parameters,
-    expected_req_params,
-    expected_headers,
-    expected_body_json,
-    expected_body_data,
-):
-    partition_router = SubstreamPartitionRouter(
-        parent_stream_configs=[
-            ParentStreamConfig(
-                stream=MockStream(parent_slices, data_first_parent_slice + data_second_parent_slice, "first_stream"),
-                parent_key="id",
-                partition_field="first_stream_id",
-                parameters={},
-                config={},
-                request_option=parent_stream_request_parameters[0],
-            ),
-            ParentStreamConfig(
-                stream=MockStream(second_parent_stream_slice, more_records, "second_stream"),
-                parent_key="id",
-                partition_field="second_stream_id",
-                parameters={},
-                config={},
-                request_option=parent_stream_request_parameters[1],
-            ),
-        ],
-        parameters={},
-        config={},
-    )
-    stream_slice = {"first_stream_id": "1234", "second_stream_id": "4567"}
-
-    assert expected_req_params == partition_router.get_request_params(stream_slice=stream_slice)
-    assert expected_headers == partition_router.get_request_headers(stream_slice=stream_slice)
-    assert expected_body_json == partition_router.get_request_body_json(stream_slice=stream_slice)
-    assert expected_body_data == partition_router.get_request_body_data(stream_slice=stream_slice)
-
-
-@pytest.mark.parametrize(
-    "field_name_first_stream, field_name_second_stream, expected_request_params",
-    [
-        (
-            "{{parameters['field_name_first_stream']}}",
-            "{{parameters['field_name_second_stream']}}",
-            {"parameter_first_stream_id": "1234", "parameter_second_stream_id": "4567"},
-        ),
-        (
-            "{{config['field_name_first_stream']}}",
-            "{{config['field_name_second_stream']}}",
-            {"config_first_stream_id": "1234", "config_second_stream_id": "4567"},
-        ),
-    ],
-    ids=[
-        "parameters_interpolation",
-        "config_interpolation",
-    ],
-)
-def test_request_params_interpolation_for_parent_stream(
-    field_name_first_stream: str, field_name_second_stream: str, expected_request_params: dict
-):
-    config = {"field_name_first_stream": "config_first_stream_id", "field_name_second_stream": "config_second_stream_id"}
-    parameters = {"field_name_first_stream": "parameter_first_stream_id", "field_name_second_stream": "parameter_second_stream_id"}
-    partition_router = SubstreamPartitionRouter(
-        parent_stream_configs=[
-            ParentStreamConfig(
-                stream=MockStream(parent_slices, data_first_parent_slice + data_second_parent_slice, "first_stream"),
-                parent_key="id",
-                partition_field="first_stream_id",
-                parameters=parameters,
-                config=config,
-                request_option=RequestOption(
-                    inject_into=RequestOptionType.request_parameter, parameters=parameters, field_name=field_name_first_stream
-                ),
-            ),
-            ParentStreamConfig(
-                stream=MockStream(second_parent_stream_slice, more_records, "second_stream"),
-                parent_key="id",
-                partition_field="second_stream_id",
-                parameters=parameters,
-                config=config,
-                request_option=RequestOption(
-                    inject_into=RequestOptionType.request_parameter, parameters=parameters, field_name=field_name_second_stream
-                ),
-            ),
-        ],
-        parameters=parameters,
-        config=config,
-    )
-    stream_slice = {"first_stream_id": "1234", "second_stream_id": "4567"}
-
-    assert expected_request_params == partition_router.get_request_params(stream_slice=stream_slice)
-
-
-def test_given_record_is_airbyte_message_when_stream_slices_then_use_record_data():
-    parent_slice = {}
-    partition_router = SubstreamPartitionRouter(
-        parent_stream_configs=[
-            ParentStreamConfig(
-                stream=MockStream(
-                    [parent_slice],
-                    [
-                        AirbyteMessage(
-                            type=Type.RECORD, record=AirbyteRecordMessage(data={"id": "record value"}, emitted_at=0, stream="stream")
-                        )
-                    ],
-                    "first_stream",
-                ),
-                parent_key="id",
-                partition_field="partition_field",
-                parameters={},
-                config={},
-            )
-        ],
-        parameters={},
-        config={},
-    )
-
-    slices = list(partition_router.stream_slices())
-    assert slices == [{"partition_field": "record value", "parent_slice": parent_slice}]
-
-
-def test_given_record_is_record_object_when_stream_slices_then_use_record_data():
-    parent_slice = {}
-    partition_router = SubstreamPartitionRouter(
-        parent_stream_configs=[
-            ParentStreamConfig(
-                stream=MockStream([parent_slice], [Record({"id": "record value"}, {})], "first_stream"),
-                parent_key="id",
-                partition_field="partition_field",
-                parameters={},
-                config={},
-            )
-        ],
-        parameters={},
-        config={},
-    )
-
-    slices = list(partition_router.stream_slices())
-    assert slices == [{"partition_field": "record value", "parent_slice": parent_slice}]

unit_tests/sources/declarative/requesters/__init__.py

@@ -1,3 +0,0 @@
-#
-# Copyright (c) 2021 Airbyte, Inc., all rights reserved.
-#

unit_tests/sources/declarative/requesters/error_handlers/__init__.py

@@ -1,3 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#

unit_tests/sources/declarative/requesters/error_handlers/backoff_strategies/__init__.py

@@ -1,3 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#

unit_tests/sources/declarative/requesters/error_handlers/backoff_strategies/test_constant_backoff.py

@@ -1,34 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from unittest.mock import MagicMock
-
-import pytest
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.constant_backoff_strategy import ConstantBackoffStrategy
-
-BACKOFF_TIME = 10
-PARAMETERS_BACKOFF_TIME = 20
-CONFIG_BACKOFF_TIME = 30
-
-
-@pytest.mark.parametrize(
-    "test_name, attempt_count, backofftime, expected_backoff_time",
-    [
-        ("test_constant_backoff_first_attempt", 1, BACKOFF_TIME, BACKOFF_TIME),
-        ("test_constant_backoff_first_attempt_float", 1, 6.7, 6.7),
-        ("test_constant_backoff_attempt_round_float", 1.0, 6.7, 6.7),
-        ("test_constant_backoff_attempt_round_float", 1.5, 6.7, 6.7),
-        ("test_constant_backoff_first_attempt_round_float", 1, 10.0, BACKOFF_TIME),
-        ("test_constant_backoff_second_attempt_round_float", 2, 10.0, BACKOFF_TIME),
-        ("test_constant_backoff_from_parameters", 1, "{{ parameters['backoff'] }}", PARAMETERS_BACKOFF_TIME),
-        ("test_constant_backoff_from_config", 1, "{{ config['backoff'] }}", CONFIG_BACKOFF_TIME),
-    ],
-)
-def test_constant_backoff(test_name, attempt_count, backofftime, expected_backoff_time):
-    response_mock = MagicMock()
-    backoff_strategy = ConstantBackoffStrategy(
-        parameters={"backoff": PARAMETERS_BACKOFF_TIME}, backoff_time_in_seconds=backofftime, config={"backoff": CONFIG_BACKOFF_TIME}
-    )
-    backoff = backoff_strategy.backoff(response_mock, attempt_count)
-    assert backoff == expected_backoff_time