airbyte-cdk 6.45.0.post24.dev14387467928__py3-none-any.whl → 6.45.1.post42.dev14452300548__py3-none-any.whl

airbyte_cdk/test/declarative/test_suites/source_base.py

@@ -1,129 +0,0 @@
-# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
-"""Base class for source test suites."""
-
-from dataclasses import asdict
-from pathlib import Path
-
-import pytest
-
-from airbyte_cdk.models import (
-    AirbyteMessage,
-    AirbyteStream,
-    ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteStream,
-    DestinationSyncMode,
-    SyncMode,
-    Type,
-)
-from airbyte_cdk.test import entrypoint_wrapper
-from airbyte_cdk.test.declarative.models import (
-    ConnectorTestScenario,
-)
-from airbyte_cdk.test.declarative.test_suites.connector_base import (
-    ConnectorTestSuiteBase,
-)
-from airbyte_cdk.test.declarative.utils.job_runner import run_test_job
-
-
-class SourceTestSuiteBase(ConnectorTestSuiteBase):
-    """Base class for source test suites.
-
-    This class provides a base set of functionality for testing source connectors, and it
-    inherits all generic connector tests from the `ConnectorTestSuiteBase` class.
-    """
-
-    def test_check(
-        self,
-        instance: ConnectorTestScenario,
-    ) -> None:
-        """Run `connection` acceptance tests."""
-        result: entrypoint_wrapper.EntrypointOutput = run_test_job(
-            self.create_connector(instance),
-            "check",
-            test_instance=instance,
-        )
-        conn_status_messages: list[AirbyteMessage] = [
-            msg for msg in result._messages if msg.type == Type.CONNECTION_STATUS
-        ]  # noqa: SLF001  # Non-public API
-        assert len(conn_status_messages) == 1, (
-            "Expected exactly one CONNECTION_STATUS message. Got: \n" + "\n".join(result._messages)
-        )
-
-    def test_basic_read(
-        self,
-        instance: ConnectorTestScenario,
-    ) -> None:
-        """Run acceptance tests."""
-        discover_result = run_test_job(
-            self.create_connector(instance),
-            "discover",
-            test_instance=instance,
-        )
-        if instance.expect_exception:
-            assert discover_result.errors, "Expected exception but got none."
-            return
-
-        configured_catalog = ConfiguredAirbyteCatalog(
-            streams=[
-                ConfiguredAirbyteStream(
-                    stream=stream,
-                    sync_mode=SyncMode.full_refresh,
-                    destination_sync_mode=DestinationSyncMode.append_dedup,
-                )
-                for stream in discover_result.catalog.catalog.streams
-            ]
-        )
-        result = run_test_job(
-            self.create_connector(instance),
-            "read",
-            test_instance=instance,
-            catalog=configured_catalog,
-        )
-
-        if not result.records:
-            raise AssertionError("Expected records but got none.")  # noqa: TRY003
-
-    def test_fail_with_bad_catalog(
-        self,
-        instance: ConnectorTestScenario,
-    ) -> None:
-        """Test that a bad catalog fails."""
-        invalid_configured_catalog = ConfiguredAirbyteCatalog(
-            streams=[
-                # Create ConfiguredAirbyteStream which is deliberately invalid
-                # with regard to the Airbyte Protocol.
-                # This should cause the connector to fail.
-                ConfiguredAirbyteStream(
-                    stream=AirbyteStream(
-                        name="__AIRBYTE__stream_that_does_not_exist",
-                        json_schema={
-                            "type": "object",
-                            "properties": {"f1": {"type": "string"}},
-                        },
-                        supported_sync_modes=[SyncMode.full_refresh],
-                    ),
-                    sync_mode="INVALID",
-                    destination_sync_mode="INVALID",
-                )
-            ]
-        )
-        # Set expected status to "failed" to ensure the test fails if the connector.
-        instance.status = "failed"
-        result = self.run_test_scenario(
-            "read",
-            test_scenario=instance,
-            catalog=asdict(invalid_configured_catalog),
-        )
-        assert result.errors, "Expected errors but got none."
-        assert result.trace_messages, "Expected trace messages but got none."
-
-    def test_discover(
-        self,
-        instance: ConnectorTestScenario,
-    ) -> None:
-        """Run acceptance tests."""
-        run_test_job(
-            self.create_connector(instance),
-            "check",
-            test_instance=instance,
-        )

airbyte_cdk/test/declarative/utils/job_runner.py

