feat(cli): add docker mode when running FAST tests via CLI

airbyte_cdk/cli/airbyte_cdk/_connector.py

@@ -93,7 +93,7 @@
 
 @click.group(
     name="connector",
-    help=__doc__.replace("\n", "\n\n"),  # Render docstring as help text (markdown)
+    help=__doc__.replace("\n", "\n\n"),  # Render docstring as help text (markdown) # type: ignore
 )
 def connector_cli_group() -> None:
     """Connector related commands."""
@@ -113,10 +113,21 @@ def connector_cli_group() -> None:
     default=False,
     help="Only collect tests, do not run them.",
 )
+@click.option(
+    "--use-docker-image",
+    # is_flag=True,
+    default=False,
+    type=str,
+    help="Run tests via docker.",
+    callback=lambda ctx, param, value: (
+        "true" if value is True else (value if isinstance(value, str) else False)
+    ),
+)
 def test(
     connector: str | Path | None = None,
     *,
     collect_only: bool = False,
+    use_docker_image: str | bool = False,
 ) -> None:
     """Run connector tests.
 
@@ -127,12 +138,20 @@ def test(
 
     If no connector name or directory is provided, we will look within the current working
     directory. If the current working directory is not a connector directory (e.g. starting
-    with 'source-') and no connector name or path is provided, the process will fail.
+    with 'source-' or 'destination-') and no connector name or path is provided, the process
+    will fail.
     """
+    if isinstance(
+        use_docker_image,
+        str,
+    ) and use_docker_image.lower() in {"true", "false"}:
+        use_docker_image = bool(use_docker_image)
+
     if pytest is None:
         raise ImportError(
             "pytest is not installed. Please install pytest to run the connector tests."
         )
+
     click.echo("Connector test command executed.")
     connector_name, connector_directory = resolve_connector_name_and_directory(connector)
 
