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

unit_tests/sources/streams/concurrent/test_default_stream.py

@@ -1,197 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-import unittest
-from unittest.mock import Mock
-
-from airbyte_cdk.models import AirbyteStream, SyncMode
-from airbyte_cdk.sources.message import InMemoryMessageRepository
-from airbyte_cdk.sources.streams.concurrent.availability_strategy import STREAM_AVAILABLE
-from airbyte_cdk.sources.streams.concurrent.cursor import Cursor, FinalStateCursor
-from airbyte_cdk.sources.streams.concurrent.default_stream import DefaultStream
-
-
-class ThreadBasedConcurrentStreamTest(unittest.TestCase):
-    def setUp(self):
-        self._partition_generator = Mock()
-        self._name = "name"
-        self._json_schema = {}
-        self._availability_strategy = Mock()
-        self._primary_key = []
-        self._cursor_field = None
-        self._logger = Mock()
-        self._cursor = Mock(spec=Cursor)
-        self._message_repository = InMemoryMessageRepository()
-        self._stream = DefaultStream(
-            self._partition_generator,
-            self._name,
-            self._json_schema,
-            self._availability_strategy,
-            self._primary_key,
-            self._cursor_field,
-            self._logger,
-            FinalStateCursor(stream_name=self._name, stream_namespace=None, message_repository=self._message_repository),
-        )
-
-    def test_get_json_schema(self):
-        json_schema = self._stream.get_json_schema()
-        assert json_schema == self._json_schema
-
-    def test_check_availability(self):
-        self._availability_strategy.check_availability.return_value = STREAM_AVAILABLE
-        availability = self._stream.check_availability()
-        assert availability == STREAM_AVAILABLE
-        self._availability_strategy.check_availability.assert_called_once_with(self._logger)
-
-    def test_check_for_error_raises_an_exception_if_any_of_the_futures_are_not_done(self):
-        futures = [Mock() for _ in range(3)]
-        for f in futures:
-            f.exception.return_value = None
-        futures[0].done.return_value = False
-
-        with self.assertRaises(Exception):
-            self._stream._check_for_errors(futures)
-
-    def test_check_for_error_raises_an_exception_if_any_of_the_futures_raised_an_exception(self):
-        futures = [Mock() for _ in range(3)]
-        for f in futures:
-            f.exception.return_value = None
-        futures[0].exception.return_value = Exception("error")
-
-        with self.assertRaises(Exception):
-            self._stream._check_for_errors(futures)
-
-    def test_as_airbyte_stream(self):
-        expected_airbyte_stream = AirbyteStream(
-            name=self._name,
-            json_schema=self._json_schema,
-            supported_sync_modes=[SyncMode.full_refresh],
-            source_defined_cursor=None,
-            default_cursor_field=None,
-            source_defined_primary_key=None,
-            namespace=None,
-        )
-        actual_airbyte_stream = self._stream.as_airbyte_stream()
-
-        assert expected_airbyte_stream == actual_airbyte_stream
-
-    def test_as_airbyte_stream_with_primary_key(self):
-        json_schema = {
-            "type": "object",
-            "properties": {
-                "id_a": {"type": ["null", "string"]},
-                "id_b": {"type": ["null", "string"]},
-            },
-        }
-        stream = DefaultStream(
-            self._partition_generator,
-            self._name,
-            json_schema,
-            self._availability_strategy,
-            ["id"],
-            self._cursor_field,
-            self._logger,
-            FinalStateCursor(stream_name=self._name, stream_namespace=None, message_repository=self._message_repository),
-        )
-
-        expected_airbyte_stream = AirbyteStream(
-            name=self._name,
-            json_schema=json_schema,
-            supported_sync_modes=[SyncMode.full_refresh],
-            source_defined_cursor=None,
-            default_cursor_field=None,
-            source_defined_primary_key=[["id"]],
-            namespace=None,
-        )
-
-        airbyte_stream = stream.as_airbyte_stream()
-        assert expected_airbyte_stream == airbyte_stream
-
-    def test_as_airbyte_stream_with_composite_primary_key(self):
-        json_schema = {
-            "type": "object",
-            "properties": {
-                "id_a": {"type": ["null", "string"]},
-                "id_b": {"type": ["null", "string"]},
-            },
-        }
-        stream = DefaultStream(
-            self._partition_generator,
-            self._name,
-            json_schema,
-            self._availability_strategy,
-            ["id_a", "id_b"],
-            self._cursor_field,
-            self._logger,
-            FinalStateCursor(stream_name=self._name, stream_namespace=None, message_repository=self._message_repository),
-        )
-
-        expected_airbyte_stream = AirbyteStream(
-            name=self._name,
-            json_schema=json_schema,
-            supported_sync_modes=[SyncMode.full_refresh],
-            source_defined_cursor=None,
-            default_cursor_field=None,
-            source_defined_primary_key=[["id_a", "id_b"]],
-            namespace=None,
-        )
-
-        airbyte_stream = stream.as_airbyte_stream()
-        assert expected_airbyte_stream == airbyte_stream
-
-    def test_as_airbyte_stream_with_a_cursor(self):
-        json_schema = {
-            "type": "object",
-            "properties": {
-                "id": {"type": ["null", "string"]},
-                "date": {"type": ["null", "string"]},
-            },
-        }
-        stream = DefaultStream(
-            self._partition_generator,
-            self._name,
-            json_schema,
-            self._availability_strategy,
-            self._primary_key,
-            "date",
-            self._logger,
-            FinalStateCursor(stream_name=self._name, stream_namespace=None, message_repository=self._message_repository),
-        )
-
-        expected_airbyte_stream = AirbyteStream(
-            name=self._name,
-            json_schema=json_schema,
-            supported_sync_modes=[SyncMode.full_refresh, SyncMode.incremental],
-            source_defined_cursor=True,
-            default_cursor_field=["date"],
-            source_defined_primary_key=None,
-            namespace=None,
-        )
-
-        airbyte_stream = stream.as_airbyte_stream()
-        assert expected_airbyte_stream == airbyte_stream
-
-    def test_as_airbyte_stream_with_namespace(self):
-        stream = DefaultStream(
-            self._partition_generator,
-            self._name,
-            self._json_schema,
-            self._availability_strategy,
-            self._primary_key,
-            self._cursor_field,
-            self._logger,
-            FinalStateCursor(stream_name=self._name, stream_namespace=None, message_repository=self._message_repository),
-            namespace="test",
-        )
-        expected_airbyte_stream = AirbyteStream(
-            name=self._name,
-            json_schema=self._json_schema,
-            supported_sync_modes=[SyncMode.full_refresh],
-            source_defined_cursor=None,
-            default_cursor_field=None,
-            source_defined_primary_key=None,
-            namespace="test",
-        )
-        actual_airbyte_stream = stream.as_airbyte_stream()
-
-        assert expected_airbyte_stream == actual_airbyte_stream

