airbyte-cdk 0.72.1__py3-none-any.whl → 6.13.1.dev4106__py3-none-any.whl

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

@@ -1,36 +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.exponential_backoff_strategy import (
-    ExponentialBackoffStrategy,
-)
-
-parameters = {"backoff": 5}
-config = {"backoff": 5}
-
-
-@pytest.mark.parametrize(
-    "test_name, attempt_count, factor, expected_backoff_time",
-    [
-        ("test_exponential_backoff_first_attempt", 1, 5, 10),
-        ("test_exponential_backoff_second_attempt", 2, 5, 20),
-        ("test_exponential_backoff_from_parameters", 2, "{{parameters['backoff']}}", 20),
-        ("test_exponential_backoff_from_config", 2, "{{config['backoff']}}", 20),
-    ],
-)
-def test_exponential_backoff(test_name, attempt_count, factor, expected_backoff_time):
-    response_mock = MagicMock()
-    backoff_strategy = ExponentialBackoffStrategy(factor=factor, parameters=parameters, config=config)
-    backoff = backoff_strategy.backoff(response_mock, attempt_count)
-    assert backoff == expected_backoff_time
-
-
-def test_exponential_backoff_default():
-    response_mock = MagicMock()
-    backoff_strategy = ExponentialBackoffStrategy(parameters=parameters, config=config)
-    backoff = backoff_strategy.backoff(response_mock, 3)
-    assert backoff == 40

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

@@ -1,38 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-import re
-from unittest.mock import MagicMock
-
-import pytest
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.header_helper import get_numeric_value_from_header
-
-
-@pytest.mark.parametrize(
-    "test_name, headers, requested_header, regex, expected_value",
-    [
-        ("test_get_numeric_value_from_header", {"header": 1}, "header", None, 1),
-        ("test_get_numeric_value_float_from_header", {"header": 1.2}, "header", None, 1.2),
-        ("test_get_numeric_value_from_string_value", {"header": "10.9"}, "header", None, 10.9),
-        ("test_get_numeric_value_from_non_numeric", {"header": "60,120"}, "header", None, None),
-        ("test_get_numeric_value_from_missing_header", {"header": 1}, "notheader", None, None),
-        ("test_get_numeric_value_with_regex", {"header": "61,60"}, "header", re.compile("([-+]?\d+)"), 61),  # noqa
-        ("test_get_numeric_value_with_regex_no_header", {"header": "61,60"}, "notheader", re.compile("([-+]?\d+)"), None),  # noqa
-        ("test_get_numeric_value_with_regex_not_matching", {"header": "abc61,60"}, "header", re.compile("([-+]?\d+)"), None),  # noqa
-    ],
-)
-def test_get_numeric_value_from_header(test_name, headers, requested_header, regex, expected_value):
-    response_mock = create_response(headers=headers)
-    numeric_value = get_numeric_value_from_header(response_mock, requested_header, regex)
-    assert numeric_value == expected_value
-
-
-def create_response(headers=None, json_body=None):
-    url = "https://airbyte.io"
-
-    response_mock = MagicMock()
-    response_mock.url = url
-    response_mock.headers = headers or {}
-    response_mock.json.return_value = json_body or {}
-    return response_mock

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

