pydocks 0.0.1__py3-none-any.whl

pydocks/__init__.py

@@ -0,0 +1,16 @@
+__version__ = "0.0.1"
+__all__ = (
+    "__version__",
+    "postgresql_clean_all_containers",
+    "postgresql_container",
+    "postgresql_container_session",
+    "docker",
+)
+
+# pytest_plugins = ["pydocks.conftest"]
+from pydocks.plugin import docker
+from pydocks.postgresql import (
+    postgresql_clean_all_containers,
+    postgresql_container,
+    postgresql_container_session,
+)

pydocks/nginx.py

@@ -0,0 +1,16 @@
+"""
+# https://hub.docker.com/r/nginx/tags
+TEST_NGINX_DOCKER_IMAGE: str = "docker.io/nginx:1.27.1-alpine"
+
+# https://hub.docker.com/r/hashicorp/terraform/tags
+TEST_TERRAFORM_DOCKER_IMAGE: str = "docker.io/hashicorp/terraform:1.5"
+
+# https://hub.docker.com/r/chainguard/opentofu/tags
+TEST_OPENTOFU_DOCKER_IMAGE: str = "docker.io/chainguard/opentofu:latest-dev"
+
+# https://hub.docker.com/_/redis/tags
+TEST_REDIS_DOCKER_IMAGE: str = "docker.io/redis:7.4.0"
+
+# https://hub.docker.com/r/hashicorp/vault/tags
+TEST_VAULT_DOCKER_IMAGE: str = "docker.io/hashicorp/vault:1.17.3"
+"""

pydocks/plugin.py

@@ -0,0 +1,63 @@
+import pytest
+from pathlib import Path
+import os
+
+import socket
+
+# from asgi_lifespan import LifespanManager
+import anyio
+from python_on_whales import DockerClient
+from reattempt import reattempt
+import logging
+
+logger = logging.getLogger("pydocks")
+logger.addHandler(logging.NullHandler())
+
+
+@pytest.fixture(scope="session", autouse=True)
+def docker():
+    if "DOCKER_SOCK" in os.environ:
+        yield DockerClient(host=os.environ["DOCKER_SOCK"])
+    elif "CI" in os.environ:
+        # Github Actions, GitLab CI, ...
+        yield DockerClient()
+    else:
+        # local with colima
+        home: str = str(Path.home())
+        yield DockerClient(host=f"unix://{home}/.colima/default/docker.sock")
+
+
+@reattempt(max_retries=30, min_time=0.1, max_time=0.5)
+async def socket_test_connection(host, port):
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect((host, port))
+    await anyio.wait_socket_writable(s)
+
+
+async def clean_containers(docker: DockerClient, name: str):
+    containers = docker.ps(all=True, filters={"name": f"^{name}"})
+
+    for container in containers:
+        if container.state.running:
+            docker.kill(container)
+        logger.info(f"remove container {container.name}")
+        docker.remove(container)
+
+
+async def wait_and_run_container(docker, container, name: str):
+    logger.debug(f"start {name}")
+    try:
+        yield container
+    finally:
+        logger.debug(f"kill container {name} and remove the docker container")
+        if container.state.status == "running":
+            logger.debug(f"container {name} is running")
+            docker.kill(container.id)
+            logger.debug(f"killed container {name}")
+        else:
+            logger.debug(f"container {name} is not running")
+
+        # keep the container id, to keep the docker images
+        # docker has a garbage collector, when all docker container are deleted the
+        # image related is deleted
+        # docker.remove(container.id)

pydocks/postgresql.py