unit_tests/sources/streams/concurrent/test_partition_enqueuer.py

@@ -1,90 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-import unittest
-from queue import Queue
-from typing import Callable, Iterable, List
-from unittest.mock import Mock, patch
-
-from airbyte_cdk.sources.concurrent_source.partition_generation_completed_sentinel import PartitionGenerationCompletedSentinel
-from airbyte_cdk.sources.concurrent_source.thread_pool_manager import ThreadPoolManager
-from airbyte_cdk.sources.streams.concurrent.abstract_stream import AbstractStream
-from airbyte_cdk.sources.streams.concurrent.partition_enqueuer import PartitionEnqueuer
-from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
-from airbyte_cdk.sources.streams.concurrent.partitions.types import QueueItem
-
-_SOME_PARTITIONS: List[Partition] = [Mock(spec=Partition), Mock(spec=Partition)]
-
-
-class PartitionEnqueuerTest(unittest.TestCase):
-    def setUp(self) -> None:
-        self._queue: Queue[QueueItem] = Queue()
-        self._thread_pool_manager = Mock(spec=ThreadPoolManager)
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit.return_value = False
-        self._partition_generator = PartitionEnqueuer(self._queue, self._thread_pool_manager)
-
-    @patch("airbyte_cdk.sources.streams.concurrent.partition_enqueuer.time.sleep")
-    def test_given_no_partitions_when_generate_partitions_then_do_not_wait(self, mocked_sleep):
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit.return_value = True  # shouldn't be called but just in case
-        stream = self._a_stream([])
-
-        self._partition_generator.generate_partitions(stream)
-
-        assert mocked_sleep.call_count == 0
-
-    def test_given_no_partitions_when_generate_partitions_then_only_push_sentinel(self):
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit.return_value = True
-        stream = self._a_stream([])
-
-        self._partition_generator.generate_partitions(stream)
-
-        assert self._consume_queue() == [PartitionGenerationCompletedSentinel(stream)]
-
-    def test_given_partitions_when_generate_partitions_then_return_partitions_before_sentinel(self):
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit.return_value = False
-        stream = self._a_stream(_SOME_PARTITIONS)
-
-        self._partition_generator.generate_partitions(stream)
-
-        assert self._consume_queue() == _SOME_PARTITIONS + [PartitionGenerationCompletedSentinel(stream)]
-
-    @patch("airbyte_cdk.sources.streams.concurrent.partition_enqueuer.time.sleep")
-    def test_given_partition_but_limit_reached_when_generate_partitions_then_wait_until_not_hitting_limit(self, mocked_sleep):
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit.side_effect = [True, True, False]
-        stream = self._a_stream([Mock(spec=Partition)])
-
-        self._partition_generator.generate_partitions(stream)
-
-        assert mocked_sleep.call_count == 2
-
-    def test_given_exception_when_generate_partitions_then_raise(self):
-        stream = Mock(spec=AbstractStream)
-        exception = ValueError()
-        stream.generate_partitions.side_effect = self._partitions_before_raising(_SOME_PARTITIONS, exception)
-
-        self._partition_generator.generate_partitions(stream)
-
-        assert self._consume_queue() == _SOME_PARTITIONS + [exception]
-
-    def _partitions_before_raising(self, partitions: List[Partition], exception: Exception) -> Callable[[], Iterable[Partition]]:
-        def inner_function() -> Iterable[Partition]:
-            for partition in partitions:
-                yield partition
-            raise exception
-
-        return inner_function
-
-    @staticmethod
-    def _a_stream(partitions: List[Partition]) -> AbstractStream:
-        stream = Mock(spec=AbstractStream)
-        stream.generate_partitions.return_value = iter(partitions)
-        return stream
-
-    def _consume_queue(self) -> List[QueueItem]:
-        queue_content: List[QueueItem] = []
-        while queue_item := self._queue.get():
-            if isinstance(queue_item, (PartitionGenerationCompletedSentinel, Exception)):
-                queue_content.append(queue_item)
-                break
-            queue_content.append(queue_item)
-        return queue_content