@@ -1,35 +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.wait_time_from_header_backoff_strategy import (
-    WaitTimeFromHeaderBackoffStrategy,
-)
-
-SOME_BACKOFF_TIME = 60
-
-
-@pytest.mark.parametrize(
-    "test_name, header, header_value, regex, expected_backoff_time",
-    [
-        ("test_wait_time_from_header", "wait_time", SOME_BACKOFF_TIME, None, SOME_BACKOFF_TIME),
-        ("test_wait_time_from_header_string", "wait_time", "60", None, SOME_BACKOFF_TIME),
-        ("test_wait_time_from_header_parameters", "{{ parameters['wait_time'] }}", "60", None, SOME_BACKOFF_TIME),
-        ("test_wait_time_from_header_config", "{{ config['wait_time'] }}", "60", None, SOME_BACKOFF_TIME),
-        ("test_wait_time_from_header_not_a_number", "wait_time", "61,60", None, None),
-        ("test_wait_time_from_header_with_regex", "wait_time", "61,60", "([-+]?\d+)", 61),  # noqa
-        ("test_wait_time_fœrom_header_with_regex_no_match", "wait_time", "...", "[-+]?\d+", None),  # noqa
-        ("test_wait_time_from_header", "absent_header", None, None, None),
-    ],
-)
-def test_wait_time_from_header(test_name, header, header_value, regex, expected_backoff_time):
-    response_mock = MagicMock()
-    response_mock.headers = {"wait_time": header_value}
-    backoff_stratery = WaitTimeFromHeaderBackoffStrategy(
-        header=header, regex=regex, parameters={"wait_time": "wait_time"}, config={"wait_time": "wait_time"}
-    )
-    backoff = backoff_stratery.backoff(response_mock, 1)
-    assert backoff == expected_backoff_time

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

@@ -1,64 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.wait_until_time_from_header_backoff_strategy import (
-    WaitUntilTimeFromHeaderBackoffStrategy,
-)
-
-SOME_BACKOFF_TIME = 60
-REGEX = "[-+]?\\d+"
-
-
-@pytest.mark.parametrize(
-    "test_name, header, wait_until, min_wait, regex, expected_backoff_time",
-    [
-        ("test_wait_until_time_from_header", "wait_until", 1600000060.0, None, None, 60),
-        ("test_wait_until_time_from_header_parameters", "{{parameters['wait_until']}}", 1600000060.0, None, None, 60),
-        ("test_wait_until_time_from_header_config", "{{config['wait_until']}}", 1600000060.0, None, None, 60),
-        ("test_wait_until_negative_time", "wait_until", 1500000000.0, None, None, None),
-        ("test_wait_until_time_less_than_min", "wait_until", 1600000060.0, 120, None, 120),
-        ("test_wait_until_no_header", "absent_header", 1600000000.0, None, None, None),
-        ("test_wait_until_time_from_header_not_numeric", "wait_until", "1600000000,1600000000", None, None, None),
-        ("test_wait_until_time_from_header_is_numeric", "wait_until", "1600000060", None, None, 60),
-        ("test_wait_until_time_from_header_with_regex", "wait_until", "1600000060,60", None, "[-+]?\d+", 60),  # noqa
-        ("test_wait_until_time_from_header_with_regex_from_parameters", "wait_until", "1600000060,60", None, "{{parameters['regex']}}", 60),
-        # noqa
-        ("test_wait_until_time_from_header_with_regex_from_config", "wait_until", "1600000060,60", None, "{{config['regex']}}", 60),  # noqa
-        ("test_wait_until_time_from_header_with_regex_no_match", "wait_time", "...", None, "[-+]?\d+", None),  # noqa
-        ("test_wait_until_no_header_with_min", "absent_header", "1600000000.0", SOME_BACKOFF_TIME, None, SOME_BACKOFF_TIME),
-        (
-            "test_wait_until_no_header_with_min_from_parameters",
-            "absent_header",
-            "1600000000.0",
-            "{{parameters['min_wait']}}",
-            None,
-            SOME_BACKOFF_TIME,
-        ),
-        (
-            "test_wait_until_no_header_with_min_from_config",
-            "absent_header",
-            "1600000000.0",
-            "{{config['min_wait']}}",
-            None,
-            SOME_BACKOFF_TIME,
-        ),
-    ],
-)
-@patch("time.time", return_value=1600000000.0)
-def test_wait_untiltime_from_header(time_mock, test_name, header, wait_until, min_wait, regex, expected_backoff_time):
-    response_mock = MagicMock()
-    response_mock.headers = {"wait_until": wait_until}
-    backoff_stratery = WaitUntilTimeFromHeaderBackoffStrategy(
-        header=header,
-        min_wait=min_wait,
-        regex=regex,
-        parameters={"wait_until": "wait_until", "regex": REGEX, "min_wait": SOME_BACKOFF_TIME},
-        config={"wait_until": "wait_until", "regex": REGEX, "min_wait": SOME_BACKOFF_TIME},
-    )
-    backoff = backoff_stratery.backoff(response_mock, 1)
-    assert backoff == expected_backoff_time

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