@@ -0,0 +1,143 @@
+import pytest
+import os
+
+
+import pytest_asyncio
+
+# from asgi_lifespan import LifespanManager
+import asyncpg
+import anyio
+from python_on_whales import docker as libdocker
+from reattempt import reattempt
+import logging
+import struct
+from anyio.abc import SocketStream
+import uuid
+
+from pydocks.plugin import (
+    clean_containers,
+    socket_test_connection,
+    wait_and_run_container,
+)
+
+
+logger = logging.getLogger("pydocks")
+logger.addHandler(logging.NullHandler())
+
+
+# https://hub.docker.com/_/postgres/tags
+# TEST_POSTGRES_DOCKER_IMAGE: str = "docker.io/postgres:16.3"
+TEST_POSTGRESQL_DOCKER_IMAGE: str = "docker.io/postgres:17rc1-alpine3.20"
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session")
+async def postgresql_clean_all_containers(docker):
+    container_name: str = "test-postgresql"
+    # clean before
+
+    await clean_containers(docker, container_name)
+    yield
+    # clean after
+    await clean_containers(docker, container_name)
+
+
+@pytest.fixture(scope="function")
+async def postgresql_container(docker: libdocker, mocker):  # type: ignore
+    mocker.patch(
+        "logging.exception",
+        lambda *args, **kwargs: logger.warning(f"Exception raised {args}"),
+    )
+
+    container_name = f"test-postgresql-{uuid.uuid4()}"
+    # await clean_containers(docker, container_name)
+
+    async for container in setup_postgresql_container(docker, container_name):
+        yield container
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session")
+async def postgresql_container_session(docker: libdocker, session_mocker):  # type: ignore
+    session_mocker.patch(
+        "logging.exception",
+        lambda *args, **kwargs: logger.warning(f"Exception raised {args}"),
+    )
+
+    await clean_containers(docker, "test-postgresql-session")
+
+    container_name = f"test-postgresql-session-{uuid.uuid4()}"
+
+    async for container in setup_postgresql_container(docker, container_name):
+        yield container
+
+
+async def setup_postgresql_container(docker: libdocker, container_name):  # type: ignore
+    postgresql_image = (
+        TEST_POSTGRESQL_DOCKER_IMAGE
+        if "TEST_POSTGRESQL_DOCKER_IMAGE" not in os.environ
+        else os.environ["TEST_POSTGRESQL_DOCKER_IMAGE"]
+    )
+    logger.debug(f"[PYDOCKS] Pull docker image : {postgresql_image}")
+
+    def run_container(container_name: str):
+        return docker.run(
+            image=postgresql_image,
+            name=container_name,
+            detach=True,
+            envs={
+                "POSTGRES_PASSWORD": "postgres",
+            },
+            publish=[(5433, 5432)],
+            expose=[5433],
+        )
+
+    # Select the container with the given name if exists, else create a new one
+    containers = docker.ps(all=True, filters={"name": f"^{container_name}$"})
+    if containers and len(containers) > 0:
+        container = containers[0]  # type: ignore
+        logger.debug(f"[PYDOCKS] Found existing container: {container_name}")
+    else:
+        logger.debug(
+            f"[PYDOCKS] No existing container found, creating new one: {container_name}"
+        )
+        container = run_container(container_name)
+
+    await postgresql_test_connection(
+        host="127.0.0.1",
+        port=5433,
+        username="postgres",
+        password="postgres",
+        db_name="postgres",
+    )
+
+    async for instance in wait_and_run_container(docker, container, container_name):
+        yield instance
+
+
+@reattempt(max_retries=30, min_time=0.1, max_time=0.5)
+async def postgresql_test_connection(
+    host: str, port: int, username: str, password: str, db_name: str
+):
+    await socket_test_connection(host, port)
+
+    stream: SocketStream = await anyio.connect_tcp(host, port)
+
+    # Send a startup packet
+    startup_packet = f"user=fake-user password=fake-password dbname=fake-db host={host} port={port}\x00".encode()
+    await stream.send(struct.pack(">I", len(startup_packet)))
+    await stream.send(b"\x00\x03\x00\x00")  # frontend protocol version 3.0
+    await stream.send(startup_packet)
+    await stream.send(b"\x00")  # terminator byte
+
+    await stream.receive()
+    logger.info("[PYDOCKS] Connection successful.")
+    await stream.aclose()
+
+    conn = await asyncpg.connect(
+        user=username, password=password, database=db_name, host=host, port=port
+    )
+    try:
+        # Execute the SELECT 1 query
+        result = await conn.fetchval("SELECT 1")
+        logger.info(f"[PYDOCKS] Query result: {result}")
+    finally:
+        await conn.close()

pydocks-0.0.1.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.3
+Name: pydocks
+Version: 0.0.1
+Summary: Pytest fixures for running tests with Docker containers
+Project-URL: homepage, https://github.com/sylvainmouquet/pydocks
+Project-URL: documentation, https://github.com/sylvainmouquet/pydocks
+Project-URL: repository, https://github.com/sylvainmouquet/ppydocks
+Project-URL: changelog, https://github.com/sylvainmouquet/pydocks/releases
+Author-email: Sylvain Mouquet <sylvain.mouquet@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: containers,docker,pydocks,pytest,test
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: asyncpg>=0.29.0
+Requires-Dist: uvloop>=0.20.0
+Description-Content-Type: text/markdown
+
+# PyDocks
+
+PyDocks is a group of pytest fixures for running tests with Docker containers
+
+### Demonstration:
+
+```python
+...
+```
+
+## Table of Contents
+
+- [PyDocks](#PyDocks)
+  - [Table of Contents](#table-of-contents)
+  - [Description](#description)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [License](#license)
+  - [Contact](#contact)
+
+## Description
+
+PyDocks is a Python library that provides a set of pytest fixtures for running tests with Docker containers. It simplifies the process of setting up, managing, and tearing down Docker containers during test execution.
+
+Key features include:
+- Easy integration with pytest
+- Support for PostgreSQL containers
+- Automatic container cleanup
+- Configurable container settings
+- Reusable session-scoped containers for improved test performance
+
+PyDocks is designed to make testing with Docker containers more efficient and less error-prone, allowing developers to focus on writing tests rather than managing infrastructure.
+
+## Installation
+
+```bash
+# Install the dependency
+pip install pydocks
+uv add pydocks
+poetry add pydocks
+```
+
+## Usage
+
+```python
+from pydocks import pydocks
+
+```
+
+
+## License
+
+PyDocks is released under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+## Contact
+
+For questions, suggestions, or issues related to ReAttempt, please open an issue on the GitHub repository.
+

pydocks-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+pydocks/__init__.py,sha256=W6CvJFv97kKviM7P4V77BwQhbHtvXhq_52Ya-yzbgM0,379
+pydocks/nginx.py,sha256=_cJaeUMG4IBBxf2M7D00fDIPQinlD2x6Gn3Mu3Acg2I,572
+pydocks/plugin.py,sha256=7RPsJs15aqu0o2JPI0qhw87Om06PlTvnKKcx76MycYI,1969
+pydocks/postgresql.py,sha256=o940-Snobfu5HyEs4QQ7jjfbXo4PCtCUfKDeVge0Bn8,4463
+pydocks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydocks-0.0.1.dist-info/METADATA,sha256=OUrktuk4zb0CZ50BAdZRdPWKRng-EsKuY_Ryd-LNcrE,2588
+pydocks-0.0.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pydocks-0.0.1.dist-info/entry_points.txt,sha256=xM0EPrcMDdbClZ8xZedU09BiL6dyq1B70eZuS2Cb_6M,29
+pydocks-0.0.1.dist-info/licenses/LICENSE,sha256=apw6aefq1u6QAh-QZbpNI5ZDDfjM5Uv3hjDPAQsrsC0,1064
+pydocks-0.0.1.dist-info/RECORD,,

pydocks-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pydocks-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+pydocks = pydocks

pydocks-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PyDocks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.