pytest-docker-compose-v2 0.1.2__tar.gz → 0.3.0__tar.gz

pytest_docker_compose_v2-0.3.0/.devcontainer/Dockerfile

@@ -0,0 +1,76 @@
+FROM python:3.11.8-bookworm
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG UID=1000
+ARG GID=1000
+ARG DEV_USER=dev
+ARG BUILD_DIR=/tmp/build
+
+ENV VIRTUAL_ENV=/venv
+ENV LC_ALL en_US.UTF-8
+ENV LANG en_US.UTF-8
+ENV LANGUAGE en_US.UTF-8
+
+RUN apt-get update \
+  && apt-get install -yq --no-install-recommends \
+    # useful OS packages
+    sudo \
+    locales \
+    locales-all \
+    build-essential \
+    openssh-client \
+    rsync \
+    iputils-ping \
+    wget \
+    git \
+    ripgrep \
+    unzip \
+    curl \
+    vim \
+    bash-completion \
+    man-db \
+    less \
+    # Docker CE CLI and other packages
+    apt-transport-https \
+    ca-certificates \
+  && rm -rf /var/lib/apt/lists/* \
+  && update-ca-certificates
+
+RUN addgroup --gid ${GID} ${DEV_USER} \
+  && adduser --disabled-password --gecos '' --uid ${UID} --gid ${GID} ${DEV_USER} \
+  && mkdir -p /etc/sudoers.d \
+  && echo ${DEV_USER} ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/${DEV_USER} \
+  && chmod 0440 /etc/sudoers.d/${DEV_USER} \
+  && mkdir -p /home/${DEV_USER} \
+  && mkdir -p /home/${DEV_USER}/.vscode-server/extensions \
+  && mkdir -p /home/${DEV_USER}/.vscode-server-insiders/extensions \
+  && chown -R ${DEV_USER}:${DEV_USER} /home/${DEV_USER}
+
+# install node
+RUN curl -sL https://deb.nodesource.com/setup_18.x | bash -
+RUN apt-get update \
+  && apt-get install -yq --no-install-recommends \
+    nodejs \
+  && rm -rf /var/lib/apt/lists/* \
+  && update-ca-certificates
+
+# install devcontainer cli tool so we can build and push devcontainer from itself
+RUN npm install -g @devcontainers/cli
+RUN mkdir ${VIRTUAL_ENV} && chown ${UID}:${GID} ${VIRTUAL_ENV}
+
+# install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+USER ${DEV_USER}
+
+ENV PATH "/home/${DEV_USER}/.local/bin:${PATH}"
+
+# install dependencies into virtualenv
+WORKDIR ${BUILD_DIR}
+RUN uv venv ${VIRTUAL_ENV}
+COPY pyproject.toml uv.lock README.md ${BUILD_DIR}
+RUN uv sync --locked
+
+WORKDIR /workspace
+
+LABEL org.opencontainers.image.source https://github.com/radusuciu/pytest-docker-compose-v2

pytest_docker_compose_v2-0.3.0/.devcontainer/devcontainer.json

@@ -0,0 +1,80 @@
+{
+    "name": "pytest docker compose v2 Development",
+    "build": {
+      "dockerfile": "Dockerfile",
+      "context": "${localWorkspaceFolder}"
+    },
+    // needed because of the interaction between the devcontainer
+    // the test docker compose project, and the hostname reported by
+    // docker inspect in the tests in the PortConfig.
+    // the hostname is 0.0.0.0 and cannot be reached by the test code
+    // unless the devcontainer is on the host network. I've tried, among
+    // many othe permutations, putting the devcontainer on the same
+    // externally created network as the test containers but that did
+    // not work
+    "runArgs": [
+      "--network=host"
+    ],
+    "workspaceFolder": "/workspace",
+    "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind",
+    "mounts": [
+        {
+            "source": "/var/run/docker.sock",
+            "target": "/var/run/docker.sock",
+            "type": "bind"
+        }
+    ],
+    // Set *default* container specific settings.json values on container create.
+    "customizations": {
+      "vscode": {
+        "extensions": [
+          "ms-python.python",
+          "charliermarsh.ruff",
+          "ms-azuretools.vscode-docker",
+          "eamodio.gitlens",
+          "Gruntfuggly.todo-tree",
+          "be5invis.toml",
+          "GitHub.vscode-github-actions",
+          "GitHub.copilot",
+          "GitHub.vscode-pull-request-github"
+        ],
+        "settings": {
+          "#terminal.integrated.defaultProfile.linux#": "/bin/bash",
+          "python.defaultInterpreterPath": "/venv/bin/python",
+          "python.terminal.activateEnvironment": true,
+          "python.testing.unittestEnabled": false,
+          "python.testing.nosetestsEnabled": false,
+          "python.testing.pytestEnabled": true,
+          "ruff.organizeImports": true,
+          "[python]": {
+            "editor.codeActionsOnSave": {
+              "source.organizeImports": "always"
+            },
+            "editor.defaultFormatter": "charliermarsh.ruff",
+            "editor.formatOnSave": true
+          },
+          "[dockerfile]": {
+            "editor.formatOnSave": false
+          },
+          "dev.containers.dockerCredentialHelper": false
+        }
+      }
+    },
+    "features": {
+      "ghcr.io/devcontainers/features/docker-outside-of-docker:1": {},
+      "ghcr.io/devcontainers/features/github-cli:1": {}
+    },
+    "remoteEnv": {
+      // Pass in the host directory for Docker mount commands from inside the container
+      "HOST_PROJECT_PATH": "${localWorkspaceFolder}",
+      "VIRTUAL_ENV": "/venv",
+      "PATH": "${containerEnv:PATH}:/venv/bin",
+      "EDITOR": "code --wait",
+      "VISUAL": "code --wait",
+      "GIT_EDITOR": "code --wait"
+    },
+    // Use 'forwardPorts' to make a list of ports inside the container available locally.
+    // Left empty because this is handled by docker compose for individual services,
+    // use this only for additional ports not needed by those services (e.g. ssh)
+    "forwardPorts": []
+}

pytest_docker_compose_v2-0.3.0/.github/workflows/release.yaml

@@ -0,0 +1,40 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - '*.*.*'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi-publish
+    permissions:
+      # for creating github release
+      contents: write
+      # for trusted publishing
+      id-token: write
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v7
+    - name: Set up uv
+      uses: astral-sh/setup-uv@v10.2.0
+      with:
+        enable-cache: true
+        python-version: '3.13'
+
+    - name: Install dependencies
+      run: uv sync
+    - name: Run tests
+      run: uv run pytest
+    - name: Create GitHub release
+      uses: softprops/action-gh-release@v3
+      with:
+        name: Release ${{ github.ref }}
+        tag_name: ${{ github.ref }}
+        draft: false
+        prerelease: false
+    - name: Build package
+      run: uv build
+    - name: Publish to PyPI
+      run: uv publish

pytest_docker_compose_v2-0.3.0/.github/workflows/test.yaml

@@ -0,0 +1,50 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
+        pytest-version: ['7', '8', '9']
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v7
+      # needed because we use git describe to get a bumpver compatible GITHASH containing version
+      # alternatively can look at using HEXHASH instead. Note that these are purposefully not
+      # documented in the bumpver project, see issues/PRs for more info.
+      # with:
+      #   fetch-depth: 0
+    - name: Set up uv
+      uses: astral-sh/setup-uv@v10.2.0
+      with:
+        enable-cache: true
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: uv sync
+    - name: Install pytest ${{ matrix.pytest-version }}
+      run: uv pip install "pytest>=${{ matrix.pytest-version }},<$(( ${{ matrix.pytest-version }} + 1 ))"
+    - name: Run tests
+      run: uv run --no-sync pytest
+    - name: Run healthcheck wait tests
+      run: uv run --no-sync pytest -m wait_for_healthcheck --docker-compose ./tests/pytest_docker_compose_tests/my_network --docker-compose-wait
+    # NOTE: publishing to test repository is disabled until I figure out a way to do it reliably
+    # this means that we need to avoid version clashes as well as local versions
+    # see: https://github.com/pypa/packaging.python.org/issues/804
+    # - name: Publish to test repository
+    #   if: matrix.python-version == '3.11'
+    #   run: |
+    #     # adding the git hash to the current version so that the package
+    #     # won't be rejected from the test repository due to version clash
+    #     TEMP_VERSION=$(git describe | sed s/\-/\./ | sed s/\-/\+/)
+    #     uv run bumpver update --no-commit --no-tag-commit --set-version="${TEMP_VERSION}"
+    #     uv publish --index testpypi

pytest_docker_compose_v2-0.3.0/.gitignore

@@ -0,0 +1,123 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

pytest_docker_compose_v2-0.3.0/Justfile

@@ -0,0 +1,76 @@
+set shell := ["bash", "-euo", "pipefail", "-c"]
+
+# Generate Markdown release notes for VERSION without modifying the repository.
+release-notes version:
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    version="{{ version }}"
+    if git show-ref --verify --quiet "refs/tags/${version}"; then
+        revision="${version}"
+        previous="$(git describe --tags --abbrev=0 "${version}^")"
+    else
+        revision="HEAD"
+        previous="$(git describe --tags --abbrev=0 HEAD)"
+    fi
+
+    uv run git-cliff "${previous}..${revision}" \
+        --tag "${version}" \
+        --config keepachangelog \
+        --strip all
+
+# Add generated notes to an existing GitHub release (requires the GitHub CLI).
+publish-release-notes version:
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    command -v gh >/dev/null || {
+        echo "The GitHub CLI (gh) is required to publish release notes." >&2
+        exit 1
+    }
+
+    notes_file="$(mktemp)"
+    trap 'rm -f "${notes_file}"' EXIT
+    uv run just release-notes "{{ version }}" > "${notes_file}"
+    gh release edit "{{ version }}" --notes-file "${notes_file}"
+
+# Bump VERSION_KIND (patch, minor, or major), commit, tag, and push the release.
+release version_kind:
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    version_kind="{{ version_kind }}"
+    case "${version_kind}" in
+        patch|minor|major) ;;
+        *)
+            echo "Version kind must be one of: patch, minor, major." >&2
+            exit 2
+            ;;
+    esac
+
+    if [[ "$(git branch --show-current)" != "main" ]]; then
+        echo "Releases must be created from the main branch." >&2
+        exit 1
+    fi
+    if [[ -n "$(git status --porcelain)" ]]; then
+        echo "The working tree must be clean before creating a release." >&2
+        exit 1
+    fi
+
+    git fetch origin main --tags
+    if [[ "$(git rev-parse HEAD)" != "$(git rev-parse origin/main)" ]]; then
+        echo "Local main must match origin/main before creating a release." >&2
+        exit 1
+    fi
+
+    uv run pytest
+    uv run bumpver update "--${version_kind}" --ignore-vcs-tag --no-fetch
+    version="$(uv run python -c 'from pytest_docker_compose import __version__; print(__version__)')"
+
+    uv run just release-notes "${version}"
+    git push origin main
+    git push origin "${version}"
+
+    echo
+    echo "Release ${version} pushed. Once GitHub creates the release, publish its notes with:"
+    echo "  uv run just publish-release-notes ${version}"

pytest-docker-compose-v2-0.1.2/README.md → pytest_docker_compose_v2-0.3.0/PKG-INFO

@@ -1,3 +1,30 @@
+Metadata-Version: 2.5
+Name: pytest-docker-compose-v2
+Version: 0.3.0
+Summary: Manages Docker containers during your integration tests
+Project-URL: repository, https://github.com/radusuciu/pytest-docker-compose-v2
+Author: Radu Suciu, Thomas Meckel, Roald Storm, Phoenix Zerin
+License: Apache
+License-File: LICENSE
+Keywords: docker compose,pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: pytest<10,>=7.2.2
+Requires-Dist: python-on-whales<1,>=0.71.0
+Description-Content-Type: text/markdown
+
 [![PyPI pyversions](https://img.shields.io/pypi/pyversions/pytest-docker-compose-v2.svg)](https://pypi.python.org/pypi/pytest-docker-compose-v2/)
 [![PyPI version](https://img.shields.io/pypi/v/pytest-docker-compose-v2.svg)](https://pypi.python.org/pypi/pytest-docker-compose-v2/)
 [![GitHub release](https://img.shields.io/github/release/radusuciu/pytest-docker-compose-v2.svg)](https://github.com/radusuciu/pytest-docker-compose-v2/releases/)
@@ -17,8 +44,8 @@ Make sure you have [Docker](https://docs.docker.com/get-docker/) installed.
 
 This plugin is automatically tested against the following software:
 
-- Python 3.9, 3.10, 3.11 and 3.12
-- pytest 7
+- Python 3.10, 3.11, 3.12, 3.13 and 3.14
+- pytest 7, 8 and 9
 
 **NOTE**: This plugin is **not** compatible with Python 2.
 
@@ -33,20 +60,17 @@ pip install pytest-docker-compose-v2
 
 ## Usage
 
-For performance reasons, the plugin is not enabled by default, so you must activate it manually in the tests that use it:
+The plugin is automatically enabled when installed. To disable it for specific test runs, use:
 
-```python
-pytest_plugins = ["docker_compose"]
+```shell
+pytest -p no:docker_compose
 ```
 
-
-See [Installing and Using Plugins](https://docs.pytest.org/en/latest/plugins.html#requiring-loading-plugins-in-a-test-module-or-conftest-file) for more information.
-
-To interact with Docker containers in your tests, use the following fixtures, these fixtures tell docker-compose to start all the services and then they can fetch the associated containers for use in a test:
+To interact with Docker containers in your tests, use the following fixtures. These fixtures tell docker-compose to start all the services and then fetch the associated containers for use in a test:
 
 ### `function_scoped_container_getter`
 
-An object that fetches containers of the Docker `compose.container.Container` objects running during the test. The containers are fetched using `function_scoped_container_getter.get('service_name')` These containers each have an extra attribute called `network_info` added to them. This attribute has a list of `pytest_docker_compose.NetworkInfo` objects.
+An object that fetches containers of the Docker `python_on_whales.Container` objects running during the test. The containers are fetched using `function_scoped_container_getter.get('service_name')` These containers each have an extra attribute called `network_info` added to them. This attribute has a list of `pytest_docker_compose.NetworkInfo` objects.
 
 This information can be used to configure API clients and other objects that will connect to services exposed by the Docker containers in your tests.
 
@@ -62,12 +86,12 @@ This information can be used to configure API clients and other objects that wil
 
 ### `docker_project`
 
-The `compose.project.Project` object that the containers are built from.
+The `python_on_whales.DockerClient` object that the containers are built from.
 This fixture is generally only used internally by the plugin.
 
 ### Wider scoped fixtures
 
-To use the following fixtures please read [Use wider scoped fixtures](#use-wider-scope-fixtures)
+To use the following fixtures please read [Use wider scoped fixtures](#use-wider-scoped-fixtures)
 
 - `class_scoped_container_getter`: Similar to `function_scoped_container_getter` just with a wider scope.
 - `module_scoped_container_getter`: Similar to `function_scoped_container_getter` just with a wider scope.
@@ -79,7 +103,53 @@ The fixtures called `[scope]_scoped_container_getter` will wait until every cont
 
 However, just because a container is up does not mean that the services running on it are ready to accept incoming requests yet!
 
-If your tests need to wait for a particular condition (for example, to wait for an HTTP health check endpoint to send back a 200 response), make sure that your fixtures account for this.
+#### Option 1: Using Docker Compose Healthchecks (Recommended)
+
+The plugin can use Docker Compose's native `--wait` functionality with healthchecks defined in your `docker-compose.yml`. This lets Docker Compose handle waiting for services to be ready.
+
+First, define healthchecks in your `docker-compose.yml`:
+
+```yaml
+services:
+  my_api_service:
+    build: ./api
+    ports:
+      - "5000:5000"
+    depends_on:
+      my_db:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 10s
+  my_db:
+    image: postgres:15
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+```
+
+Then opt in to waiting when you run pytest:
+
+```shell
+pytest --docker-compose-wait
+```
+
+You can also specify a timeout (in seconds):
+
+```shell
+pytest --docker-compose-wait --docker-compose-wait-timeout=120
+```
+
+Waiting remains opt-in for backward compatibility. It is planned to become the default in version 1.0.
+
+#### Option 2: Python-based Wait Fixtures
+
+If your tests need to wait for a particular condition (for example, to wait for an HTTP health check endpoint to send back a 200 response), you can implement custom wait logic in your fixtures.
 
 Here's an example of a fixture called `wait_for_api` that waits for an HTTP service to come online before a test called `test_read_and_write` can run.
 
@@ -90,8 +160,6 @@ from urllib.parse import urljoin
 from urllib3.util.retry import Retry
 from requests.adapters import HTTPAdapter
 
-pytest_plugins = ["docker_compose"]
-
 # Invoking this fixture: 'function_scoped_container_getter' starts all services
 @pytest.fixture(scope="function")
 def wait_for_api(function_scoped_container_getter):
@@ -137,7 +205,7 @@ pytest --use-running-containers
 
 With this flag, `pytest-docker-compose` checks that all containers are running
 during the project creation. If they are not running a warning is given and
-they are spun up anyways. They are then used for all the tests and NOT TORE
+they are spun up anyways. They are then used for all the tests and NOT TORN
 DOWN afterwards.
 
 This mode is best used in combination with the `--docker-compose-no-build` flag since the newly build containers won't be used anyways. like so:
@@ -186,7 +254,7 @@ addopts = --docker-compose=/path/to/docker-compose.yml
 
 The option will be ignored for tests that do not use this plugin.
 
-See [Configuration Options](https://docs.pytest.org/en/latest/customize.html#adding-default-options) for more information on using configuration
+See [Configuration Options](https://docs.pytest.org/en/stable/reference/customize.html#adding-default-options) for more information on using configuration
 files to modify pytest behavior.
 
 ### Remove volumes after tests
@@ -199,5 +267,47 @@ pytest --docker-compose-remove-volumes
 
 This option will be ignored if the plugin is not used. Again, this option can also be added to the `pytest.ini` file.
 
+### Command Line Options Summary
+
+| Option | Description |
+|--------|-------------|
+| `--docker-compose` | Path to docker-compose.yml file or directory containing one. Multiple files can be specified with commas. |
+| `--docker-compose-no-build` | Skip building Docker images before running tests. |
+| `--docker-compose-remove-volumes` | Remove container volumes after tests complete. |
+| `--use-running-containers` | Use already running containers instead of starting new ones. |
+| `--docker-compose-wait` | Wait for services to be healthy before running tests (requires healthcheck definitions). |
+| `--docker-compose-wait-timeout` | Timeout in seconds when waiting for services to be healthy. |
+
 For more examples on how to use this plugin look at the testing suite of this plugin itself! It will give you some examples for configuring `pyproject.toml` and how to use the different fixtures to run docker containers.
 
+## Releasing
+
+Release commands are managed with `just`, which is installed by the development
+dependency group:
+
+```shell
+uv sync
+```
+
+Preview the release notes for a version without modifying the repository:
+
+```shell
+uv run just release-notes 0.3.0
+```
+
+Create and push a release from a clean, up-to-date `main` branch by choosing a
+semantic version increment:
+
+```shell
+uv run just release patch
+uv run just release minor
+uv run just release major
+```
+
+The command runs the tests, updates the package version, creates the version
+commit and tag, and pushes both. Once GitHub Actions has created the GitHub
+Release, its generated notes can be added with:
+
+```shell
+uv run just publish-release-notes 0.3.0
+```