@@ -1,213 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from unittest.mock import MagicMock
-
-import airbyte_cdk.sources.declarative.requesters.error_handlers.response_status as response_status
-import pytest
-from airbyte_cdk.sources.declarative.requesters.error_handlers import HttpResponseFilter
-from airbyte_cdk.sources.declarative.requesters.error_handlers.composite_error_handler import CompositeErrorHandler
-from airbyte_cdk.sources.declarative.requesters.error_handlers.default_error_handler import DefaultErrorHandler, ResponseStatus
-from airbyte_cdk.sources.declarative.requesters.error_handlers.response_action import ResponseAction
-
-SOME_BACKOFF_TIME = 60
-
-
-@pytest.mark.parametrize(
-    "test_name, first_handler_behavior, second_handler_behavior, expected_behavior",
-    [
-        (
-            "test_chain_retrier_ok_ok",
-            response_status.SUCCESS,
-            response_status.SUCCESS,
-            response_status.SUCCESS,
-        ),
-        (
-            "test_chain_retrier_ignore_fail",
-            response_status.IGNORE,
-            response_status.FAIL,
-            response_status.IGNORE,
-        ),
-        (
-            "test_chain_retrier_fail_ignore",
-            response_status.FAIL,
-            response_status.IGNORE,
-            response_status.IGNORE,
-        ),
-        (
-            "test_chain_retrier_ignore_retry",
-            response_status.IGNORE,
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            response_status.IGNORE,
-        ),
-        (
-            "test_chain_retrier_retry_ignore",
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            response_status.IGNORE,
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-        ),
-        (
-            "test_chain_retrier_retry_fail",
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            response_status.FAIL,
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-        ),
-        (
-            "test_chain_retrier_fail_retry",
-            response_status.FAIL,
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-        ),
-        (
-            "test_chain_retrier_ignore_ok",
-            response_status.IGNORE,
-            response_status.SUCCESS,
-            response_status.IGNORE,
-        ),
-        (
-            "test_chain_retrier_ok_ignore",
-            response_status.SUCCESS,
-            response_status.IGNORE,
-            response_status.SUCCESS,
-        ),
-        (
-            "test_chain_retrier_ok_retry",
-            response_status.SUCCESS,
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            response_status.SUCCESS,
-        ),
-        (
-            "test_chain_retrier_retry_ok",
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            response_status.SUCCESS,
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-        ),
-        (
-            "test_chain_retrier_return_first_retry",
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            ResponseStatus.retry(2 * SOME_BACKOFF_TIME),
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-        ),
-    ],
-)
-def test_composite_error_handler(test_name, first_handler_behavior, second_handler_behavior, expected_behavior):
-    first_error_handler = MagicMock()
-    first_error_handler.interpret_response.return_value = first_handler_behavior
-    second_error_handler = MagicMock()
-    second_error_handler.interpret_response.return_value = second_handler_behavior
-    second_error_handler.interpret_response.return_value = second_handler_behavior
-    retriers = [first_error_handler, second_error_handler]
-    retrier = CompositeErrorHandler(error_handlers=retriers, parameters={})
-    response_mock = MagicMock()
-    response_mock.ok = first_handler_behavior == response_status.SUCCESS or second_handler_behavior == response_status.SUCCESS
-    assert retrier.interpret_response(response_mock) == expected_behavior
-
-
-def test_composite_error_handler_no_handlers():
-    try:
-        CompositeErrorHandler(error_handlers=[], parameters={})
-        assert False
-    except ValueError:
-        pass
-
-
-def test_error_handler_compatibility_simple():
-    status_code = 403
-    expected_action = ResponseAction.IGNORE
-    response_mock = create_response(status_code)
-    default_error_handler = DefaultErrorHandler(
-        config={},
-        parameters={},
-        response_filters=[HttpResponseFilter(action=ResponseAction.IGNORE, http_codes={403}, config={}, parameters={})],
-    )
-    composite_error_handler = CompositeErrorHandler(
-        error_handlers=[
-            DefaultErrorHandler(
-                response_filters=[HttpResponseFilter(action=ResponseAction.IGNORE, http_codes={403}, parameters={}, config={})],
-                parameters={},
-                config={},
-            )
-        ],
-        parameters={},
-    )
-    assert default_error_handler.interpret_response(response_mock).action == expected_action
-    assert composite_error_handler.interpret_response(response_mock).action == expected_action
-
-
-@pytest.mark.parametrize(
-    "test_name, status_code, expected_action",
-    [("test_first_filter", 403, ResponseAction.IGNORE), ("test_second_filter", 404, ResponseAction.FAIL)],
-)
-def test_error_handler_compatibility_multiple_filters(test_name, status_code, expected_action):
-    response_mock = create_response(status_code)
-    error_handler_with_multiple_filters = CompositeErrorHandler(
-        error_handlers=[
-            DefaultErrorHandler(
-                response_filters=[
-                    HttpResponseFilter(action=ResponseAction.IGNORE, http_codes={403}, parameters={}, config={}),
-                    HttpResponseFilter(action=ResponseAction.FAIL, http_codes={404}, parameters={}, config={}),
-                ],
-                parameters={},
-                config={},
-            ),
-        ],
-        parameters={},
-    )
-    composite_error_handler_with_single_filters = CompositeErrorHandler(
-        error_handlers=[
-            DefaultErrorHandler(
-                response_filters=[HttpResponseFilter(action=ResponseAction.IGNORE, http_codes={403}, parameters={}, config={})],
-                parameters={},
-                config={},
-            ),
-            DefaultErrorHandler(
-                response_filters=[HttpResponseFilter(action=ResponseAction.FAIL, http_codes={404}, parameters={}, config={})],
-                parameters={},
-                config={},
-            ),
-        ],
-        parameters={},
-    )
-    actual_action_multiple_filters = error_handler_with_multiple_filters.interpret_response(response_mock).action
-    assert actual_action_multiple_filters == expected_action
-
-    actual_action_single_filters = composite_error_handler_with_single_filters.interpret_response(response_mock).action
-    assert actual_action_single_filters == expected_action
-
-
-def create_response(status_code: int, headers=None, json_body=None):
-    url = "https://airbyte.io"
-
-    response_mock = MagicMock()
-    response_mock.status_code = status_code
-    response_mock.ok = status_code < 400 or status_code >= 600
-    response_mock.url = url
-    response_mock.headers = headers or {}
-    response_mock.json.return_value = json_body or {}
-    return response_mock
-
-
-@pytest.mark.parametrize(
-    "test_name, max_times, expected_max_time",
-    [
-        ("test_single_handler", [10], 10),
-        ("test_multiple_handlers", [10, 15], 15),
-    ],
-)
-def test_max_time_is_max_of_underlying_handlers(test_name, max_times, expected_max_time):
-    composite_error_handler = CompositeErrorHandler(
-        error_handlers=[
-            DefaultErrorHandler(
-                response_filters=[HttpResponseFilter(action=ResponseAction.IGNORE, http_codes={403}, parameters={}, config={})],
-                max_time=max_time,
-                parameters={},
-                config={},
-            )
-            for max_time in max_times
-        ],
-        parameters={},
-    )
-
-    max_time = composite_error_handler.max_time
-    assert max_time == expected_max_time

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

