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

unit_tests/sources/test_concurrent_source.py

@@ -1,112 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-import concurrent
-import logging
-from typing import Any, Callable, Dict, Iterable, Mapping, Optional, Tuple
-from unittest.mock import Mock
-
-from airbyte_cdk.models import SyncMode
-from airbyte_cdk.sources.concurrent_source.concurrent_source import ConcurrentSource
-from airbyte_cdk.sources.concurrent_source.thread_pool_manager import ThreadPoolManager
-from airbyte_cdk.sources.message import InMemoryMessageRepository, MessageRepository
-from airbyte_cdk.sources.streams.concurrent.abstract_stream import AbstractStream
-from airbyte_cdk.sources.streams.concurrent.availability_strategy import StreamAvailability, StreamAvailable, StreamUnavailable
-from airbyte_cdk.sources.streams.concurrent.cursor import Cursor, FinalStateCursor
-from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
-from airbyte_cdk.sources.streams.concurrent.partitions.record import Record
-from airbyte_protocol.models import AirbyteStream
-
-logger = logging.getLogger("airbyte")
-
-
-class _MockSource(ConcurrentSource):
-    def __init__(
-        self,
-        check_lambda: Callable[[], Tuple[bool, Optional[Any]]] = None,
-        per_stream: bool = True,
-        message_repository: MessageRepository = InMemoryMessageRepository(),
-        threadpool: ThreadPoolManager = ThreadPoolManager(
-            concurrent.futures.ThreadPoolExecutor(max_workers=1, thread_name_prefix="workerpool"), logger
-        ),
-        exception_on_missing_stream: bool = True,
-    ):
-        super().__init__(threadpool, Mock(), Mock(), message_repository)
-        self.check_lambda = check_lambda
-        self.per_stream = per_stream
-        self.exception_on_missing_stream = exception_on_missing_stream
-        self._message_repository = message_repository
-
-
-MESSAGE_FROM_REPOSITORY = Mock()
-
-
-class _MockStream(AbstractStream):
-    def __init__(self, name: str, message_repository: MessageRepository, available: bool = True, json_schema: Dict[str, Any] = {}):
-        self._name = name
-        self._available = available
-        self._json_schema = json_schema
-        self._message_repository = message_repository
-
-    def generate_partitions(self) -> Iterable[Partition]:
-        yield _MockPartition(self._name)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def cursor_field(self) -> Optional[str]:
-        raise NotImplementedError
-
-    def check_availability(self) -> StreamAvailability:
-        if self._available:
-            return StreamAvailable()
-        else:
-            return StreamUnavailable("stream is unavailable")
-
-    def get_json_schema(self) -> Mapping[str, Any]:
-        return self._json_schema
-
-    def as_airbyte_stream(self) -> AirbyteStream:
-        return AirbyteStream(name=self.name, json_schema=self.get_json_schema(), supported_sync_modes=[SyncMode.full_refresh])
-
-    def log_stream_sync_configuration(self) -> None:
-        raise NotImplementedError
-
-    @property
-    def cursor(self) -> Cursor:
-        return FinalStateCursor(stream_name=self._name, stream_namespace=None, message_repository=self._message_repository)
-
-
-class _MockPartition(Partition):
-    def __init__(self, name: str):
-        self._name = name
-        self._closed = False
-
-    def read(self) -> Iterable[Record]:
-        yield from [Record({"key": "value"}, self._name)]
-
-    def to_slice(self) -> Optional[Mapping[str, Any]]:
-        return {}
-
-    def stream_name(self) -> str:
-        return self._name
-
-    def close(self) -> None:
-        self._closed = True
-
-    def is_closed(self) -> bool:
-        return self._closed
-
-    def __hash__(self) -> int:
-        return hash(self._name)
-
-
-def test_concurrent_source_reading_from_no_streams():
-    message_repository = InMemoryMessageRepository()
-    stream = _MockStream("my_stream", message_repository,False, {})
-    source = _MockSource(message_repository=message_repository)
-    messages = []
-    for m in source.read([stream]):
-        messages.append(m)

unit_tests/sources/test_config.py