unit_tests/sources/streams/concurrent/test_partition_reader.py

@@ -1,67 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-import unittest
-from queue import Queue
-from typing import Callable, Iterable, List
-from unittest.mock import Mock
-
-import pytest
-from airbyte_cdk.sources.streams.concurrent.partition_reader import PartitionReader
-from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
-from airbyte_cdk.sources.streams.concurrent.partitions.record import Record
-from airbyte_cdk.sources.streams.concurrent.partitions.types import PartitionCompleteSentinel, QueueItem
-
-_RECORDS = [
-    Record({"id": 1, "name": "Jack"}, "stream"),
-    Record({"id": 2, "name": "John"}, "stream"),
-]
-
-
-class PartitionReaderTest(unittest.TestCase):
-    def setUp(self) -> None:
-        self._queue: Queue[QueueItem] = Queue()
-        self._partition_reader = PartitionReader(self._queue)
-
-    def test_given_no_records_when_process_partition_then_only_emit_sentinel(self):
-        self._partition_reader.process_partition(self._a_partition([]))
-
-        while queue_item := self._queue.get():
-            if not isinstance(queue_item, PartitionCompleteSentinel):
-                pytest.fail("Only one PartitionCompleteSentinel is expected")
-            break
-
-    def test_given_read_partition_successful_when_process_partition_then_queue_records_and_sentinel(self):
-        self._partition_reader.process_partition(self._a_partition(_RECORDS))
-
-        actual_records = []
-        while queue_item := self._queue.get():
-            if isinstance(queue_item, PartitionCompleteSentinel):
-                break
-            actual_records.append(queue_item)
-
-        assert _RECORDS == actual_records
-
-    def test_given_exception_when_process_partition_then_queue_records_and_raise_exception(self):
-        partition = Mock()
-        exception = ValueError()
-        partition.read.side_effect = self._read_with_exception(_RECORDS, exception)
-
-        self._partition_reader.process_partition(partition)
-
-        for i in range(len(_RECORDS)):
-            assert self._queue.get() == _RECORDS[i]
-        assert self._queue.get() == exception
-
-    def _a_partition(self, records: List[Record]) -> Partition:
-        partition = Mock(spec=Partition)
-        partition.read.return_value = iter(records)
-        return partition
-
-    @staticmethod
-    def _read_with_exception(records: List[Record], exception: Exception) -> Callable[[], Iterable[Record]]:
-        def mocked_function() -> Iterable[Record]:
-            yield from records
-            raise exception
-
-        return mocked_function