@@ -157,9 +176,19 @@ def test(
     test_file_path.parent.mkdir(parents=True, exist_ok=True)
     test_file_path.write_text(file_text)
 
+    pytest_args.append("-p airbyte_cdk.test.standard_tests.pytest_hooks")
+
     if collect_only:
         pytest_args.append("--collect-only")
 
+    if use_docker_image:
+        click.echo(f"Using Docker-based test runner...")
+        pytest_args.append("--use-docker-image")
+        if isinstance(use_docker_image, str):
+            pytest_args.append(
+                use_docker_image,
+            )
+
     pytest_args.append(str(test_file_path))
     click.echo(f"Running tests from connector directory: {connector_directory}...")
     click.echo(f"Test file: {test_file_path}")

airbyte_cdk/cli/airbyte_cdk/_image.py

@@ -50,6 +50,10 @@ def build(
 ) -> None:
     """Build a connector Docker image.
 
+    This command builds a Docker image for a connector, using either
+    the connector's Dockerfile or a base image specified in the metadata.
+    The image is built for both AMD64 and ARM64 architectures.
+
     [CONNECTOR] can be a connector name (e.g. 'source-pokeapi'), a path to a connector directory, or omitted to use the current working directory.
     If a string containing '/' is provided, it is treated as a path. Otherwise, it is treated as a connector name.
     """

airbyte_cdk/test/standard_tests/_job_runner.py

@@ -4,15 +4,18 @@
 import logging
 import tempfile
 import uuid
+from abc import abstractmethod
+from collections.abc import Callable
 from dataclasses import asdict
 from pathlib import Path
-from typing import Any, Callable, Literal
+from typing import Any, Literal
 
 import orjson
 from typing_extensions import Protocol, runtime_checkable
 
 from airbyte_cdk.models import (
     ConfiguredAirbyteCatalog,
+    ConnectorSpecification,
     Status,
 )
 from airbyte_cdk.test import entrypoint_wrapper
@@ -50,8 +53,10 @@ class IConnector(Protocol):
     directly on the connector (which doesn't yet exist).
     """
 
-    def spec(self, logger: logging.Logger) -> Any:
+    @abstractmethod
+    def spec(self, logger: logging.Logger) -> ConnectorSpecification:
         """Connectors should have a `spec` method."""
+        ...
 
 
 def run_test_job(

airbyte_cdk/test/standard_tests/connector_base.py

@@ -8,10 +8,10 @@
 import inspect
 import os
 import sys
-from collections.abc import Callable
 from pathlib import Path
-from typing import cast
+from typing import Literal, cast
 
+import pytest
 import yaml
 from boltons.typeutils import classproperty
 
@@ -21,6 +21,7 @@
 )
 from airbyte_cdk.test import entrypoint_wrapper
 from airbyte_cdk.test.standard_tests._job_runner import IConnector, run_test_job
+from airbyte_cdk.test.standard_tests.docker_connectors import DockerConnector
 from airbyte_cdk.test.standard_tests.models import (
     ConnectorTestScenario,
 )
@@ -30,19 +31,43 @@
 )
 
 
+@pytest.fixture
+def use_docker_image(request: pytest.FixtureRequest) -> str | bool:
+    """Fixture to determine if a Docker image should be used for the test."""
+    return request.config.getoption("use_docker_image")
+
+
 class ConnectorTestSuiteBase(abc.ABC):
     """Base class for connector test suites."""
 
-    connector: type[IConnector] | Callable[[], IConnector] | None  # type: ignore [reportRedeclaration]
+    connector_class: type[IConnector] | None = None
     """The connector class or a factory function that returns an scenario of IConnector."""
 
-    @classproperty  # type: ignore [no-redef]
-    def connector(cls) -> type[IConnector] | Callable[[], IConnector] | None:
+    @classmethod
+    def get_test_class_dir(cls) -> Path:
+        """Get the file path that contains the class."""
+        module = sys.modules[cls.__module__]
+        # Get the directory containing the test file
+        return Path(inspect.getfile(module)).parent
+
+    @classmethod
+    def create_connector(
+        cls,
+        scenario: ConnectorTestScenario,
+        *,
+        use_docker_image: str | bool,
+    ) -> IConnector:
+        """Instantiate the connector class."""
         """Get the connector class for the test suite.
 
         This assumes a python connector and should be overridden by subclasses to provide the
         specific connector class to be tested.
         """
+        if use_docker_image:
+            return cls.create_docker_connector(
+                docker_image=use_docker_image,
+            )
+
         connector_root = cls.get_connector_root_dir()
         connector_name = connector_root.absolute().name
 
@@ -65,7 +90,10 @@ def connector(cls) -> type[IConnector] | Callable[[], IConnector] | None:
 
         # Dynamically get the class from the module
         try:
-            return cast(type[IConnector], getattr(module, expected_class_name))
+            return cast(
+                type[IConnector],
+                getattr(module, expected_class_name),
+            )()
         except AttributeError as e:
             # We did not find it based on our expectations, so let's check if we can find it
             # with a case-insensitive match.
@@ -77,43 +105,52 @@ def connector(cls) -> type[IConnector] | Callable[[], IConnector] | None:
                 raise ImportError(
                     f"Module '{expected_module_name}' does not have a class named '{expected_class_name}'."
                 ) from e
-            return cast(type[IConnector], getattr(module, matching_class_name))
-
-    @classmethod
-    def get_test_class_dir(cls) -> Path:
-        """Get the file path that contains the class."""
-        module = sys.modules[cls.__module__]
-        # Get the directory containing the test file
-        return Path(inspect.getfile(module)).parent
+            return cast(
+                type[IConnector],
+                getattr(module, matching_class_name),
+            )()
 
     @classmethod
-    def create_connector(
+    def create_docker_connector(
         cls,
-        scenario: ConnectorTestScenario | None,
+        docker_image: str | Literal[True],
     ) -> IConnector:
-        """Instantiate the connector class."""
-        connector = cls.connector  # type: ignore
-        if connector:
-            if callable(connector) or isinstance(connector, type):
-                # If the connector is a class or factory function, instantiate it:
-                return cast(IConnector, connector())  # type: ignore [redundant-cast]
-
-        # Otherwise, we can't instantiate the connector. Fail with a clear error message.
-        raise NotImplementedError(
-            "No connector class or connector factory function provided. "
-            "Please provide a class or factory function in `cls.connector`, or "
-            "override `cls.create_connector()` to define a custom initialization process."
+        """Create a connector instance using Docker."""
+        if not docker_image:
+            raise ValueError("Docker image is required to create a Docker connector.")
+
+        # Create the connector object by building the connector
+        if docker_image is True:
+            return DockerConnector.from_connector_directory(
+                connector_directory=cls.get_connector_root_dir(),
+            )
+
+        if not isinstance(docker_image, str):
+            raise ValueError(
+                "Expected `docker_image` to be 'True' or of type `str`. "
+                f"Type found: {type(docker_image).__name__}"
+            )
+
+        # Create the connector object using the provided Docker image
+        return DockerConnector(
+            connector_name=cls.get_connector_root_dir().name,
+            docker_image=docker_image,
         )
 
     # Test Definitions
 
     def test_check(
         self,
         scenario: ConnectorTestScenario,
+        *,
+        use_docker_image: str | bool,
     ) -> None:
         """Run `connection` acceptance tests."""
         result: entrypoint_wrapper.EntrypointOutput = run_test_job(
-            self.create_connector(scenario),
+            self.create_connector(
+                scenario,
+                use_docker_image=use_docker_image,
+            ),
             "check",
             test_scenario=scenario,
         )

airbyte_cdk/test/standard_tests/declarative_sources.py

@@ -64,7 +64,9 @@ def components_py_path(cls) -> Path | None:
     @classmethod
     def create_connector(
         cls,
-        scenario: ConnectorTestScenario | None,
+        scenario: ConnectorTestScenario,
+        *,
+        use_docker_image: str | bool,
     ) -> IConnector:
         """Create a connector scenario for the test suite.
 
@@ -74,6 +76,13 @@ def create_connector(
         Subclasses should not need to override this method.
         """
         scenario = scenario or ConnectorTestScenario()  # Use default (empty) scenario if None
+        if use_docker_image:
+            return cls.create_docker_connector(
+                docker_image=use_docker_image,
+            )
+
+        config: dict[str, Any] = scenario.get_config_dict(empty_if_missing=True)
+
         manifest_dict = yaml.safe_load(cls.manifest_yaml_path.read_text())
         config = {
             "__injected_manifest": manifest_dict,