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

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

@@ -1,18 +1,28 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: robotframework-testcontainers
-Version: 0.1.0
+Version: 0.2.0
 Summary: Robot Framework keywords for Testcontainers.
+Keywords: robotframework,testing,test,automation,container,testcontainers,docker
 Author: Andreas Finkler
 Author-email: Andreas Finkler <andi.finkler@gmail.com>
+License-Expression: MIT
+Classifier: Framework :: Robot Framework
+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-Python: >=3.10
+Project-URL: Documentation, https://dudenr33.github.io/robotframework-testcontainers/
+Project-URL: Repository, https://github.com/DudeNr33/robotframework-testcontainers
 Description-Content-Type: text/markdown
 
 # robotframework-testcontainers
 
 Robot Framework keywords for [testcontainers](https://github.com/testcontainers/testcontainers-python).
 
+[Keyword Documentation](https://dudenr33.github.io/robotframework-testcontainers/)
+
 ## Installation
 
 - using `pip`:

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

@@ -2,6 +2,8 @@
 
 Robot Framework keywords for [testcontainers](https://github.com/testcontainers/testcontainers-python).
 
+[Keyword Documentation](https://dudenr33.github.io/robotframework-testcontainers/)
+
 ## Installation
 
 - using `pip`:

{robotframework_testcontainers-0.1.0 → robotframework_testcontainers-0.2.0}/pyproject.toml

@@ -1,11 +1,32 @@
 [project]
 name = "robotframework-testcontainers"
-version = "0.1.0"
+version = "0.2.0"
 description = "Robot Framework keywords for Testcontainers."
 readme = "README.md"
 authors = [{ name = "Andreas Finkler", email = "andi.finkler@gmail.com" }]
+license = "MIT"
+license-file = "LICENSE"
+keywords = [
+  "robotframework",
+  "testing",
+  "test",
+  "automation",
+  "container",
+  "testcontainers",
+  "docker",
+]
 requires-python = ">=3.10"
 dependencies = ["robotframework>=7.3.2", "testcontainers[generic]>=4.13.2"]
+classifiers = [
+  "Framework :: Robot Framework",
+  "Framework :: Robot Framework :: Library",
+  "Topic :: Software Development :: Testing",
+  "Topic :: Software Development :: Testing :: Mocking",
+]
+
+[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"]
@@ -27,3 +48,4 @@ dev = [
 
 [tool.mypy]
 ignore_missing_imports = true
+strict = true

robotframework_testcontainers-0.2.0/src/TestcontainersLibrary/library.py

@@ -0,0 +1,232 @@
+import importlib
+from pathlib import Path
+from typing import Any
+
+from robot.api import logger
+from robot.api.deco import keyword, library
+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
+
+
+@library(listener="SELF")
+class TestcontainersLibrary:
+    """
+    Keywords for [https://testcontainers.com/|Testcontainers].
+    """
+
+    def __init__(self) -> None:
+        self._containers: list[DockerContainer] = []
+        self._networks: list[Network] = []
+
+    @keyword
+    def create_docker_container(
+        self,
+        image: str,
+        command: str | None = None,
+        env: dict[str, str] | None = None,
+        name: str | None = None,
+        ports: list[int] | None = None,
+        volumes: list[tuple[Path, str, str]] | None = None,
+        network: Network | None = None,
+        network_aliases: list[str] | None = None,
+        start: bool = True,
+    ) -> DockerContainer:
+        """
+        Create a basic [https://testcontainers-python.readthedocs.io/en/latest/core/README.html#testcontainers.core.container.DockerContainer|DockerContainer].
+        Returns the container instance.
+
+        By default, the created container is started directly.
+
+        This can be prevented by setting ``start=False``, e.g. if
+        you need to customize the container before starting, like
+        binding specific ports etc.
+        In this case, use the ``Start Container`` keyword afterwards.
+        """
+        container = DockerContainer(
+            image=image,
+            command=command,
+            env=env,
+            name=name,
+            ports=ports,
+            volumes=self._resolve_volume_paths(volumes) if volumes else None,
+            network=network,
+            network_aliases=network_aliases,
+        )
+        if start:
+            self.start_container(container)
+        return container
+
+    def _resolve_volume_paths(
+        self, volumes: list[tuple[Path, str, str]]
+    ) -> list[tuple[str, str, str]]:
+        return [(v[0].resolve().as_posix(), v[1], v[2]) for v in volumes]
+
+    @keyword
+    def create_server_container(
+        self, port: int, image: str, start: bool = True
+    ) -> ServerContainer:
+        """
+        Create a [https://testcontainers-python.readthedocs.io/en/latest/modules/generic/README.html#testcontainers.generic.ServerContainer|ServerContainer]
+
+        By default, the created container is started directly.
+
+        This can be prevented by setting ``start=False``, e.g. if
+        you need to customize the container before starting, like
+        binding specific ports etc.
+        In this case, use the ``Start Container`` keyword afterwards.
+        """
+        container = ServerContainer(port=port, image=image)
+        if start:
+            self.start_container(container)
+        return container
+
+    @keyword
+    def create_community_container(
+        self, module: str, container_class: str, start: bool = True, **kwargs: Any
+    ) -> DockerContainer:
+        """
+        Create a [https://testcontainers-python.readthedocs.io/en/latest/modules/index.html|community maintained container].
+
+        Specify the ``module`` and ``container_class`` the same way you would import
+        it in Python.\nFor example, the ``RedisContainer`` that you would import via\n
+        ``from testcontainers.redis import RedisContainer``
+        \nin Python code can be created with\n
+        ``| Create Community Container | module=testcontainers.redis | container_class=RedisContainer |``.\n
+        Extra arguments required by the container can be passed as keyword arguments.
+
+        By default, the created container is started directly.
+
+        This can be prevented by setting ``start=False``, e.g. if
+        you need to customize the container before starting, like
+        binding specific ports etc.
+        In this case, use the ``Start Container`` keyword afterwards.
+        """
+        _module = importlib.import_module(module)
+        clazz = getattr(_module, container_class)
+        container = clazz(**kwargs)
+        if start:
+            self.start_container(container)
+        return container
+
+    @keyword
+    def bind_ports(
+        self, container: DockerContainer, container_port: int, host_port: int
+    ) -> DockerContainer:
+        """
+        Bind a container port to a host port.
+        """
+        container.with_bind_ports(container_port, host_port)
+        return container
+
+    @keyword
+    def start_container(self, container: DockerContainer) -> DockerContainer:
+        """
+        Start the given container.
+        """
+        try:
+            container.start()
+            self._containers.append(container)
+            return container
+        except Exception:
+            container.stop()
+            raise
+
+    @keyword
+    def wait_for_log_message(
+        self, container: DockerContainer, message: str, times: int = 1
+    ) -> None:
+        """
+        Wait until the given container has emitted the specified log message.
+        The message can be a simple string or a regular expression.
+
+        The container must already be started when calling this keyword.
+        """
+        LogMessageWaitStrategy(message, times).wait_until_ready(container)
+
+    @keyword
+    def wait_for_http_endpoint(
+        self, container: DockerContainer, port: int, path: str, status_code: int = 200
+    ) -> None:
+        """
+        Wait until the specified endpoint is reachable on the given container.
+
+        The container must already be started when calling this keyword.
+        """
+        HttpWaitStrategy(port, path).for_status_code(status_code).wait_until_ready(
+            container
+        )
+
+    @keyword
+    def stop_container(self, container: DockerContainer) -> None:
+        """
+        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.
+        """
+        self._containers.remove(container)
+        container.stop()
+
+    @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.
+        """
+        network = Network()
+        network.create()
+        self._networks.append(network)
+        return network
+
+    @keyword
+    def remove_network(self, network: Network) -> None:
+        """
+        Delete the given network.
+        """
+        self._networks.remove(network)
+        network.remove()
+
+    @keyword
+    def connect_container_to_network(
+        self,
+        container: DockerContainer,
+        network: Network,
+        aliases: list[str] | None = None,
+    ) -> None:
+        """
+        Connect a container to a network. It will be reachable from other containers by its alias, if set.
+        """
+        container_id = container.get_wrapped_container().id
+        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.1.0/src/TestcontainersLibrary/library.py

@@ -1,111 +0,0 @@
-import importlib
-from pathlib import Path
-from robot.api.deco import library, keyword
-from robot.api import logger
-from testcontainers.core.container import DockerContainer
-from testcontainers.core.wait_strategies import LogMessageWaitStrategy, HttpWaitStrategy
-from testcontainers.generic.server import ServerContainer
-
-
-@library(listener="SELF")
-class TestcontainersLibrary:
-    def __init__(self):
-        self._containers: list[DockerContainer] = []
-
-    @keyword
-    def create_docker_container(
-        self,
-        image: str,
-        command: str | None = None,
-        env: dict[str, str] | None = None,
-        name: str | None = None,
-        ports: list[int] | None = None,
-        volumes: list[tuple[Path, str, str]] | None = None,
-        start: bool = True,
-    ) -> DockerContainer:
-        container = DockerContainer(
-            image=image,
-            command=command,
-            env=env,
-            name=name,
-            ports=ports,
-            volumes=self._resolve_volume_paths(volumes) if volumes else None,
-        )
-        if start:
-            self.start_container(container)
-        return container
-
-    def _resolve_volume_paths(
-        self, volumes: list[tuple[Path, str, str]]
-    ) -> list[tuple[str, str, str]]:
-        return [(v[0].resolve().as_posix(), v[1], v[2]) for v in volumes]
-
-    @keyword
-    def create_server_container(
-        self, port: int, image: str, start: bool = True
-    ) -> ServerContainer:
-        container = ServerContainer(port=port, image=image)
-        if start:
-            self.start_container(container)
-        return container
-
-    @keyword
-    def create_community_container(
-        self, module: str, container_class: str, start: bool = True, **kwargs
-    ) -> DockerContainer:
-        _module = importlib.import_module(module)
-        clazz = getattr(_module, container_class)
-        container = clazz(**kwargs)
-        if start:
-            self.start_container(container)
-        return container
-
-    @keyword
-    def bind_ports(
-        self, container: DockerContainer, container_port: int, host_port: int
-    ) -> DockerContainer:
-        container.with_bind_ports(container_port, host_port)
-        return container
-
-    @keyword
-    def start_container(self, container: DockerContainer) -> DockerContainer:
-        try:
-            container.start()
-            self._containers.append(container)
-            return container
-        except Exception:
-            container.stop()
-            raise
-
-    @keyword
-    def wait_for_log_message(
-        self, container: DockerContainer, message: str, times: int = 1
-    ) -> None:
-        LogMessageWaitStrategy(message, times).wait_until_ready(container)
-
-    @keyword
-    def wait_for_http_endpoint(
-        self, container: DockerContainer, port: int, path: str
-    ) -> None:
-        HttpWaitStrategy(port, path).wait_until_ready(container)
-
-    @keyword
-    def stop_container(self, container: DockerContainer) -> None:
-        self._containers.remove(container)
-        container.stop()
-
-    def _end_test(self, name, attrs) -> 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)
-
-    def _end_suite(self, name, attrs) -> 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)