robotframework-okw-env-docker 0.1.0__tar.gz

robotframework_okw_env_docker-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: robotframework-okw-env-docker
+Version: 0.1.0
+Summary: Robot Framework library providing OKW environment provisioning with Docker.
+Project-URL: Repository, http://192.168.1.130:3000/Hrabovszki1023/robotframework-okw-env-docker
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: robotframework>=6.0
+Requires-Dist: robotframework-okw-env>=0.1.0
+Requires-Dist: docker>=7.0.0
+Requires-Dist: pyyaml>=6.0
+
+# robotframework-okw-env-docker
+
+Docker Compose provider for [okw-env](http://192.168.1.130:3000/Hrabovszki1023/robotframework-okw-env).
+
+> Deutsche Version: [README_de.md](README_de.md)
+
+## What
+
+Implements the OKW Environment Provider Contract using Docker Compose.
+Generates `docker-compose.yml` from YAML component definitions and
+manages the full container lifecycle (create, start, health check,
+logs, snapshot, stop, destroy).
+
+## Why — Signal vs. NOISE
+
+Docker Compose syntax is NOISE. The tester only writes:
+
+```robot
+ENV_Start        PostgresDB
+ENV_BuildAndRun
+ENV_WaitForReady PostgresDB
+```
+
+The framework generates the Compose file, starts the container,
+and polls the health check. No Docker knowledge required in test code.
+
+## Install
+
+```bash
+pip install robotframework-okw-env-docker
+```
+
+This automatically installs `robotframework-okw-env` (core) and
+`robotframework-docker` (Docker Compose engine).
+
+## Component YAML
+
+```yaml
+PostgresDB:
+  provider: docker
+  image: postgres
+  version: "17"
+  port: 5432
+  env:
+    POSTGRES_DB: testdb
+    POSTGRES_PASSWORD: testpass
+  healthcheck: "pg_isready -U postgres"
+  timeout: 30s
+```
+
+## Minimal Example
+
+```robot
+*** Settings ***
+Library    okw_env.library.OkwEnvLibrary    components_dir=components    WITH NAME    ENV
+
+*** Test Cases ***
+Database Is Reachable
+    ENV_Start        PostgresDB
+    ENV_BuildAndRun
+    ENV_WaitForReady    PostgresDB
+    Log    PostgresDB is ready for testing.
+    [Teardown]    ENV_Stop
+```
+
+## Architecture
+
+```
+okw-env (keywords, YAML loader, registry)
+    │
+    ▼
+okw-env-docker (this library)
+    │
+    ▼
+DockerComposeLibrary (robotframework-docker)
+    │
+    ▼
+Docker Compose CLI → Docker Engine
+```
+
+## Documentation
+
+- [CONTRACT.md](docs/CONTRACT.md) — How this provider implements the contract
+- [SPECIFICATION.md](docs/SPECIFICATION.md) — Lifecycle, isolation, snapshot model
+- [KEYWORDS.md](docs/KEYWORDS.md) — Keyword reference with examples

robotframework_okw_env_docker-0.1.0/README.md

@@ -0,0 +1,85 @@
+# robotframework-okw-env-docker
+
+Docker Compose provider for [okw-env](http://192.168.1.130:3000/Hrabovszki1023/robotframework-okw-env).
+
+> Deutsche Version: [README_de.md](README_de.md)
+
+## What
+
+Implements the OKW Environment Provider Contract using Docker Compose.
+Generates `docker-compose.yml` from YAML component definitions and
+manages the full container lifecycle (create, start, health check,
+logs, snapshot, stop, destroy).
+
+## Why — Signal vs. NOISE
+
+Docker Compose syntax is NOISE. The tester only writes:
+
+```robot
+ENV_Start        PostgresDB
+ENV_BuildAndRun
+ENV_WaitForReady PostgresDB
+```
+
+The framework generates the Compose file, starts the container,
+and polls the health check. No Docker knowledge required in test code.
+
+## Install
+
+```bash
+pip install robotframework-okw-env-docker
+```
+
+This automatically installs `robotframework-okw-env` (core) and
+`robotframework-docker` (Docker Compose engine).
+
+## Component YAML
+
+```yaml
+PostgresDB:
+  provider: docker
+  image: postgres
+  version: "17"
+  port: 5432
+  env:
+    POSTGRES_DB: testdb
+    POSTGRES_PASSWORD: testpass
+  healthcheck: "pg_isready -U postgres"
+  timeout: 30s
+```
+
+## Minimal Example
+
+```robot
+*** Settings ***
+Library    okw_env.library.OkwEnvLibrary    components_dir=components    WITH NAME    ENV
+
+*** Test Cases ***
+Database Is Reachable
+    ENV_Start        PostgresDB
+    ENV_BuildAndRun
+    ENV_WaitForReady    PostgresDB
+    Log    PostgresDB is ready for testing.
+    [Teardown]    ENV_Stop
+```
+
+## Architecture
+
+```
+okw-env (keywords, YAML loader, registry)
+    │
+    ▼
+okw-env-docker (this library)
+    │
+    ▼
+DockerComposeLibrary (robotframework-docker)
+    │
+    ▼
+Docker Compose CLI → Docker Engine
+```
+
+## Documentation
+
+- [CONTRACT.md](docs/CONTRACT.md) — How this provider implements the contract
+- [SPECIFICATION.md](docs/SPECIFICATION.md) — Lifecycle, isolation, snapshot model
+- [KEYWORDS.md](docs/KEYWORDS.md) — Keyword reference with examples

robotframework_okw_env_docker-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "robotframework-okw-env-docker"
+version = "0.1.0"
+description = "Robot Framework library providing OKW environment provisioning with Docker."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "robotframework>=6.0",
+  "robotframework-okw-env>=0.1.0",
+  "docker>=7.0.0",
+  "pyyaml>=6.0"
+]
+
+[project.urls]
+Repository = "http://192.168.1.130:3000/Hrabovszki1023/robotframework-okw-env-docker"
+
+[project.entry-points."okw_env.providers"]
+docker = "okw_env_docker:DockerProvider"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

robotframework_okw_env_docker-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

robotframework_okw_env_docker-0.1.0/src/okw_env_docker/__init__.py

@@ -0,0 +1,4 @@
+from .docker_provider import DockerProvider
+from .library import OkwEnvDockerLibrary
+
+__all__ = ["DockerProvider", "OkwEnvDockerLibrary"]

robotframework_okw_env_docker-0.1.0/src/okw_env_docker/docker_provider.py

@@ -0,0 +1,117 @@
+"""Docker provider for OKW environments.
+
+Uses the Docker Python SDK (docker-py) to communicate directly with the
+Docker Engine API. No local Docker CLI installation required.
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+
+import docker
+
+from okw_env.provider_base import OkwEnvProviderBase
+
+
+class DockerProvider(OkwEnvProviderBase):
+    """Provisions environment components as Docker containers via the Engine API."""
+
+    def __init__(self, base_url: str | None = None, component: dict | None = None):
+        component = component or {}
+        self._base_url = (
+            base_url
+            or component.get("docker_host")
+            or os.environ.get("DOCKER_HOST", "unix:///var/run/docker.sock")
+        )
+        self._client: docker.DockerClient | None = None
+        self._containers: dict[str, docker.models.containers.Container] = {}
+
+    def _get_client(self) -> docker.DockerClient:
+        if self._client is None:
+            self._client = docker.DockerClient(base_url=self._base_url)
+        return self._client
+
+    def create(self, component: dict) -> str:
+        """Pull image and create a container (without starting)."""
+        image = component.get("image", "")
+        version = component.get("version", "latest")
+        full_image = f"{image}:{version}"
+        port = component.get("port")
+        env = component.get("env", {})
+        healthcheck_cmd = component.get("healthcheck")
+        name = f"okw-{uuid.uuid4().hex[:8]}"
+
+        self._get_client().images.pull(image, tag=version)
+
+        ports = {f"{port}/tcp": None} if port else {}
+        env_list = [f"{k}={v}" for k, v in env.items()]
+
+        healthcheck = None
+        if healthcheck_cmd:
+            healthcheck = docker.types.Healthcheck(
+                test=["CMD-SHELL", healthcheck_cmd],
+                interval=5_000_000_000,
+                timeout=3_000_000_000,
+                retries=10,
+            )
+
+        container = self._get_client().containers.create(
+            full_image,
+            name=name,
+            ports=ports,
+            environment=env_list,
+            healthcheck=healthcheck,
+            detach=True,
+        )
+        self._containers[name] = container
+        return name
+
+    def start(self, component_id: str) -> None:
+        container = self._require_container(component_id)
+        container.start()
+
+    def get_runtime_info(self, component_id: str) -> dict:
+        """Read the actual host port assigned by Docker after start."""
+        container = self._require_container(component_id)
+        container.reload()
+        ports = container.attrs.get("NetworkSettings", {}).get("Ports", {})
+        for container_port, bindings in ports.items():
+            if bindings:
+                return {"port": int(bindings[0]["HostPort"])}
+        return {}
+
+    def is_ready(self, component_id: str) -> bool:
+        container = self._require_container(component_id)
+        container.reload()
+        state = container.attrs.get("State", {})
+
+        health = state.get("Health", {})
+        if health:
+            return health.get("Status") == "healthy"
+
+        return state.get("Status") == "running"
+
+    def get_logs(self, component_id: str) -> str:
+        container = self._require_container(component_id)
+        return container.logs().decode("utf-8", errors="replace")
+
+    def snapshot(self, component_id: str) -> str:
+        container = self._require_container(component_id)
+        snapshot_tag = f"{component_id}-snapshot"
+        container.commit(repository=snapshot_tag)
+        return snapshot_tag
+
+    def stop(self, component_id: str) -> None:
+        container = self._require_container(component_id)
+        container.stop(timeout=10)
+
+    def destroy(self, component_id: str) -> None:
+        container = self._require_container(component_id)
+        container.remove(v=True, force=True)
+        del self._containers[component_id]
+
+    def _require_container(self, component_id: str):
+        if component_id not in self._containers:
+            raise KeyError(f"Unknown container '{component_id}'. Active: {list(self._containers.keys())}")
+        return self._containers[component_id]

robotframework_okw_env_docker-0.1.0/src/okw_env_docker/library.py

@@ -0,0 +1,139 @@
+"""OKW Environment Docker Library – Robot Framework keywords for Docker-based environments."""
+
+from __future__ import annotations
+
+from robot.api.deco import library
+
+from okw_env.library import OkwEnvLibrary
+
+from .docker_provider import DockerProvider
+
+
+@library(scope="GLOBAL")
+class OkwEnvDockerLibrary(OkwEnvLibrary):
+    """OKW Environment provisioning for Docker.
+
+    = Zero-Install Architecture =
+
+    This library communicates with the Docker Engine API directly via
+    the [https://docker-py.readthedocs.io/|Docker SDK for Python].
+    **No Docker CLI, no Docker Desktop, no docker-compose installation
+    required** — only ``pip install robotframework-okw-env-docker``
+    and a reachable Docker host.
+
+    This dramatically reduces installation NOISE: every machine that can
+    run Python and reach a Docker host over the network can provision
+    test environments — no admin rights, no platform-specific installers.
+
+    = Connection =
+
+    The Docker host is configured **per component in the YAML file** via
+    the ``docker_host`` key. This is intentional: the connection target is
+    a property of the test environment, not of the test machine. A test
+    suite can mix components on different Docker hosts — or even different
+    providers (Docker + Proxmox) — without any local configuration.
+
+    Resolution order for ``docker_host``:
+
+    | 1. | ``docker_host`` key in component YAML (recommended) |
+    | 2. | ``docker_host`` parameter on the Library constructor (fallback) |
+    | 3. | Environment variable ``DOCKER_HOST`` |
+    | 4. | Default: ``unix:///var/run/docker.sock`` (Linux only) |
+
+    *Why YAML and not a Library parameter?*
+
+    The test machine (Windows laptop, Linux CI runner) should not determine
+    where Docker runs. A developer on Windows and a CI runner on Linux use
+    the same YAML — the connection target stays the same. No ``DOCKER_HOST``
+    environment variable, no platform-specific config, no surprises.
+
+    = Installation =
+
+    | ``pip install robotframework-okw-env-docker`` |
+
+    That's it. One ``pip install``, one IP address in the YAML, test environments ready.
+
+    = Usage =
+
+    | **Settings** |
+    | Library | OkwEnvDockerLibrary | components_dir=components |
+
+    | **Test Cases** |
+    | Webshop mit Datenbank |
+    |     | ENV_Start       | PostgresDB |
+    |     | ENV_BuildAndRun |            |
+    |     | ENV_WaitForReady | PostgresDB |
+    |     | # ... test steps ... |        |
+    |     | [Teardown] | Run Keywords | ENV_SnapshotOnFail | ENV_Stop |
+
+    = Component YAML =
+
+    Each environment component is defined in a YAML file.
+    The ``docker_host`` tells the provider where to connect:
+
+    | ``PostgresDB.yaml`` |
+    | provider: docker |
+    | docker_host: tcp://192.168.1.123:2375 |
+    | image: postgres |
+    | version: "17" |
+    | port: 5432 |
+    | env: |
+    |     POSTGRES_DB: testdb |
+    | healthcheck: "pg_isready -U postgres" |
+    | timeout: 30s |
+
+    = Environment Variables via $MEM{} =
+
+    After ``ENV_BuildAndRun``, **all YAML keys** are published as Robot
+    Framework test variables using dot-notation. This bridges environment
+    provisioning with test keywords — the test knows where to connect
+    without hardcoding anything.
+
+    | *Variable* | *Source* | *Example value* |
+    | ``${PostgresDB.image}`` | YAML key | ``postgres`` |
+    | ``${PostgresDB.version}`` | YAML key | ``17`` |
+    | ``${PostgresDB.port}`` | YAML key | ``5432`` |
+    | ``${PostgresDB.env.POSTGRES_DB}`` | YAML nested key | ``testdb`` |
+    | ``${PostgresDB.env.POSTGRES_PASSWORD}`` | YAML nested key | ``secret`` |
+    | ``${PostgresDB.docker_host}`` | YAML key | ``tcp://192.168.1.123:2375`` |
+    | ``${PostgresDB.ID}`` | Runtime (container ID) | ``okw-3df2dcc8`` |
+
+    Usage in test:
+
+    | ENV_Start       | PostgresDB |
+    | ENV_BuildAndRun |            |
+    | ENV_WaitForReady | PostgresDB |
+    | Log | DB name: ${PostgresDB.env.POSTGRES_DB} |
+    | Log | Port: ${PostgresDB.port} |
+
+    In OKW GUI/API keywords, use ``$MEM{}`` syntax:
+
+    | SetValue | DB_Host | $MEM{PostgresDB.docker_host} |
+    | SetValue | DB_Name | $MEM{PostgresDB.env.POSTGRES_DB} |
+
+    *Design rationale:* The connection data lives in the YAML — not in
+    environment variables, not in CI config, not hardcoded in the test.
+    The same test runs against any Docker host by changing one YAML file.
+
+    = Signal vs. NOISE =
+
+    | *Signal* | *NOISE (hidden)* |
+    | ``ENV_Start PostgresDB`` | Docker API calls, image pull, container config |
+    | ``ENV_WaitForReady PostgresDB`` | Health check polling, timeout logic |
+    | ``${PostgresDB.env.POSTGRES_DB}`` | YAML parsing, variable publishing |
+    | ``ENV_Stop`` | Container stop, remove, volume cleanup |
+
+    The test case reads like a specification. The infrastructure is invisible.
+
+    = Runnable Examples =
+
+    See [https://github.com/Hrabovszki1023/okw-examples|okw-examples]
+    for complete working test suites.
+    """
+
+    ROBOT_LIBRARY_SCOPE = "GLOBAL"
+
+    def __init__(self, components_dir: str | None = None, docker_host: str | None = None):
+        super().__init__(components_dir=components_dir)
+        provider = DockerProvider(base_url=docker_host)
+        self._manager.set_provider(provider)

robotframework_okw_env_docker-0.1.0/src/robotframework_okw_env_docker.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: robotframework-okw-env-docker
+Version: 0.1.0
+Summary: Robot Framework library providing OKW environment provisioning with Docker.
+Project-URL: Repository, http://192.168.1.130:3000/Hrabovszki1023/robotframework-okw-env-docker
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: robotframework>=6.0
+Requires-Dist: robotframework-okw-env>=0.1.0
+Requires-Dist: docker>=7.0.0
+Requires-Dist: pyyaml>=6.0
+
+# robotframework-okw-env-docker
+
+Docker Compose provider for [okw-env](http://192.168.1.130:3000/Hrabovszki1023/robotframework-okw-env).
+
+> Deutsche Version: [README_de.md](README_de.md)
+
+## What
+
+Implements the OKW Environment Provider Contract using Docker Compose.
+Generates `docker-compose.yml` from YAML component definitions and
+manages the full container lifecycle (create, start, health check,
+logs, snapshot, stop, destroy).
+
+## Why — Signal vs. NOISE
+
+Docker Compose syntax is NOISE. The tester only writes:
+
+```robot
+ENV_Start        PostgresDB
+ENV_BuildAndRun
+ENV_WaitForReady PostgresDB
+```
+
+The framework generates the Compose file, starts the container,
+and polls the health check. No Docker knowledge required in test code.
+
+## Install
+
+```bash
+pip install robotframework-okw-env-docker
+```
+
+This automatically installs `robotframework-okw-env` (core) and
+`robotframework-docker` (Docker Compose engine).
+
+## Component YAML
+
+```yaml
+PostgresDB:
+  provider: docker
+  image: postgres
+  version: "17"
+  port: 5432
+  env:
+    POSTGRES_DB: testdb
+    POSTGRES_PASSWORD: testpass
+  healthcheck: "pg_isready -U postgres"
+  timeout: 30s
+```
+
+## Minimal Example
+
+```robot
+*** Settings ***
+Library    okw_env.library.OkwEnvLibrary    components_dir=components    WITH NAME    ENV
+
+*** Test Cases ***
+Database Is Reachable
+    ENV_Start        PostgresDB
+    ENV_BuildAndRun
+    ENV_WaitForReady    PostgresDB
+    Log    PostgresDB is ready for testing.
+    [Teardown]    ENV_Stop
+```
+
+## Architecture
+
+```
+okw-env (keywords, YAML loader, registry)
+    │
+    ▼
+okw-env-docker (this library)
+    │
+    ▼
+DockerComposeLibrary (robotframework-docker)
+    │
+    ▼
+Docker Compose CLI → Docker Engine
+```
+
+## Documentation
+
+- [CONTRACT.md](docs/CONTRACT.md) — How this provider implements the contract
+- [SPECIFICATION.md](docs/SPECIFICATION.md) — Lifecycle, isolation, snapshot model
+- [KEYWORDS.md](docs/KEYWORDS.md) — Keyword reference with examples

robotframework_okw_env_docker-0.1.0/src/robotframework_okw_env_docker.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/okw_env_docker/__init__.py
+src/okw_env_docker/docker_provider.py
+src/okw_env_docker/library.py
+src/robotframework_okw_env_docker.egg-info/PKG-INFO
+src/robotframework_okw_env_docker.egg-info/SOURCES.txt
+src/robotframework_okw_env_docker.egg-info/dependency_links.txt
+src/robotframework_okw_env_docker.egg-info/entry_points.txt
+src/robotframework_okw_env_docker.egg-info/requires.txt
+src/robotframework_okw_env_docker.egg-info/top_level.txt
+tests/test_docker_provider.py
+tests/test_integration_docker.py

robotframework_okw_env_docker-0.1.0/src/robotframework_okw_env_docker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

robotframework_okw_env_docker-0.1.0/src/robotframework_okw_env_docker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[okw_env.providers]
+docker = okw_env_docker:DockerProvider

robotframework_okw_env_docker-0.1.0/src/robotframework_okw_env_docker.egg-info/requires.txt

@@ -0,0 +1,4 @@
+robotframework>=6.0
+robotframework-okw-env>=0.1.0
+docker>=7.0.0
+pyyaml>=6.0

robotframework_okw_env_docker-0.1.0/src/robotframework_okw_env_docker.egg-info/top_level.txt

@@ -0,0 +1 @@
+okw_env_docker

robotframework_okw_env_docker-0.1.0/tests/test_docker_provider.py

@@ -0,0 +1,204 @@
+"""Unit tests for DockerProvider using mocked Docker SDK."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from okw_env_docker.docker_provider import DockerProvider
+
+
+@pytest.fixture
+def mock_client():
+    with patch("okw_env_docker.docker_provider.docker.DockerClient") as mock_cls:
+        client = MagicMock()
+        mock_cls.return_value = client
+        yield client
+
+
+@pytest.fixture
+def provider(mock_client):
+    return DockerProvider(base_url="tcp://fake:2375")
+
+
+@pytest.fixture
+def component():
+    return {
+        "image": "postgres",
+        "version": "16",
+        "port": 5432,
+        "env": {"POSTGRES_PASSWORD": "test"},
+        "healthcheck": "pg_isready -U postgres",
+    }
+
+
+def test_create_pulls_image_and_creates_container(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_client.containers.create.return_value = mock_container
+
+    cid = provider.create(component)
+
+    mock_client.images.pull.assert_called_once_with("postgres", tag="16")
+    mock_client.containers.create.assert_called_once()
+    assert cid.startswith("okw-")
+
+
+def test_create_without_healthcheck(provider, mock_client):
+    mock_client.containers.create.return_value = MagicMock()
+
+    provider.create({"image": "redis", "version": "7"})
+
+    call_kwargs = mock_client.containers.create.call_args[1]
+    assert call_kwargs["healthcheck"] is None
+
+
+def test_create_default_version(provider, mock_client):
+    mock_client.containers.create.return_value = MagicMock()
+
+    provider.create({"image": "nginx"})
+
+    mock_client.images.pull.assert_called_once_with("nginx", tag="latest")
+
+
+def test_start(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    provider.start(cid)
+
+    mock_container.start.assert_called_once()
+
+
+def test_is_ready_healthy(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_container.attrs = {"State": {"Health": {"Status": "healthy"}}}
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    assert provider.is_ready(cid) is True
+    mock_container.reload.assert_called_once()
+
+
+def test_is_ready_unhealthy(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_container.attrs = {"State": {"Health": {"Status": "starting"}}}
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    assert provider.is_ready(cid) is False
+
+
+def test_is_ready_no_healthcheck_running(provider, mock_client):
+    mock_container = MagicMock()
+    mock_container.attrs = {"State": {"Status": "running"}}
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create({"image": "redis"})
+
+    assert provider.is_ready(cid) is True
+
+
+def test_is_ready_no_healthcheck_not_running(provider, mock_client):
+    mock_container = MagicMock()
+    mock_container.attrs = {"State": {"Status": "created"}}
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create({"image": "redis"})
+
+    assert provider.is_ready(cid) is False
+
+
+def test_get_logs(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_container.logs.return_value = b"2024-01-01 LOG: ready"
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    logs = provider.get_logs(cid)
+
+    assert "ready" in logs
+
+
+def test_snapshot(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    tag = provider.snapshot(cid)
+
+    mock_container.commit.assert_called_once_with(repository=f"{cid}-snapshot")
+    assert tag == f"{cid}-snapshot"
+
+
+def test_stop(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    provider.stop(cid)
+
+    mock_container.stop.assert_called_once_with(timeout=10)
+
+
+def test_destroy(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    provider.destroy(cid)
+
+    mock_container.remove.assert_called_once_with(v=True, force=True)
+
+
+def test_destroy_removes_from_tracking(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+    provider.destroy(cid)
+
+    with pytest.raises(KeyError, match="Unknown container"):
+        provider.stop(cid)
+
+
+def test_unknown_container_raises(provider):
+    with pytest.raises(KeyError, match="Unknown container"):
+        provider.start("nonexistent")
+
+
+def test_get_runtime_info_returns_host_port(provider, mock_client, component):
+    mock_container = MagicMock()
+    mock_container.attrs = {
+        "NetworkSettings": {"Ports": {"5432/tcp": [{"HostIp": "0.0.0.0", "HostPort": "49321"}]}}
+    }
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create(component)
+
+    info = provider.get_runtime_info(cid)
+
+    assert info == {"port": 49321}
+
+
+def test_get_runtime_info_no_ports(provider, mock_client):
+    mock_container = MagicMock()
+    mock_container.attrs = {"NetworkSettings": {"Ports": {}}}
+    mock_client.containers.create.return_value = mock_container
+    cid = provider.create({"image": "redis"})
+
+    info = provider.get_runtime_info(cid)
+
+    assert info == {}
+
+
+def test_create_uses_dynamic_host_port(provider, mock_client, component):
+    mock_client.containers.create.return_value = MagicMock()
+    provider.create(component)
+
+    call_kwargs = mock_client.containers.create.call_args[1]
+    assert call_kwargs["ports"] == {"5432/tcp": None}
+
+
+def test_env_var_fallback():
+    with patch("okw_env_docker.docker_provider.docker.DockerClient") as mock_cls, \
+         patch.dict("os.environ", {"DOCKER_HOST": "tcp://envhost:2375"}):
+        mock_cls.return_value = MagicMock()
+        p = DockerProvider()
+        p._get_client()
+        mock_cls.assert_called_once_with(base_url="tcp://envhost:2375")

robotframework_okw_env_docker-0.1.0/tests/test_integration_docker.py

@@ -0,0 +1,73 @@
+"""Integration test against a real Docker host.
+
+Requires: Docker Engine at tcp://192.168.1.123:2375
+Run with: pytest tests/test_integration_docker.py -v -s
+"""
+
+import pytest
+
+from okw_env_docker.docker_provider import DockerProvider
+
+DOCKER_HOST = "tcp://192.168.1.123:2375"
+
+
+@pytest.fixture
+def provider():
+    return DockerProvider(base_url=DOCKER_HOST)
+
+
+@pytest.fixture
+def redis_component():
+    return {
+        "image": "redis",
+        "version": "7",
+        "port": 6379,
+        "healthcheck": "redis-cli ping",
+    }
+
+
+@pytest.fixture
+def redis_container(provider, redis_component):
+    cid = provider.create(redis_component)
+    yield cid
+    try:
+        provider.stop(cid)
+    except Exception:
+        pass
+    try:
+        provider.destroy(cid)
+    except Exception:
+        pass
+
+
+def test_full_lifecycle(provider, redis_component, redis_container):
+    cid = redis_container
+    print(f"\n  Container: {cid}")
+
+    # Start
+    provider.start(cid)
+    print("  Started.")
+
+    # Wait for ready (poll)
+    import time
+    for i in range(30):
+        if provider.is_ready(cid):
+            print(f"  Ready after {i + 1} poll(s).")
+            break
+        time.sleep(1)
+    else:
+        pytest.fail("Container not ready after 30s")
+
+    # Logs
+    logs = provider.get_logs(cid)
+    print(f"  Logs ({len(logs)} chars): {logs[:200]}")
+    assert len(logs) > 0
+
+    # Snapshot
+    tag = provider.snapshot(cid)
+    print(f"  Snapshot: {tag}")
+    assert "snapshot" in tag
+
+    # Stop
+    provider.stop(cid)
+    print("  Stopped.")