unit_tests/sources/streams/concurrent/test_thread_pool_manager.py

@@ -1,106 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-from concurrent.futures import Future, ThreadPoolExecutor
-from unittest import TestCase
-from unittest.mock import Mock
-
-from airbyte_cdk.sources.concurrent_source.thread_pool_manager import ThreadPoolManager
-
-
-class ThreadPoolManagerTest(TestCase):
-    def setUp(self):
-        self._threadpool = Mock(spec=ThreadPoolExecutor)
-        self._thread_pool_manager = ThreadPoolManager(self._threadpool, Mock(), max_concurrent_tasks=1)
-        self._fn = lambda x: x
-        self._arg = "arg"
-
-    def test_submit_calls_underlying_thread_pool(self):
-        self._thread_pool_manager.submit(self._fn, self._arg)
-        self._threadpool.submit.assert_called_with(self._fn, self._arg)
-
-        assert len(self._thread_pool_manager._futures) == 1
-
-    def test_given_no_exceptions_when_shutdown_if_exception_then_do_not_raise(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = None
-        future.done.side_effect = [True, True]
-
-        self._thread_pool_manager._futures = [future]
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit()
-
-        self._thread_pool_manager.shutdown_if_exception()  # do not raise
-
-    def test_given_exception_when_shutdown_if_exception_then_raise(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = RuntimeError
-        future.done.side_effect = [True, True]
-
-        self._thread_pool_manager._futures = [future]
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit()
-
-        with self.assertRaises(RuntimeError):
-            self._thread_pool_manager.shutdown_if_exception()
-
-    def test_given_exception_during_pruning_when_check_for_errors_and_shutdown_then_shutdown_and_raise(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = RuntimeError
-        future.done.side_effect = [True, True]
-
-        self._thread_pool_manager._futures = [future]
-        self._thread_pool_manager.prune_to_validate_has_reached_futures_limit()
-
-        with self.assertRaises(RuntimeError):
-            self._thread_pool_manager.check_for_errors_and_shutdown()
-        self._threadpool.shutdown.assert_called_with(wait=False, cancel_futures=True)
-
-    def test_shutdown(self):
-        self._thread_pool_manager.shutdown()
-        self._threadpool.shutdown.assert_called_with(wait=False, cancel_futures=True)
-
-    def test_is_done_is_false_if_not_all_futures_are_done(self):
-        future = Mock(spec=Future)
-        future.done.return_value = False
-
-        self._thread_pool_manager._futures = [future]
-
-        assert not self._thread_pool_manager.is_done()
-
-    def test_is_done_is_true_if_all_futures_are_done(self):
-        future = Mock(spec=Future)
-        future.done.return_value = True
-
-        self._thread_pool_manager._futures = [future]
-
-        assert self._thread_pool_manager.is_done()
-
-    def test_threadpool_shutdown_if_errors(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = RuntimeError
-
-        self._thread_pool_manager._futures = [future]
-
-        with self.assertRaises(RuntimeError):
-            self._thread_pool_manager.check_for_errors_and_shutdown()
-        self._threadpool.shutdown.assert_called_with(wait=False, cancel_futures=True)
-
-    def test_check_for_errors_and_shutdown_raises_error_if_futures_are_not_done(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = None
-        future.done.return_value = False
-
-        self._thread_pool_manager._futures = [future]
-
-        with self.assertRaises(RuntimeError):
-            self._thread_pool_manager.check_for_errors_and_shutdown()
-        self._threadpool.shutdown.assert_called_with(wait=False, cancel_futures=True)
-
-    def test_check_for_errors_and_shutdown_does_not_raise_error_if_futures_are_done(self):
-        future = Mock(spec=Future)
-        future.exception.return_value = None
-        future.done.return_value = True
-
-        self._thread_pool_manager._futures = [future]
-
-        self._thread_pool_manager.check_for_errors_and_shutdown()
-        self._threadpool.shutdown.assert_called_with(wait=False, cancel_futures=True)

unit_tests/sources/streams/http/auth/test_auth.py

@@ -1,173 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-import logging
-
-import pytest
-from airbyte_cdk.sources.streams.http.auth import (
-    BasicHttpAuthenticator,
-    MultipleTokenAuthenticator,
-    NoAuth,
-    Oauth2Authenticator,
-    TokenAuthenticator,
-)
-
-LOGGER = logging.getLogger(__name__)
-
-
-def test_token_authenticator():
-    """
-    Should match passed in token, no matter how many times token is retrieved.
-    """
-    token = TokenAuthenticator("test-token")
-    header = token.get_auth_header()
-    assert {"Authorization": "Bearer test-token"} == header
-    header = token.get_auth_header()
-    assert {"Authorization": "Bearer test-token"} == header
-
-
-def test_multiple_token_authenticator():
-    token = MultipleTokenAuthenticator(["token1", "token2"])
-    header1 = token.get_auth_header()
-    assert {"Authorization": "Bearer token1"} == header1
-    header2 = token.get_auth_header()
-    assert {"Authorization": "Bearer token2"} == header2
-    header3 = token.get_auth_header()
-    assert {"Authorization": "Bearer token1"} == header3
-
-
-def test_no_auth():
-    """
-    Should always return empty body, no matter how many times token is retrieved.
-    """
-    no_auth = NoAuth()
-    assert {} == no_auth.get_auth_header()
-    no_auth = NoAuth()
-    assert {} == no_auth.get_auth_header()
-
-
-def test_basic_authenticator():
-    token = BasicHttpAuthenticator("client_id", "client_secret")
-    header = token.get_auth_header()
-    assert {"Authorization": "Basic Y2xpZW50X2lkOmNsaWVudF9zZWNyZXQ="} == header
-
-
-class TestOauth2Authenticator:
-    """
-    Test class for OAuth2Authenticator.
-    """
-
-    refresh_endpoint = "https://some_url.com/v1"
-    client_id = "client_id"
-    client_secret = "client_secret"
-    refresh_token = "refresh_token"
-    refresh_access_token_headers = {"Header_1": "value 1", "Header_2": "value 2"}
-    refresh_access_token_authenticator = BasicHttpAuthenticator(client_id, client_secret)
-
-    def test_get_auth_header_fresh(self, mocker):
-        """
-        Should not retrieve new token if current token is valid.
-        """
-        oauth = Oauth2Authenticator(
-            TestOauth2Authenticator.refresh_endpoint,
-            TestOauth2Authenticator.client_id,
-            TestOauth2Authenticator.client_secret,
-            TestOauth2Authenticator.refresh_token,
-        )
-
-        mocker.patch.object(Oauth2Authenticator, "refresh_access_token", return_value=("access_token", 1000))
-        header = oauth.get_auth_header()
-        assert {"Authorization": "Bearer access_token"} == header
-
-    def test_get_auth_header_expired(self, mocker):
-        """
-        Should retrieve new token if current token is expired.
-        """
-        oauth = Oauth2Authenticator(
-            TestOauth2Authenticator.refresh_endpoint,
-            TestOauth2Authenticator.client_id,
-            TestOauth2Authenticator.client_secret,
-            TestOauth2Authenticator.refresh_token,
-        )
-
-        expire_immediately = 0
-        mocker.patch.object(Oauth2Authenticator, "refresh_access_token", return_value=("access_token_1", expire_immediately))
-        oauth.get_auth_header()  # Set the first expired token.
-
-        valid_100_secs = 100
-        mocker.patch.object(Oauth2Authenticator, "refresh_access_token", return_value=("access_token_2", valid_100_secs))
-        header = oauth.get_auth_header()
-        assert {"Authorization": "Bearer access_token_2"} == header
-
-    def test_refresh_request_body(self):
-        """
-        Request body should match given configuration.
-        """
-        scopes = ["scope1", "scope2"]
-        oauth = Oauth2Authenticator(
-            TestOauth2Authenticator.refresh_endpoint,
-            TestOauth2Authenticator.client_id,
-            TestOauth2Authenticator.client_secret,
-            TestOauth2Authenticator.refresh_token,
-            scopes,
-        )
-        body = oauth.get_refresh_request_body()
-        expected = {
-            "grant_type": "refresh_token",
-            "client_id": "client_id",
-            "client_secret": "client_secret",
-            "refresh_token": "refresh_token",
-            "scopes": scopes,
-        }
-        assert body == expected
-
-    def test_refresh_access_token(self, requests_mock):
-        mock_refresh_token_call = requests_mock.post(
-            TestOauth2Authenticator.refresh_endpoint, json={"access_token": "token", "expires_in": 10}
-        )
-
-        oauth = Oauth2Authenticator(
-            TestOauth2Authenticator.refresh_endpoint,
-            TestOauth2Authenticator.client_id,
-            TestOauth2Authenticator.client_secret,
-            TestOauth2Authenticator.refresh_token,
-            refresh_access_token_headers=TestOauth2Authenticator.refresh_access_token_headers,
-        )
-
-        token, expires_in = oauth.refresh_access_token()
-
-        assert isinstance(expires_in, int)
-        assert ("token", 10) == (token, expires_in)
-        for header in self.refresh_access_token_headers:
-            assert header in mock_refresh_token_call.last_request.headers
-            assert self.refresh_access_token_headers[header] == mock_refresh_token_call.last_request.headers[header]
-        assert mock_refresh_token_call.called
-
-    @pytest.mark.parametrize("error_code", (429, 500, 502, 504))
-    def test_refresh_access_token_retry(self, error_code, requests_mock):
-        oauth = Oauth2Authenticator(
-            TestOauth2Authenticator.refresh_endpoint,
-            TestOauth2Authenticator.client_id,
-            TestOauth2Authenticator.client_secret,
-            TestOauth2Authenticator.refresh_token,
-        )
-        requests_mock.post(
-            TestOauth2Authenticator.refresh_endpoint,
-            [{"status_code": error_code}, {"status_code": error_code}, {"json": {"access_token": "token", "expires_in": 10}}],
-        )
-        token, expires_in = oauth.refresh_access_token()
-        assert (token, expires_in) == ("token", 10)
-        assert requests_mock.call_count == 3
-
-    def test_refresh_access_authenticator(self):
-        oauth = Oauth2Authenticator(
-            TestOauth2Authenticator.refresh_endpoint,
-            TestOauth2Authenticator.client_id,
-            TestOauth2Authenticator.client_secret,
-            TestOauth2Authenticator.refresh_token,
-            refresh_access_token_authenticator=TestOauth2Authenticator.refresh_access_token_authenticator,
-        )
-        expected_headers = {"Authorization": "Basic Y2xpZW50X2lkOmNsaWVudF9zZWNyZXQ="}
-        assert expected_headers == oauth.get_refresh_access_token_headers()