@@ -1,92 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from typing import List, Union
-
-from airbyte_cdk.sources.config import BaseConfig
-from pydantic import BaseModel, Field
-
-
-class InnerClass(BaseModel):
-    field1: str
-    field2: int
-
-
-class Choice1(BaseModel):
-    selected_strategy = Field("option1", const=True)
-
-    name: str
-    count: int
-
-
-class Choice2(BaseModel):
-    selected_strategy = Field("option2", const=True)
-
-    sequence: List[str]
-
-
-class SomeSourceConfig(BaseConfig):
-    class Config:
-        title = "Some Source"
-
-    items: List[InnerClass]
-    choice: Union[Choice1, Choice2]
-
-
-class TestBaseConfig:
-    EXPECTED_SCHEMA = {
-        "properties": {
-            "choice": {
-                "oneOf": [
-                    {
-                        "properties": {
-                            "count": {"title": "Count", "type": "integer"},
-                            "name": {"title": "Name", "type": "string"},
-                            "selected_strategy": {
-                                "const": "option1",
-                                "title": "Selected " "Strategy",
-                                "type": "string",
-                                "default": "option1",
-                            },
-                        },
-                        "required": ["name", "count"],
-                        "title": "Choice1",
-                        "type": "object",
-                    },
-                    {
-                        "properties": {
-                            "selected_strategy": {
-                                "const": "option2",
-                                "title": "Selected " "Strategy",
-                                "type": "string",
-                                "default": "option2",
-                            },
-                            "sequence": {"items": {"type": "string"}, "title": "Sequence", "type": "array"},
-                        },
-                        "required": ["sequence"],
-                        "title": "Choice2",
-                        "type": "object",
-                    },
-                ],
-                "title": "Choice",
-            },
-            "items": {
-                "items": {
-                    "properties": {"field1": {"title": "Field1", "type": "string"}, "field2": {"title": "Field2", "type": "integer"}},
-                    "required": ["field1", "field2"],
-                    "title": "InnerClass",
-                    "type": "object",
-                },
-                "title": "Items",
-                "type": "array",
-            },
-        },
-        "required": ["items", "choice"],
-        "title": "Some Source",
-        "type": "object",
-    }
-
-    def test_schema_postprocessing(self):
-        schema = SomeSourceConfig.schema()
-        assert schema == self.EXPECTED_SCHEMA

unit_tests/sources/test_connector_state_manager.py