@@ -1,128 +0,0 @@
-import tempfile
-import uuid
-from pathlib import Path
-from typing import Any, Callable, Literal
-
-import orjson
-
-from airbyte_cdk import Connector
-from airbyte_cdk.models import (
-    Status,
-)
-from airbyte_cdk.sources.abstract_source import AbstractSource
-from airbyte_cdk.sources.declarative.declarative_source import DeclarativeSource
-from airbyte_cdk.test import entrypoint_wrapper
-from airbyte_cdk.test.declarative.models import (
-    ConnectorTestScenario,
-)
-
-
-def run_test_job(
-    connector: Connector | type[Connector] | Callable[[], Connector],
-    verb: Literal["read", "check", "discover"],
-    test_instance: ConnectorTestScenario,
-    *,
-    catalog: dict[str, Any] | None = None,
-) -> entrypoint_wrapper.EntrypointOutput:
-    """Run a test job from provided CLI args and return the result."""
-    if not connector:
-        raise ValueError("Connector is required")
-
-    connector_obj: Connector
-    if isinstance(connector, type):
-        connector_obj = connector()
-    elif isinstance(connector, Connector):
-        connector_obj = connector
-    elif isinstance(connector, DeclarativeSource | AbstractSource):
-        connector_obj = connector
-    elif isinstance(connector, Callable):
-        try:
-            connector_obj = connector()
-        except Exception as ex:
-            if not test_instance.expect_exception:
-                raise
-
-            return entrypoint_wrapper.EntrypointOutput(
-                messages=[],
-                uncaught_exception=ex,
-            )
-    else:
-        raise ValueError(f"Invalid source type: {type(connector)}")
-
-    args: list[str] = [verb]
-    if test_instance.config_path:
-        args += ["--config", str(test_instance.config_path)]
-    elif test_instance.config_dict:
-        config_path = (
-            Path(tempfile.gettempdir()) / "airbyte-test" / f"temp_config_{uuid.uuid4().hex}.json"
-        )
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        config_path.write_text(orjson.dumps(test_instance.config_dict).decode())
-        args += ["--config", str(config_path)]
-
-    catalog_path: Path | None = None
-    if verb not in ["discover", "check"]:
-        # We need a catalog for read.
-        if catalog:
-            # Write the catalog to a temp json file and pass the path to the file as an argument.
-            catalog_path = (
-                Path(tempfile.gettempdir())
-                / "airbyte-test"
-                / f"temp_catalog_{uuid.uuid4().hex}.json"
-            )
-            catalog_path.parent.mkdir(parents=True, exist_ok=True)
-            catalog_path.write_text(orjson.dumps(catalog).decode())
-        elif test_instance.configured_catalog_path:
-            catalog_path = Path(test_instance.configured_catalog_path)
-
-        if catalog_path:
-            args += ["--catalog", str(catalog_path)]
-
-    # This is a bit of a hack because the source needs the catalog early.
-    # Because it *also* can fail, we have ot redundantly wrap it in a try/except block.
-
-    result: entrypoint_wrapper.EntrypointOutput = entrypoint_wrapper._run_command(  # noqa: SLF001  # Non-public API
-        source=connector_obj,
-        args=args,
-        expecting_exception=test_instance.expect_exception,
-    )
-    if result.errors and not test_instance.expect_exception:
-        raise AssertionError(
-            "\n\n".join(
-                [str(err.trace.error).replace("\\n", "\n") for err in result.errors],
-            )
-        )
-
-    if verb == "check":
-        # Check is expected to fail gracefully without an exception.
-        # Instead, we assert that we have a CONNECTION_STATUS message with
-        # a failure status.
-        assert not result.errors, "Expected no errors from check. Got:\n" + "\n".join(
-            [str(error) for error in result.errors]
-        )
-        assert len(result.connection_status_messages) == 1, (
-            "Expected exactly one CONNECTION_STATUS message. Got "
-            f"{len(result.connection_status_messages)}:\n"
-            + "\n".join([str(msg) for msg in result.connection_status_messages])
-        )
-        if test_instance.expect_exception:
-            assert result.connection_status_messages[0].connectionStatus.status == Status.FAILED, (
-                "Expected CONNECTION_STATUS message to be FAILED. Got: \n"
-                + "\n".join([str(msg) for msg in result.connection_status_messages])
-            )
-        return result
-
-    # For all other verbs, we assert check that an exception is raised (or not).
-    if test_instance.expect_exception:
-        if not result.errors:
-            raise AssertionError("Expected exception but got none.")
-
-        return result
-    if result.errors:
-        raise AssertionError(
-            "\n\n".join(
-                [str(err.trace.error).replace("\\n", "\n") for err in result.errors],
-            )
-        )
-
-    return result

airbyte_cdk/test/fixtures/auto.py

@@ -1,14 +0,0 @@
-"""Auto-use fixtures for pytest.
-
-WARNING: Importing this module will automatically apply these fixtures. If you want to selectively
-enable fixtures in a different context, you can import directly from the `fixtures.general` module.
-
-
-Usage:
-
-```python
-from airbyte_cdk.test.fixtures import auto
-# OR
-from airbyte_cdk.test.fixtures.auto import *
-```
-"""

airbyte_cdk/test/pytest_config/plugin.py

@@ -1,46 +0,0 @@
-"""Global pytest configuration for the Airbyte CDK tests."""
-
-from pathlib import Path
-from typing import Optional
-
-import pytest
-
-
-def pytest_collect_file(parent: Optional[pytest.Module], path: Path) -> pytest.Module | None:
-    """Collect test files based on their names."""
-    if path.name == "test_connector.py":
-        return cast(pytest.Module, pytest.Module.from_parent(parent, path=path))
-
-    return None
-
-
-def pytest_configure(config: pytest.Config) -> None:
-    config.addinivalue_line("markers", "connector: mark test as a connector test")
-
-
-def pytest_addoption(parser: pytest.Parser) -> None:
-    parser.addoption(
-        "--run-connector",
-        action="store_true",
-        default=False,
-        help="run connector tests",
-    )
-
-
-def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]) -> None:
-    if config.getoption("--run-connector"):
-        return
-    skip_connector = pytest.mark.skip(reason="need --run-connector option to run")
-    for item in items:
-        if "connector" in item.keywords:
-            item.add_marker(skip_connector)
-
-
-def pytest_runtest_setup(item: pytest.Item) -> None:
-    # This hook is called before each test function is executed
-    print(f"Setting up test: {item.name}")
-
-
-def pytest_runtest_teardown(item: pytest.Item, nextitem: Optional[pytest.Item]) -> None:
-    # This hook is called after each test function is executed
-    print(f"Tearing down test: {item.name}")