feat: new container valkey (#44)

Author: sylvainmouquet

README.md

@@ -45,7 +45,7 @@ PyDocks is a Python library that provides a set of pytest fixtures for running t
 
 Key features include:
 - Easy integration with pytest
-- Support for PostgreSQL, Hashicorp Vault containers, Redis
+- Support for PostgreSQL, Hashicorp Vault, Redis, Valkey, and more
 - Automatic container cleanup
 - Configurable container settings
 - Reusable session-scoped containers for improved test performance
@@ -98,12 +98,22 @@ async def test_reuse_postgresql_container_2_2(postgresql_container_session):
   # postgresql_container_session uses the same instance of container created in test_reuse_postgresql_container_1_2
 ```
 
+### Available Containers
+
+PyDocks provides fixtures for the following Docker containers:
+
+- **PostgreSQL**: `postgresql_container`, `postgresql_container_session`, `postgresql_clean_all_containers`
+- **Redis**: `redis_container`, `redis_container_session`, `redis_clean_all_containers`
+- **Valkey**: `valkey_container`, `valkey_container_session`, `valkey_clean_all_containers`
+- **Hashicorp Vault**: `vault_container`, `vault_container_session`, `vault_clean_all_containers`
+- **Ubuntu**: `ubuntu_container`, `ubuntu_container_session`, `ubuntu_clean_all_containers`
+- **Alpine**: `alpine_container`, `alpine_container_session`, `alpine_clean_all_containers`
+- **OpenTofu**: `opentofu_container`, `opentofu_container_session`, `opentofu_clean_all_containers`
 
 ## License
 
 PyDocks is released under the MIT License. See the [LICENSE](LICENSE) file for more details.
 
 ## Contact
 
-For questions, suggestions, or issues related to PyDocks, please open an issue on the GitHub repository.
-
+For questions, suggestions, or issues related to PyDocks, please open an issue on the GitHub repository.

pydocks/__init__.py

@@ -20,6 +20,9 @@
     "alpine_clean_all_containers",
     "alpine_container",
     "alpine_container_session",
+    "valkey_clean_all_containers",
+    "valkey_container",
+    "valkey_container_session",
 )
 
 # pytest_plugins = ["pydocks.conftest"]
@@ -58,4 +61,10 @@
     alpine_clean_all_containers,
     alpine_container,
     alpine_container_session,
+)
+
+from pydocks.valkey import (
+    valkey_clean_all_containers,
+    valkey_container,
+    valkey_container_session,
 )

pydocks/valkey.py

@@ -0,0 +1,100 @@
+import pytest
+import os
+
+
+import pytest_asyncio
+from python_on_whales import docker as libdocker
+from reattempt import reattempt
+import logging
+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/r/valkey/valkey/tags
+TEST_VALKEY_DOCKER_IMAGE: str = "docker.io/valkey/valkey:8.1.1"
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session")
+async def valkey_clean_all_containers(docker):
+    container_name: str = "test-valkey"
+    # clean before
+
+    await clean_containers(docker, container_name)
+    yield
+    # clean after
+    await clean_containers(docker, container_name)
+
+
+@pytest.fixture(scope="function")
+async def valkey_container(docker: libdocker, mocker):  # type: ignore
+    mocker.patch(
+        "logging.exception",
+        lambda *args, **kwargs: logger.warning(f"Exception raised {args}"),
+    )
+
+    container_name = f"test-valkey-{uuid.uuid4()}"
+    # optional : await clean_containers(docker, container_name)
+
+    async for container in setup_valkey_container(docker, container_name):
+        yield container
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session")
+async def valkey_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-valkey-session")
+
+    container_name = f"test-valkey-session-{uuid.uuid4()}"
+
+    async for container in setup_valkey_container(docker, container_name):
+        yield container
+
+
+async def setup_valkey_container(docker: libdocker, container_name):  # type: ignore
+    valkey_image = (
+        TEST_VALKEY_DOCKER_IMAGE
+        if "TEST_VALKEY_DOCKER_IMAGE" not in os.environ
+        else os.environ["TEST_VALKEY_DOCKER_IMAGE"]
+    )
+    logger.debug(f"pull docker image : {valkey_image}")
+
+    def run_container(container_name: str):
+        return docker.run(
+            image=valkey_image,
+            name=container_name,
+            detach=True,
+            publish=[(6380, 6379)],
+            expose=[6380],
+        )
+
+    # 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"found existing container: {container_name}")
+    else:
+        logger.debug(f"no existing container found, creating new one: {container_name}")
+        container = run_container(container_name)
+
+    await valkey_test_connection()
+
+    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 valkey_test_connection():
+    await socket_test_connection("127.0.0.1", 6380)

pyproject.toml

@@ -16,10 +16,10 @@ keywords = [
     "opentofu",
     "postgresql",
     "pydocks",
-    "pytest",
     "redis",
     "test",
     "ubuntu",
+    "valkey",
     "vault"
 ]
 classifiers = [
@@ -70,4 +70,4 @@ pydocks = { path = "pydocks" }
 # asyncpg = { git = "https://github.com/MagicStack/asyncpg"}
 
 [project.entry-points.pytest11]
-pydocks = "pydocks"
+pydocks = "pydocks"

tests/test_valkey.py

@@ -0,0 +1,77 @@
+import pytest
+import os
+import redis.asyncio as redis
+from loguru import logger
+import pytest_asyncio
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session", autouse=True)
+async def begin_clean_all_containers(valkey_clean_all_containers):
+    logger.info("Begin - clean all containers")
+
+
+@pytest.mark.asyncio
+async def test_valkey_default_version(valkey_container):
+    container_env_dict = dict(env.split("=") for env in valkey_container.config.env)
+
+    assert "VALKEY_VERSION" in container_env_dict, "VALKEY_VERSION environment variable not found"
+    assert container_env_dict["VALKEY_VERSION"] == "8.1.1"
+
+
+@pytest.fixture
+def custom_valkey_version():
+    os.environ["TEST_VALKEY_DOCKER_IMAGE"] = "docker.io/valkey/valkey:7.2.9"
+    yield
+    del os.environ["TEST_VALKEY_DOCKER_IMAGE"]
+
+
+@pytest.mark.asyncio
+async def test_valkey_custom_version(custom_valkey_version, valkey_container):
+    container_env_dict = dict(env.split("=") for env in valkey_container.config.env)
+
+    assert "VALKEY_VERSION" in container_env_dict, "VALKEY_VERSION environment variable not found"
+    assert container_env_dict["VALKEY_VERSION"] == "7.2.9"
+
+
+@pytest.mark.asyncio
+async def test_valkey_execute_command(valkey_container):
+    # Execute Valkey CLI command
+    result = valkey_container.execute(["valkey-cli", "PING"])
+    assert result.strip() == "PONG"
+
+    # Set a key-value pair
+    set_result = valkey_container.execute(["valkey-cli", "SET", "test_key", "test_value"])
+    assert set_result.strip() == "OK"
+
+    # Get the value
+    get_result = valkey_container.execute(["valkey-cli", "GET", "test_key"])
+    assert get_result.strip() == "test_value"
+
+    # Delete the key
+    del_result = valkey_container.execute(["valkey-cli", "DEL", "test_key"])
+    assert del_result.strip() == "1"
+
+    # Verify key is deleted
+    get_deleted = valkey_container.execute(["valkey-cli", "GET", "test_key"])
+    assert get_deleted.strip() == ""
+
+    async with await redis.from_url(
+        "redis://localhost:6380", encoding="utf8"
+    ) as vkey:
+        # Flush all existing data
+        await vkey.flushall()
+
+        # Set a key-value pair
+        await vkey.set("test_key", "test_value")
+
+        # Get the value
+        value = await vkey.get("test_key")
+        assert value == b"test_value"
+
+        # Delete the key
+        deleted = await vkey.delete("test_key")
+        assert deleted == 1
+
+        # Verify key is deleted
+        deleted_value = await vkey.get("test_key")
+        assert deleted_value is None