@@ -1,482 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from contextlib import nullcontext as does_not_raise
-from typing import List
-
-import pytest
-from airbyte_cdk.models import (
-    AirbyteMessage,
-    AirbyteStateBlob,
-    AirbyteStateMessage,
-    AirbyteStateType,
-    AirbyteStream,
-    AirbyteStreamState,
-    StreamDescriptor,
-    SyncMode,
-)
-from airbyte_cdk.models import Type as MessageType
-from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager, HashableStreamDescriptor
-
-
-@pytest.mark.parametrize(
-    "input_stream_state, expected_stream_state, expected_error",
-    (
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "actors", "namespace": "public"}, "stream_state": {"id": "mando_michael"}},
-                },
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "actresses", "namespace": "public"}, "stream_state": {"id": "seehorn_rhea"}},
-                },
-            ],
-            {
-                HashableStreamDescriptor(name="actors", namespace="public"): AirbyteStateBlob.parse_obj({"id": "mando_michael"}),
-                HashableStreamDescriptor(name="actresses", namespace="public"): AirbyteStateBlob.parse_obj({"id": "seehorn_rhea"}),
-            },
-            does_not_raise(),
-            id="test_incoming_per_stream_state",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.LEGACY,
-                    "data": {"actors": {"id": "fabian_patrick"}, "actresses": {"id": "seehorn_rhea"}, "writers": {"id": "gilligan_vince"}},
-                }
-            ],
-            {
-                HashableStreamDescriptor(name="actors", namespace="public"): AirbyteStateBlob.parse_obj({"id": "fabian_patrick"}),
-                HashableStreamDescriptor(name="actresses"): AirbyteStateBlob.parse_obj({"id": "seehorn_rhea"}),
-                HashableStreamDescriptor(name="writers"): AirbyteStateBlob.parse_obj({"id": "gilligan_vince"}),
-            },
-            does_not_raise(),
-            id="test_incoming_legacy_state_and_uses_stream_namespace",
-        ),
-        pytest.param([], {}, does_not_raise(), id="test_incoming_empty_stream_state"),
-        pytest.param(
-            [{"type": AirbyteStateType.STREAM, "stream": {"stream_descriptor": {"name": "actresses", "namespace": "public"}}}],
-            {HashableStreamDescriptor(name="actresses", namespace="public"): None},
-            does_not_raise(),
-            id="test_stream_states_that_have_none_state_blob",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.GLOBAL,
-                    "global": {
-                        "shared_state": {"television": "better_call_saul"},
-                        "stream_states": [
-                            {
-                                "stream_descriptor": StreamDescriptor(name="actors", namespace="public"),
-                                "stream_state": AirbyteStateBlob.parse_obj({"id": "mando_michael"}),
-                            },
-                            {
-                                "stream_descriptor": StreamDescriptor(name="actresses", namespace="public"),
-                                "stream_state": AirbyteStateBlob.parse_obj({"id": "seehorn_rhea"}),
-                            },
-                        ],
-                    },
-                },
-            ],
-            {
-                HashableStreamDescriptor(name="actors", namespace="public"): AirbyteStateBlob.parse_obj({"id": "mando_michael"}),
-                HashableStreamDescriptor(name="actresses", namespace="public"): AirbyteStateBlob.parse_obj({"id": "seehorn_rhea"}),
-            },
-            pytest.raises(ValueError),
-            id="test_incoming_global_state_with_shared_state_throws_error",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.GLOBAL,
-                    "global": {
-                        "stream_states": [
-                            {"stream_descriptor": {"name": "actors", "namespace": "public"}, "stream_state": {"id": "mando_michael"}},
-                        ],
-                    },
-                },
-            ],
-            {
-                HashableStreamDescriptor(name="actors", namespace="public"): AirbyteStateBlob.parse_obj({"id": "mando_michael"}),
-            },
-            does_not_raise(),
-            id="test_incoming_global_state_without_shared",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.GLOBAL,
-                    "global": {
-                        "shared_state": None,
-                        "stream_states": [
-                            {
-                                "stream_descriptor": StreamDescriptor(name="actors", namespace="public"),
-                                "stream_state": AirbyteStateBlob.parse_obj({"id": "mando_michael"}),
-                            },
-                        ],
-                    },
-                },
-            ],
-            {
-                HashableStreamDescriptor(name="actors", namespace="public"): AirbyteStateBlob.parse_obj({"id": "mando_michael"}),
-            },
-            does_not_raise(),
-            id="test_incoming_global_state_with_none_shared",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.GLOBAL,
-                    "global": {
-                        "stream_states": [
-                            {"stream_descriptor": {"name": "actresses", "namespace": "public"}},
-                        ],
-                    },
-                },
-            ],
-            {HashableStreamDescriptor(name="actresses", namespace="public"): None},
-            does_not_raise(),
-            id="test_incoming_global_state_without_stream_state",
-        ),
-        pytest.param(
-            {"actors": {"id": "esposito_giancarlo"}, "actresses": {"id": "seehorn_rhea"}},
-            {
-                HashableStreamDescriptor(name="actors", namespace="public"): AirbyteStateBlob.parse_obj({"id": "esposito_giancarlo"}),
-                HashableStreamDescriptor(name="actresses"): AirbyteStateBlob.parse_obj({"id": "seehorn_rhea"}),
-            },
-            does_not_raise(),
-            id="test_incoming_legacy_json_blob_and_uses_stream_namespace",
-        ),
-        pytest.param({}, {}, does_not_raise(), id="test_legacy_state_empty_object"),
-        pytest.param("strings_are_not_allowed", {}, pytest.raises(ValueError), id="test_value_error_is_raised_on_invalid_state_input"),
-    ),
-)
-def test_initialize_state_manager(input_stream_state, expected_stream_state, expected_error):
-    stream_to_instance_map = {
-        "actors": AirbyteStream(
-            name="actors",
-            namespace="public",
-            json_schema={},
-            supported_sync_modes=[SyncMode.full_refresh, SyncMode.incremental],
-        )
-    }
-
-    if isinstance(input_stream_state, List):
-        input_stream_state = [AirbyteStateMessage.parse_obj(state_obj) for state_obj in list(input_stream_state)]
-
-    with expected_error:
-        state_manager = ConnectorStateManager(stream_to_instance_map, input_stream_state)
-
-        assert state_manager.per_stream_states == expected_stream_state
-
-
-@pytest.mark.parametrize(
-    "input_state, stream_name, namespace, expected_state",
-    [
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "users", "namespace": "public"}, "stream_state": {"created_at": 12345}},
-                },
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "accounts", "namespace": "public"}, "stream_state": {"id": "abc"}},
-                },
-            ],
-            "users",
-            "public",
-            {"created_at": 12345},
-            id="test_get_stream_only",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "users"}, "stream_state": {"created_at": 12345}},
-                },
-                {"type": AirbyteStateType.STREAM, "stream": {"stream_descriptor": {"name": "accounts"}, "stream_state": {"id": "abc"}}},
-            ],
-            "users",
-            None,
-            {"created_at": 12345},
-            id="test_get_stream_without_namespace",
-        ),
-        pytest.param(
-            [
-                {"type": AirbyteStateType.STREAM, "stream": {"stream_descriptor": {"name": "users"}}},
-                {"type": AirbyteStateType.STREAM, "stream": {"stream_descriptor": {"name": "accounts"}, "stream_state": {"id": "abc"}}},
-            ],
-            "users",
-            None,
-            {},
-            id="test_get_stream_without_stream_state",
-        ),
-        pytest.param(
-            [{"type": AirbyteStateType.LEGACY, "data": {"users": {"created_at": 12345}, "accounts": {"id": "abc"}}}],
-            "users",
-            "public",
-            {"created_at": 12345},
-            id="test_get_stream_from_legacy_state",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "users", "namespace": "public"}, "stream_state": {"created_at": 12345}},
-                },
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "accounts", "namespace": "public"}, "stream_state": {"id": "abc"}},
-                },
-            ],
-            "missing",
-            "public",
-            {},
-            id="test_get_missing_stream",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "users", "namespace": "public"}, "stream_state": {"created_at": 12345}},
-                },
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "accounts", "namespace": "public"}, "stream_state": {"id": "abc"}},
-                },
-            ],
-            "users",
-            "wrong_namespace",
-            {},
-            id="test_get_stream_wrong_namespace",
-        ),
-        pytest.param([], "users", "public", {}, id="test_get_empty_stream_state_defaults_to_empty_dictionary"),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "users", "namespace": "public"}, "stream_state": None},
-                },
-            ],
-            "users",
-            "public",
-            {},
-            id="test_get_stream_with_stream_state_none_returns_empty_map",
-        ),
-    ],
-)
-def test_get_stream_state(input_state, stream_name, namespace, expected_state):
-    stream_to_instance_map = {
-        stream_name: AirbyteStream(
-            name=stream_name, namespace=namespace, json_schema={}, supported_sync_modes=[SyncMode.full_refresh, SyncMode.incremental]
-        )
-    }
-    state_messages = [AirbyteStateMessage.parse_obj(state_obj) for state_obj in list(input_state)]
-    state_manager = ConnectorStateManager(stream_to_instance_map, state_messages)
-
-    actual_state = state_manager.get_stream_state(stream_name, namespace)
-
-    assert actual_state == expected_state
-
-
-def test_get_state_returns_deep_copy():
-    input_state = [
-        AirbyteStateMessage(
-            type=AirbyteStateType.STREAM,
-            stream=AirbyteStreamState(
-                stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                stream_state=AirbyteStateBlob.parse_obj({"id": [109]}),
-            ),
-        )
-    ]
-    state_manager = ConnectorStateManager({}, input_state)
-
-    per_stream_state = state_manager.get_stream_state("episodes", "public")
-    per_stream_state["id"].append(309)
-
-    assert state_manager.get_stream_state("episodes", "public") == {"id": [109]}
-
-
-@pytest.mark.parametrize(
-    "start_state, update_name, update_namespace, update_value, expected_legacy_state",
-    [
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "actors", "namespace": "public"}, "stream_state": {"id": "mckean_michael"}},
-                },
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "actresses", "namespace": "public"}, "stream_state": {"id": "seehorn_rhea"}},
-                },
-            ],
-            "actors",
-            "public",
-            {"id": "fabian_patrick"},
-            {"actors": {"id": "fabian_patrick"}, "actresses": {"id": "seehorn_rhea"}},
-            id="test_update_existing_stream_state",
-        ),
-        pytest.param(
-            [],
-            "actresses",
-            None,
-            {"id": "seehorn_rhea"},
-            {"actresses": {"id": "seehorn_rhea"}},
-            id="test_update_first_time_sync_without_namespace",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "actresses", "namespace": "public"}, "stream_state": {"id": "seehorn_rhea"}},
-                }
-            ],
-            "actors",
-            "public",
-            {"id": "banks_jonathan"},
-            {"actors": {"id": "banks_jonathan"}, "actresses": {"id": "seehorn_rhea"}},
-            id="test_update_missing_state",
-        ),
-        pytest.param(
-            [
-                {
-                    "type": AirbyteStateType.STREAM,
-                    "stream": {"stream_descriptor": {"name": "actresses", "namespace": "public"}, "stream_state": {"id": "seehorn_rhea"}},
-                }
-            ],
-            "actors",
-            "public",
-            {"id": "banks_jonathan"},
-            {"actors": {"id": "banks_jonathan"}, "actresses": {"id": "seehorn_rhea"}},
-            id="test_ignore_when_per_stream_state_value_is_none",
-        ),
-    ],
-)
-def test_update_state_for_stream(start_state, update_name, update_namespace, update_value, expected_legacy_state):
-    state_messages = [AirbyteStateMessage.parse_obj(state_obj) for state_obj in list(start_state)]
-    state_manager = ConnectorStateManager({}, state_messages)
-
-    state_manager.update_state_for_stream(update_name, update_namespace, update_value)
-
-    assert state_manager.per_stream_states[
-        HashableStreamDescriptor(name=update_name, namespace=update_namespace)
-    ] == AirbyteStateBlob.parse_obj(update_value)
-
-
-@pytest.mark.parametrize(
-    "start_state, update_name, update_namespace, expected_state_message",
-    [
-        pytest.param(
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                        stream_state=AirbyteStateBlob.parse_obj({"created_at": "2022_05_22"}),
-                    ),
-                ),
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="seasons", namespace="public"),
-                        stream_state=AirbyteStateBlob.parse_obj({"id": 1}),
-                    ),
-                ),
-            ],
-            "episodes",
-            "public",
-            AirbyteMessage(
-                type=MessageType.STATE,
-                state=AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                        stream_state=AirbyteStateBlob.parse_obj({"created_at": "2022_05_22"}),
-                    ),
-                ),
-            ),
-            id="test_emit_state_message_with_stream_and_legacy",
-        ),
-        pytest.param(
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                        stream_state=None,
-                    ),
-                ),
-            ],
-            "episodes",
-            "public",
-            AirbyteMessage(
-                type=MessageType.STATE,
-                state=AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                        stream_state=AirbyteStateBlob(),
-                    ),
-                ),
-            ),
-            id="test_always_emit_message_with_stream_state_blob",
-        ),
-        pytest.param(
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                        stream_state=AirbyteStateBlob.parse_obj({"id": 507}),
-                    ),
-                )
-            ],
-            "missing",
-            "public",
-            AirbyteMessage(
-                type=MessageType.STATE,
-                state=AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="missing", namespace="public"), stream_state=AirbyteStateBlob()
-                    ),
-                ),
-            ),
-            id="test_emit_state_nonexistent_stream_name",
-        ),
-        pytest.param(
-            [
-                AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="public"),
-                        stream_state=AirbyteStateBlob.parse_obj({"id": 507}),
-                    ),
-                )
-            ],
-            "episodes",
-            "nonexistent",
-            AirbyteMessage(
-                type=MessageType.STATE,
-                state=AirbyteStateMessage(
-                    type=AirbyteStateType.STREAM,
-                    stream=AirbyteStreamState(
-                        stream_descriptor=StreamDescriptor(name="episodes", namespace="nonexistent"), stream_state=AirbyteStateBlob()
-                    ),
-                ),
-            ),
-            id="test_emit_state_wrong_namespace",
-        ),
-    ],
-)
-def test_create_state_message(start_state, update_name, update_namespace, expected_state_message):
-    state_manager = ConnectorStateManager({}, start_state)
-
-    actual_state_message = state_manager.create_state_message(stream_name=update_name, namespace=update_namespace)
-    assert actual_state_message == expected_state_message