robotframework-testcontainers 0.2.0__tar.gz → 0.3.0__tar.gz

{robotframework_testcontainers-0.2.0 → robotframework_testcontainers-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-testcontainers
-Version: 0.2.0
+Version: 0.3.0
 Summary: Robot Framework keywords for Testcontainers.
 Keywords: robotframework,testing,test,automation,container,testcontainers,docker
 Author: Andreas Finkler
@@ -11,10 +11,11 @@ Classifier: Framework :: Robot Framework :: Library
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Testing :: Mocking
 Requires-Dist: robotframework>=7.3.2
-Requires-Dist: testcontainers[generic]>=4.13.2
+Requires-Dist: robotframework-assertion-engine>=5.0.1
+Requires-Dist: testcontainers[generic]>=4.15.0
 Requires-Python: >=3.10
-Project-URL: Documentation, https://dudenr33.github.io/robotframework-testcontainers/
 Project-URL: Repository, https://github.com/DudeNr33/robotframework-testcontainers
+Project-URL: Documentation, https://dudenr33.github.io/robotframework-testcontainers/
 Description-Content-Type: text/markdown
 
 # robotframework-testcontainers
@@ -56,9 +57,9 @@ Basic Usage Example
     Create Docker Container    image=hello-world
 ```
 
-`TestcontainersLibrary` keeps track of all created containers.
-It will take care of stopping all created containers at the end of the test,
-by making use of the `end_test`/`end_suite` listener methods.
+`TestcontainersLibrary` keeps track of all started containers. It stops containers
+started during a test when that test ends, and containers started during suite
+initialization or suite setup when that suite ends.
 
 If you require more control, you can also manually start and stop
 the container. Additionally, you can use different wait strategies
@@ -101,6 +102,36 @@ Starting an CockroachDb Container
 
 You can read the acceptance tests in `test/acceptance/` for more concrete usage examples.
 
+## Failed-test log artifacts
+
+Register the failed-test log collector on the Robot command line to retain stdout and stderr for every active container started through the library. The listener covers every test in the execution, including child suites that do not import `TestcontainersLibrary`:
+
+```shell
+robot \
+  --listener TestcontainersLibrary.FailedTestLogCollector \
+  tests/
+```
+
+By default, artifacts go to `${OUTPUT_DIR}/container-logs`. Pass a different root after the listener name when needed:
+
+```shell
+robot \
+  --listener TestcontainersLibrary.FailedTestLogCollector:/tmp/container-logs \
+  tests/
+```
+
+The listener uses absolute custom paths as written. It resolves relative custom paths from the process working directory, not Robot's output directory.
+
+The log window extends one second before and after the failed test to account for Docker log timing. Each Robot run gets one timestamped directory. Beneath it, the listener preserves the logical suite hierarchy:
+
+```text
+<artifact-root>/<timestamp>/<suite>/<child-suite>/<test>/<container files>
+```
+
+Unsafe path characters and whitespace become underscores. Each container gets separate stdout and stderr files. When collection writes at least one log or error file, `log.html` includes one INFO message with the absolute path to that test's artifact directory. Collection errors do not change the Robot test result.
+
+The files contain raw container logs and may include passwords, tokens, or other secrets. Choose an artifact directory with suitable access and retention controls.
+
 ## License
 
 This project is licensed under the [MIT License](LICENSE).

{robotframework_testcontainers-0.2.0 → robotframework_testcontainers-0.3.0}/README.md

@@ -37,9 +37,9 @@ Basic Usage Example
     Create Docker Container    image=hello-world
 ```
 
-`TestcontainersLibrary` keeps track of all created containers.
-It will take care of stopping all created containers at the end of the test,
-by making use of the `end_test`/`end_suite` listener methods.
+`TestcontainersLibrary` keeps track of all started containers. It stops containers
+started during a test when that test ends, and containers started during suite
+initialization or suite setup when that suite ends.
 
 If you require more control, you can also manually start and stop
 the container. Additionally, you can use different wait strategies
@@ -82,6 +82,36 @@ Starting an CockroachDb Container
 
 You can read the acceptance tests in `test/acceptance/` for more concrete usage examples.
 
+## Failed-test log artifacts
+
+Register the failed-test log collector on the Robot command line to retain stdout and stderr for every active container started through the library. The listener covers every test in the execution, including child suites that do not import `TestcontainersLibrary`:
+
+```shell
+robot \
+  --listener TestcontainersLibrary.FailedTestLogCollector \
+  tests/
+```
+
+By default, artifacts go to `${OUTPUT_DIR}/container-logs`. Pass a different root after the listener name when needed:
+
+```shell
+robot \
+  --listener TestcontainersLibrary.FailedTestLogCollector:/tmp/container-logs \
+  tests/
+```
+
+The listener uses absolute custom paths as written. It resolves relative custom paths from the process working directory, not Robot's output directory.
+
+The log window extends one second before and after the failed test to account for Docker log timing. Each Robot run gets one timestamped directory. Beneath it, the listener preserves the logical suite hierarchy:
+
+```text
+<artifact-root>/<timestamp>/<suite>/<child-suite>/<test>/<container files>
+```
+
+Unsafe path characters and whitespace become underscores. Each container gets separate stdout and stderr files. When collection writes at least one log or error file, `log.html` includes one INFO message with the absolute path to that test's artifact directory. Collection errors do not change the Robot test result.
+
+The files contain raw container logs and may include passwords, tokens, or other secrets. Choose an artifact directory with suitable access and retention controls.
+
 ## License
 
 This project is licensed under the [MIT License](LICENSE).

robotframework_testcontainers-0.3.0/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "robotframework-testcontainers"
+version = "0.3.0"
+description = "Robot Framework keywords for Testcontainers."
+readme = "README.md"
+license = "MIT"
+license-file = "LICENSE"
+keywords = [
+    "robotframework",
+    "testing",
+    "test",
+    "automation",
+    "container",
+    "testcontainers",
+    "docker",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "robotframework>=7.3.2",
+    "robotframework-assertion-engine>=5.0.1",
+    "testcontainers[generic]>=4.15.0",
+]
+classifiers = [
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Library",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Testing :: Mocking",
+]
+
+[[project.authors]]
+name = "Andreas Finkler"
+email = "andi.finkler@gmail.com"
+
+[project.urls]
+Repository = "https://github.com/DudeNr33/robotframework-testcontainers"
+Documentation = "https://dudenr33.github.io/robotframework-testcontainers/"
+
+[build-system]
+requires = ["uv_build>=0.9.5,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv]
+exclude-newer = "7 days"
+
+[tool.uv.audit]
+malware-check = true
+
+[tool.uv.build-backend]
+module-name = "TestcontainersLibrary"
+module-root = "src"
+
+[tool.mypy]
+ignore_missing_imports = true
+strict = true
+
+[dependency-groups]
+dev = [
+    "mypy>=2.3.0",
+    "pre-commit>=4.3.0",
+    "robotframework-requests>=0.9.7",
+    "ruff>=0.14.2",
+    "robotcode[all]>=2.0.1",
+    "testcontainers[cockroachdb,redis]>=4.13.2",
+    "pytest>=9.1.1",
+]

robotframework_testcontainers-0.2.0/pyproject.toml → robotframework_testcontainers-0.3.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "robotframework-testcontainers"
-version = "0.2.0"
+version = "0.3.0"
 description = "Robot Framework keywords for Testcontainers."
 readme = "README.md"
 authors = [{ name = "Andreas Finkler", email = "andi.finkler@gmail.com" }]
@@ -16,7 +16,11 @@ keywords = [
   "docker",
 ]
 requires-python = ">=3.10"
-dependencies = ["robotframework>=7.3.2", "testcontainers[generic]>=4.13.2"]
+dependencies = [
+  "robotframework>=7.3.2",
+  "robotframework-assertion-engine>=5.0.1",
+  "testcontainers[generic]>=4.15.0",
+]
 classifiers = [
   "Framework :: Robot Framework",
   "Framework :: Robot Framework :: Library",
@@ -32,18 +36,23 @@ Documentation = "https://dudenr33.github.io/robotframework-testcontainers/"
 requires = ["uv_build>=0.9.5,<0.10.0"]
 build-backend = "uv_build"
 
+[tool.uv]
+exclude-newer = "7 days"
+audit.malware-check = true
+
 [tool.uv.build-backend]
 module-name = "TestcontainersLibrary"
 module-root = "src"
 
 [dependency-groups]
 dev = [
-  "mypy>=1.18.2",
+  "mypy>=2.3.0",
   "pre-commit>=4.3.0",
   "robotframework-requests>=0.9.7",
   "ruff>=0.14.2",
   "robotcode[all]>=2.0.1",
   "testcontainers[cockroachdb,redis]>=4.13.2",
+  "pytest>=9.1.1",
 ]
 
 [tool.mypy]

robotframework_testcontainers-0.3.0/src/TestcontainersLibrary/__init__.py

@@ -0,0 +1,6 @@
+# ruff: noqa: N999
+
+from TestcontainersLibrary.library import TestcontainersLibrary
+from TestcontainersLibrary.listener import FailedTestLogCollector
+
+__all__ = ["FailedTestLogCollector", "TestcontainersLibrary"]

{robotframework_testcontainers-0.2.0 → robotframework_testcontainers-0.3.0}/src/TestcontainersLibrary/library.py

@@ -1,24 +1,30 @@
 import importlib
+from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal, cast
 
-from robot.api import logger
+from assertionengine import AssertionOperator, verify_assertion
 from robot.api.deco import keyword, library
+
+# see https://github.com/testcontainers/testcontainers-python/blob/main/src/testcontainers/generic.py#L9
+from testcontainers.community.generic import ServerContainer  # type: ignore[attr-defined]  # ruff: isort: skip
 from testcontainers.core.container import DockerContainer
 from testcontainers.core.network import Network
 from testcontainers.core.wait_strategies import HttpWaitStrategy, LogMessageWaitStrategy
-from testcontainers.generic.server import ServerContainer
+
+from TestcontainersLibrary.lifecycle import ResourceLifecycle
+from TestcontainersLibrary.listener import LifecycleListener
 
 
-@library(listener="SELF")
+@library
 class TestcontainersLibrary:
     """
     Keywords for [https://testcontainers.com/|Testcontainers].
     """
 
     def __init__(self) -> None:
-        self._containers: list[DockerContainer] = []
-        self._networks: list[Network] = []
+        self._resources = ResourceLifecycle.for_execution()
+        self.ROBOT_LIBRARY_LISTENER = LifecycleListener(self._resources)
 
     @keyword
     def create_docker_container(
@@ -105,7 +111,7 @@ class TestcontainersLibrary:
         """
         _module = importlib.import_module(module)
         clazz = getattr(_module, container_class)
-        container = clazz(**kwargs)
+        container = cast(DockerContainer, clazz(**kwargs))
         if start:
             self.start_container(container)
         return container
@@ -125,13 +131,58 @@ class TestcontainersLibrary:
         """
         Start the given container.
         """
-        try:
-            container.start()
-            self._containers.append(container)
-            return container
-        except Exception:
-            container.stop()
-            raise
+        return self._resources.start_container(container)
+
+    @keyword
+    def get_container_logs(
+        self,
+        container: DockerContainer,
+        assertion_operator: AssertionOperator | None = None,
+        assertion_expected: Any = None,
+        message: str = "",
+        custom_message: str | None = None,
+        stream: Literal["stdout", "stderr"] = "stdout",
+        since: datetime | None = None,
+        until: datetime | None = None,
+        timestamps: bool = False,
+    ) -> str:
+        """
+        Return a managed container's stdout or stderr.
+
+        Stdout is selected by default. Set ``stream=stderr`` to retrieve stderr.
+        Pass absolute datetimes with ``since`` and ``until`` to bound the logs.
+        Set ``timestamps=True`` to include Docker timestamps in each line. Pass
+        assertion-engine arguments after the container to assert against the selected
+        container log.
+
+        Examples:
+        | ${stderr}= | Get Container Logs | ${container} | stream=stderr |         |
+        |            | Get Container Logs | ${container} | contains      | started |
+        | ${logs}=   | Get Container Logs | ${container} | since=${start} | timestamps=${True} |
+        """
+        wrapped_container = container.get_wrapped_container()
+
+        stdout = stream == "stdout"
+        stderr = stream == "stderr"
+        log_bytes = wrapped_container.logs(
+            stdout=stdout,
+            stderr=stderr,
+            since=since,
+            until=until,
+            timestamps=timestamps,
+        )
+
+        container_log = log_bytes.decode("utf-8", errors="replace")
+        return cast(
+            str,
+            verify_assertion(
+                container_log,
+                assertion_operator,
+                assertion_expected,
+                message,
+                custom_message,
+            ),
+        )
 
     @keyword
     def wait_for_log_message(
@@ -164,31 +215,27 @@ class TestcontainersLibrary:
         Stop the given container.
 
         It is not required to call this keyword manually just to clean up after tests.
-        The library instance will take care of stopping all containers it has
-        started during it's lifecycle via listener methods.
+        The library stops containers automatically when the Robot test or suite
+        that started them ends.
         """
-        self._containers.remove(container)
-        container.stop()
+        self._resources.stop_container(container)
 
     @keyword
     def create_network(self) -> Network:
         """
         Create a network to connect different containers with each other.
 
-        Created networks are cleaned up automatically at the end of the test/suite.
+        Created networks are cleaned up when the Robot test or suite that created
+        them ends.
         """
-        network = Network()
-        network.create()
-        self._networks.append(network)
-        return network
+        return self._resources.create_network()
 
     @keyword
     def remove_network(self, network: Network) -> None:
         """
         Delete the given network.
         """
-        self._networks.remove(network)
-        network.remove()
+        self._resources.remove_network(network)
 
     @keyword
     def connect_container_to_network(
@@ -204,29 +251,3 @@ class TestcontainersLibrary:
         if container_id is None:
             raise ValueError("Failed to obtain ID of wrapped container")
         network.connect(container_id=container_id, network_aliases=aliases)
-
-    def _end_test(self, name: Any, attrs: Any) -> None:
-        for container in self._containers.copy():
-            cname = container.get_wrapped_container().name
-            logger.console(
-                f"\n\tTestcontainersLibrary: stopping container {cname} in end_test hook."
-            )
-            self.stop_container(container)
-        for network in self._networks.copy():
-            logger.console(
-                f"\n\tTestcontainersLibrary: removing network {network.id} in end_test hook."
-            )
-            self.remove_network(network)
-
-    def _end_suite(self, name: Any, attrs: Any) -> None:
-        for container in self._containers.copy():
-            cname = container.get_wrapped_container().name
-            logger.console(
-                f"\n\tTestcontainersLibrary: stopping container {cname} in end_suite hook."
-            )
-            self.stop_container(container)
-        for network in self._networks.copy():
-            logger.console(
-                f"\n\tTestcontainersLibrary: removing network {network.id} in end_suite hook."
-            )
-            self.remove_network(network)

robotframework_testcontainers-0.3.0/src/TestcontainersLibrary/lifecycle.py

@@ -0,0 +1,151 @@
+from dataclasses import dataclass
+from typing import ClassVar, Literal, cast
+
+from robot.api import logger
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.network import Network
+
+CleanupHook = Literal["end_test", "end_suite"]
+
+
+@dataclass(frozen=True)
+class ResourceOwner:
+    kind: Literal["suite", "test"]
+    longname: str
+
+
+@dataclass
+class ManagedResource:
+    kind: Literal["container", "network"]
+    resource: DockerContainer | Network
+    owner: ResourceOwner | None
+
+
+class ResourceLifecycle:
+    """Track resources for one Robot execution and clean them by owner."""
+
+    _execution: ClassVar["ResourceLifecycle | None"] = None
+
+    def __init__(self) -> None:
+        self._resources: list[ManagedResource] = []
+        self._active_owner: ResourceOwner | None = None
+
+    @classmethod
+    def for_execution(cls) -> "ResourceLifecycle":
+        if cls._execution is None:
+            cls._execution = cls()
+        return cls._execution
+
+    def enter_suite(self, longname: str) -> None:
+        self._active_owner = ResourceOwner("suite", longname)
+
+    def enter_test(self, longname: str) -> None:
+        self._active_owner = ResourceOwner("test", longname)
+
+    def clear_owner(self) -> None:
+        self._active_owner = None
+
+    def start_container(self, container: DockerContainer) -> DockerContainer:
+        owner = self._require_active_owner()
+        try:
+            container.start()
+            self._resources.append(ManagedResource("container", container, owner))
+            return container
+        except Exception:
+            container.stop()
+            raise
+
+    def stop_container(self, container: DockerContainer) -> None:
+        container.stop()
+        self._remove_resource(container)
+
+    def active_containers(self) -> tuple[DockerContainer, ...]:
+        return tuple(
+            cast(DockerContainer, resource.resource)
+            for resource in self._resources
+            if resource.kind == "container"
+        )
+
+    def create_network(self) -> Network:
+        owner = self._require_active_owner()
+        network = Network()
+        network.create()
+        self._resources.append(ManagedResource("network", network, owner))
+        return network
+
+    def remove_network(self, network: Network) -> None:
+        network.remove()
+        self._remove_resource(network)
+
+    def cleanup_test(self, longname: str) -> None:
+        self._cleanup_owner(ResourceOwner("test", longname), "end_test")
+
+    def cleanup_suite(self, longname: str) -> None:
+        self._cleanup_owner(ResourceOwner("suite", longname), "end_suite")
+
+    def cleanup(self, hook: CleanupHook) -> None:
+        self._cleanup_resources(self._resources.copy(), hook)
+
+    def _cleanup_owner(self, owner: ResourceOwner, hook: CleanupHook) -> None:
+        self._cleanup_resources(
+            [
+                managed_resource
+                for managed_resource in self._resources
+                if managed_resource.owner == owner
+            ],
+            hook,
+        )
+
+    def _cleanup_resources(
+        self,
+        managed_resources: list[ManagedResource],
+        hook: CleanupHook,
+    ) -> None:
+        first_error: Exception | None = None
+        for kind in ("container", "network"):
+            for managed_resource in managed_resources:
+                if managed_resource.kind != kind:
+                    continue
+                try:
+                    self._cleanup_resource(managed_resource, hook)
+                except Exception as error:  # noqa: BLE001
+                    logger.error(
+                        f"TestcontainersLibrary: failed to clean up {kind}: {error}"
+                    )
+                    if first_error is None:
+                        first_error = error
+        if first_error is not None:
+            raise first_error
+
+    def _cleanup_resource(
+        self, managed_resource: ManagedResource, hook: CleanupHook
+    ) -> None:
+        resource = managed_resource.resource
+        if managed_resource.kind == "container":
+            container = cast(DockerContainer, resource)
+            name = container.get_wrapped_container().name
+            logger.console(
+                f"\n\tTestcontainersLibrary: stopping container {name} in {hook} hook."
+            )
+            self.stop_container(container)
+        else:
+            network = cast(Network, resource)
+            logger.console(
+                f"\n\tTestcontainersLibrary: removing network {network.id} in {hook} hook."
+            )
+            self.remove_network(network)
+
+    def _require_active_owner(self) -> ResourceOwner:
+        if self._active_owner is None:
+            raise RuntimeError(
+                "Containers and networks can only be started during Robot suite "
+                "setup or test execution."
+            )
+        return self._active_owner
+
+    def _remove_resource(self, resource: DockerContainer | Network) -> None:
+        for managed_resource in self._resources:
+            if managed_resource.resource is resource:
+                self._resources.remove(managed_resource)
+                return
+        raise ValueError("Resource is not managed by this library execution.")

robotframework_testcontainers-0.3.0/src/TestcontainersLibrary/listener.py

@@ -0,0 +1,112 @@
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, cast
+
+from robot.api import logger
+from robot.libraries.BuiltIn import BuiltIn
+
+from TestcontainersLibrary.lifecycle import ResourceLifecycle
+from TestcontainersLibrary.log_capture import FailedTestLogCapture, safe_path_component
+
+
+class FailedTestLogCollector:
+    """Collect active container logs when any test in the execution fails."""
+
+    ROBOT_LISTENER_API_VERSION = 3
+
+    def __init__(self, artifact_root: str | None = None) -> None:
+        if artifact_root == "":
+            raise ValueError("artifact root must not be empty")
+
+        root = Path(artifact_root) if artifact_root is not None else None
+        if root is not None and not root.is_absolute():
+            root = Path.cwd() / root
+        if root is not None and root.exists() and not root.is_dir():
+            raise ValueError(f"artifact root is not a directory: {root}")
+
+        self._resources = ResourceLifecycle.for_execution()
+        self._artifact_root = root
+        self._run_directory: Path | None = None
+        self._capture = FailedTestLogCapture()
+
+    def end_test(self, data: Any, result: Any) -> None:
+        if result.status != "FAIL":
+            return
+        try:
+            artifact_directory = self._artifact_directory(data, result)
+            wrote_artifact = self._capture.write(
+                artifact_directory,
+                result.start_time,
+                result.end_time,
+                self._resources.active_containers(),
+            )
+            if wrote_artifact:
+                logger.info(
+                    "TestcontainersLibrary: failed-test container logs written to "
+                    f"{artifact_directory}"
+                )
+        except Exception:  # noqa: BLE001
+            # Log collection must never change Robot's test result.
+            return
+
+    def _artifact_directory(self, data: Any, result: Any) -> Path:
+        if self._run_directory is None:
+            self._run_directory = self._artifact_root_for_execution() / self._timestamp(
+                result.start_time
+            )
+
+        directory = self._run_directory
+        for suite_name in self._suite_names(result):
+            directory /= safe_path_component(suite_name)
+        return directory / safe_path_component(data.name)
+
+    def _artifact_root_for_execution(self) -> Path:
+        if self._artifact_root is None:
+            output_directory = cast(str, BuiltIn().get_variable_value("${OUTPUT_DIR}"))
+            self._artifact_root = Path(output_directory) / "container-logs"
+        return self._artifact_root
+
+    @staticmethod
+    def _suite_names(result: Any) -> list[str]:
+        # Suite names can contain dots, so splitting longname would lose the
+        # boundaries in Robot's logical suite hierarchy.
+        names: list[str] = []
+        suite = result.parent
+        while suite is not None:
+            names.append(suite.name)
+            suite = suite.parent
+        names.reverse()
+        return names
+
+    @staticmethod
+    def _timestamp(start_time: datetime) -> str:
+        if start_time.tzinfo is None:
+            start_time = start_time.astimezone()
+        return start_time.astimezone(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+
+
+class LifecycleListener:
+    """Forward Robot Framework lifecycle events to resource cleanup."""
+
+    ROBOT_LISTENER_API_VERSION = 3
+
+    def __init__(self, resources: ResourceLifecycle) -> None:
+        self._resources = resources
+
+    def start_suite(self, data: Any, result: Any) -> None:
+        self._resources.enter_suite(result.longname)
+
+    def start_test(self, data: Any, result: Any) -> None:
+        self._resources.enter_test(result.longname)
+
+    def end_test(self, data: Any, result: Any) -> None:
+        try:
+            self._resources.cleanup_test(result.longname)
+        finally:
+            self._resources.clear_owner()
+
+    def end_suite(self, data: Any, result: Any) -> None:
+        try:
+            self._resources.cleanup_suite(result.longname)
+        finally:
+            self._resources.clear_owner()

robotframework_testcontainers-0.3.0/src/TestcontainersLibrary/log_capture.py

@@ -0,0 +1,93 @@
+import re
+from collections.abc import Iterable
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from testcontainers.core.container import DockerContainer
+
+
+def safe_path_component(value: str) -> str:
+    sanitized = re.sub(r"[^A-Za-z0-9._-]+", "_", value).strip("._-")
+    return sanitized or "unnamed"
+
+
+class FailedTestLogCapture:
+    """Write active containers' logs when a Robot test fails."""
+
+    _time_tolerance = timedelta(seconds=1)
+
+    def write(
+        self,
+        artifact_directory: Path,
+        start_time: datetime,
+        end_time: datetime,
+        containers: Iterable[DockerContainer],
+    ) -> bool:
+        containers = tuple(containers)
+        if not containers:
+            return False
+
+        try:
+            artifact_directory.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            return False
+
+        wrote_artifact = False
+        for container in containers:
+            wrote_artifact = (
+                self._write_container_logs(
+                    container, artifact_directory, start_time, end_time
+                )
+                or wrote_artifact
+            )
+        return wrote_artifact
+
+    def _write_container_logs(
+        self,
+        container: DockerContainer,
+        artifact_directory: Path,
+        start_time: datetime,
+        end_time: datetime,
+    ) -> bool:
+        try:
+            wrapped_container = container.get_wrapped_container()
+            name = safe_path_component(wrapped_container.name or "container")
+            if wrapped_container.id is None:
+                raise KeyError(f"No ID found on container object {wrapped_container}.")
+            container_id = wrapped_container.id[:12]
+            filename = f"{name}-{container_id}"
+        except Exception as error:  # noqa: BLE001
+            return self._write_collection_error(
+                artifact_directory / "container.error.txt", error
+            )
+
+        wrote_artifact = False
+        for stream in ("stdout", "stderr"):
+            try:
+                log_bytes = wrapped_container.logs(
+                    stdout=stream == "stdout",
+                    stderr=stream == "stderr",
+                    since=start_time - self._time_tolerance,
+                    until=end_time + self._time_tolerance,
+                    timestamps=False,
+                )
+                (artifact_directory / f"{filename}.{stream}.log").write_text(
+                    log_bytes.decode("utf-8", errors="replace")
+                )
+                wrote_artifact = True
+            except Exception as error:  # noqa: BLE001
+                wrote_artifact = (
+                    self._write_collection_error(
+                        artifact_directory / f"{filename}.error.txt", error
+                    )
+                    or wrote_artifact
+                )
+        return wrote_artifact
+
+    @staticmethod
+    def _write_collection_error(path: Path, error: Exception) -> bool:
+        try:
+            path.write_text(f"Could not collect container logs: {error}\n")
+        except OSError:
+            return False
+        return True

robotframework_testcontainers-0.2.0/src/TestcontainersLibrary/__init__.py

@@ -1 +0,0 @@
-from TestcontainersLibrary.library import TestcontainersLibrary  # noqa