@@ -1,178 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from http import HTTPStatus
-from unittest.mock import MagicMock
-
-import airbyte_cdk.sources.declarative.requesters.error_handlers.response_status as response_status
-import pytest
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.constant_backoff_strategy import ConstantBackoffStrategy
-from airbyte_cdk.sources.declarative.requesters.error_handlers.default_error_handler import (
-    DefaultErrorHandler,
-    HttpResponseFilter,
-    ResponseStatus,
-)
-from airbyte_cdk.sources.declarative.requesters.error_handlers.response_action import ResponseAction
-
-SOME_BACKOFF_TIME = 60
-
-
-@pytest.mark.parametrize(
-    "test_name, http_code, retry_response_filter, ignore_response_filter, response_headers, should_retry, backoff_strategy",
-    [
-        ("test_bad_gateway", HTTPStatus.BAD_GATEWAY, None, None, {}, ResponseStatus.retry(10), None),
-        ("test_too_many_requests", HTTPStatus.TOO_MANY_REQUESTS, None, None, {}, ResponseStatus.retry(10), None),
-        (
-            "test_bad_gateway_constant_retry",
-            HTTPStatus.BAD_GATEWAY,
-            None,
-            None,
-            {},
-            ResponseStatus.retry(SOME_BACKOFF_TIME),
-            [ConstantBackoffStrategy(parameters={}, backoff_time_in_seconds=SOME_BACKOFF_TIME, config={})],
-        ),
-        ("test_exponential_backoff", HTTPStatus.BAD_GATEWAY, None, None, {}, ResponseStatus.retry(10), None),
-        (
-            "test_bad_gateway_exponential_backoff_explicit_parameter",
-            HTTPStatus.BAD_GATEWAY,
-            None,
-            None,
-            {},
-            ResponseStatus.retry(10),
-            [DefaultErrorHandler.DEFAULT_BACKOFF_STRATEGY(parameters={}, config={})],
-        ),
-        ("test_chain_backoff_strategy", HTTPStatus.BAD_GATEWAY, None, None, {}, ResponseStatus.retry(10), None),
-        (
-            "test_bad_gateway_chain_backoff",
-            HTTPStatus.BAD_GATEWAY,
-            None,
-            None,
-            {},
-            ResponseStatus.retry(10),
-            [
-                DefaultErrorHandler.DEFAULT_BACKOFF_STRATEGY(parameters={}, config={}),
-                ConstantBackoffStrategy(parameters={}, backoff_time_in_seconds=SOME_BACKOFF_TIME, config={}),
-            ],
-        ),
-        ("test_200", HTTPStatus.OK, None, None, {}, response_status.SUCCESS, None),
-        ("test_3XX", HTTPStatus.PERMANENT_REDIRECT, None, None, {}, response_status.SUCCESS, None),
-        ("test_403", HTTPStatus.FORBIDDEN, None, None, {}, response_status.FAIL, None),
-        (
-            "test_403_ignore_error_message",
-            HTTPStatus.FORBIDDEN,
-            None,
-            HttpResponseFilter(action=ResponseAction.IGNORE, error_message_contains="found", config={}, parameters={}),
-            {},
-            response_status.IGNORE,
-            None,
-        ),
-        (
-            "test_403_dont_ignore_error_message",
-            HTTPStatus.FORBIDDEN,
-            None,
-            HttpResponseFilter(action=ResponseAction.IGNORE, error_message_contains="not_found", config={}, parameters={}),
-            {},
-            response_status.FAIL,
-            None,
-        ),
-        ("test_429", HTTPStatus.TOO_MANY_REQUESTS, None, None, {}, ResponseStatus.retry(10), None),
-        (
-            "test_ignore_403",
-            HTTPStatus.FORBIDDEN,
-            None,
-            HttpResponseFilter(action=ResponseAction.IGNORE, http_codes={HTTPStatus.FORBIDDEN}, config={}, parameters={}),
-            {},
-            response_status.IGNORE,
-            None,
-        ),
-        (
-            "test_403_with_predicate",
-            HTTPStatus.FORBIDDEN,
-            HttpResponseFilter(action=ResponseAction.RETRY, predicate="{{ 'code' in response }}", config={}, parameters={}),
-            None,
-            {},
-            ResponseStatus.retry(10),
-            None,
-        ),
-        (
-            "test_403_with_predicate",
-            HTTPStatus.FORBIDDEN,
-            HttpResponseFilter(action=ResponseAction.RETRY, predicate="{{ 'some_absent_field' in response }}", config={}, parameters={}),
-            None,
-            {},
-            response_status.FAIL,
-            None,
-        ),
-        (
-            "test_200_fail_with_predicate",
-            HTTPStatus.OK,
-            HttpResponseFilter(action=ResponseAction.FAIL, error_message_contains="found", config={}, parameters={}),
-            None,
-            {},
-            response_status.FAIL,
-            None,
-        ),
-        (
-            "test_retry_403",
-            HTTPStatus.FORBIDDEN,
-            HttpResponseFilter(action=ResponseAction.RETRY, http_codes={HTTPStatus.FORBIDDEN}, config={}, parameters={}),
-            None,
-            {},
-            ResponseStatus.retry(10),
-            None,
-        ),
-        (
-            "test_200_fail_with_predicate_from_header",
-            HTTPStatus.OK,
-            HttpResponseFilter(action=ResponseAction.FAIL, predicate="{{ headers['fail'] }}", config={}, parameters={}),
-            None,
-            {"fail": True},
-            response_status.FAIL,
-            None,
-        ),
-    ],
-)
-def test_default_error_handler(
-    test_name, http_code, retry_response_filter, ignore_response_filter, response_headers, should_retry, backoff_strategy
-):
-    response_mock = create_response(http_code, headers=response_headers, json_body={"code": "1000", "error": "found"})
-    response_mock.ok = http_code < 400
-    response_filters = [f for f in [retry_response_filter, ignore_response_filter] if f]
-    error_handler = DefaultErrorHandler(response_filters=response_filters, backoff_strategies=backoff_strategy, config={}, parameters={})
-    actual_should_retry = error_handler.interpret_response(response_mock)
-    assert actual_should_retry == should_retry
-    if should_retry.action == ResponseAction.RETRY:
-        assert actual_should_retry.retry_in == should_retry.retry_in
-
-
-def test_default_error_handler_attempt_count_increases():
-    status_code = 500
-    response_mock = create_response(status_code)
-    error_handler = DefaultErrorHandler(config={}, parameters={})
-    actual_should_retry = error_handler.interpret_response(response_mock)
-    assert actual_should_retry == ResponseStatus.retry(10)
-    assert actual_should_retry.retry_in == 10
-
-    # This is the same request, so the count should increase
-    actual_should_retry = error_handler.interpret_response(response_mock)
-    assert actual_should_retry == ResponseStatus.retry(20)
-    assert actual_should_retry.retry_in == 20
-
-    # This is a different request, so the count should not increase
-    another_identical_request = create_response(status_code)
-    actual_should_retry = error_handler.interpret_response(another_identical_request)
-    assert actual_should_retry == ResponseStatus.retry(10)
-    assert actual_should_retry.retry_in == 10
-
-
-def create_response(status_code: int, headers=None, json_body=None):
-    url = "https://airbyte.io"
-
-    response_mock = MagicMock()
-    response_mock.status_code = status_code
-    response_mock.ok = status_code < 400 or status_code >= 600
-    response_mock.url = url
-    response_mock.headers = headers or {}
-    response_mock.json.return_value = json_body or {}
-    return response_mock