fix: Don't downgrade from https to http if certificate is missing

Before, if a site's certificate was not found, the site was served over http rather than https. Failing open like this is problematic for sites where security is important. Presumably the user set `HTTPS_METHOD` to a non-`noredirect` value (or left it unset) for a good reason; we should honor it even if it means serving error messages. WARNING: This change breaks compatibility. Any vhost where all of the following are true will fail after this change: * `HTTPS_METHOD` is either unset or set to a value other than `nohttps`. * The vhost does not have its own certificate (`default.crt` doesn't count). * Clients expect to be able to access the vhost by using plain http to nginx-proxy. To get the previous behavior, set `HTTPS_METHOD` to `nohttps` for the vhost.
2023-05-14 14:56:43 -04:00
284 changed files with 2627 additions and 5777 deletions
--- a/.github/workflows/build-publish-dispatch.yml
+++ b/.github/workflows/build-publish-dispatch.yml
@ -1,85 +0,0 @@
-name: Build and publish Docker images on demand
-
-on:
-  workflow_dispatch:
-    inputs:
-      image_tag:
-        description: "Image tag"
-        type: string
-        required: true
-
-jobs:
-  multiarch-build:
-    name: Build and publish ${{ matrix.base }} image with tag ${{ inputs.image_tag }}
-    strategy:
-      matrix:
-        base: [alpine, debian]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Retrieve nginx-proxy version
-        id: nginx-proxy_version
-        run: echo "VERSION=$(git describe --tags)" >> "$GITHUB_OUTPUT"
-
-      - name: Retrieve docker-gen version
-        id: docker-gen_version
-        run: sed -n -e 's;^FROM nginxproxy/docker-gen:\([0-9.]*\).*;VERSION=\1;p' Dockerfile.${{ matrix.base }} >> "$GITHUB_OUTPUT"
-
-      - name: Get Docker tags
-        id: docker_meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            nginxproxy/nginx-proxy
-          tags: |
-            type=raw,value=${{ inputs.image_tag }},enable=${{ matrix.base == 'debian' }}
-            type=raw,value=${{ inputs.image_tag }},suffix=-alpine,enable=${{ matrix.base == 'alpine' }}
-          labels: |
-            org.opencontainers.image.authors=Nicolas Duchon <nicolas.duchon@gmail.com> (@buchdag), Jason Wilder
-            org.opencontainers.image.version=${{ steps.nginx-proxy_version.outputs.VERSION }}
-          flavor: |
-            latest=false
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push the image
-        id: docker_build
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: Dockerfile.${{ matrix.base }}
-          build-args: |
-            NGINX_PROXY_VERSION=${{ steps.nginx-proxy_version.outputs.VERSION }}
-            DOCKER_GEN_VERSION=${{ steps.docker-gen_version.outputs.VERSION }}
-          platforms: linux/amd64,linux/arm64,linux/s390x,linux/arm/v7
-          sbom: true
-          push: true
-          provenance: mode=max
-          tags: ${{ steps.docker_meta.outputs.tags }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-
-      - name: Images digests
-        run: echo ${{ steps.docker_build.outputs.digest }}
--- a/.github/workflows/build-publish.yml
+++ b/.github/workflows/build-publish.yml
@ -19,15 +19,12 @@ on:
      - "*.md"

 jobs:
-  multiarch-build:
-    name: Build and publish image
-    strategy:
-      matrix:
-        base: [alpine, debian]
+  multiarch-build-debian:
+    name: Build and publish Debian image
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          fetch-depth: 0

@ -35,67 +32,128 @@ jobs:
        id: nginx-proxy_version
        run: echo "VERSION=$(git describe --tags)" >> "$GITHUB_OUTPUT"

-      - name: Retrieve docker-gen version
-        id: docker-gen_version
-        run: sed -n -e 's;^FROM nginxproxy/docker-gen:\([0-9.]*\).*;VERSION=\1;p' Dockerfile.${{ matrix.base }} >> "$GITHUB_OUTPUT"
-
-      - name: Get Docker tags
-        id: docker_meta
-        uses: docker/metadata-action@v5
+      - name: Get Docker tags for Debian based image
+        id: docker_meta_debian
+        uses: docker/metadata-action@v4
        with:
          images: |
            ghcr.io/nginx-proxy/nginx-proxy
            nginxproxy/nginx-proxy
            jwilder/nginx-proxy
          tags: |
-            type=semver,pattern={{version}},enable=${{ matrix.base == 'debian' }}
-            type=semver,pattern={{major}}.{{minor}},enable=${{ matrix.base == 'debian' }}
-            type=semver,suffix=-alpine,pattern={{version}},enable=${{ matrix.base == 'alpine' }}
-            type=semver,suffix=-alpine,pattern={{major}}.{{minor}},enable=${{ matrix.base == 'alpine' }}
-            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' && matrix.base == 'debian' }}
-            type=raw,value=alpine,enable=${{ github.ref == 'refs/heads/main' && matrix.base == 'alpine' }}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest,enable={{is_default_branch}}
          labels: |
            org.opencontainers.image.authors=Nicolas Duchon <nicolas.duchon@gmail.com> (@buchdag), Jason Wilder
            org.opencontainers.image.version=${{ steps.nginx-proxy_version.outputs.VERSION }}
-          flavor: |
-            latest=false

      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v2

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2

      - name: Login to DockerHub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

-      - name: Build and push the image
-        id: docker_build
-        uses: docker/build-push-action@v6
+      - name: Retrieve docker-gen version
+        id: docker-gen_version
+        run: sed -n -e 's;^FROM nginxproxy/docker-gen:\([0-9.]*\).*;VERSION=\1;p' Dockerfile >> "$GITHUB_OUTPUT"
+
+      - name: Build and push the Debian based image
+        id: docker_build_debian
+        uses: docker/build-push-action@v4
        with:
          context: .
-          file: Dockerfile.${{ matrix.base }}
+          file: Dockerfile
          build-args: |
            NGINX_PROXY_VERSION=${{ steps.nginx-proxy_version.outputs.VERSION }}
            DOCKER_GEN_VERSION=${{ steps.docker-gen_version.outputs.VERSION }}
-          platforms: linux/amd64,linux/arm64,linux/s390x,linux/arm/v7
-          sbom: true
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
          push: true
-          provenance: mode=max
-          tags: ${{ steps.docker_meta.outputs.tags }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
+          tags: ${{ steps.docker_meta_debian.outputs.tags }}
+          labels: ${{ steps.docker_meta_debian.outputs.labels }}

      - name: Images digests
-        run: echo ${{ steps.docker_build.outputs.digest }}
+        run: echo ${{ steps.docker_build_debian.outputs.digest }}
+
+  multiarch-build-alpine:
+    name: Build and publish Alpine image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Retrieve nginx-proxy version
+        id: nginx-proxy_version
+        run: echo "VERSION=$(git describe --tags)" >> "$GITHUB_OUTPUT"
+
+      - name: Get Docker tags for Alpine based image
+        id: docker_meta_alpine
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ghcr.io/nginx-proxy/nginx-proxy
+            nginxproxy/nginx-proxy
+            jwilder/nginx-proxy
+          tags: |
+            type=semver,suffix=-alpine,pattern={{version}}
+            type=semver,suffix=-alpine,pattern={{major}}.{{minor}}
+            type=raw,value=alpine,enable={{is_default_branch}}
+          labels: |
+            org.opencontainers.image.authors=Nicolas Duchon <nicolas.duchon@gmail.com> (@buchdag), Jason Wilder
+            org.opencontainers.image.version=${{ steps.nginx-proxy_version.outputs.VERSION }}
+          flavor: latest=false
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Retrieve docker-gen version
+        id: docker-gen_version
+        run: sed -n -e 's;^FROM nginxproxy/docker-gen:\([0-9.]*\).*;VERSION=\1;p' Dockerfile >> "$GITHUB_OUTPUT"
+
+      - name: Build and push the Alpine based image
+        id: docker_build_alpine
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          file: Dockerfile.alpine
+          build-args: |
+            NGINX_PROXY_VERSION=${{ steps.nginx-proxy_version.outputs.VERSION }}
+            DOCKER_GEN_VERSION=${{ steps.docker-gen_version.outputs.VERSION }}
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          push: true
+          tags: ${{ steps.docker_meta_alpine.outputs.tags }}
+          labels: ${{ steps.docker_meta_alpine.outputs.labels }}
+
+      - name: Images digests
+        run: echo ${{ steps.docker_build_alpine.outputs.digest }}
--- a/.github/workflows/dockerhub-description.yml
+++ b/.github/workflows/dockerhub-description.yml
@ -1,27 +0,0 @@
-name: Update Docker Hub Description
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - README.md
-      - .github/workflows/dockerhub-description.yml
-
-jobs:
-  dockerHubDescription:
-    name: Update Docker Hub Description
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Docker Hub Description
-        uses: peter-evans/dockerhub-description@v4
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN_RWD }}
-          repository: nginxproxy/nginx-proxy
-          short-description: ${{ github.event.repository.description }}
-          enable-url-completion: true
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@ -23,12 +23,12 @@ jobs:
        base_docker_image: [alpine, debian]

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

-      - name: Set up Python 3.12
-        uses: actions/setup-python@v5
+      - name: Set up Python 3.9
+        uses: actions/setup-python@v4
        with:
-          python-version: 3.12
+          python-version: 3.9

      - name: Install dependencies
        run: |
@ -36,9 +36,6 @@ jobs:
          pip install -r python-requirements.txt
        working-directory: test/requirements

-      - name: Pull nginx:alpine image
-        run: docker pull nginx:alpine
-
      - name: Build Docker web server image
        run: make build-webserver

--- a/.gitignore
+++ b/.gitignore
@ -1,4 +1,3 @@
 **/__pycache__/
 **/.cache/
 .idea/
-wip
--- a/Dockerfile.debian
+++ b/Dockerfile.debian
@ -1,9 +1,9 @@
-FROM docker.io/nginxproxy/docker-gen:0.14.5-debian AS docker-gen
+FROM nginxproxy/docker-gen:0.10.4-debian AS docker-gen

-FROM docker.io/nginxproxy/forego:0.18.2-debian AS forego
+FROM nginxproxy/forego:0.17.1-debian AS forego

 # Build the final image
-FROM docker.io/library/nginx:1.27.3
+FROM nginx:1.23.4

 ARG NGINX_PROXY_VERSION
 # Add DOCKER_GEN_VERSION environment variable because 
@ -13,14 +13,17 @@ ENV NGINX_PROXY_VERSION=${NGINX_PROXY_VERSION} \
   DOCKER_GEN_VERSION=${DOCKER_GEN_VERSION} \
   DOCKER_HOST=unix:///tmp/docker.sock

+# Install/update certificates
+RUN apt-get update \
+   && apt-get install -y -q --no-install-recommends ca-certificates \
+   && apt-get clean \
+   && rm -r /var/lib/apt/lists/*
+
 # Configure Nginx
-RUN echo "\ninclude /etc/nginx/toplevel.conf.d/*.conf;" >> /etc/nginx/nginx.conf \
-   && sed -i 's/worker_connections.*;$/worker_connections  10240;/' /etc/nginx/nginx.conf \
-   && sed -i -e '/^\}$/{s//\}\nworker_rlimit_nofile 20480;/;:a' -e '$!N;$!ba' -e '}' /etc/nginx/nginx.conf \
-   && mkdir -p '/etc/nginx/toplevel.conf.d' \
-   && mkdir -p '/etc/nginx/dhparam' \
-   && mkdir -p '/etc/nginx/certs' \
-   && mkdir -p '/usr/share/nginx/html/errors'
+RUN echo "daemon off;" >> /etc/nginx/nginx.conf \
+   && sed -i 's/worker_processes  1/worker_processes  auto/' /etc/nginx/nginx.conf \
+   && sed -i 's/worker_connections  1024/worker_connections  10240/' /etc/nginx/nginx.conf \
+   && mkdir -p '/etc/nginx/dhparam'

 # Install Forego + docker-gen
 COPY --from=forego /usr/local/bin/forego /usr/local/bin/forego
--- a/Dockerfile.alpine
+++ b/Dockerfile.alpine
@ -1,9 +1,9 @@
-FROM docker.io/nginxproxy/docker-gen:0.14.5 AS docker-gen
+FROM nginxproxy/docker-gen:0.10.4 AS docker-gen

-FROM docker.io/nginxproxy/forego:0.18.2 AS forego
+FROM nginxproxy/forego:0.17.1 AS forego

 # Build the final image
-FROM docker.io/library/nginx:1.27.3-alpine
+FROM nginx:1.23.4-alpine

 ARG NGINX_PROXY_VERSION
 # Add DOCKER_GEN_VERSION environment variable because 
@ -14,16 +14,17 @@ ENV NGINX_PROXY_VERSION=${NGINX_PROXY_VERSION} \
   DOCKER_HOST=unix:///tmp/docker.sock

 # Install dependencies
-RUN apk add --no-cache --virtual .run-deps bash openssl
+RUN apk add --no-cache --virtual .run-deps \
+   bash \
+   ca-certificates \
+   openssl \
+   && update-ca-certificates

 # Configure Nginx
-RUN echo -e "\ninclude /etc/nginx/toplevel.conf.d/*.conf;" >> /etc/nginx/nginx.conf \
-   && sed -i 's/worker_connections.*;$/worker_connections   10240;/' /etc/nginx/nginx.conf \
-   && sed -i -e '/^\}$/{s//\}\nworker_rlimit_nofile 20480;/;:a' -e '$!N;$!ba' -e '}' /etc/nginx/nginx.conf \
-   && mkdir -p '/etc/nginx/toplevel.conf.d' \
-   && mkdir -p '/etc/nginx/dhparam' \
-   && mkdir -p '/etc/nginx/certs' \
-   && mkdir -p '/usr/share/nginx/html/errors'
+RUN echo "daemon off;" >> /etc/nginx/nginx.conf \
+   && sed -i 's/worker_processes  1/worker_processes  auto/' /etc/nginx/nginx.conf \
+   && sed -i 's/worker_connections  1024/worker_connections  10240/' /etc/nginx/nginx.conf \
+   && mkdir -p '/etc/nginx/dhparam'

 # Install Forego + docker-gen
 COPY --from=forego /usr/local/bin/forego /usr/local/bin/forego
--- a/2
+++ b/2
@ -6,7 +6,7 @@ build-webserver:
 	docker build --pull -t web test/requirements/web

 build-nginx-proxy-test-debian:
-	docker build --pull --build-arg NGINX_PROXY_VERSION="test" -f Dockerfile.debian -t nginxproxy/nginx-proxy:test .
+	docker build --pull --build-arg NGINX_PROXY_VERSION="test" -t nginxproxy/nginx-proxy:test .

 build-nginx-proxy-test-alpine:
 	docker build --pull --build-arg NGINX_PROXY_VERSION="test" -f Dockerfile.alpine -t nginxproxy/nginx-proxy:test .
--- a/README.md
+++ b/README.md
@ -1,9 +1,10 @@
 [![Test](https://github.com/nginx-proxy/nginx-proxy/actions/workflows/test.yml/badge.svg)](https://github.com/nginx-proxy/nginx-proxy/actions/workflows/test.yml)
 [![GitHub release](https://img.shields.io/github/v/release/nginx-proxy/nginx-proxy)](https://github.com/nginx-proxy/nginx-proxy/releases)
-[![nginx 1.27.3](https://img.shields.io/badge/nginx-1.27.3-brightgreen.svg?logo=nginx)](https://nginx.org/en/CHANGES)
+![nginx 1.23.4](https://img.shields.io/badge/nginx-1.23.4-brightgreen.svg)
 [![Docker Image Size](https://img.shields.io/docker/image-size/nginxproxy/nginx-proxy?sort=semver)](https://hub.docker.com/r/nginxproxy/nginx-proxy "Click to view the image on Docker Hub")
-[![Docker stars](https://img.shields.io/docker/stars/nginxproxy/nginx-proxy.svg)](https://hub.docker.com/r/nginxproxy/nginx-proxy "DockerHub")
-[![Docker pulls](https://img.shields.io/docker/pulls/nginxproxy/nginx-proxy.svg)](https://hub.docker.com/r/nginxproxy/nginx-proxy "DockerHub")
+[![Docker stars](https://img.shields.io/docker/stars/nginxproxy/nginx-proxy.svg)](https://hub.docker.com/r/nginxproxy/nginx-proxy 'DockerHub')
+[![Docker pulls](https://img.shields.io/docker/pulls/nginxproxy/nginx-proxy.svg)](https://hub.docker.com/r/nginxproxy/nginx-proxy 'DockerHub')
+

 nginx-proxy sets up a container running nginx and [docker-gen](https://github.com/nginx-proxy/docker-gen). docker-gen generates reverse proxy configs for nginx and reloads nginx when containers are started and stopped.

@ -14,79 +15,632 @@ See [Automated Nginx Reverse Proxy for Docker](http://jasonwilder.com/blog/2014/
 To run it:

 ```console
-docker run --detach \
-    --name nginx-proxy \
-    --publish 80:80 \
-    --volume /var/run/docker.sock:/tmp/docker.sock:ro \
-    nginxproxy/nginx-proxy:1.6
+docker run -d -p 80:80 -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
 ```
-docker-compose
-```docker-compose
-services:
-  nginx-proxy:
-    image: nginxproxy/nginx-proxy
-    restart: always
-    ports:
-      - "80:80"
-    volumes:
-      - "/var/run/docker.sock:/tmp/docker.sock"
-```
-Then start any containers (here an nginx container) you want proxied with an env var `VIRTUAL_HOST=subdomain.yourdomain.com`
+
+Then start any containers you want proxied with an env var `VIRTUAL_HOST=subdomain.youdomain.com`

 ```console
-docker run --detach \
-    --name your-proxied-app \
-    --env VIRTUAL_HOST=foo.bar.com \
-    nginx
+docker run -e VIRTUAL_HOST=foo.bar.com  ...
 ```
-docker-compose
-```docker-compose
-    environment:
-      - VIRTUAL_HOST=git.patachina.casacam.net
-      - VIRTUAL_PORT=3000
-```
-Provided your DNS is setup to resolve `foo.bar.com` to the host running nginx-proxy, a request to `http://foo.bar.com` will then be routed to a container with the `VIRTUAL_HOST` env var set to `foo.bar.com` (in this case, the **your-proxied-app** container).

-The containers being proxied must :
+The containers being proxied must [expose](https://docs.docker.com/engine/reference/run/#expose-incoming-ports) the port to be proxied, either by using the `EXPOSE` directive in their `Dockerfile` or by using the `--expose` flag to `docker run` or `docker create` and be in the same network. By default, if you don't pass the --net flag when your nginx-proxy container is created, it will only be attached to the default bridge network. This means that it will not be able to connect to containers on networks other than bridge.

- [expose](https://docs.docker.com/engine/reference/run/#expose-incoming-ports) the port to be proxied, either by using the `EXPOSE` directive in their `Dockerfile` or by using the `--expose` flag to `docker run` or `docker create`.
- share at least one Docker network with the nginx-proxy container: by default, if you don't pass the `--net` flag when your nginx-proxy container is created, it will only be attached to the default bridge network. This means that it will not be able to connect to containers on networks other than bridge.
+Provided your DNS is setup to forward foo.bar.com to the host running nginx-proxy, the request will be routed to a container with the `VIRTUAL_HOST` env var set.

-Note: providing a port number in `VIRTUAL_HOST` isn't suported, please see [virtual ports](https://github.com/nginx-proxy/nginx-proxy/tree/main/docs#virtual-ports) or [custom external HTTP/HTTPS ports](https://github.com/nginx-proxy/nginx-proxy/tree/main/docs#custom-external-httphttps-ports) depending on what you want to achieve.
+Note: providing a port number in `VIRTUAL_HOST` isn't suported, please see [virtual ports](https://github.com/nginx-proxy/nginx-proxy#virtual-ports) or [custom external HTTP/HTTPS ports](https://github.com/nginx-proxy/nginx-proxy#custom-external-httphttps-ports) depending on what you want to achieve.

 ### Image variants

 The nginx-proxy images are available in two flavors.

-#### Debian based version
+#### nginxproxy/nginx-proxy:latest

-This image is based on the nginx:mainline image, itself based on the debian slim image.
+This image uses the debian:buster based nginx image.

 ```console
-docker pull nginxproxy/nginx-proxy:1.6
+docker pull nginxproxy/nginx-proxy:latest
 ```

-#### Alpine based version (`-alpine` suffix)
+#### nginxproxy/nginx-proxy:alpine

-This image is based on the nginx:alpine image.
+This image is based on the nginx:alpine image. Use this image to fully support HTTP/2 (including ALPN required by recent Chrome versions). A valid certificate is required as well (see eg. below "SSL Support using an ACME CA" for more info).

 ```console
-docker pull nginxproxy/nginx-proxy:1.6-alpine
+docker pull nginxproxy/nginx-proxy:alpine
 ```

-> [!IMPORTANT]
+### Docker Compose
+
+```yaml
+version: '2'
+
+services:
+  nginx-proxy:
+    image: nginxproxy/nginx-proxy
+    ports:
+      - "80:80"
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
+
+  whoami:
+    image: jwilder/whoami
+    expose:
+      - "8000"
+    environment:
+      - VIRTUAL_HOST=whoami.local
+      - VIRTUAL_PORT=8000
+```
+
+```console
+docker-compose up
+curl -H "Host: whoami.local" localhost
+```
+
+Example output:
+```console
+I'm 5b129ab83266
+```
+
+### IPv6 support
+
+You can activate the IPv6 support for the nginx-proxy container by passing the value `true` to the `ENABLE_IPV6` environment variable:
+
+```console
+docker run -d -p 80:80 -e ENABLE_IPV6=true -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+```
+
+#### Scoped IPv6 Resolvers
+
+NginX does not support scoped IPv6 resolvers. In [docker-entrypoint.sh](./docker-entrypoint.sh) the resolvers are parsed from resolv.conf, but any scoped IPv6 addreses will be removed. 
+
+#### IPv6 NAT
+
+By default, docker uses IPv6-to-IPv4 NAT. This means all client connections from IPv6 addresses will show docker's internal IPv4 host address. To see true IPv6 client IP addresses, you must [enable IPv6](https://docs.docker.com/config/daemon/ipv6/) and use [ipv6nat](https://github.com/robbertkl/docker-ipv6nat). You must also disable the userland proxy by adding `"userland-proxy": false` to `/etc/docker/daemon.json` and restarting the daemon.
+
+### Multiple Hosts
+
+If you need to support multiple virtual hosts for a container, you can separate each entry with commas.  For example, `foo.bar.com,baz.bar.com,bar.com` and each host will be setup the same.
+
+### Virtual Ports
+
+When your container exposes only one port, nginx-proxy will default to this port, else to port 80.
+
+If you need to specify a different port, you can set a `VIRTUAL_PORT` env var to select a different one. This variable cannot be set to more than one port.
+
+For each host defined into `VIRTUAL_HOST`, the associated virtual port is retrieved by order of precedence:
+1. From the `VIRTUAL_PORT` environment variable
+1. From the container's exposed port if there is only one
+1. From the default port 80 when none of the above methods apply
+
+### Wildcard Hosts
+
+You can also use wildcards at the beginning and the end of host name, like `*.bar.com` or `foo.bar.*`. Or even a regular expression, which can be very useful in conjunction with a wildcard DNS service like [nip.io](https://nip.io) or [sslip.io](https://sslip.io), using `~^foo\.bar\..*\.nip\.io` will match `foo.bar.127.0.0.1.nip.io`, `foo.bar.10.0.2.2.nip.io` and all other given IPs. More information about this topic can be found in the nginx documentation about [`server_names`](http://nginx.org/en/docs/http/server_names.html).
+
+### Path-based Routing
+
+You can have multiple containers proxied by the same `VIRTUAL_HOST` by adding a `VIRTUAL_PATH` environment variable containing the absolute path to where the container should be mounted. For example with `VIRTUAL_HOST=foo.example.com` and `VIRTUAL_PATH=/api/v2/service`, then requests to http://foo.example.com/api/v2/service will be routed to the container. If you wish to have a container serve the root while other containers serve other paths, give the root container a `VIRTUAL_PATH` of `/`.  Unmatched paths will be served by the container at `/` or will return the default nginx error page if no container has been assigned `/`.
+It is also possible to specify multiple paths with regex locations like `VIRTUAL_PATH=~^/(app1|alternative1)/`. For further details see the nginx documentation on location blocks. This is not compatible with `VIRTUAL_DEST`.
+
+The full request URI will be forwarded to the serving container in the `X-Original-URI` header.
+
+**NOTE**: Your application needs to be able to generate links starting with `VIRTUAL_PATH`. This can be achieved by it being natively on this path or having an option to prepend this path. The application does not need to expect this path in the request.
+
+#### VIRTUAL_DEST
+
+This environment variable can be used to rewrite the `VIRTUAL_PATH` part of the requested URL to proxied application. The default value is empty (off).
+Make sure that your settings won't result in the slash missing or being doubled. Both these versions can cause troubles.
+
+If the application runs natively on this sub-path or has a setting to do so, `VIRTUAL_DEST` should not be set or empty.
+If the requests are expected to not contain a sub-path and the generated links contain the sub-path, `VIRTUAL_DEST=/` should be used.
+
+```console
+$ docker run -d -e VIRTUAL_HOST=example.tld -e VIRTUAL_PATH=/app1/ -e VIRTUAL_DEST=/ --name app1 app
+```
+
+In this example, the incoming request `http://example.tld/app1/foo` will be proxied as `http://app1/foo` instead of `http://app1/app1/foo`.
+
+#### Per-VIRTUAL_PATH location configuration
+
+The same options as from [Per-VIRTUAL_HOST location configuration](#Per-VIRTUAL_HOST-location-configuration) are available on a `VIRTUAL_PATH` basis.
+The only difference is that the filename gets an additional block `HASH=$(echo -n $VIRTUAL_PATH | sha1sum | awk '{ print $1 }')`. This is the sha1-hash of the `VIRTUAL_PATH` (no newline). This is done filename sanitization purposes.
+The used filename is `${VIRTUAL_HOST}_${HASH}_location`
+
+The filename of the previous example would be `example.tld_8610f6c344b4096614eab6e09d58885349f42faf_location`.
+
+#### DEFAULT_ROOT
+
+This environment variable of the nginx proxy container can be used to customize the return error page if no matching path is found. Furthermore it is possible to use anything which is compatible with the `return` statement of nginx.
+
+Exception:  If this is set to the string `none`, no default `location /` directive will be generated.  This makes it possible for you to provide your own `location /` directive in your [`/etc/nginx/vhost.d/VIRTUAL_HOST`](#per-virtual_host) or [`/etc/nginx/vhost.d/default`](#per-virtual_host-default-configuration) files.
+
+If unspecified, `DEFAULT_ROOT` defaults to `404`.
+
+Examples (YAML syntax):
+
+  * `DEFAULT_ROOT: "none"` prevents `nginx-proxy` from generating a default `location /` directive.
+  * `DEFAULT_ROOT: "418"` returns a 418 error page instead of the normal 404 one.
+  * `DEFAULT_ROOT: "301 https://github.com/nginx-proxy/nginx-proxy/blob/main/README.md"` redirects the client to this documentation.
+
+Nginx variables such as `$scheme`, `$host`, and `$request_uri` can be used.  However, care must be taken to make sure the `$` signs are escaped properly.  For example, if you want to use `301 $scheme://$host/myapp1$request_uri` you should use:
+
+* Bash: `DEFAULT_ROOT='301 $scheme://$host/myapp1$request_uri'`
+* Docker Compose yaml: `- DEFAULT_ROOT: 301 $$scheme://$$host/myapp1$$request_uri`
+
+
+### Multiple Networks
+
+With the addition of [overlay networking](https://docs.docker.com/engine/userguide/networking/get-started-overlay/) in Docker 1.9, your `nginx-proxy` container may need to connect to backend containers on multiple networks. By default, if you don't pass the `--net` flag when your `nginx-proxy` container is created, it will only be attached to the default `bridge` network. This means that it will not be able to connect to containers on networks other than `bridge`.
+
+If you want your `nginx-proxy` container to be attached to a different network, you must pass the `--net=my-network` option in your `docker create` or `docker run` command. At the time of this writing, only a single network can be specified at container creation time. To attach to other networks, you can use the `docker network connect` command after your container is created:
+
+```console
+docker run -d -p 80:80 -v /var/run/docker.sock:/tmp/docker.sock:ro \
+    --name my-nginx-proxy --net my-network nginxproxy/nginx-proxy
+docker network connect my-other-network my-nginx-proxy
+```
+
+In this example, the `my-nginx-proxy` container will be connected to `my-network` and `my-other-network` and will be able to proxy to other containers attached to those networks.
+
+### Custom external HTTP/HTTPS ports
+
+If you want to use `nginx-proxy` with different external ports that the default ones of `80` for `HTTP` traffic and `443` for `HTTPS` traffic, you'll have to use the environment variable(s) `HTTP_PORT` and/or `HTTPS_PORT` in addition to the changes to the Docker port mapping. If you change the `HTTPS` port, the redirect for `HTTPS` traffic will also be configured to redirect to the custom port. Typical usage, here with the custom ports `1080` and `10443`:
+
+```console
+docker run -d -p 1080:1080 -p 10443:10443 -e HTTP_PORT=1080 -e HTTPS_PORT=10443 -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+```
+
+### Internet vs. Local Network Access
+
+If you allow traffic from the public internet to access your `nginx-proxy` container, you may want to restrict some containers to the internal network only, so they cannot be accessed from the public internet.  On containers that should be restricted to the internal network, you should set the environment variable `NETWORK_ACCESS=internal`.  By default, the *internal* network is defined as `127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16`.  To change the list of networks considered internal, mount a file on the `nginx-proxy` at `/etc/nginx/network_internal.conf` with these contents, edited to suit your needs:
+
+```Nginx
+# These networks are considered "internal"
+allow 127.0.0.0/8;
+allow 10.0.0.0/8;
+allow 192.168.0.0/16;
+allow 172.16.0.0/12;
+
+# Traffic from all other networks will be rejected
+deny all;
+```
+
+When internal-only access is enabled, external clients will be denied with an `HTTP 403 Forbidden`
+
+> If there is a load-balancer / reverse proxy in front of `nginx-proxy` that hides the client IP (example: AWS Application/Elastic Load Balancer), you will need to use the nginx `realip` module (already installed) to extract the client's IP from the HTTP request headers.  Please see the [nginx realip module configuration](http://nginx.org/en/docs/http/ngx_http_realip_module.html) for more details.  This configuration can be added to a new config file and mounted in `/etc/nginx/conf.d/`.
+
+### SSL Backends
+
+If you would like the reverse proxy to connect to your backend using HTTPS instead of HTTP, set `VIRTUAL_PROTO=https` on the backend container.
+
+> Note: If you use `VIRTUAL_PROTO=https` and your backend container exposes port 80 and 443, `nginx-proxy` will use HTTPS on port 80.  This is almost certainly not what you want, so you should also include `VIRTUAL_PORT=443`.
+
+### uWSGI Backends
+
+If you would like to connect to uWSGI backend, set `VIRTUAL_PROTO=uwsgi` on the backend container. Your backend container should then listen on a port rather than a socket and expose that port.
+
+### FastCGI Backends
+ 
+If you would like to connect to FastCGI backend, set `VIRTUAL_PROTO=fastcgi` on the backend container. Your backend container should then listen on a port rather than a socket and expose that port.
+ 
+### FastCGI File Root Directory
+
+If you use fastcgi,you can set `VIRTUAL_ROOT=xxx`  for your root directory
+
+### Custom log format
+
+If you want to use a custom log format, you can set `LOG_FORMAT=xxx` on the proxy container. 
+
+With docker compose take care to escape the `$` character with `$$` to avoid variable interpolation. Example: `$remote_addr` becomes `$$remote_addr`.
+
+### Default Host
+
+To set the default host for nginx use the env var `DEFAULT_HOST=foo.bar.com` for example
+
+```console
+docker run -d -p 80:80 -e DEFAULT_HOST=foo.bar.com -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+```
+
+nginx-proxy will then redirect all requests to a container where `VIRTUAL_HOST` is set to `DEFAULT_HOST`, if they don't match any (other) `VIRTUAL_HOST`. Using the example above requests without matching `VIRTUAL_HOST` will be redirected to a plain nginx instance after running the following command:
+
+```console
+docker run -d -e VIRTUAL_HOST=foo.bar.com nginx
+```
+
+### Separate Containers
+
+nginx-proxy can also be run as two separate containers using the [nginxproxy/docker-gen](https://hub.docker.com/r/nginxproxy/docker-gen) image and the official [nginx](https://registry.hub.docker.com/_/nginx/) image.
+
+You may want to do this to prevent having the docker socket bound to a publicly exposed container service.
+
+You can demo this pattern with docker-compose:
+
+```console
+docker-compose --file docker-compose-separate-containers.yml up
+curl -H "Host: whoami.local" localhost
+```
+
+Example output:
+```console
+I'm 5b129ab83266
+```
+
+To run nginx proxy as a separate container you'll need to have [nginx.tmpl](https://github.com/nginx-proxy/nginx-proxy/blob/main/nginx.tmpl) on your host system.
+
+First start nginx with a volume:
+
+
+```console
+docker run -d -p 80:80 --name nginx -v /tmp/nginx:/etc/nginx/conf.d -t nginx
+```
+
+Then start the docker-gen container with the shared volume and template:
+
+```console
+docker run --volumes-from nginx \
+    -v /var/run/docker.sock:/tmp/docker.sock:ro \
+    -v $(pwd):/etc/docker-gen/templates \
+    -t nginxproxy/docker-gen -notify-sighup nginx -watch /etc/docker-gen/templates/nginx.tmpl /etc/nginx/conf.d/default.conf
+```
+
+Finally, start your containers with `VIRTUAL_HOST` environment variables.
+
+```console
+docker run -e VIRTUAL_HOST=foo.bar.com  ...
+```
+
+### SSL Support using an ACME CA
+
+[acme-companion](https://github.com/nginx-proxy/acme-companion) is a lightweight companion container for the nginx-proxy. It allows the automated creation/renewal of SSL certificates using the ACME protocol.
+
+### SSL Support
+
+SSL is supported using single host, wildcard and SNI certificates using naming conventions for certificates or optionally specifying a cert name (for SNI) as an environment variable.
+
+To enable SSL:
+
+```console
+docker run -d -p 80:80 -p 443:443 -v /path/to/certs:/etc/nginx/certs -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+```
+
+The contents of `/path/to/certs` should contain the certificates and private keys for any virtual hosts in use. The certificate and keys should be named after the virtual host with a `.crt` and `.key` extension. For example, a container with `VIRTUAL_HOST=foo.bar.com` should have a `foo.bar.com.crt` and `foo.bar.com.key` file in the certs directory.
+
+If you are running the container in a virtualized environment (Hyper-V, VirtualBox, etc...), /path/to/certs must exist in that environment or be made accessible to that environment. By default, Docker is not able to mount directories on the host machine to containers running in a virtual machine.
+
+#### Diffie-Hellman Groups
+
+[RFC7919 groups](https://datatracker.ietf.org/doc/html/rfc7919#appendix-A) with key lengths of 2048, 3072, and 4096 bits are [provided by `nginx-proxy`](https://github.com/nginx-proxy/nginx-proxy/dhparam). The ENV `DHPARAM_BITS` can be set to `2048` or `3072` to change from the default 4096-bit key. The DH key file will be located in the container at `/etc/nginx/dhparam/dhparam.pem`. Mounting a different `dhparam.pem` file at that location will override the RFC7919 key.
+
+To use custom `dhparam.pem` files per-virtual-host, the files should be named after the virtual host with a `dhparam` suffix and `.pem` extension. For example, a container with `VIRTUAL_HOST=foo.bar.com` should have a `foo.bar.com.dhparam.pem` file in the `/etc/nginx/certs` directory.
+
+> COMPATIBILITY WARNING: The default generated `dhparam.pem` key is 4096 bits for A+ security. Some older clients (like Java 6 and 7) do not support DH keys with over 1024 bits. In order to support these clients, you must provide your own `dhparam.pem`.
+
+In the separate container setup, no pre-generated key will be available and neither the [nginxproxy/docker-gen](https://hub.docker.com/r/nginxproxy/docker-gen) image, nor the offical [nginx](https://registry.hub.docker.com/_/nginx/) image will provide one. If you still want A+ security in a separate container setup, you should mount an RFC7919 DH key file to the nginx container at `/etc/nginx/dhparam/dhparam.pem`.
+
+Set `DHPARAM_SKIP` environment variable to `true` to disable using default Diffie-Hellman parameters. The default value is `false`.
+
+```console
+docker run -e DHPARAM_SKIP=true ....
+```
+
+#### Wildcard Certificates
+
+Wildcard certificates and keys should be named after the domain name with a `.crt` and `.key` extension. For example `VIRTUAL_HOST=foo.bar.com` would use cert name `bar.com.crt` and `bar.com.key`.
+
+#### SNI
+
+If your certificate(s) supports multiple domain names, you can start a container with `CERT_NAME=<name>` to identify the certificate to be used.  For example, a certificate for `*.foo.com` and `*.bar.com` could be named `shared.crt` and `shared.key`.  A container running with `VIRTUAL_HOST=foo.bar.com` and `CERT_NAME=shared` will then use this shared cert.
+
+#### OCSP Stapling
+
+To enable OCSP Stapling for a domain, `nginx-proxy` looks for a PEM certificate containing the trusted CA certificate chain at `/etc/nginx/certs/<domain>.chain.pem`, where `<domain>` is the domain name in the `VIRTUAL_HOST` directive. The format of this file is a concatenation of the public PEM CA certificates starting with the intermediate CA most near the SSL certificate, down to the root CA. This is often referred to as the "SSL Certificate Chain". If found, this filename is passed to the NGINX [`ssl_trusted_certificate` directive](http://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_trusted_certificate) and OCSP Stapling is enabled.
+
+#### How SSL Support Works
+
+The default SSL cipher configuration is based on the [Mozilla intermediate profile](https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28recommended.29) version 5.0 which should provide compatibility with clients back to Firefox 27, Android 4.4.2, Chrome 31, Edge, IE 11 on Windows 7, Java 8u31, OpenSSL 1.0.1, Opera 20, and Safari 9. Note that the DES-based TLS ciphers were removed for security. The configuration also enables HSTS, PFS, OCSP stapling and SSL session caches. Currently TLS 1.2 and 1.3 are supported.
+
+If you don't require backward compatibility, you can use the [Mozilla modern profile](https://wiki.mozilla.org/Security/Server_Side_TLS#Modern_compatibility) profile instead by including the environment variable `SSL_POLICY=Mozilla-Modern` to the nginx-proxy container or to your container. This profile is compatible with clients back to Firefox 63, Android 10.0, Chrome 70, Edge 75, Java 11, OpenSSL 1.1.1, Opera 57, and Safari 12.1.  Note that this profile is **not** compatible with any version of Internet Explorer.
+
+Other policies available through the `SSL_POLICY` environment variable are [`Mozilla-Old`](https://wiki.mozilla.org/Security/Server_Side_TLS#Old_backward_compatibility) and the [AWS ELB Security Policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-policy-table.html) `AWS-TLS-1-2-2017-01`, `AWS-TLS-1-1-2017-01`, `AWS-2016-08`, `AWS-2015-05`, `AWS-2015-03` and `AWS-2015-02`.
+
+Note that the `Mozilla-Old` policy should use a 1024 bits DH key for compatibility but this container provides a 4096 bits key. The [Diffie-Hellman Groups](#diffie-hellman-groups) section details different methods of bypassing this, either globally or per virtual-host.
+
+The default behavior for the proxy when port 80 and 443 are exposed is as follows:
+
+* If a virtual host has a usable cert, port 80 will redirect to 443 for that virtual host so that HTTPS is always preferred when available.
+* If the virtual host does not have a usable cert, but `default.crt` and `default.key` exist, those will be used as the virtual host's certificate and the client browser will receive a 500 error.
+* If the virtual host does not have a usable cert, and `default.crt` and `default.key` do not exist, TLS negotiation will fail (see [Missing Certificate](#missing-certificate) below).
+
+To serve traffic in both SSL and non-SSL modes without redirecting to SSL, you can include the environment variable `HTTPS_METHOD=noredirect` (the default is `HTTPS_METHOD=redirect`). You can also disable the non-SSL site entirely with `HTTPS_METHOD=nohttp`, or disable the HTTPS site with `HTTPS_METHOD=nohttps`. `HTTPS_METHOD` can be specified on each container for which you want to override the default behavior or on the proxy container to set it globally. If `HTTPS_METHOD=noredirect` is used, Strict Transport Security (HSTS) is disabled to prevent HTTPS users from being redirected by the client. If you cannot get to the HTTP site after changing this setting, your browser has probably cached the HSTS policy and is automatically redirecting you back to HTTPS. You will need to clear your browser's HSTS cache or use an incognito window / different browser.
+
+By default, [HTTP Strict Transport Security (HSTS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security)  is enabled with `max-age=31536000` for HTTPS sites. You can disable HSTS with the environment variable `HSTS=off` or use a custom HSTS configuration like `HSTS=max-age=31536000; includeSubDomains; preload`. 
+
+*WARNING*: HSTS will force your users to visit the HTTPS version of your site for the `max-age` time - even if they type in `http://` manually.  The only way to get to an HTTP site after receiving an HSTS response is to clear your browser's HSTS cache.
+
+#### Missing Certificate
+
+If HTTPS is enabled for a virtual host but its certificate is missing, nginx-proxy will configure nginx to use the default certificate (`default.crt` with `default.key`) and return a 500 error.
+
+If the default certificate is also missing, nginx-proxy will configure nginx to accept HTTPS connections but fail the TLS negotiation.  Client browsers will render a TLS error page.  As of March 2023, web browsers display the following error messages:
+
+  * Chrome:
+
+    > This site can't provide a secure connection
    >
-> #### A note on `latest` and `alpine`:
+    > example.test sent an invalid response.
    >
-> It is not recommended to use the `latest` (`nginxproxy/nginx-proxy`, `nginxproxy/nginx-proxy:latest`) or `alpine` (`nginxproxy/nginx-proxy:alpine`) tag for production setups.
+    > Try running Connectivity Diagnostics.
    >
-> [Those tags point](https://hub.docker.com/r/nginxproxy/nginx-proxy/tags) to the latest commit in the `main` branch. They do not carry any promise of stability, and using them will probably put your nginx-proxy setup at risk of experiencing uncontrolled updates to non backward compatible versions (or versions with breaking changes). You should always specify the version you want to use explicitly to ensure your setup doesn't break when the image is updated.
+    > `ERR_SSL_PROTOCOL_ERROR`

-### Additional documentation
+  * Firefox:

-Please check the [docs section](https://github.com/nginx-proxy/nginx-proxy/tree/main/docs).
+    > Secure Connection Failed
+    >
+    > An error occurred during a connection to example.test.
+    > Peer reports it experienced an internal error.
+    >
+    > Error code: `SSL_ERROR_INTERNAL_ERROR_ALERT` "TLS error".

-### Powered by 
+### Basic Authentication Support

-[![GoLand logo](https://resources.jetbrains.com/storage/products/company/brand/logos/GoLand_icon.svg)](https://www.jetbrains.com/go/)
-[![PyCharm logo](https://resources.jetbrains.com/storage/products/company/brand/logos/PyCharm_icon.svg)](https://www.jetbrains.com/pycharm/)
+In order to be able to secure your virtual host, you have to create a file named as its equivalent VIRTUAL_HOST variable on directory
+/etc/nginx/htpasswd/$VIRTUAL_HOST
+
+```console
+docker run -d -p 80:80 -p 443:443 \
+    -v /path/to/htpasswd:/etc/nginx/htpasswd \
+    -v /path/to/certs:/etc/nginx/certs \
+    -v /var/run/docker.sock:/tmp/docker.sock:ro \
+    nginxproxy/nginx-proxy
+```
+
+You'll need apache2-utils on the machine where you plan to create the htpasswd file. Follow these [instructions](http://httpd.apache.org/docs/2.2/programs/htpasswd.html)
+
+### Upstream (Backend) Server HTTP Load Balancing Support
+
+> **Warning**
+> This feature is experimental.  The behavior may change (or the feature may be removed entirely) without warning in a future release, even if the release is not a new major version.  If you use this feature, or if you would like to use this feature but you require changes to it first, please [provide feedback in #2195](https://github.com/nginx-proxy/nginx-proxy/discussions/2195).  Once we have collected enough feedback we will promote this feature to officially supported.
+
+If you have multiple containers with the same `VIRTUAL_HOST` and `VIRTUAL_PATH` settings, nginx will spread the load across all of them.  To change the load balancing algorithm from nginx's default (round-robin), set the `com.github.nginx-proxy.nginx-proxy.loadbalance` label on one or more of your application containers to the desired load balancing directive.  See the [`ngx_http_upstream_module` documentation](https://nginx.org/en/docs/http/ngx_http_upstream_module.html) for available directives.
+
+> **Note**
+> * Don't forget the terminating semicolon (`;`).
+> * If you are using Docker Compose, remember to escape any dollar sign (`$`) characters (`$` becomes `$$`).
+
+Docker Compose example:
+
+```yaml
+services:
+  nginx-proxy:
+    image: nginxproxy/nginx-proxy
+    ports:
+      - "80:80"
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
+    environment:
+      HTTPS_METHOD: nohttps
+  myapp:
+    image: jwilder/whoami
+    expose:
+      - "8000"
+    environment:
+      VIRTUAL_HOST: myapp.example
+      VIRTUAL_PORT: "8000"
+    labels:
+      com.github.nginx-proxy.nginx-proxy.loadbalance: "hash $$remote_addr;"
+    deploy:
+      replicas: 4
+```
+
+### Upstream (Backend) Server HTTP Keep-Alive Support
+
+> **Warning**
+> This feature is experimental.  The behavior may change (or the feature may be removed entirely) without warning in a future release, even if the release is not a new major version.  If you use this feature, or if you would like to use this feature but you require changes to it first, please [provide feedback in #2194](https://github.com/nginx-proxy/nginx-proxy/discussions/2194).  Once we have collected enough feedback we will promote this feature to officially supported.
+
+To enable HTTP keep-alive between `nginx-proxy` and a backend server, set the `com.github.nginx-proxy.nginx-proxy.keepalive` label on the server's container to the desired maximum number of idle connections. See the [nginx keepalive documentation](https://nginx.org/en/docs/http/ngx_http_upstream_module.html#keepalive) and the [Docker label documentation](https://docs.docker.com/config/labels-custom-metadata/) for details.
+
+### Headers
+
+By default, `nginx-proxy` forwards all incoming request headers from the client to the backend server unmodified, with the following exceptions:
+
+  * `Connection`: Set to `upgrade` if the client sets the `Upgrade` header, otherwise set to `close`. (Keep-alive between `nginx-proxy` and the backend server is not supported.)
+  * `Proxy`: Always removed if present. This prevents attackers from using the so-called [httpoxy attack](http://httpoxy.org). There is no legitimate reason for a client to send this header, and there are many vulnerable languages / platforms (`CVE-2016-5385`, `CVE-2016-5386`, `CVE-2016-5387`, `CVE-2016-5388`, `CVE-2016-1000109`, `CVE-2016-1000110`, `CERT-VU#797896`).
+  * `X-Real-IP`: Set to the client's IP address.
+  * `X-Forwarded-For`: The client's IP address is appended to the value provided by the client. (If the client did not provide this header, it is set to the client's IP address.)
+  * `X-Forwarded-Host`: If the client did not provide this header or if the `TRUST_DOWNSTREAM_PROXY` environment variable is set to `false` (see below), this is set to the value of the `Host` header provided by the client. Otherwise, the header is forwarded to the backend server unmodified.
+  * `X-Forwarded-Proto`: If the client did not provide this header or if the `TRUST_DOWNSTREAM_PROXY` environment variable is set to `false` (see below), this is set to `http` for plain HTTP connections and `https` for TLS connections. Otherwise, the header is forwarded to the backend server unmodified.
+  * `X-Forwarded-Ssl`: Set to `on` if the `X-Forwarded-Proto` header sent to the backend server is `https`, otherwise set to `off`.
+  * `X-Forwarded-Port`: If the client did not provide this header or if the `TRUST_DOWNSTREAM_PROXY` environment variable is set to `false` (see below), this is set to the port of the server that accepted the client's request. Otherwise, the header is forwarded to the backend server unmodified.
+  * `X-Original-URI`: Set to the original request URI.
+
+#### Trusting Downstream Proxy Headers
+
+For legacy compatibility reasons, `nginx-proxy` forwards any client-supplied `X-Forwarded-Proto` (which affects the value of `X-Forwarded-Ssl`), `X-Forwarded-Host`, and `X-Forwarded-Port` headers unchecked and unmodified. To prevent malicious clients from spoofing the protocol, hostname, or port that is perceived by your backend server, you are encouraged to set the `TRUST_DOWNSTREAM_PROXY` value to `false` if:
+
+  * you do not operate a second reverse proxy downstream of `nginx-proxy`, or
+  * you do operate a second reverse proxy downstream of `nginx-proxy` but that proxy forwards those headers unchecked from untrusted clients.
+
+The default for `TRUST_DOWNSTREAM_PROXY` may change to `false` in a future version of `nginx-proxy`. If you require it to be enabled, you are encouraged to explicitly set it to `true` to avoid compatibility problems when upgrading.
+
+### Custom Nginx Configuration
+
+If you need to configure Nginx beyond what is possible using environment variables, you can provide custom configuration files on either a proxy-wide or per-`VIRTUAL_HOST` basis.
+
+#### Replacing default proxy settings
+
+If you want to replace the default proxy settings for the nginx container, add a configuration file at `/etc/nginx/proxy.conf`. A file with the default settings would look like this:
+
+```Nginx
+# HTTP 1.1 support
+proxy_http_version 1.1;
+proxy_buffering off;
+proxy_set_header Host $http_host;
+proxy_set_header Upgrade $http_upgrade;
+proxy_set_header Connection $proxy_connection;
+proxy_set_header X-Real-IP $remote_addr;
+proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+proxy_set_header X-Forwarded-Host $proxy_x_forwarded_host;
+proxy_set_header X-Forwarded-Proto $proxy_x_forwarded_proto;
+proxy_set_header X-Forwarded-Ssl $proxy_x_forwarded_ssl;
+proxy_set_header X-Forwarded-Port $proxy_x_forwarded_port;
+proxy_set_header X-Original-URI $request_uri;
+
+# Mitigate httpoxy attack (see README for details)
+proxy_set_header Proxy "";
+```
+
+***NOTE***: If you provide this file it will replace the defaults; you may want to check the .tmpl file to make sure you have all of the needed options.
+
+#### Proxy-wide
+
+To add settings on a proxy-wide basis, add your configuration file under `/etc/nginx/conf.d` using a name ending in `.conf`.
+
+This can be done in a derived image by creating the file in a `RUN` command or by `COPY`ing the file into `conf.d`:
+
+```Dockerfile
+FROM nginxproxy/nginx-proxy
+RUN { \
+      echo 'server_tokens off;'; \
+      echo 'client_max_body_size 100m;'; \
+    } > /etc/nginx/conf.d/my_proxy.conf
+```
+
+Or it can be done by mounting in your custom configuration in your `docker run` command:
+
+```console
+docker run -d -p 80:80 -p 443:443 -v /path/to/my_proxy.conf:/etc/nginx/conf.d/my_proxy.conf:ro -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+```
+
+#### Per-VIRTUAL_HOST
+
+To add settings on a per-`VIRTUAL_HOST` basis, add your configuration file under `/etc/nginx/vhost.d`. Unlike in the proxy-wide case, which allows multiple config files with any name ending in `.conf`, the per-`VIRTUAL_HOST` file must be named exactly after the `VIRTUAL_HOST`.
+
+In order to allow virtual hosts to be dynamically configured as backends are added and removed, it makes the most sense to mount an external directory as `/etc/nginx/vhost.d` as opposed to using derived images or mounting individual configuration files.
+
+For example, if you have a virtual host named `app.example.com`, you could provide a custom configuration for that host as follows:
+
+```console
+docker run -d -p 80:80 -p 443:443 -v /path/to/vhost.d:/etc/nginx/vhost.d:ro -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+{ echo 'server_tokens off;'; echo 'client_max_body_size 100m;'; } > /path/to/vhost.d/app.example.com
+```
+
+If you are using multiple hostnames for a single container (e.g. `VIRTUAL_HOST=example.com,www.example.com`), the virtual host configuration file must exist for each hostname. If you would like to use the same configuration for multiple virtual host names, you can use a symlink:
+
+```console
+{ echo 'server_tokens off;'; echo 'client_max_body_size 100m;'; } > /path/to/vhost.d/www.example.com
+ln -s /path/to/vhost.d/www.example.com /path/to/vhost.d/example.com
+```
+
+#### Per-VIRTUAL_HOST default configuration
+
+If you want most of your virtual hosts to use a default single configuration and then override on a few specific ones, add those settings to the `/etc/nginx/vhost.d/default` file. This file will be used on any virtual host which does not have a `/etc/nginx/vhost.d/{VIRTUAL_HOST}` file associated with it.
+
+#### Per-VIRTUAL_HOST location configuration
+
+To add settings to the "location" block on a per-`VIRTUAL_HOST` basis, add your configuration file under `/etc/nginx/vhost.d` just like the previous section except with the suffix `_location`.
+
+For example, if you have a virtual host named `app.example.com` and you have configured a proxy_cache `my-cache` in another custom file, you could tell it to use a proxy cache as follows:
+
+```console
+docker run -d -p 80:80 -p 443:443 -v /path/to/vhost.d:/etc/nginx/vhost.d:ro -v /var/run/docker.sock:/tmp/docker.sock:ro nginxproxy/nginx-proxy
+{ echo 'proxy_cache my-cache;'; echo 'proxy_cache_valid  200 302  60m;'; echo 'proxy_cache_valid  404 1m;' } > /path/to/vhost.d/app.example.com_location
+```
+
+If you are using multiple hostnames for a single container (e.g. `VIRTUAL_HOST=example.com,www.example.com`), the virtual host configuration file must exist for each hostname. If you would like to use the same configuration for multiple virtual host names, you can use a symlink:
+
+```console
+{ echo 'proxy_cache my-cache;'; echo 'proxy_cache_valid  200 302  60m;'; echo 'proxy_cache_valid  404 1m;' } > /path/to/vhost.d/app.example.com_location
+ln -s /path/to/vhost.d/www.example.com /path/to/vhost.d/example.com
+```
+
+#### Per-VIRTUAL_HOST location default configuration
+
+If you want most of your virtual hosts to use a default single `location` block configuration and then override on a few specific ones, add those settings to the `/etc/nginx/vhost.d/default_location` file. This file will be used on any virtual host which does not have a `/etc/nginx/vhost.d/{VIRTUAL_HOST}_location` file associated with it.
+
+#### Overriding `location` blocks
+
+The `${VIRTUAL_HOST}_${PATH_HASH}_location`, `${VIRTUAL_HOST}_location`, and `default_location` files documented above make it possible to *augment* the generated [`location` block(s)](https://nginx.org/en/docs/http/ngx_http_core_module.html#location) in a virtual host.  In some circumstances, you may need to *completely override* the `location` block for a particular combination of virtual host and path.  To do this, create a file whose name follows this pattern:
+
+```
+/etc/nginx/vhost.d/${VIRTUAL_HOST}_${PATH_HASH}_location_override
+```
+
+where `${VIRTUAL_HOST}` is the name of the virtual host (the `VIRTUAL_HOST` environment variable) and `${PATH_HASH}` is the SHA-1 hash of the path, as [described above](#per-virtual_path-location-configuration).
+
+For convenience, the `_${PATH_HASH}` part can be omitted if the path is `/`:
+
+```
+/etc/nginx/vhost.d/${VIRTUAL_HOST}_location_override
+```
+
+When an override file exists, the `location` block that is normally created by `nginx-proxy` is not generated.  Instead, the override file is included via the [nginx `include` directive](https://nginx.org/en/docs/ngx_core_module.html#include).
+
+You are responsible for providing a suitable `location` block in your override file as required for your service.  By default, `nginx-proxy` uses the `VIRTUAL_HOST` name as the upstream name for your application's Docker container; see [here](#unhashed-vs-sha1-upstream-names) for details.  As an example, if your container has a `VIRTUAL_HOST` value of `app.example.com`, then to override the location block for `/` you would create a file named `/etc/nginx/vhost.d/app.example.com_location_override` that contains something like this:
+
+```
+location / {
+    proxy_pass http://app.example.com;
+}
+```
+
+#### Per-VIRTUAL_HOST `server_tokens` configuration
+Per virtual-host `servers_tokens` directive can be configured by passing appropriate value to the `SERVER_TOKENS` environment variable. Please see the [nginx http_core module configuration](https://nginx.org/en/docs/http/ngx_http_core_module.html#server_tokens) for more details.
+
+### Unhashed vs SHA1 upstream names
+
+By default the nginx configuration `upstream` blocks will use this block's corresponding hostname as a predictable name. However, this can cause issues in some setups (see [this issue](https://github.com/nginx-proxy/nginx-proxy/issues/1162)). In those cases you might want to switch to SHA1 names for the `upstream` blocks by setting the `SHA1_UPSTREAM_NAME` environment variable to `true` on the nginx-proxy container.
+
+Please note that using regular expressions in `VIRTUAL_HOST` will always result in a corresponding `upstream` block with an SHA1 name.
+
+### Troubleshooting
+
+If you can't access your `VIRTUAL_HOST`, inspect the generated nginx configuration:
+
+```console
+docker exec <nginx-proxy-instance> nginx -T
+```
+
+Pay attention to the `upstream` definition blocks, which should look like this:
+
+```Nginx
+# foo.example.com
+upstream foo.example.com {
+	## Can be connected with "my_network" network
+	# Exposed ports: [{   <exposed_port1>  tcp } {   <exposed_port2>  tcp } ...]
+	# Default virtual port: <exposed_port|80>
+	# VIRTUAL_PORT: <VIRTUAL_PORT>
+	# foo
+	server 172.18.0.9:<Port>;
+	# Fallback entry
+	server 127.0.0.1 down;
+}
+```
+
+The effective `Port` is retrieved by order of precedence:
+1. From the `VIRTUAL_PORT` environment variable
+1. From the container's exposed port if there is only one
+1. From the default port 80 when none of the above methods apply
+
+### Contributing
+
+Before submitting pull requests or issues, please check github to make sure an existing issue or pull request is not already open.
+
+#### Running Tests Locally
+
+To run tests, you just need to run the command below:
+
+```console
+make test
+```
+
+This commands run tests on two variants of the nginx-proxy docker image: Debian and Alpine.
+
+You can run the tests for each of these images with their respective commands:
+
+```console
+make test-debian
+make test-alpine
+```
+
+You can learn more about how the test suite works and how to write new tests in the [test/README.md](test/README.md) file.
--- a/app/Procfile
+++ b/app/Procfile
@ -1,2 +1,2 @@
 dockergen: docker-gen -watch -notify "nginx -s reload" /app/nginx.tmpl /etc/nginx/conf.d/default.conf
-nginx: nginx -g "daemon off;"
+nginx: nginx
--- a/docker-compose-separate-containers.yml
+++ b/docker-compose-separate-containers.yml
@ -1,6 +1,4 @@
-volumes:
-  nginx_conf:
-
+version: '2'
 services:
  nginx:
    image: nginx
@ -8,17 +6,19 @@ services:
    ports:
      - "80:80"
    volumes:
-      - nginx_conf:/etc/nginx/conf.d:ro
+      - /etc/nginx/conf.d

  dockergen:
    image: nginxproxy/docker-gen
-    command: -notify-sighup nginx -watch /etc/docker-gen/templates/nginx.tmpl /etc/nginx/conf.d/default.conf
+    command: -notify-sighup nginx -watch /etc/docker-gen/templates/nginx.tmpl
+      /etc/nginx/conf.d/default.conf
+    volumes_from:
+      - nginx
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - ./nginx.tmpl:/etc/docker-gen/templates/nginx.tmpl
-      - nginx_conf:/etc/nginx/conf.d

  whoami:
    image: jwilder/whoami
    environment:
-      - VIRTUAL_HOST=whoami.example
+      - VIRTUAL_HOST=whoami.local
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -1,3 +1,4 @@
+version: '2'
 services:
  nginx-proxy:
    image: nginxproxy/nginx-proxy
@ -7,10 +8,7 @@ services:
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro

-    # if you want to proxy based on host ports, you'll want to use the host network
-    # network_mode: "host"
-
  whoami:
    image: jwilder/whoami
    environment:
-      - VIRTUAL_HOST=whoami.example
+      - VIRTUAL_HOST=whoami.local
--- a/docs/README.md
+++ b/docs/README.md
--- a/nginx.tmpl
+++ b/nginx.tmpl
--- a/test/README.md
+++ b/test/README.md
@ -4,10 +4,12 @@ Nginx proxy test suite
 Install requirements
 --------------------

-You need [Docker Compose v2](https://docs.docker.com/compose/install/linux/), [python 3.9](https://www.python.org/) and [pip](https://pip.pypa.io/en/stable/installation/)  installed. Then run the commands:
+You need [python 3.9](https://www.python.org/) and [pip](https://pip.pypa.io/en/stable/installing/) installed. Then run the commands:

    pip install -r requirements/python-requirements.txt

+
+
 Prepare the nginx-proxy test image
 ----------------------------------

@ -26,25 +28,12 @@ need more verbosity ?

    pytest -s

-Note: By default this test suite relies on Docker Compose v2 with the command `docker compose`. It still supports Docker Compose v1 via the `DOCKER_COMPOSE` environment variable:
-
-    DOCKER_COMPOSE=docker-compose pytest

 Run one single test module
 --------------------------

    pytest test_nominal.py

-Run the test suite from a Docker container
------------------------------------------
-
-If you cannot (or don't want to) install pytest and its requirements on your computer. You can use the nginx-proxy-tester docker image to run the test suite from a Docker container.
-
-    make test-debian
-
-or if you want to test the alpine flavor:
-
-    make test-alpine

 Write a test module
 -------------------
@ -57,39 +46,13 @@ This test suite uses [pytest](http://doc.pytest.org/en/latest/). The [conftest.p

 ### docker_compose fixture

-When using the `docker_compose` fixture in a test, pytest will try to start the [Docker Compose](https://docs.docker.com/compose/) services corresponding to the current test module, based on the test module filename.
+When using the `docker_compose` fixture in a test, pytest will try to find a yml file named after your test module filename. For instance, if your test module is `test_example.py`, then the `docker_compose` fixture will try to load a `test_example.yml` [docker compose file](https://docs.docker.com/compose/compose-file/).

-By default, if your test module file is `test/test_subdir/test_example.py`, then the `docker_compose` fixture will try to load the following files, [merging them](https://docs.docker.com/reference/compose-file/merge/) in this order:
+Once the docker compose file found, the fixture will remove all containers, run `docker-compose up`, and finally your test will be executed.

-1. `test/compose.base.yml`
-2. `test/test_subdir/compose.base.override.yml` (if it exists)
-3. `test/test_subdir/test_example.yml`
+The fixture will run the _docker-compose_ command with the `-f` option to load the given compose file. So you can test your docker compose file syntax by running it yourself with:

-The fixture will run the _docker compose_ command with the `-f` option to load the given compose files. So you can test your docker compose file syntax by running it yourself with:
-
-    docker compose -f test/compose.base.yml -f test/test_subdir/test_example.yml up -d
-
-The first file contains the base configuration of the nginx-proxy container common to most tests:
-
-```yaml
-services:
-  nginx-proxy:
-    image: nginxproxy/nginx-proxy:test
-    container_name: nginx-proxy
-    volumes:
-      - /var/run/docker.sock:/tmp/docker.sock:ro
-    ports:
-      - "80:80"
-      - "443:443"
-```
-
-The second optional file allow you to override this base configuration for all test modules in a subfolder.
-
-The third file contains the services and overrides specific to a given test module.
-
-This automatic merge can be bypassed by using a file named `test_example.base.yml` (instead of `test_example.yml`). When this file exist, it will be the only one used by the test and no merge with other compose files will automatically occur.
-
-The `docker_compose` fixture also set the `PYTEST_MODULE_PATH` environment variable to the absolute path of the current test module directory, so it can be used to mount files or directory relatives to the current test.
+    docker-compose -f test_example.yml up -d

 In the case you are running pytest from within a docker container, the `docker_compose` fixture will make sure the container running pytest is attached to all docker networks. That way, your test will be able to reach any of them.

@ -97,10 +60,7 @@ In your tests, you can use the `docker_compose` variable to query and command th

 Also this fixture alters the way the python interpreter resolves domain names to IP addresses in the following ways:

-Any domain name containing the substring `nginx-proxy` will resolve to `127.0.0.1` if the tests are executed on a Darwin (macOS) system, otherwise the IP address of the container that was created from the `nginxproxy/nginx-proxy:test` image.
-
-So, in tests, all the following domain names will resolve to either localhost or the nginx-proxy container's IP:
-
+Any domain name containing the substring `nginx-proxy` will resolve to the IP address of the container that was created from the `nginxproxy/nginx-proxy:test` image. So all the following domain names will resolve to the nginx-proxy container in tests:
 - `nginx-proxy`
 - `nginx-proxy.com`
 - `www.nginx-proxy.com`
@ -109,16 +69,14 @@ So, in tests, all the following domain names will resolve to either localhost or
 - `whatever.nginx-proxyooooooo`
 - ...

-Any domain name ending with `XXX.container.docker` will resolve to `127.0.0.1` if the tests are executed on a Darwin (macOS) system, otherwise the IP address of the container named `XXX`.
-
-So, on a non-Darwin system:
-
+Any domain name ending with `XXX.container.docker` will resolve to the IP address of the XXX container.
 - `web1.container.docker` will resolve to the IP address of the `web1` container
 - `f00.web1.container.docker` will resolve to the IP address of the `web1` container
 - `anything.whatever.web2.container.docker` will resolve to the IP address of the `web2` container

 Otherwise, domain names are resoved as usual using your system DNS resolver.

+
 ### nginxproxy fixture

 The `nginxproxy` fixture will provide you with a replacement for the python [requests](https://pypi.python.org/pypi/requests/) module. This replacement will just repeat up to 30 times a requests if it receives the HTTP error 404 or 502. This error occurs when you try to send queries to nginx-proxy too early after the container creation.
--- a/test/certs/create_server_certificate.sh
+++ b/test/certs/create_server_certificate.sh
@ -24,7 +24,7 @@ fi
 # Create a nginx container (which conveniently provides the `openssl` command)
 ###############################################################################

-CONTAINER=$(docker run -d -v $DIR:/work -w /work -e SAN="$ALTERNATE_DOMAINS" nginx:1.27.3)
+CONTAINER=$(docker run -d -v $DIR:/work -w /work -e SAN="$ALTERNATE_DOMAINS" nginx:1.19.10)
 # Configure openssl
 docker exec $CONTAINER bash -c '
 	mkdir -p /ca/{certs,crl,private,newcerts} 2>/dev/null
--- a/test/compose.base.yml
+++ b/test/compose.base.yml
@ -1,9 +0,0 @@
-services:
-  nginx-proxy:
-    image: nginxproxy/nginx-proxy:test
-    container_name: nginx-proxy
-    volumes:
-      - /var/run/docker.sock:/tmp/docker.sock:ro
-    ports:
-      - "80:80"
-      - "443:443"
--- a/test/conftest.py
+++ b/test/conftest.py
@ -1,39 +1,31 @@
 import contextlib
 import logging
 import os
-import pathlib
-import platform
 import re
 import shlex
 import socket
 import subprocess
 import time
-from io import StringIO
-from typing import Iterator, List, Optional
+from typing import List

 import backoff
-import docker.errors
+import docker
 import pytest
 import requests
-from _pytest.fixtures import FixtureRequest
-from docker import DockerClient
+from _pytest._code.code import ReprExceptionInfo
+from distutils.version import LooseVersion
 from docker.models.containers import Container
-from docker.models.networks import Network
-from packaging.version import Version
-from requests import Response
-from urllib3.util.connection import HAS_IPV6
-
+from requests.packages.urllib3.util.connection import HAS_IPV6

 logging.basicConfig(level=logging.INFO)
 logging.getLogger('backoff').setLevel(logging.INFO)
 logging.getLogger('DNS').setLevel(logging.DEBUG)
 logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.WARN)

-CA_ROOT_CERTIFICATE = pathlib.Path(__file__).parent.joinpath("certs/ca-root.crt")
+CA_ROOT_CERTIFICATE = os.path.join(os.path.dirname(__file__), 'certs/ca-root.crt')
 PYTEST_RUNNING_IN_CONTAINER = os.environ.get('PYTEST_RUNNING_IN_CONTAINER') == "1"
 FORCE_CONTAINER_IPV6 = False  # ugly global state to consider containers' IPv6 address instead of IPv4

-DOCKER_COMPOSE = os.environ.get('DOCKER_COMPOSE', 'docker compose')

 docker_client = docker.from_env()

@ -47,17 +39,16 @@ test_container = 'nginx-proxy-pytest'
 #
 ###############################################################################

-
@contextlib.contextmanager
-def ipv6(force_ipv6: bool = True):
+def ipv6(force_ipv6=True):
    """
    Meant to be used as a context manager to force IPv6 sockets:

        with ipv6():
-            nginxproxy.get("http://something.nginx-proxy.example")  # force use of IPv6
+            nginxproxy.get("http://something.nginx-proxy.local")  # force use of IPv6

        with ipv6(False):
-            nginxproxy.get("http://something.nginx-proxy.example")  # legacy behavior
+            nginxproxy.get("http://something.nginx-proxy.local")  # legacy behavior


    """
@ -67,19 +58,19 @@ def ipv6(force_ipv6: bool = True):
    FORCE_CONTAINER_IPV6 = False


-class RequestsForDocker:
+class requests_for_docker(object):
    """
    Proxy for calling methods of the requests module.
-    When an HTTP response failed due to HTTP Error 404 or 502, retry a few times.
+    When a HTTP response failed due to HTTP Error 404 or 502, retry a few times.
    Provides method `get_conf` to extract the nginx-proxy configuration content.
    """
    def __init__(self):
        self.session = requests.Session()
-        if CA_ROOT_CERTIFICATE.is_file():
-            self.session.verify = CA_ROOT_CERTIFICATE.as_posix()
+        if os.path.isfile(CA_ROOT_CERTIFICATE):
+            self.session.verify = CA_ROOT_CERTIFICATE

    @staticmethod
-    def get_nginx_proxy_container() -> Container:
+    def get_nginx_proxy_containers() -> List[Container]:
        """
        Return list of containers
        """
@ -88,69 +79,69 @@ class RequestsForDocker:
            pytest.fail("Too many running nginxproxy/nginx-proxy:test containers", pytrace=False)
        elif len(nginx_proxy_containers) == 0:
            pytest.fail("No running nginxproxy/nginx-proxy:test container", pytrace=False)
-        return nginx_proxy_containers.pop()
+        return nginx_proxy_containers

-    def get_conf(self) -> bytes:
+    def get_conf(self):
        """
        Return the nginx config file
        """
-        nginx_proxy_container = self.get_nginx_proxy_container()
-        return get_nginx_conf_from_container(nginx_proxy_container)
+        nginx_proxy_containers = self.get_nginx_proxy_containers()
+        return get_nginx_conf_from_container(nginx_proxy_containers[0])

    def get_ip(self) -> str:
        """
        Return the nginx container ip address
        """
-        nginx_proxy_container = self.get_nginx_proxy_container()
-        return container_ip(nginx_proxy_container)
+        nginx_proxy_containers = self.get_nginx_proxy_containers()
+        return container_ip(nginx_proxy_containers[0])

-    def get(self, *args, **kwargs) -> Response:
+    def get(self, *args, **kwargs):
        with ipv6(kwargs.pop('ipv6', False)):
            @backoff.on_predicate(backoff.constant, lambda r: r.status_code in (404, 502), interval=.3, max_tries=30, jitter=None)
-            def _get(*_args, **_kwargs):
-                return self.session.get(*_args, **_kwargs)
+            def _get(*args, **kwargs):
+                return self.session.get(*args, **kwargs)
            return _get(*args, **kwargs)

-    def post(self, *args, **kwargs) -> Response:
+    def post(self, *args, **kwargs):
        with ipv6(kwargs.pop('ipv6', False)):
            @backoff.on_predicate(backoff.constant, lambda r: r.status_code in (404, 502), interval=.3, max_tries=30, jitter=None)
-            def _post(*_args, **_kwargs):
-                return self.session.post(*_args, **_kwargs)
+            def _post(*args, **kwargs):
+                return self.session.post(*args, **kwargs)
            return _post(*args, **kwargs)

-    def put(self, *args, **kwargs) -> Response:
+    def put(self, *args, **kwargs):
        with ipv6(kwargs.pop('ipv6', False)):
            @backoff.on_predicate(backoff.constant, lambda r: r.status_code in (404, 502), interval=.3, max_tries=30, jitter=None)
-            def _put(*_args, **_kwargs):
-                return self.session.put(*_args, **_kwargs)
+            def _put(*args, **kwargs):
+                return self.session.put(*args, **kwargs)
            return _put(*args, **kwargs)

-    def head(self, *args, **kwargs) -> Response:
+    def head(self, *args, **kwargs):
        with ipv6(kwargs.pop('ipv6', False)):
            @backoff.on_predicate(backoff.constant, lambda r: r.status_code in (404, 502), interval=.3, max_tries=30, jitter=None)
-            def _head(*_args, **_kwargs):
-                return self.session.head(*_args, **_kwargs)
+            def _head(*args, **kwargs):
+                return self.session.head(*args, **kwargs)
            return _head(*args, **kwargs)

-    def delete(self, *args, **kwargs) -> Response:
+    def delete(self, *args, **kwargs):
        with ipv6(kwargs.pop('ipv6', False)):
            @backoff.on_predicate(backoff.constant, lambda r: r.status_code in (404, 502), interval=.3, max_tries=30, jitter=None)
-            def _delete(*_args, **_kwargs):
-                return self.session.delete(*_args, **_kwargs)
+            def _delete(*args, **kwargs):
+                return self.session.delete(*args, **kwargs)
            return _delete(*args, **kwargs)

-    def options(self, *args, **kwargs) -> Response:
+    def options(self, *args, **kwargs):
        with ipv6(kwargs.pop('ipv6', False)):
            @backoff.on_predicate(backoff.constant, lambda r: r.status_code in (404, 502), interval=.3, max_tries=30, jitter=None)
-            def _options(*_args, **_kwargs):
-                return self.session.options(*_args, **_kwargs)
+            def _options(*args, **kwargs):
+                return self.session.options(*args, **kwargs)
            return _options(*args, **kwargs)

    def __getattr__(self, name):
        return getattr(requests, name)


-def container_ip(container: Container) -> str:
+def container_ip(container: Container):
    """
    return the IP address of a container.

@ -170,16 +161,12 @@ def container_ip(container: Container) -> str:
        if "bridge" in net_info:
            return net_info["bridge"]["IPAddress"]

-        # container is running in host network mode
-        if "host" in net_info:
-            return "127.0.0.1"
-
        # not default bridge network, fallback on first network defined
        network_name = list(net_info.keys())[0]
        return net_info[network_name]["IPAddress"]


-def container_ipv6(container: Container) -> str:
+def container_ipv6(container):
    """
    return the IPv6 address of a container.
    """
@ -187,16 +174,12 @@ def container_ipv6(container: Container) -> str:
    if "bridge" in net_info:
        return net_info["bridge"]["GlobalIPv6Address"]

-    # container is running in host network mode
-    if "host" in net_info:
-        return "::1"
-
    # not default bridge network, fallback on first network defined
    network_name = list(net_info.keys())[0]
    return net_info[network_name]["GlobalIPv6Address"]


-def nginx_proxy_dns_resolver(domain_name: str) -> Optional[str]:
+def nginx_proxy_dns_resolver(domain_name):
    """
    if "nginx-proxy" if found in host, return the ip address of the docker container
    issued from the docker image nginxproxy/nginx-proxy:test.
@ -208,21 +191,21 @@ def nginx_proxy_dns_resolver(domain_name: str) -> Optional[str]:
    if 'nginx-proxy' in domain_name:
        nginxproxy_containers = docker_client.containers.list(filters={"status": "running", "ancestor": "nginxproxy/nginx-proxy:test"})
        if len(nginxproxy_containers) == 0:
-            log.warning(f"no container found from image nginxproxy/nginx-proxy:test while resolving {domain_name!r}")
+            log.warn(f"no container found from image nginxproxy/nginx-proxy:test while resolving {domain_name!r}")
            exited_nginxproxy_containers = docker_client.containers.list(filters={"status": "exited", "ancestor": "nginxproxy/nginx-proxy:test"})
            if len(exited_nginxproxy_containers) > 0:
                exited_nginxproxy_container_logs = exited_nginxproxy_containers[0].logs()
-                log.warning(f"nginxproxy/nginx-proxy:test container might have exited unexpectedly. Container logs: " + "\n" + exited_nginxproxy_container_logs.decode())
-            return None
+                log.warn(f"nginxproxy/nginx-proxy:test container might have exited unexpectedly. Container logs: " + "\n" + exited_nginxproxy_container_logs.decode())
+            return
        nginxproxy_container = nginxproxy_containers[0]
        ip = container_ip(nginxproxy_container)
        log.info(f"resolving domain name {domain_name!r} as IP address {ip} of nginx-proxy container {nginxproxy_container.name}")
        return ip

-def docker_container_dns_resolver(domain_name: str) -> Optional[str]:
+def docker_container_dns_resolver(domain_name):
    """
-    if domain name is of the form "XXX.container.docker" or "anything.XXX.container.docker",
-    return the ip address of the docker container named XXX.
+    if domain name is of the form "XXX.container.docker" or "anything.XXX.container.docker", return the ip address of the docker container
+    named XXX.

    :return: IP or None
    """
@ -232,15 +215,15 @@ def docker_container_dns_resolver(domain_name: str) -> Optional[str]:
    match = re.search(r'(^|.+\.)(?P<container>[^.]+)\.container\.docker$', domain_name)
    if not match:
        log.debug(f"{domain_name!r} does not match")
-        return None
+        return

    container_name = match.group('container')
    log.debug(f"looking for container {container_name!r}")
    try:
        container = docker_client.containers.get(container_name)
    except docker.errors.NotFound:
-        log.warning(f"container named {container_name!r} not found while resolving {domain_name!r}")
-        return None
+        log.warn(f"container named {container_name!r} not found while resolving {domain_name!r}")
+        return
    log.debug(f"container {container.name!r} found ({container.short_id})")

    ip = container_ip(container)
@ -252,10 +235,7 @@ def monkey_patch_urllib_dns_resolver():
    """
    Alter the behavior of the urllib DNS resolver so that any domain name
    containing substring 'nginx-proxy' will resolve to the IP address
-    of the container created from image 'nginxproxy/nginx-proxy:test',
-    or to 127.0.0.1 on Darwin.
-
-    see https://docs.docker.com/desktop/features/networking/#i-want-to-connect-to-a-container-from-the-host
+    of the container created from image 'nginxproxy/nginx-proxy:test'.
    """
    prv_getaddrinfo = socket.getaddrinfo
    dns_cache = {}
@ -263,17 +243,12 @@ def monkey_patch_urllib_dns_resolver():
        logging.getLogger('DNS').debug(f"resolving domain name {repr(args)}")
        _args = list(args)

-        # Fail early when querying IP directly, and it is forced ipv6 when not supported,
+        # Fail early when querying IP directly and it is forced ipv6 when not supported,
        # Otherwise a pytest container not using the host network fails to pass `test_raw-ip-vhost`.
        if FORCE_CONTAINER_IPV6 and not HAS_IPV6:
            pytest.skip("This system does not support IPv6")

        # custom DNS resolvers
-        ip = None
-        # Docker Desktop can't route traffic directly to Linux containers.
-        if platform.system() == "Darwin":
-            ip = "127.0.0.1"
-        if ip is None:
        ip = nginx_proxy_dns_resolver(args[0])
        if ip is None:
            ip = docker_container_dns_resolver(args[0])
@ -290,12 +265,19 @@ def monkey_patch_urllib_dns_resolver():
    socket.getaddrinfo = new_getaddrinfo
    return prv_getaddrinfo

-
 def restore_urllib_dns_resolver(getaddrinfo_func):
    socket.getaddrinfo = getaddrinfo_func


-def get_nginx_conf_from_container(container: Container) -> bytes:
+def remove_all_containers():
+    for container in docker_client.containers.list(all=True):
+        if PYTEST_RUNNING_IN_CONTAINER and container.name == test_container:
+            continue  # pytest is running within a Docker container, so we do not want to remove that particular container
+        logging.info(f"removing container {container.name}")
+        container.remove(v=True, force=True)
+
+
+def get_nginx_conf_from_container(container):
    """
    return the nginx /etc/nginx/conf.d/default.conf file content from a container
    """
@ -310,40 +292,20 @@ def get_nginx_conf_from_container(container: Container) -> bytes:
        return conffile.read()


-def __prepare_and_execute_compose_cmd(compose_files: List[str], project_name: str, cmd: str):
-    """
-    Prepare and execute the Docker Compose command with the provided compose files and project name.
-    """
-    compose_cmd = StringIO()
-    compose_cmd.write(DOCKER_COMPOSE)
-    compose_cmd.write(f" --project-name {project_name}")
-    for compose_file in compose_files:
-        compose_cmd.write(f" --file {compose_file}")
-    compose_cmd.write(f" {cmd}")
-
-    logging.info(compose_cmd.getvalue())
+def docker_compose_up(compose_file='docker-compose.yml'):
+    logging.info(f'docker-compose -f {compose_file} up -d')
    try:
-        subprocess.check_output(shlex.split(compose_cmd.getvalue()), stderr=subprocess.STDOUT)
+        subprocess.check_output(shlex.split(f'docker-compose -f {compose_file} up -d'), stderr=subprocess.STDOUT)
    except subprocess.CalledProcessError as e:
-        pytest.fail(f"Error while running '{compose_cmd.getvalue()}':\n{e.output}", pytrace=False)
+        pytest.fail(f"Error while runninng 'docker-compose -f {compose_file} up -d':\n{e.output}", pytrace=False)


-def docker_compose_up(compose_files: List[str], project_name: str):
-    """
-    Execute compose up --detach with the provided compose files and project name.
-    """
-    if compose_files is None or len(compose_files) == 0:
-        pytest.fail(f"No compose file passed to docker_compose_up", pytrace=False)
-    __prepare_and_execute_compose_cmd(compose_files, project_name, cmd="up --detach")
-
-
-def docker_compose_down(compose_files: List[str], project_name: str):
-    """
-    Execute compose down --volumes with the provided compose files and project name.
-    """
-    if compose_files is None or len(compose_files) == 0:
-        pytest.fail(f"No compose file passed to docker_compose_up", pytrace=False)
-    __prepare_and_execute_compose_cmd(compose_files, project_name, cmd="down --volumes")
+def docker_compose_down(compose_file='docker-compose.yml'):
+    logging.info(f'docker-compose -f {compose_file} down -v')
+    try:
+        subprocess.check_output(shlex.split(f'docker-compose -f {compose_file} down -v'), stderr=subprocess.STDOUT)
+    except subprocess.CalledProcessError as e:
+        pytest.fail(f"Error while runninng 'docker-compose -f {compose_file} down -v':\n{e.output}", pytrace=False)


 def wait_for_nginxproxy_to_be_ready():
@ -362,50 +324,35 @@ def wait_for_nginxproxy_to_be_ready():


@pytest.fixture
-def docker_compose_files(request: FixtureRequest) -> List[str]:
-    """Fixture returning the docker compose files to consider:
+def docker_compose_file(request):
+    """Fixture naming the docker-compose file to consider.

-    If a YAML file exists with the same name as the test module (with the `.py` extension
-    replaced with `.base.yml`, ie `test_foo.py`-> `test_foo.base.yml`) and in the same
-    directory as the test module, use only that file.
-
-    Otherwise, merge the following files in this order:
-
-    - the `compose.base.yml` file in the parent `test` directory.
-    - if present in the same directory as the test module, the `compose.base.override.yml` file.
-    - the YAML file named after the current test module (ie `test_foo.py`-> `test_foo.yml`)
+    If a YAML file exists with the same name as the test module (with the `.py` extension replaced
+    with `.yml` or `.yaml`), use that.  Otherwise, use `docker-compose.yml` in the same directory
+    as the test module.

    Tests can override this fixture to specify a custom location.
    """
-    compose_files: List[str] = []
-    test_module_path = pathlib.Path(request.module.__file__).parent
+    test_module_dir = os.path.dirname(request.module.__file__)
+    yml_file = os.path.join(test_module_dir, request.module.__name__ + '.yml')
+    yaml_file = os.path.join(test_module_dir, request.module.__name__ + '.yaml')
+    default_file = os.path.join(test_module_dir, 'docker-compose.yml')

-    module_base_file = test_module_path.joinpath(f"{request.module.__name__}.base.yml")
-    if module_base_file.is_file():
-        return [module_base_file.as_posix()]
+    if os.path.isfile(yml_file):
+        docker_compose_file = yml_file
+    elif os.path.isfile(yaml_file):
+        docker_compose_file = yaml_file
+    else:
+        docker_compose_file = default_file

-    global_base_file = test_module_path.parent.joinpath("compose.base.yml")
-    if global_base_file.is_file():
-        compose_files.append(global_base_file.as_posix())
+    if not os.path.isfile(docker_compose_file):
+        logging.error("Could not find any docker-compose file named either '{0}.yml', '{0}.yaml' or 'docker-compose.yml'".format(request.module.__name__))

-    module_base_override_file = test_module_path.joinpath("compose.base.override.yml")
-    if module_base_override_file.is_file():
-        compose_files.append(module_base_override_file.as_posix())
-
-    module_compose_file = test_module_path.joinpath(f"{request.module.__name__}.yml")
-    if module_compose_file.is_file():
-        compose_files.append(module_compose_file.as_posix())
-
-    if not module_base_file.is_file() and not module_compose_file.is_file():
-        logging.error(
-            f"Could not find any docker compose file named '{module_base_file.name}' or '{module_compose_file.name}'"
-        )
-
-    logging.debug(f"using docker compose files {compose_files}")
-    return compose_files
+    logging.debug(f"using docker compose file {docker_compose_file}")
+    return docker_compose_file


-def connect_to_network(network: Network) -> Optional[Network]:
+def connect_to_network(network):
    """
    If we are running from a container, connect our container to the given network

@ -415,8 +362,8 @@ def connect_to_network(network: Network) -> Optional[Network]:
        try:
            my_container = docker_client.containers.get(test_container)
        except docker.errors.NotFound:
-            logging.warning(f"container {test_container} not found")
-            return None
+            logging.warn(f"container {test_container} not found")
+            return

        # figure out our container networks
        my_networks = list(my_container.attrs["NetworkSettings"]["Networks"].keys())
@ -433,7 +380,7 @@ def connect_to_network(network: Network) -> Optional[Network]:
            return network


-def disconnect_from_network(network: Network = None):
+def disconnect_from_network(network=None):
    """
    If we are running from a container, disconnect our container from the given network.

@ -443,7 +390,7 @@ def disconnect_from_network(network: Network = None):
        try:
            my_container = docker_client.containers.get(test_container)
        except docker.errors.NotFound:
-            logging.warning(f"container {test_container} not found")
+            logging.warn(f"container {test_container} not found")
            return

        # figure out our container networks
@ -455,7 +402,7 @@ def disconnect_from_network(network: Network = None):
            network.disconnect(my_container)


-def connect_to_all_networks() -> List[Network]:
+def connect_to_all_networks():
    """
    If we are running from a container, connect our container to all current docker networks.

@ -471,34 +418,31 @@ def connect_to_all_networks() -> List[Network]:

 class DockerComposer(contextlib.AbstractContextManager):
    def __init__(self):
-        self._networks = None
-        self._docker_compose_files = None
-        self._project_name = None
+        self._docker_compose_file = None

    def __exit__(self, *exc_info):
        self._down()

    def _down(self):
-        if self._docker_compose_files is None:
+        if self._docker_compose_file is None:
            return
        for network in self._networks:
            disconnect_from_network(network)
-        docker_compose_down(self._docker_compose_files, self._project_name)
+        docker_compose_down(self._docker_compose_file)
        self._docker_compose_file = None
-        self._project_name = None

-    def compose(self, docker_compose_files: List[str], project_name: str):
-        if docker_compose_files == self._docker_compose_files and project_name == self._project_name:
+    def compose(self, docker_compose_file):
+        if docker_compose_file == self._docker_compose_file:
            return
        self._down()
-        if docker_compose_files is None or project_name is None:
+        if docker_compose_file is None:
            return
-        docker_compose_up(docker_compose_files, project_name)
+        remove_all_containers()
+        docker_compose_up(docker_compose_file)
        self._networks = connect_to_all_networks()
        wait_for_nginxproxy_to_be_ready()
        time.sleep(3)  # give time to containers to be ready
-        self._docker_compose_files = docker_compose_files
-        self._project_name = project_name
+        self._docker_compose_file = docker_compose_file


 ###############################################################################
@ -509,14 +453,14 @@ class DockerComposer(contextlib.AbstractContextManager):


@pytest.fixture(scope="module")
-def docker_composer() -> Iterator[DockerComposer]:
+def docker_composer():
    with DockerComposer() as d:
        yield d


@pytest.fixture
-def ca_root_certificate() -> str:
-    return CA_ROOT_CERTIFICATE.as_posix()
+def ca_root_certificate():
+    return CA_ROOT_CERTIFICATE


@pytest.fixture
@ -527,38 +471,25 @@ def monkey_patched_dns():


@pytest.fixture
-def docker_compose(
-        request: FixtureRequest,
-        monkeypatch,
-        monkey_patched_dns,
-        docker_composer,
-        docker_compose_files
-) -> Iterator[DockerClient]:
+def docker_compose(monkey_patched_dns, docker_composer, docker_compose_file):
+    """Ensures containers described in a docker compose file are started.
+
+    A custom docker compose file name can be specified by overriding the `docker_compose_file`
+    fixture.
+
+    Also, in the case where pytest is running from a docker container, this fixture makes sure
+    our container will be attached to all the docker networks.
    """
-    Ensures containers necessary for the test module are started in a compose project,
-    and set the environment variable `PYTEST_MODULE_PATH` to the test module's parent folder.
-
-    A list of custom docker compose files path can be specified by overriding
-    the `docker_compose_file` fixture.
-
-    Also, in the case where pytest is running from a docker container, this fixture
-    makes sure our container will be attached to all the docker networks.
-    """
-    pytest_module_path = pathlib.Path(request.module.__file__).parent
-    monkeypatch.setenv("PYTEST_MODULE_PATH", pytest_module_path.as_posix())
-
-    project_name = request.module.__name__
-    docker_composer.compose(docker_compose_files, project_name)
-
+    docker_composer.compose(docker_compose_file)
    yield docker_client


-@pytest.fixture
-def nginxproxy() -> Iterator[RequestsForDocker]:
+@pytest.fixture()
+def nginxproxy():
    """
    Provides the `nginxproxy` object that can be used in the same way the requests module is:

-    r = nginxproxy.get("https://foo.com")
+    r = nginxproxy.get("http://foo.com")

    The difference is that in case an HTTP requests has status code 404 or 502 (which mostly
    indicates that nginx has just reloaded), we retry up to 30 times the query.
@ -567,29 +498,23 @@ def nginxproxy() -> Iterator[RequestsForDocker]:
    made against containers to use the containers IPv6 address when set to `True`. If IPv6 is not
    supported by the system or docker, that particular test will be skipped.
    """
-    yield RequestsForDocker()
+    yield requests_for_docker()


-@pytest.fixture
-def acme_challenge_path() -> str:
-    """
-    Provides fake Let's Encrypt ACME challenge path used in certain tests
-    """
-    return ".well-known/acme-challenge/test-filename"
-
 ###############################################################################
 #
 # Py.test hooks
 #
 ###############################################################################

-# pytest hook to display additional stuff in test report
+# pytest hook to display additionnal stuff in test report
 def pytest_runtest_logreport(report):
    if report.failed:
+        if isinstance(report.longrepr, ReprExceptionInfo):
            test_containers = docker_client.containers.list(all=True, filters={"ancestor": "nginxproxy/nginx-proxy:test"})
            for container in test_containers:
-            report.longrepr.addsection('nginx-proxy logs', container.logs().decode())
-            report.longrepr.addsection('nginx-proxy conf', get_nginx_conf_from_container(container).decode())
+                report.longrepr.addsection('nginx-proxy logs', container.logs())
+                report.longrepr.addsection('nginx-proxy conf', get_nginx_conf_from_container(container))


 # Py.test `incremental` marker, see http://stackoverflow.com/a/12579625/107049
@ -616,5 +541,5 @@ try:
 except docker.errors.ImageNotFound:
    pytest.exit("The docker image 'nginxproxy/nginx-proxy:test' is missing")

-if Version(docker.__version__) < Version("7.0.0"):
-    pytest.exit("This test suite is meant to work with the python docker module v7.0.0 or later")
+if LooseVersion(docker.__version__) < LooseVersion("5.0.0"):
+    pytest.exit("This test suite is meant to work with the python docker module v5.0.0 or later")
--- a/test/pytest.ini
+++ b/test/pytest.ini
@ -1,5 +1,5 @@
 [pytest]
 # disable the creation of the `.cache` folders
-addopts = -p no:cacheprovider --ignore=requirements --ignore=certs --color=yes -v
+addopts = -p no:cacheprovider --ignore=requirements --ignore=certs -r s -v
 markers =
    incremental: mark a test as incremental.
--- a/test/pytest.sh
+++ b/test/pytest.sh
@ -3,7 +3,7 @@
 #                                                                             #
 # This script is meant to run the test suite from a Docker container.         #
 #                                                                             #
-# This is useful when you want to run the test suite from Mac or             #
+# This is usefull when you want to run the test suite from Mac or             #
 # Docker Toolbox.                                                             #
 #                                                                             #
 ###############################################################################
@ -19,8 +19,8 @@ docker build --pull -t nginx-proxy-tester \
  "${TESTDIR}/requirements" \
  || exit 1

-# run the nginx-proxy-tester container setting the correct value for the working dir 
-# in order for docker compose to work properly when run from within that container.
+# run the nginx-proxy-tester container setting the correct value for the working dir in order for
+# docker-compose to work properly when run from within that container.
 exec docker run --rm -it --name "nginx-proxy-pytest" \
  --volume "/var/run/docker.sock:/var/run/docker.sock" \
  --volume "${DIR}:${DIR}" \
--- a/test/requirements/Dockerfile-nginx-proxy-tester
+++ b/test/requirements/Dockerfile-nginx-proxy-tester
@ -1,35 +1,9 @@
-FROM python:3.12
+FROM python:3.9

 ENV PYTEST_RUNNING_IN_CONTAINER=1

 COPY python-requirements.txt /requirements.txt
 RUN pip install -r /requirements.txt

-# Add Docker's official GPG key
-RUN apt-get update \
-  && apt-get install -y \
-    ca-certificates \
-    curl \
-  && install -m 0755 -d /etc/apt/keyrings \
-  && curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc \
-  && chmod a+r /etc/apt/keyrings/docker.asc
-
-# Add the Docker repository to Apt sources
-RUN echo \
-  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
-  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
-  tee /etc/apt/sources.list.d/docker.list > /dev/null
-
-# Install docker-ce-cli and docker-compose-plugin requirements for Pytest docker_compose fixture
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends \
-    docker-ce-cli \
-    docker-compose-plugin \
-  && apt-get clean \
-  && rm -r /var/lib/apt/lists/*
-
-# Check if docker compose is available
-RUN docker compose version
-
 WORKDIR /test
 ENTRYPOINT ["pytest"]
--- a/test/requirements/python-requirements.txt
+++ b/test/requirements/python-requirements.txt
@ -1,6 +1,5 @@
 backoff==2.2.1
-docker==7.1.0
-packaging==24.2
-pytest==8.3.4
-requests==2.32.3
-urllib3==2.3.0
+docker-compose==1.29.2
+docker==6.1.1
+pytest==7.3.1
+requests==2.30.0
--- a/test/requirements/web/Dockerfile
+++ b/test/requirements/web/Dockerfile
@ -1,7 +1,6 @@
 # Docker Image running one (or multiple) webservers listening on all given ports from WEB_PORTS environment variable

-FROM python:3-alpine
-RUN apk add --no-cache bash
+FROM python:3
 COPY ./webserver.py /
 COPY ./entrypoint.sh /
 WORKDIR /opt
--- a/test/requirements/web/entrypoint.sh
+++ b/test/requirements/web/entrypoint.sh
@ -5,11 +5,11 @@ trap '[ ${#PIDS[@]} -gt 0 ] && kill -TERM ${PIDS[@]}' TERM
 declare -a PIDS

 for port in $WEB_PORTS; do
-	echo starting a web server listening on port "$port";
-	/webserver.py "$port" &
+	echo starting a web server listening on port $port;
+	/webserver.py $port &
 	PIDS+=($!)
 done

-wait "${PIDS[@]}"
+wait ${PIDS[@]}
 trap - TERM
-wait "${PIDS[@]}"
+wait ${PIDS[@]}
--- a/test/requirements/web/webserver.py
+++ b/test/requirements/web/webserver.py
@ -14,8 +14,8 @@ class Handler(http.server.SimpleHTTPRequestHandler):
            response_body += self.headers.as_string()
        elif self.path == "/port":
            response_body += f"answer from port {PORT}\n"
-        elif re.match(r"/status/(\d+)", self.path):
-            result = re.match(r"/status/(\d+)", self.path)
+        elif re.match("/status/(\d+)", self.path):
+            result = re.match("/status/(\d+)", self.path)
            response_code = int(result.group(1))
            response_body += f"answer with response code {response_code}\n"
        elif self.path == "/":
@ -28,7 +28,7 @@ class Handler(http.server.SimpleHTTPRequestHandler):
        self.send_header("Content-Type", "text/plain")
        self.end_headers()

-        if len(response_body):
+        if (len(response_body)):
            self.wfile.write(response_body.encode())

 if __name__ == '__main__':
--- a/test/stress_tests/README.md
+++ b/test/stress_tests/README.md
@ -0,0 +1 @@
+This directory contains tests that showcase scenarios known to break the expected behavior of nginx-proxy.
--- a/test/stress_tests/test_deleted_cert/README.md
+++ b/test/stress_tests/test_deleted_cert/README.md
@ -0,0 +1,5 @@
+Test the behavior of nginx-proxy when restarted after deleting a certificate file is was using.
+
+1. nginx-proxy is created with a virtual host having a certificate
+1. while nginx-proxy is running, the certificate file is deleted
+1. nginx-proxy is then restarted (without removing the container)
--- a/test/stress_tests/test_deleted_cert/certs/web.nginx-proxy.crt
+++ b/test/stress_tests/test_deleted_cert/certs/web.nginx-proxy.crt
@ -0,0 +1,70 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number: 4096 (0x1000)
+    Signature Algorithm: sha256WithRSAEncryption
+        Issuer: O=nginx-proxy test suite, CN=www.nginx-proxy.tld
+        Validity
+            Not Before: Feb 17 23:20:54 2017 GMT
+            Not After : Jul  5 23:20:54 2044 GMT
+        Subject: CN=web.nginx-proxy
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+                Public-Key: (2048 bit)
+                Modulus:
+                    00:b6:27:63:a5:c6:e8:f4:7a:94:0e:cc:a2:62:76:
+                    6d:5d:33:6f:cf:19:fc:e7:e5:bb:0e:0e:d0:7c:4f:
+                    73:4c:48:2b:17:d1:4d:d5:9f:42:08:73:84:54:8c:
+                    86:d2:c5:da:59:01:3f:42:22:e0:36:f0:dc:ab:de:
+                    0a:bd:26:2b:22:13:87:a6:1f:23:ef:0e:99:27:8b:
+                    15:4a:1b:ef:93:c9:6b:91:de:a0:02:0c:62:bb:cc:
+                    56:37:e8:25:92:c3:1f:f1:69:d8:7c:a8:33:e0:89:
+                    ce:14:67:a0:39:77:88:91:e6:a3:07:97:90:22:88:
+                    d0:79:18:63:fb:6f:7e:ee:2b:42:7e:23:f5:e7:da:
+                    e9:ee:6a:fa:96:65:9f:e1:2b:15:49:c8:cd:2d:ce:
+                    86:4f:2c:2a:67:79:bf:41:30:14:cc:f6:0f:14:74:
+                    9e:b6:d3:d0:3b:f0:1b:b8:e8:19:2a:fd:d6:fd:dc:
+                    4b:4e:65:7d:9b:bf:37:7e:2d:35:22:2e:74:90:ce:
+                    41:35:3d:41:a0:99:db:97:1f:bf:3e:18:3c:48:fb:
+                    da:df:c6:4e:4e:b9:67:b8:10:d5:a5:13:03:c4:b7:
+                    65:e7:aa:f0:14:4b:d3:4d:ea:fe:8f:69:cf:50:21:
+                    63:27:cf:9e:4c:67:15:7b:3f:3b:da:cb:17:80:61:
+                    1e:25
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Alternative Name: 
+                DNS:web.nginx-proxy
+    Signature Algorithm: sha256WithRSAEncryption
+         09:31:be:db:4e:b0:b6:68:da:ae:5b:16:51:29:fc:9f:61:b6:
+         5a:2f:3c:35:ef:67:76:97:b0:34:4e:3b:b4:d6:88:19:4f:84:
+         2e:73:d3:c0:3a:4c:41:54:6c:bb:67:89:67:ad:25:55:d7:d4:
+         80:fe:a7:3f:3d:9e:f1:34:96:d8:da:5a:78:51:c0:63:f1:52:
+         29:35:55:f4:7d:70:1c:d3:96:62:7f:64:86:81:52:27:c4:c6:
+         10:13:c6:73:56:4d:32:d0:b3:c3:c8:2c:25:83:e4:2b:1d:d4:
+         74:30:e5:85:af:2d:b6:a5:6b:fe:5d:d3:3c:00:58:94:f4:6a:
+         f5:a6:1d:cf:f9:ed:d5:27:ed:13:24:b2:4f:2b:f3:b8:e4:af:
+         0c:1d:fe:e0:6a:01:5e:a2:44:ff:3e:96:fa:6c:39:a3:51:37:
+         f3:72:55:d8:2d:29:6e:de:95:b9:d8:e3:1e:65:a5:9c:0d:79:
+         2d:39:ab:c7:ac:16:b6:a5:71:4b:35:a4:6c:72:47:1b:72:9c:
+         67:58:c1:fc:f6:7f:a7:73:50:7b:d6:27:57:74:a1:31:38:a7:
+         31:e3:b9:d4:c9:45:33:ec:ed:16:cf:c5:bd:d0:03:b1:45:3f:
+         68:0d:91:5c:26:4e:37:05:74:ed:3e:75:5e:ca:5e:ee:e2:51:
+         4b:da:08:99
+-----BEGIN CERTIFICATE-----
+MIIC8zCCAdugAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwPzEfMB0GA1UECgwWbmdp
+bngtcHJveHkgdGVzdCBzdWl0ZTEcMBoGA1UEAwwTd3d3Lm5naW54LXByb3h5LnRs
+ZDAeFw0xNzAyMTcyMzIwNTRaFw00NDA3MDUyMzIwNTRaMBoxGDAWBgNVBAMMD3dl
+Yi5uZ2lueC1wcm94eTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALYn
+Y6XG6PR6lA7MomJ2bV0zb88Z/Ofluw4O0HxPc0xIKxfRTdWfQghzhFSMhtLF2lkB
+P0Ii4Dbw3KveCr0mKyITh6YfI+8OmSeLFUob75PJa5HeoAIMYrvMVjfoJZLDH/Fp
+2HyoM+CJzhRnoDl3iJHmoweXkCKI0HkYY/tvfu4rQn4j9efa6e5q+pZln+ErFUnI
+zS3Ohk8sKmd5v0EwFMz2DxR0nrbT0DvwG7joGSr91v3cS05lfZu/N34tNSIudJDO
+QTU9QaCZ25cfvz4YPEj72t/GTk65Z7gQ1aUTA8S3Zeeq8BRL003q/o9pz1AhYyfP
+nkxnFXs/O9rLF4BhHiUCAwEAAaMeMBwwGgYDVR0RBBMwEYIPd2ViLm5naW54LXBy
+b3h5MA0GCSqGSIb3DQEBCwUAA4IBAQAJMb7bTrC2aNquWxZRKfyfYbZaLzw172d2
+l7A0Tju01ogZT4Quc9PAOkxBVGy7Z4lnrSVV19SA/qc/PZ7xNJbY2lp4UcBj8VIp
+NVX0fXAc05Zif2SGgVInxMYQE8ZzVk0y0LPDyCwlg+QrHdR0MOWFry22pWv+XdM8
+AFiU9Gr1ph3P+e3VJ+0TJLJPK/O45K8MHf7gagFeokT/Ppb6bDmjUTfzclXYLSlu
+3pW52OMeZaWcDXktOavHrBa2pXFLNaRsckcbcpxnWMH89n+nc1B71idXdKExOKcx
+47nUyUUz7O0Wz8W90AOxRT9oDZFcJk43BXTtPnVeyl7u4lFL2giZ
+-----END CERTIFICATE-----
--- a/test/stress_tests/test_deleted_cert/certs/web.nginx-proxy.key
+++ b/test/stress_tests/test_deleted_cert/certs/web.nginx-proxy.key
@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAtidjpcbo9HqUDsyiYnZtXTNvzxn85+W7Dg7QfE9zTEgrF9FN
+1Z9CCHOEVIyG0sXaWQE/QiLgNvDcq94KvSYrIhOHph8j7w6ZJ4sVShvvk8lrkd6g
+Agxiu8xWN+glksMf8WnYfKgz4InOFGegOXeIkeajB5eQIojQeRhj+29+7itCfiP1
+59rp7mr6lmWf4SsVScjNLc6GTywqZ3m/QTAUzPYPFHSettPQO/AbuOgZKv3W/dxL
+TmV9m783fi01Ii50kM5BNT1BoJnblx+/Phg8SPva38ZOTrlnuBDVpRMDxLdl56rw
+FEvTTer+j2nPUCFjJ8+eTGcVez872ssXgGEeJQIDAQABAoIBAGQCMFW+ZfyEqHGP
+rMA+oUEAkqy0agSwPwky3QjDXlxNa0uCYSeebtTRB6CcHxHuCzm+04puN4gyqhW6
+rU64fAoTivCMPGBuNWxekmvD9r+/YM4P2u4E+th9EgFT9f0kII+dO30FpKXtQzY0
+xuWGWXcxl+T9M+eiEkPKPmq4BoqgTDo5ty7qDv0ZqksGotKFmdYbtSvgBAueJdwu
+VWJvenI9F42ExBRKOW1aldiRiaYBCLiCVPKJtOg9iuOP9RHUL1SE8xy5I5mm78g3
+a13ji3BNq3yS+VhGjQ7zDy1V1jGupLoJw4I7OThu8hy+B8Vt8EN/iqakufOkjlTN
+xTJ33CkCgYEA5Iymg0NTjWk6aEkFa9pERjfUWqdVp9sWSpFFZZgi55n7LOx6ohi3
+vuLim3is/gYfK2kU/kHGZZLPnT0Rdx0MbOB4XK0CAUlqtUd0IyO4jMZ06g4/kn3N
+e2jLdCCIBoEQuLk4ELxj2mHsLQhEvDrg7nzU2WpTHHhvJbIbDWOAxhsCgYEAzAgv
+rKpanF+QDf4yeKHxAj2rrwRksTw4Pe7ZK/bog/i+HIVDA70vMapqftHbual/IRrB
+JL7hxskoJ/h9c1w4xkWDjqkSKz8/Ihr4dyPfWyGINWbx/rarT/m5MU5SarScoK7o
+Xgb25x+W+61rtI+2JhVRGO86+JiAeT4LkAX88L8CgYAwHHug/jdEeXZWJakCfzwI
+HBCT1M3vO+uBXvtg25ndb0i0uENIhDOJ93EEkW65Osis9r34mBgPocwaqZRXosHO
+2aH8wF6/rpjL+HK2QvrCh7Rs4Pr494qeA/1wQLjhxaGjgToQK9hJTHvPLwJpLWvU
+SGr2Ka+9Oo0LPmb7dorRKQKBgQCLsNcjOodLJMp2KiHYIdfmlt6itzlRd09yZ8Nc
+rHHJWVagJEUbnD1hnbHIHlp3pSqbObwfMmlWNoc9xo3tm6hrZ1CJLgx4e5b3/Ms8
+ltznge/F0DPDFsH3wZwfu+YFlJ7gDKCfL9l/qEsxCS0CtJobPOEHV1NivNbJK8ey
+1ca19QKBgDTdMOUsobAmDEkPQIpxfK1iqYAB7hpRLi79OOhLp23NKeyRNu8FH9fo
+G3DZ4xUi6hP2bwiYugMXDyLKfvxbsXwQC84kGF8j+bGazKNhHqEC1OpYwmaTB3kg
+qL9cHbjWySeRdIsRY/eWmiKjUwmiO54eAe1HWUdcsuz8yM3xf636
+-----END RSA PRIVATE KEY-----
--- a/test/stress_tests/test_deleted_cert/docker-compose.yml
+++ b/test/stress_tests/test_deleted_cert/docker-compose.yml
@ -0,0 +1,15 @@
+web:
+  image: web
+  expose:
+  - "81"
+  environment:
+    WEB_PORTS: 81
+    VIRTUAL_HOST: web.nginx-proxy
+
+
+reverseproxy:
+  image: nginxproxy/nginx-proxy:test
+  container_name: reverseproxy
+  volumes:
+  - /var/run/docker.sock:/tmp/docker.sock:ro
+  - ./tmp_certs:/etc/nginx/certs:ro
--- a/test/stress_tests/test_deleted_cert/test_restart_while_missing_cert.py
+++ b/test/stress_tests/test_deleted_cert/test_restart_while_missing_cert.py
@ -0,0 +1,72 @@
+import logging
+import os
+from os.path import join, isfile
+from shutil import copy
+from time import sleep
+
+import pytest
+from requests import ConnectionError
+
+script_dir = os.path.dirname(__file__)
+
+pytestmark = pytest.mark.xfail()  # TODO delete this marker once those issues are fixed
+
+@pytest.fixture(scope="module", autouse=True)
+def certs():
+    """
+    pytest fixture that provides cert and key files into the tmp_certs directory
+    """
+    file_names = ("web.nginx-proxy.crt", "web.nginx-proxy.key")
+    logging.info("copying server cert and key files into tmp_certs")
+    for f_name in file_names:
+        copy(join(script_dir, "certs", f_name), join(script_dir, "tmp_certs"))
+    yield
+    logging.info("cleaning up the tmp_cert directory")
+    for f_name in file_names:
+        if isfile(join(script_dir, "tmp_certs", f_name)):
+            os.remove(join(script_dir, "tmp_certs", f_name))
+
+###############################################################################
+
+
+def test_unknown_virtual_host_is_503(docker_compose, nginxproxy):
+    r = nginxproxy.get("http://foo.nginx-proxy/")
+    assert r.status_code == 503
+
+
+def test_http_web_is_301(docker_compose, nginxproxy):
+    r = nginxproxy.get("http://web.nginx-proxy/port", allow_redirects=False)
+    assert r.status_code == 301
+
+
+def test_https_web_is_200(docker_compose, nginxproxy):
+    r = nginxproxy.get("https://web.nginx-proxy/port")
+    assert r.status_code == 200
+    assert "answer from port 81\n" in r.text
+
+
+@pytest.mark.incremental
+def test_delete_cert_and_restart_reverseproxy(docker_compose):
+    os.remove(join(script_dir, "tmp_certs", "web.nginx-proxy.crt"))
+    docker_compose.containers.get("reverseproxy").restart()
+    sleep(3)  # give time for the container to initialize
+    assert "running" == docker_compose.containers.get("reverseproxy").status
+
+
+@pytest.mark.incremental
+def test_unknown_virtual_host_is_still_503(nginxproxy):
+    r = nginxproxy.get("http://foo.nginx-proxy/")
+    assert r.status_code == 503
+
+
+@pytest.mark.incremental
+def test_http_web_is_now_200(nginxproxy):
+    r = nginxproxy.get("http://web.nginx-proxy/port", allow_redirects=False)
+    assert r.status_code == 200
+    assert "answer from port 81\n" == r.text
+
+
+@pytest.mark.incremental
+def test_https_web_is_now_broken_since_there_is_no_cert(nginxproxy):
+    with pytest.raises(ConnectionError):
+        nginxproxy.get("https://web.nginx-proxy/port")
--- a/test/stress_tests/test_deleted_cert/tmp_certs/.gitignore
+++ b/test/stress_tests/test_deleted_cert/tmp_certs/.gitignore
@ -0,0 +1,2 @@
+*
+!.gitignore
--- a/test/stress_tests/test_unreachable_network/README.md
+++ b/test/stress_tests/test_unreachable_network/README.md
--- a/test/stress_tests/test_unreachable_network/docker-compose.yml
+++ b/test/stress_tests/test_unreachable_network/docker-compose.yml
@ -1,12 +1,19 @@
+version: "2"
+
 networks:
  netA:
  netB:

 services:
-  nginx-proxy:
+  reverseproxy:
    container_name: reverseproxy
    networks:
      - netA
+    image: nginxproxy/nginx-proxy:test
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
+    environment:
+      HTTPS_METHOD: nohttps

  webA:
    networks:
@ -15,7 +22,7 @@ services:
    expose:
      - 81
    environment:
-      WEB_PORTS: "81"
+      WEB_PORTS: 81
      VIRTUAL_HOST: webA.nginx-proxy

  webB:
@ -25,5 +32,6 @@ services:
    expose:
      - 82
    environment:
-      WEB_PORTS: "82"
+      WEB_PORTS: 82
      VIRTUAL_HOST: webB.nginx-proxy
+
--- a/test/stress_tests/test_unreachable_network/test_unreachable_net.py
+++ b/test/stress_tests/test_unreachable_network/test_unreachable_net.py
--- a/test/test_docker-unix-socket/test_docker-unix-socket.py
+++ b/test/test_docker-unix-socket/test_docker-unix-socket.py
@ -1,3 +1,5 @@
+import pytest
+
 def test_unknown_virtual_host(docker_compose, nginxproxy):
    r = nginxproxy.get("http://nginx-proxy/port")
    assert r.status_code == 503
--- a/test/test_DOCKER_HOST_unix_socket.yml
+++ b/test/test_DOCKER_HOST_unix_socket.yml
@ -0,0 +1,24 @@
+web1:
+  image: web
+  expose:
+    - "81"
+  environment:
+    WEB_PORTS: 81
+    VIRTUAL_HOST: web1.nginx-proxy.tld
+
+web2:
+  image: web
+  expose:
+    - "82"
+  environment:
+    WEB_PORTS: 82
+    VIRTUAL_HOST: web2.nginx-proxy.tld
+
+
+sut:
+  image: nginxproxy/nginx-proxy:test
+  volumes:
+    - /var/run/docker.sock:/f00.sock:ro
+  environment:
+    DOCKER_HOST: unix:///f00.sock
+    HTTPS_METHOD: nohttps
--- a/test/test_acme-http-challenge-location/acme_root/.well-known/acme-challenge/test-filename
+++ b/test/test_acme-http-challenge-location/acme_root/.well-known/acme-challenge/test-filename
@ -1 +0,0 @@
-challenge-teststring
--- a/test/test_acme-http-challenge-location/certs/nginx-proxy.tld.crt
+++ b/test/test_acme-http-challenge-location/certs/nginx-proxy.tld.crt
@ -1,70 +0,0 @@
-Certificate:
-    Data:
-        Version: 3 (0x2)
-        Serial Number: 4096 (0x1000)
-    Signature Algorithm: sha256WithRSAEncryption
-        Issuer: O=nginx-proxy test suite, CN=www.nginx-proxy.tld
-        Validity
-            Not Before: Jan 10 00:08:52 2017 GMT
-            Not After : May 28 00:08:52 2044 GMT
-        Subject: CN=*.nginx-proxy.tld
-        Subject Public Key Info:
-            Public Key Algorithm: rsaEncryption
-                Public-Key: (2048 bit)
-                Modulus:
-                    00:cb:45:f4:14:9b:fe:64:85:79:4a:36:8d:3d:d1:
-                    27:d0:7c:36:28:30:e6:73:80:6f:7c:49:23:d0:6c:
-                    17:e4:44:c0:77:4d:9a:c2:bc:24:84:e3:a5:4d:ba:
-                    d2:da:51:7b:a1:2a:12:d4:c0:19:55:69:2c:22:27:
-                    2d:1a:f6:fc:4b:7f:e9:cb:a8:3c:e8:69:b8:d2:4f:
-                    de:4e:50:e2:d0:74:30:7c:42:5a:ae:aa:85:a5:b1:
-                    71:4d:c9:7e:86:8b:62:8c:3e:0d:e3:3b:c3:f5:81:
-                    0b:8c:68:79:fe:bf:10:fb:ae:ec:11:49:6d:64:5e:
-                    1a:7d:b3:92:93:4e:96:19:3a:98:04:a7:66:b2:74:
-                    61:2d:41:13:0c:a4:54:0d:2c:78:fd:b4:a3:e8:37:
-                    78:9a:de:fa:bc:2e:a8:0f:67:14:58:ce:c3:87:d5:
-                    14:0e:8b:29:7d:48:19:b2:a9:f5:b4:e8:af:32:21:
-                    67:15:7e:43:52:8b:20:cf:9f:38:43:bf:fd:c8:24:
-                    7f:52:a3:88:f2:f1:4a:14:91:2a:6e:91:6f:fb:7d:
-                    6a:78:c6:6d:2e:dd:1e:4c:2b:63:bb:3a:43:9c:91:
-                    f9:df:d3:08:13:63:86:7d:ce:e8:46:cf:f1:6c:1f:
-                    ca:f7:4c:de:d8:4b:e0:da:bc:06:d9:87:0f:ff:96:
-                    45:85
-                Exponent: 65537 (0x10001)
-        X509v3 extensions:
-            X509v3 Subject Alternative Name: 
-                DNS:*.nginx-proxy.tld
-    Signature Algorithm: sha256WithRSAEncryption
-         6e:a5:0e:e4:d3:cc:d5:b7:fc:34:75:89:4e:98:8c:e7:08:06:
-         a8:5b:ec:13:7d:83:99:a2:61:b8:d5:12:6e:c5:b4:53:4e:9a:
-         22:cd:ad:14:30:6a:7d:58:d7:23:d9:a4:2a:96:a0:40:9e:50:
-         9f:ce:f2:fe:8c:dd:9a:ac:99:39:5b:89:2d:ca:e5:3e:c3:bc:
-         03:04:1c:12:d9:6e:b8:9f:f0:3a:be:12:44:7e:a4:21:86:73:
-         af:d5:00:51:3f:2c:56:70:34:8f:26:b0:7f:b0:cf:cf:7f:f9:
-         40:6f:00:29:c4:cf:c3:b7:c2:49:3d:3f:b0:26:78:87:b9:c7:
-         6c:1b:aa:6a:1a:dd:c5:eb:f2:69:ba:6d:46:0b:92:49:b5:11:
-         3c:eb:48:c7:2f:fb:33:a6:6a:82:a2:ab:f8:1e:5f:7d:e3:b7:
-         f2:fd:f5:88:a5:09:4d:a0:bc:f4:3b:cd:d2:8b:d7:57:1f:86:
-         3b:d2:3e:a4:92:21:b0:02:0b:e9:e0:c4:1c:f1:78:e2:58:a7:
-         26:5f:4c:29:c8:23:f0:6e:12:3f:bd:ad:44:7b:0b:bd:db:ba:
-         63:8d:07:c6:9d:dc:46:cc:63:40:ba:5e:45:82:dd:9a:e5:50:
-         e8:e7:d7:27:88:fc:6f:1d:8a:e7:5c:49:28:aa:10:29:75:28:
-         c7:52:de:f9
-----BEGIN CERTIFICATE-----
-MIIC9zCCAd+gAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwPzEfMB0GA1UECgwWbmdp
-bngtcHJveHkgdGVzdCBzdWl0ZTEcMBoGA1UEAwwTd3d3Lm5naW54LXByb3h5LnRs
-ZDAeFw0xNzAxMTAwMDA4NTJaFw00NDA1MjgwMDA4NTJaMBwxGjAYBgNVBAMMESou
-bmdpbngtcHJveHkudGxkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
-y0X0FJv+ZIV5SjaNPdEn0Hw2KDDmc4BvfEkj0GwX5ETAd02awrwkhOOlTbrS2lF7
-oSoS1MAZVWksIictGvb8S3/py6g86Gm40k/eTlDi0HQwfEJarqqFpbFxTcl+hoti
-jD4N4zvD9YELjGh5/r8Q+67sEUltZF4afbOSk06WGTqYBKdmsnRhLUETDKRUDSx4
-/bSj6Dd4mt76vC6oD2cUWM7Dh9UUDospfUgZsqn1tOivMiFnFX5DUosgz584Q7/9
-yCR/UqOI8vFKFJEqbpFv+31qeMZtLt0eTCtjuzpDnJH539MIE2OGfc7oRs/xbB/K
-90ze2Evg2rwG2YcP/5ZFhQIDAQABoyAwHjAcBgNVHREEFTATghEqLm5naW54LXBy
-b3h5LnRsZDANBgkqhkiG9w0BAQsFAAOCAQEAbqUO5NPM1bf8NHWJTpiM5wgGqFvs
-E32DmaJhuNUSbsW0U06aIs2tFDBqfVjXI9mkKpagQJ5Qn87y/ozdmqyZOVuJLcrl
-PsO8AwQcEtluuJ/wOr4SRH6kIYZzr9UAUT8sVnA0jyawf7DPz3/5QG8AKcTPw7fC
-ST0/sCZ4h7nHbBuqahrdxevyabptRguSSbURPOtIxy/7M6ZqgqKr+B5ffeO38v31
-iKUJTaC89DvN0ovXVx+GO9I+pJIhsAIL6eDEHPF44linJl9MKcgj8G4SP72tRHsL
-vdu6Y40Hxp3cRsxjQLpeRYLdmuVQ6OfXJ4j8bx2K51xJKKoQKXUox1Le+Q==
-----END CERTIFICATE-----
--- a/test/test_acme-http-challenge-location/certs/nginx-proxy.tld.key
+++ b/test/test_acme-http-challenge-location/certs/nginx-proxy.tld.key
@ -1,27 +0,0 @@
-----BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAy0X0FJv+ZIV5SjaNPdEn0Hw2KDDmc4BvfEkj0GwX5ETAd02a
-wrwkhOOlTbrS2lF7oSoS1MAZVWksIictGvb8S3/py6g86Gm40k/eTlDi0HQwfEJa
-rqqFpbFxTcl+hotijD4N4zvD9YELjGh5/r8Q+67sEUltZF4afbOSk06WGTqYBKdm
-snRhLUETDKRUDSx4/bSj6Dd4mt76vC6oD2cUWM7Dh9UUDospfUgZsqn1tOivMiFn
-FX5DUosgz584Q7/9yCR/UqOI8vFKFJEqbpFv+31qeMZtLt0eTCtjuzpDnJH539MI
-E2OGfc7oRs/xbB/K90ze2Evg2rwG2YcP/5ZFhQIDAQABAoIBAQCjAro2PNLJMfCO
-fyjNRgmzu6iCmpR0U68T8GN0JPsT576g7e8J828l0pkhuIyW33lRSThIvLSUNf9a
-dChL032H3lBTLduKVh4NKleQXnVFzaeEPoISSFVdButiAhAhPW4OIUVp0OfY3V+x
-fac3j2nDLAfL5SKAtqZv363Py9m66EBYm5BmGTQqT/frQWeCEBvlErQef5RIaU8p
-e2zMWgSNNojVai8U3nKNRvYHWeWXM6Ck7lCvkHhMF+RpbmCZuqhbEARVnehU/Jdn
-QHJ3nxeA2OWpoWKXvAHtSnno49yxq1UIstiQvY+ng5C5i56UlB60UiU2NJ6doZkB
-uQ7/1MaBAoGBAORdcFtgdgRALjXngFWhpCp0CseyUehn1KhxDCG+D1pJ142/ymcf
-oJOzKJPMRNDdDUBMnR1GBfy7rmwvYevI/SMNy2Qs7ofcXPbdtwwvTCToZ1V9/54k
-VfuPBFT+3QzWRvG1tjTV3E4L2VV3nrl2qNPhE5DlfIaU3nQq5Fl0HprJAoGBAOPf
-MWOTGev61CdODO5KN3pLAoamiPs5lEUlz3kM3L1Q52YLITxNDjRj9hWBUATJZOS2
-pLOoYRwmhD7vrnimMc41+NuuFX+4T7hWPc8uSuOxX0VijYtULyNRK57mncG1Fq9M
-RMLbOJ7FD+8jdXNsSMqpQ+pxLJRX/A10O2fOQnbdAoGAL5hV4YWSM0KZHvz332EI
-ER0MXiCJN7HkPZMKH0I4eu3m8hEmAyYxVndBnsQ1F37q0xrkqAQ/HTSUntGlS/og
-4Bxw5pkCwegoq/77tpto+ExDtSrEitYx4XMmSPyxX4qNULU5m3tzJgUML+b1etwD
-Rd2kMU/TC02dq4KBAy/TbRkCgYAl1xN5iJz+XenLGR/2liZ+TWR+/bqzlU006mF4
-pZUmbv/uJxz+yYD5XDwqOA4UrWjuvhG9r9FoflDprp2XdWnB556KxG7XhcDfSJr9
-A5/2DadXe1Ur9O/a+oi2228JEsxQkea9QPA3FVxfBtFjOHEiDlez39VaUP4PMeUH
-iO3qlQKBgFQhdTb7HeYnApYIDHLmd1PvjRvp8XKR1CpEN0nkw8HpHcT1q1MUjQCr
-iT6FQupULEvGmO3frQsgVeRIQDbEdZK3C5xCtn6qOw70sYATVf361BbTtidmU9yV
-THFxwDSVLiVZgFryoY/NtAc27sVdJnGsPRjjaeVgALAsLbmZ1K/H
-----END RSA PRIVATE KEY-----
--- a/test/test_acme-http-challenge-location/compose.base.override.yml
+++ b/test/test_acme-http-challenge-location/compose.base.override.yml
@ -1,6 +0,0 @@
-services:
-  nginx-proxy:
-    volumes:
-      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/certs:/etc/nginx/certs:ro
-      - ${PYTEST_MODULE_PATH}/acme_root:/usr/share/nginx/html:ro
--- a/test/test_acme-http-challenge-location/test_acme-http-challenge-location-disabled.py
+++ b/test/test_acme-http-challenge-location/test_acme-http-challenge-location-disabled.py
@ -1,27 +0,0 @@
-def test_redirect_acme_challenge_location_disabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web1.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 301
-
-def test_redirect_acme_challenge_location_enabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web2.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 200
-
-def test_noredirect_acme_challenge_location_disabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web3.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 404
-
-def test_noredirect_acme_challenge_location_enabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web4.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 200
--- a/test/test_acme-http-challenge-location/test_acme-http-challenge-location-disabled.yml
+++ b/test/test_acme-http-challenge-location/test_acme-http-challenge-location-disabled.yml
@ -1,40 +0,0 @@
-services:
-  nginx-proxy:
-    environment:
-      ACME_HTTP_CHALLENGE_LOCATION: "false"
-
-  web1:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: "web1.nginx-proxy.tld"
-
-  web2:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: "web2.nginx-proxy.tld"
-      ACME_HTTP_CHALLENGE_LOCATION: "true"
-
-  web3:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: "web3.nginx-proxy.tld"
-      HTTPS_METHOD: noredirect
-
-  web4:
-    image: web
-    expose:
-      - "84"
-    environment:
-      WEB_PORTS: "84"
-      VIRTUAL_HOST: "web4.nginx-proxy.tld"
-      HTTPS_METHOD: noredirect
-      ACME_HTTP_CHALLENGE_LOCATION: "true"
--- a/test/test_acme-http-challenge-location/test_acme-http-challenge-location-enabled-is-default.py
+++ b/test/test_acme-http-challenge-location/test_acme-http-challenge-location-enabled-is-default.py
@ -1,27 +0,0 @@
-def test_redirect_acme_challenge_location_enabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web1.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 200
-
-def test_redirect_acme_challenge_location_disabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web2.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 301
-
-def test_noredirect_acme_challenge_location_enabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web3.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 200
-
-def test_noredirect_acme_challenge_location_disabled(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web4.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 404
--- a/test/test_acme-http-challenge-location/test_acme-http-challenge-location-enabled-is-default.yml
+++ b/test/test_acme-http-challenge-location/test_acme-http-challenge-location-enabled-is-default.yml
@ -1,36 +0,0 @@
-services:
-  web1:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: "web1.nginx-proxy.tld"
-
-  web2:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: "web2.nginx-proxy.tld"
-      ACME_HTTP_CHALLENGE_LOCATION: "false"
-
-  web3:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: "web3.nginx-proxy.tld"
-      HTTPS_METHOD: noredirect
-
-  web4:
-    image: web
-    expose:
-      - "84"
-    environment:
-      WEB_PORTS: "84"
-      VIRTUAL_HOST: "web4.nginx-proxy.tld"
-      HTTPS_METHOD: noredirect
-      ACME_HTTP_CHALLENGE_LOCATION: "false"
--- a/test/test_acme-http-challenge-location/test_acme-http-challenge-location-legacy.py
+++ b/test/test_acme-http-challenge-location/test_acme-http-challenge-location-legacy.py
@ -1,13 +0,0 @@
-def test_redirect_acme_challenge_location_legacy(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web1.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 200
-
-def test_noredirect_acme_challenge_location_legacy(docker_compose, nginxproxy, acme_challenge_path):
-    r = nginxproxy.get(
-        f"http://web2.nginx-proxy.tld/{acme_challenge_path}",
-        allow_redirects=False
-    )
-    assert r.status_code == 404
--- a/test/test_acme-http-challenge-location/test_acme-http-challenge-location-legacy.yml
+++ b/test/test_acme-http-challenge-location/test_acme-http-challenge-location-legacy.yml
@ -1,21 +0,0 @@
-services:
-  nginx-proxy:
-    environment:
-      ACME_HTTP_CHALLENGE_LOCATION: "legacy"
-
-  web1:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: "web1.nginx-proxy.tld"
-
-  web2:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: "web2.nginx-proxy.tld"
-      HTTPS_METHOD: noredirect
--- a/test/test_build/test_build.py
+++ b/test/test_build/test_build.py
@ -1,66 +0,0 @@
-"""
-Test that nginx-proxy-tester can build successfully
-"""
-import pathlib
-import re
-
-import docker
-import pytest
-
-
-client = docker.from_env()
-
-@pytest.fixture(scope = "session")
-def docker_build(request):
-    # Define Dockerfile path
-    current_file_path = pathlib.Path(__file__)
-    dockerfile_path = current_file_path.parent.parent.joinpath("requirements")
-    dockerfile_name = "Dockerfile-nginx-proxy-tester"
-
-    # Build the Docker image
-    image, logs = client.images.build(
-        path = dockerfile_path.as_posix(),
-        dockerfile = dockerfile_name,
-        rm = True,  # Remove intermediate containers
-        tag = "nginx-proxy-tester-ci",  # Tag for the built image
-    )
-
-    # Check for build success
-    for log in logs:
-        if "stream" in log:
-            print(log["stream"].strip())
-        if "error" in log:
-            raise Exception(log["error"])
-
-    def teardown():
-        # Clean up after teardown
-        client.images.remove(image.id, force=True)
-
-    request.addfinalizer(teardown)
-
-    # Return the image name
-    return "nginx-proxy-tester-ci"
-
-def test_build_nginx_proxy_tester(docker_build):
-    assert docker_build == "nginx-proxy-tester-ci"
-
-def test_run_nginx_proxy_tester(docker_build):
-    # Run the container with 'pytest -v' command to output version info
-    container = client.containers.run("nginx-proxy-tester-ci",
-        command = "pytest -V",
-        detach = True,
-    )
-
-    # Wait for the container to finish and get the exit code
-    result = container.wait()
-    exit_code = result.get("StatusCode", 1)  # Default to 1 (error) if not found
-
-    # Get the output logs from the container
-    output = container.logs().decode("utf-8").strip()
-
-    # Clean up: Remove the container
-    container.remove()
-
-    # Assertions
-    assert exit_code == 0, "Container exited with a non-zero exit code"
-    assert re.search(r"pytest\s\d+\.\d+\.\d+", output)
--- a/test/test_composev2.py
+++ b/test/test_composev2.py
@ -0,0 +1,10 @@
+import pytest
+
+def test_unknown_virtual_host(docker_compose, nginxproxy):
+    r = nginxproxy.get("http://nginx-proxy/")
+    assert r.status_code == 503
+
+def test_forwards_to_whoami(docker_compose, nginxproxy):
+    r = nginxproxy.get("http://web.nginx-proxy.local/port")
+    assert r.status_code == 200   
+    assert r.text == "answer from port 81\n"
--- a/test/test_composev2.yml
+++ b/test/test_composev2.yml
@ -0,0 +1,16 @@
+version: '2'
+services:
+  nginx-proxy:
+    image: nginxproxy/nginx-proxy:test
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
+    environment:
+      HTTPS_METHOD: nohttps
+
+  web:
+    image: web
+    expose:
+      - "81"
+    environment:
+      WEB_PORTS: 81
+      VIRTUAL_HOST: web.nginx-proxy.local
--- a/test/test_custom-error-page/50x.html
+++ b/test/test_custom-error-page/50x.html
@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Maintenance</title>
-    <style>
-      html {
-        color-scheme: light dark;
-      }
-      body {
-        width: 35em;
-        margin: 0 auto;
-        font-family: Tahoma, Verdana, Arial, sans-serif;
-      }
-    </style>
-  </head>
-  <body>
-    <h1>Damn, there's some maintenance in progress.</h1>
-    <p>
-      Our apologies for this temporary inconvenience. Regular service
-      performance will be re-established shortly.
-    </p>
-  </body>
-</html>
--- a/test/test_custom-error-page/test_custom-error-page.py
+++ b/test/test_custom-error-page/test_custom-error-page.py
@ -1,7 +0,0 @@
-import re
-
-
-def test_custom_error_page(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://unknown.nginx-proxy.tld")
-    assert r.status_code == 503
-    assert re.search(r"Damn, there's some maintenance in progress.", r.text)
--- a/test/test_custom-error-page/test_custom-error-page.yml
+++ b/test/test_custom-error-page/test_custom-error-page.yml
@ -1,5 +0,0 @@
-services:
-  nginx-proxy:
-    volumes:
-      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/50x.html:/usr/share/nginx/html/errors/50x.html:ro
--- a/test/test_custom/my_custom_proxy_settings_f00.conf
+++ b/test/test_custom/my_custom_proxy_settings_f00.conf
--- a/test/test_custom/test_defaults-location.py
+++ b/test/test_custom/test_defaults-location.py
@ -1,17 +1,19 @@
+import pytest
+
 def test_custom_default_conf_does_not_apply_to_unknown_vhost(docker_compose, nginxproxy):
    r = nginxproxy.get("http://nginx-proxy/")
    assert r.status_code == 503
    assert "X-test" not in r.headers

 def test_custom_default_conf_applies_to_web1(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web1.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web1.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 81\n"
    assert "X-test" in r.headers
    assert "f00" == r.headers["X-test"]

 def test_custom_default_conf_applies_to_web2(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web2.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web2.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 82\n"
    assert "X-test" in r.headers
@ -19,7 +21,7 @@ def test_custom_default_conf_applies_to_web2(docker_compose, nginxproxy):


 def test_custom_default_conf_is_overriden_for_web3(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web3.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web3.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 83\n"
    assert "X-test" in r.headers
--- a/test/test_custom/test_defaults-location.yml
+++ b/test/test_custom/test_defaults-location.yml
@ -1,30 +1,32 @@
-services:
 nginx-proxy:
+  image: nginxproxy/nginx-proxy:test
  volumes:
    - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_f00.conf:/etc/nginx/vhost.d/default_location:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_bar.conf:/etc/nginx/vhost.d/web3.nginx-proxy.example_location:ro
+    - ./my_custom_proxy_settings.conf:/etc/nginx/vhost.d/default_location:ro
+    - ./my_custom_proxy_settings_bar.conf:/etc/nginx/vhost.d/web3.nginx-proxy.local_location:ro
+  environment:
+    HTTPS_METHOD: nohttps

 web1:
  image: web
  expose:
    - "81"
  environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.nginx-proxy.example
+    WEB_PORTS: 81
+    VIRTUAL_HOST: web1.nginx-proxy.local

 web2:
  image: web
  expose:
    - "82"
  environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: web2.nginx-proxy.example
+    WEB_PORTS: 82
+    VIRTUAL_HOST: web2.nginx-proxy.local

 web3:
  image: web
  expose:
    - "83"
  environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: web3.nginx-proxy.example
+    WEB_PORTS: 83
+    VIRTUAL_HOST: web3.nginx-proxy.local
--- a/test/test_custom/test_defaults.py
+++ b/test/test_custom/test_defaults.py
@ -1,17 +1,19 @@
+import pytest
+
 def test_custom_conf_does_not_apply_to_unknown_vhost(docker_compose, nginxproxy):
    r = nginxproxy.get("http://nginx-proxy/")
    assert r.status_code == 503
    assert "X-test" not in r.headers

 def test_custom_conf_applies_to_web1(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web1.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web1.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 81\n"
    assert "X-test" in r.headers
    assert "f00" == r.headers["X-test"]

 def test_custom_conf_applies_to_web2(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web2.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web2.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 82\n"
    assert "X-test" in r.headers
--- a/test/test_custom/test_defaults.yml
+++ b/test/test_custom/test_defaults.yml
@ -1,21 +1,25 @@
+version: '2'
 services:
  nginx-proxy:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_f00.conf:/etc/nginx/proxy.conf:ro
+      - ./my_custom_proxy_settings.conf:/etc/nginx/proxy.conf:ro
+    environment:
+      HTTPS_METHOD: nohttps

  web1:
    image: web
    expose:
      - "81"
    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.nginx-proxy.example
+      WEB_PORTS: 81
+      VIRTUAL_HOST: web1.nginx-proxy.local

  web2:
    image: web
    expose:
      - "82"
    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: web2.nginx-proxy.example
+      WEB_PORTS: 82
+      VIRTUAL_HOST: web2.nginx-proxy.local
--- a/test/test_custom/test_location-per-vhost.py
+++ b/test/test_custom/test_location-per-vhost.py
@ -1,27 +1,22 @@
+import pytest
+
 def test_custom_conf_does_not_apply_to_unknown_vhost(docker_compose, nginxproxy):
    r = nginxproxy.get("http://nginx-proxy/")
    assert r.status_code == 503
    assert "X-test" not in r.headers

 def test_custom_conf_applies_to_web1(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web1.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web1.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 81\n"
    assert "X-test" in r.headers
    assert "f00" == r.headers["X-test"]

-def test_custom_conf_applies_to_regex(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://regex.foo.nginx-proxy.example/port")
-    assert r.status_code == 200   
-    assert r.text == "answer from port 83\n"
-    assert "X-test" in r.headers
-    assert "bar" == r.headers["X-test"]
-
 def test_custom_conf_does_not_apply_to_web2(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web2.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web2.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 82\n"
    assert "X-test" not in r.headers

 def test_custom_block_is_present_in_nginx_generated_conf(docker_compose, nginxproxy):
-    assert b"include /etc/nginx/vhost.d/web1.nginx-proxy.example_location;" in nginxproxy.get_conf()
+    assert b"include /etc/nginx/vhost.d/web1.nginx-proxy.local_location;" in nginxproxy.get_conf()
--- a/test/test_custom/test_location-per-vhost.yml
+++ b/test/test_custom/test_location-per-vhost.yml
@ -1,30 +1,25 @@
+version: '2'
 services:
  nginx-proxy:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_f00.conf:/etc/nginx/vhost.d/web1.nginx-proxy.example_location:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_bar.conf:/etc/nginx/vhost.d/561032515ede3ab3a015edfb244608b72409c430_location:ro
+      - ./my_custom_proxy_settings.conf:/etc/nginx/vhost.d/web1.nginx-proxy.local_location:ro
+    environment:
+      HTTPS_METHOD: nohttps

  web1:
    image: web
    expose:
      - "81"
    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.nginx-proxy.example
+      WEB_PORTS: 81
+      VIRTUAL_HOST: web1.nginx-proxy.local

  web2:
    image: web
    expose:
      - "82"
    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: web2.nginx-proxy.example
-  
-  regex:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: ~^regex.*\.nginx-proxy\.example$
+      WEB_PORTS: 82
+      VIRTUAL_HOST: web2.nginx-proxy.local
--- a/test/test_custom/test_per-vhost.py
+++ b/test/test_custom/test_per-vhost.py
@ -1,24 +1,19 @@
+import pytest
+
 def test_custom_conf_does_not_apply_to_unknown_vhost(docker_compose, nginxproxy):
    r = nginxproxy.get("http://nginx-proxy/")
    assert r.status_code == 503
    assert "X-test" not in r.headers

 def test_custom_conf_applies_to_web1(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web1.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web1.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 81\n"
    assert "X-test" in r.headers
    assert "f00" == r.headers["X-test"]

-def test_custom_conf_applies_to_regex(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://regex.foo.nginx-proxy.example/port")
-    assert r.status_code == 200   
-    assert r.text == "answer from port 83\n"
-    assert "X-test" in r.headers
-    assert "bar" == r.headers["X-test"]
-
 def test_custom_conf_does_not_apply_to_web2(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web2.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web2.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 82\n"
    assert "X-test" not in r.headers
--- a/test/test_custom/test_per-vhost.yml
+++ b/test/test_custom/test_per-vhost.yml
@ -1,30 +1,25 @@
+version: '2'
 services:
  nginx-proxy:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_f00.conf:/etc/nginx/vhost.d/web1.nginx-proxy.example:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_bar.conf:/etc/nginx/vhost.d/561032515ede3ab3a015edfb244608b72409c430:ro
+      - ./my_custom_proxy_settings.conf:/etc/nginx/vhost.d/web1.nginx-proxy.local:ro
+    environment:
+      HTTPS_METHOD: nohttps

  web1:
    image: web
    expose:
      - "81"
    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.nginx-proxy.example
+      WEB_PORTS: 81
+      VIRTUAL_HOST: web1.nginx-proxy.local

  web2:
    image: web
    expose:
      - "82"
    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: web2.nginx-proxy.example
-  
-  regex:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: ~^regex.*\.nginx-proxy\.example$
+      WEB_PORTS: 82
+      VIRTUAL_HOST: web2.nginx-proxy.local
--- a/test/test_custom/test_proxy-wide.py
+++ b/test/test_custom/test_proxy-wide.py
@ -1,17 +1,19 @@
+import pytest
+
 def test_custom_conf_does_not_apply_to_unknown_vhost(docker_compose, nginxproxy):
    r = nginxproxy.get("http://nginx-proxy/")
    assert r.status_code == 503
    assert "X-test" not in r.headers

 def test_custom_conf_applies_to_web1(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web1.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web1.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 81\n"
    assert "X-test" in r.headers
    assert "f00" == r.headers["X-test"]

 def test_custom_conf_applies_to_web2(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://web2.nginx-proxy.example/port")
+    r = nginxproxy.get("http://web2.nginx-proxy.local/port")
    assert r.status_code == 200   
    assert r.text == "answer from port 82\n"
    assert "X-test" in r.headers
--- a/test/test_custom/test_proxy-wide.yml
+++ b/test/test_custom/test_proxy-wide.yml
@ -1,21 +1,25 @@
+version: '2'
 services:
  nginx-proxy:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/my_custom_proxy_settings_f00.conf:/etc/nginx/conf.d/my_custom_proxy_settings_f00.conf:ro
+      - ./my_custom_proxy_settings.conf:/etc/nginx/conf.d/my_custom_proxy_settings.conf:ro
+    environment:
+      HTTPS_METHOD: nohttps

  web1:
    image: web
    expose:
      - "81"
    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.nginx-proxy.example
+      WEB_PORTS: 81
+      VIRTUAL_HOST: web1.nginx-proxy.local

  web2:
    image: web
    expose:
      - "82"
    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: web2.nginx-proxy.example
+      WEB_PORTS: 82
+      VIRTUAL_HOST: web2.nginx-proxy.local
--- a/test/test_debug-endpoint/test_global.py
+++ b/test/test_debug-endpoint/test_global.py
@ -1,48 +0,0 @@
-import json
-
-import pytest
-
-
-def test_debug_endpoint_is_enabled_globally(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://enabled.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-    r = nginxproxy.get("http://stripped.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-
-
-def test_debug_endpoint_response_contains_expected_values(docker_compose, nginxproxy):   
-    r = nginxproxy.get("http://enabled.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-    try:
-        jsonResponse = json.loads(r.text)
-    except ValueError as err:
-        pytest.fail("Failed to parse debug endpoint response as JSON: %s" % err, pytrace=False)
-    assert jsonResponse["global"]["enable_debug_endpoint"] == "true"
-    assert jsonResponse["vhost"]["enable_debug_endpoint"] == True
-
-
-def test_debug_endpoint_paths_stripped_if_response_too_long(docker_compose, nginxproxy):   
-    r = nginxproxy.get("http://stripped.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-    try:
-        jsonResponse = json.loads(r.text)
-    except ValueError as err:
-        pytest.fail("Failed to parse debug endpoint response as JSON: %s" % err, pytrace=False)
-    if "paths" in jsonResponse["vhost"]:
-        pytest.fail("Expected paths to be stripped from debug endpoint response", pytrace=False)
-    assert jsonResponse["warning"] == "Virtual paths configuration for this hostname is too large and has been stripped from response."
-
-
-def test_debug_endpoint_hostname_replaced_by_warning_if_regexp(docker_compose, nginxproxy):   
-    r = nginxproxy.get("http://regexp.foo.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-    try:
-        jsonResponse = json.loads(r.text)
-    except ValueError as err:
-        pytest.fail("Failed to parse debug endpoint response as JSON: %s" % err, pytrace=False)
-    assert jsonResponse["vhost"]["hostname"] == "Hostname is a regexp and unsafe to include in the debug response."
-
-
-def test_debug_endpoint_is_disabled_per_container(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://disabled.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 404  
--- a/test/test_debug-endpoint/test_global.yml
+++ b/test/test_debug-endpoint/test_global.yml
@ -1,59 +0,0 @@
-services:
-  nginx-proxy:
-    environment:
-      DEBUG_ENDPOINT: "true"
-
-  debug_enabled:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: enabled.debug.nginx-proxy.example
-  
-  debug_stripped:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST_MULTIPORTS: |-
-        stripped.debug.nginx-proxy.example:
-          "/1":
-          "/2":
-          "/3":
-          "/4":
-          "/5":
-          "/6":
-          "/7":
-          "/8":
-          "/9":
-          "/10":
-          "/11":
-          "/12":
-          "/13":
-          "/14":
-          "/15":
-          "/16":
-          "/17":
-          "/18":
-          "/19":
-          "/20":
-  
-  debug_regexp:
-    image: web
-    expose:
-      - "84"
-    environment:
-      WEB_PORTS: "84"
-      VIRTUAL_HOST: ~^regexp.*\.debug.nginx-proxy.example
-
-  debug_disabled:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: disabled.debug.nginx-proxy.example
-    labels:
-      com.github.nginx-proxy.nginx-proxy.debug-endpoint: "false"
--- a/test/test_debug-endpoint/test_per-container.py
+++ b/test/test_debug-endpoint/test_per-container.py
@ -1,26 +0,0 @@
-import json
-
-import pytest
-
-
-def test_debug_endpoint_is_disabled_globally(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://disabled1.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 404 
-    r = nginxproxy.get("http://disabled2.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 404 
-
-
-def test_debug_endpoint_is_enabled_per_container(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://enabled.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-
-
-def test_debug_endpoint_response_contains_expected_values(docker_compose, nginxproxy):   
-    r = nginxproxy.get("http://enabled.debug.nginx-proxy.example/nginx-proxy-debug")
-    assert r.status_code == 200
-    try:
-        jsonResponse = json.loads(r.text)
-    except ValueError as err:
-        pytest.fail("Failed to parse debug endpoint response as JSON:: %s" % err, pytrace=False)
-    assert jsonResponse["global"]["enable_debug_endpoint"] == "false"
-    assert jsonResponse["vhost"]["enable_debug_endpoint"] == True
--- a/test/test_debug-endpoint/test_per-container.yml
+++ b/test/test_debug-endpoint/test_per-container.yml
@ -1,27 +0,0 @@
-services:
-  debug_disabled1:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: disabled1.debug.nginx-proxy.example
-  
-  debug_disabled2:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: disabled2.debug.nginx-proxy.example
-
-
-  debug_enabled:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: enabled.debug.nginx-proxy.example
-    labels:
-      com.github.nginx-proxy.nginx-proxy.debug-endpoint: "true"
--- a/test/test_default-host/test_default-host.py
+++ b/test/test_default-host/test_default-host.py
@ -1,3 +1,6 @@
+import pytest
+
+
 def test_fallback_on_default(docker_compose, nginxproxy):
    r = nginxproxy.get("http://unknown.nginx-proxy.tld/port")
    assert r.status_code == 200
--- a/test/test_default-host.yml
+++ b/test/test_default-host.yml
@ -0,0 +1,18 @@
+# GIVEN a webserver with VIRTUAL_HOST set to web1.tld
+web1:
+  image: web
+  expose:
+    - "81"
+  environment:
+    WEB_PORTS: 81
+    VIRTUAL_HOST: web1.tld
+
+
+# WHEN nginx-proxy runs with DEFAULT_HOST set to web1.tld
+sut:
+  image: nginxproxy/nginx-proxy:test
+  volumes:
+    - /var/run/docker.sock:/tmp/docker.sock:ro
+  environment:
+    DEFAULT_HOST: web1.tld
+    HTTPS_METHOD: nohttps
--- a/test/test_default-host/test_default-host.yml
+++ b/test/test_default-host/test_default-host.yml
@ -1,12 +0,0 @@
-services:
-  nginx-proxy:
-    environment:
-      DEFAULT_HOST: web1.tld
-
-  web1:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.tld
--- a/test/test_virtual-path/test_default-root-none.py
+++ b/test/test_virtual-path/test_default-root-none.py
--- a/test/test_virtual-path/test_default-root-none.yml
+++ b/test/test_virtual-path/test_default-root-none.yml
@ -1,8 +1,11 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
    environment:
      DEFAULT_ROOT: none
-
+      HTTPS_METHOD: nohttps
  web:
    image: web
    expose:
--- a/test/test_docker-unix-socket/test_docker-unix-socket.yml
+++ b/test/test_docker-unix-socket/test_docker-unix-socket.yml
@ -1,22 +0,0 @@
-services:
-  nginx-proxy:
-    volumes:
-      - /var/run/docker.sock:/f00.sock:ro
-    environment:
-      DOCKER_HOST: unix:///f00.sock
-
-  web1:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: web1.nginx-proxy.tld
-
-  web2:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: web2.nginx-proxy.tld
--- a/test/test_dockergen/.gitignore
+++ b/test/test_dockergen/.gitignore
@ -0,0 +1 @@
+nginx.tmpl
--- a/test/test_dockergen/test_dockergen_v2.py
+++ b/test/test_dockergen/test_dockergen_v2.py
@ -0,0 +1,10 @@
+def test_unknown_virtual_host_is_503(docker_compose, nginxproxy):
+    r = nginxproxy.get("http://unknown.nginx.container.docker/")
+    assert r.status_code == 503
+
+
+def test_forwards_to_whoami(docker_compose, nginxproxy):
+    r = nginxproxy.get("http://whoami.nginx.container.docker/")
+    assert r.status_code == 200
+    whoami_container = docker_compose.containers.get("whoami")
+    assert r.text == f"I'm {whoami_container.id[:12]}\n"
--- a/test/test_dockergen/test_dockergen_v2.yml
+++ b/test/test_dockergen/test_dockergen_v2.yml
@ -0,0 +1,28 @@
+version: '2'
+
+services:
+  nginx:
+    image: nginx
+    container_name: nginx
+    volumes:
+      - /etc/nginx/conf.d
+
+  dockergen:
+    image: nginxproxy/docker-gen
+    command: -notify-sighup nginx -watch /etc/docker-gen/templates/nginx.tmpl /etc/nginx/conf.d/default.conf
+    volumes_from:
+      - nginx
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
+      - ../../nginx.tmpl:/etc/docker-gen/templates/nginx.tmpl
+    environment:
+      HTTPS_METHOD: nohttps
+
+  web:
+    image: web
+    container_name: whoami
+    expose:
+      - "80"
+    environment:
+      WEB_PORTS: 80
+      VIRTUAL_HOST: whoami.nginx.container.docker
--- a/test/test_dockergen/test_dockergen_v3.py
+++ b/test/test_dockergen/test_dockergen_v3.py
@ -1,11 +1,11 @@
 import docker
 import pytest
-from packaging.version import Version
+from distutils.version import LooseVersion


 raw_version = docker.from_env().version()["Version"]
 pytestmark = pytest.mark.skipif(
-    Version(raw_version) < Version("1.13"),
+    LooseVersion(raw_version) < LooseVersion("1.13"),
    reason="Docker compose syntax v3 requires docker engine v1.13 or later (got {raw_version})"
 )

--- a/test/test_dockergen/test_dockergen.base.yml
+++ b/test/test_dockergen/test_dockergen.base.yml
@ -1,24 +1,20 @@
-volumes:
-  nginx_conf:
-
-
+version: '3'
 services:
-  nginx-proxy-nginx:
+  nginx:
    image: nginx
    container_name: nginx
    volumes:
-      - nginx_conf:/etc/nginx/conf.d:ro
-    ports:
-      - "80:80"
-      - "443:443"
+      - nginx_conf:/etc/nginx/conf.d

-  nginx-proxy-dockergen:
+  dockergen:
    image: nginxproxy/docker-gen
    command: -notify-sighup nginx -watch /etc/docker-gen/templates/nginx.tmpl /etc/nginx/conf.d/default.conf
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - ../../nginx.tmpl:/etc/docker-gen/templates/nginx.tmpl
      - nginx_conf:/etc/nginx/conf.d
+    environment:
+      HTTPS_METHOD: nohttps

  web:
    image: web
@ -26,5 +22,8 @@ services:
    expose:
      - "80"
    environment:
-      WEB_PORTS: "80"
+      WEB_PORTS: 80
      VIRTUAL_HOST: whoami.nginx.container.docker
+
+volumes:
+  nginx_conf: {}
--- a/test/test_enable-http-on-missing-cert/test_enable-http-on-missing-cert.py
+++ b/test/test_enable-http-on-missing-cert/test_enable-http-on-missing-cert.py
@ -1,15 +0,0 @@
-def test_nohttp_missing_cert_disabled(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://nohttp-missing-cert-disabled.nginx-proxy.tld/", allow_redirects=False)
-    assert r.status_code == 503
-
-def test_nohttp_missing_cert_enabled(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://nohttp-missing-cert-enabled.nginx-proxy.tld/", allow_redirects=False)
-    assert r.status_code == 200
-
-def test_redirect_missing_cert_disabled(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://redirect-missing-cert-disabled.nginx-proxy.tld/", allow_redirects=False)
-    assert r.status_code == 301
-
-def test_redirect_missing_cert_enabled(docker_compose, nginxproxy):
-    r = nginxproxy.get("http://redirect-missing-cert-enabled.nginx-proxy.tld/", allow_redirects=False)
-    assert r.status_code == 200
--- a/test/test_enable-http-on-missing-cert/test_enable-http-on-missing-cert.yml
+++ b/test/test_enable-http-on-missing-cert/test_enable-http-on-missing-cert.yml
@ -1,40 +0,0 @@
-services:
-  nginx-proxy:
-    environment:
-      ENABLE_HTTP_ON_MISSING_CERT: "false"
-
-  nohttp-missing-cert-disabled:
-    image: web
-    expose:
-      - "81"
-    environment:
-      WEB_PORTS: "81"
-      VIRTUAL_HOST: nohttp-missing-cert-disabled.nginx-proxy.tld
-      HTTPS_METHOD: nohttp
-
-  nohttp-missing-cert-enabled:
-    image: web
-    expose:
-      - "82"
-    environment:
-      WEB_PORTS: "82"
-      VIRTUAL_HOST: nohttp-missing-cert-enabled.nginx-proxy.tld
-      HTTPS_METHOD: nohttp
-      ENABLE_HTTP_ON_MISSING_CERT: "true"
-
-  redirect-missing-cert-disabled:
-    image: web
-    expose:
-      - "83"
-    environment:
-      WEB_PORTS: "83"
-      VIRTUAL_HOST: redirect-missing-cert-disabled.nginx-proxy.tld
-
-  redirect-missing-cert-enabled:
-    image: web
-    expose:
-      - "84"
-    environment:
-      WEB_PORTS: "84"
-      VIRTUAL_HOST: redirect-missing-cert-enabled.nginx-proxy.tld
-      ENABLE_HTTP_ON_MISSING_CERT: "true"
--- a/test/test_events/test_events.py
+++ b/test/test_events/test_events.py
@ -7,7 +7,7 @@ import pytest
 from docker.errors import NotFound


-@pytest.fixture
+@pytest.fixture()
 def web1(docker_compose):
    """
    pytest fixture creating a web container with `VIRTUAL_HOST=web1.nginx-proxy` listening on port 81.
@ -22,7 +22,6 @@ def web1(docker_compose):
        },
        ports={"81/tcp": None}
    )
-    docker_compose.networks.get("test_events-net").connect(container)
    sleep(2)  # give it some time to initialize and for docker-gen to detect it
    yield container
    try:
@ -30,7 +29,7 @@ def web1(docker_compose):
    except NotFound:
        pass

-@pytest.fixture
+@pytest.fixture()
 def web2(docker_compose):
    """
    pytest fixture creating a web container with `VIRTUAL_HOST=nginx-proxy`, `VIRTUAL_PATH=/web2/` and `VIRTUAL_DEST=/` listening on port 82.
@ -47,7 +46,6 @@ def web2(docker_compose):
        },
        ports={"82/tcp": None}
    )
-    docker_compose.networks.get("test_events-net").connect(container)
    sleep(2)  # give it some time to initialize and for docker-gen to detect it
    yield container
    try:
--- a/test/test_events.yml
+++ b/test/test_events.yml
@ -0,0 +1,6 @@
+nginxproxy:
+  image: nginxproxy/nginx-proxy:test
+  volumes:
+    - /var/run/docker.sock:/tmp/docker.sock:ro
+  environment:
+    HTTPS_METHOD: nohttps
--- a/test/test_events/test_events.yml
+++ b/test/test_events/test_events.yml
@ -1,3 +0,0 @@
-networks:
-  default:
-    name: test_events-net
--- a/test/test_fallback/test_fallback.data/custom-fallback.conf
+++ b/test/test_fallback/test_fallback.data/custom-fallback.conf
--- a/test/test_fallback/test_fallback.data/custom-fallback.yml
+++ b/test/test_fallback/test_fallback.data/custom-fallback.yml
@ -1,9 +1,9 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/test_fallback.data/custom-fallback.conf:/etc/nginx/conf.d/zzz-custom-fallback.conf:ro
-
+      - ./custom-fallback.conf:/etc/nginx/conf.d/zzz-custom-fallback.conf:ro
  http-only:
    image: web
    expose:
--- a/test/test_fallback/test_fallback.data/nodefault.certs/http-only.nginx-proxy.test.crt
+++ b/test/test_fallback/test_fallback.data/nodefault.certs/http-only.nginx-proxy.test.crt
--- a/test/test_fallback/test_fallback.data/nodefault.certs/http-only.nginx-proxy.test.key
+++ b/test/test_fallback/test_fallback.data/nodefault.certs/http-only.nginx-proxy.test.key
--- a/test/test_fallback/test_fallback.data/nodefault.certs/https-and-http.nginx-proxy.test.crt
+++ b/test/test_fallback/test_fallback.data/nodefault.certs/https-and-http.nginx-proxy.test.crt
--- a/test/test_fallback/test_fallback.data/nodefault.certs/https-and-http.nginx-proxy.test.key
+++ b/test/test_fallback/test_fallback.data/nodefault.certs/https-and-http.nginx-proxy.test.key
--- a/test/test_fallback/test_fallback.data/nodefault.certs/https-only.nginx-proxy.test.crt
+++ b/test/test_fallback/test_fallback.data/nodefault.certs/https-only.nginx-proxy.test.crt
--- a/test/test_fallback/test_fallback.data/nodefault.certs/https-only.nginx-proxy.test.key
+++ b/test/test_fallback/test_fallback.data/nodefault.certs/https-only.nginx-proxy.test.key
--- a/test/test_fallback/test_fallback.data/nodefault.yml
+++ b/test/test_fallback/test_fallback.data/nodefault.yml
@ -1,9 +1,9 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/test_fallback.data/nodefault.certs:/etc/nginx/certs:ro
-
+      - ./nodefault.certs:/etc/nginx/certs:ro
  https-and-http:
    image: web
    expose:
@ -11,7 +11,6 @@ services:
    environment:
      WEB_PORTS: "81"
      VIRTUAL_HOST: https-and-http.nginx-proxy.test
-
  https-only:
    image: web
    expose:
@ -20,7 +19,6 @@ services:
      WEB_PORTS: "82"
      VIRTUAL_HOST: https-only.nginx-proxy.test
      HTTPS_METHOD: nohttp
-
  http-only:
    image: web
    expose:
@ -29,7 +27,6 @@ services:
      WEB_PORTS: "83"
      VIRTUAL_HOST: http-only.nginx-proxy.test
      HTTPS_METHOD: nohttps
-
  missing-cert:
    image: web
    expose:
--- a/test/test_fallback/test_fallback.data/nohttp-on-app.yml
+++ b/test/test_fallback/test_fallback.data/nohttp-on-app.yml
@ -1,11 +1,11 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/test_fallback.data/withdefault.certs:/etc/nginx/certs:ro
+      - ./withdefault.certs:/etc/nginx/certs:ro
    environment:
      HTTPS_METHOD: redirect
-
  https-only:
    image: web
    expose:
--- a/test/test_fallback/test_fallback.data/nohttp-with-missing-cert.yml
+++ b/test/test_fallback/test_fallback.data/nohttp-with-missing-cert.yml
@ -1,11 +1,11 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/test_fallback.data/withdefault.certs:/etc/nginx/certs:ro
+      - ./withdefault.certs:/etc/nginx/certs:ro
    environment:
      HTTPS_METHOD: nohttp
-
  https-only:
    image: web
    expose:
@ -13,7 +13,6 @@ services:
    environment:
      WEB_PORTS: "82"
      VIRTUAL_HOST: https-only.nginx-proxy.test
-
  missing-cert:
    image: web
    expose:
@ -21,13 +20,3 @@ services:
    environment:
      WEB_PORTS: "84"
      VIRTUAL_HOST: missing-cert.nginx-proxy.test
-
-  missing-cert-default-untrusted:
-    image: web
-    expose:
-      - "85"
-    environment:
-      WEB_PORTS: "85"
-      VIRTUAL_HOST: missing-cert.default-untrusted.nginx-proxy.test
-    labels:
-      com.github.nginx-proxy.nginx-proxy.trust-default-cert: "false"
--- a/test/test_fallback/test_fallback.data/nohttp.yml
+++ b/test/test_fallback/test_fallback.data/nohttp.yml
@ -1,11 +1,11 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
-      - ${PYTEST_MODULE_PATH}/test_fallback.data/withdefault.certs:/etc/nginx/certs:ro
+      - ./withdefault.certs:/etc/nginx/certs:ro
    environment:
      HTTPS_METHOD: nohttp
-
  https-only:
    image: web
    expose:
--- a/test/test_fallback/test_fallback.data/nohttps-on-app.yml
+++ b/test/test_fallback/test_fallback.data/nohttps-on-app.yml
@ -1,8 +1,10 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
    environment:
      HTTPS_METHOD: redirect
-
  http-only:
    image: web
    expose:
--- a/test/test_fallback/test_fallback.data/nohttps.yml
+++ b/test/test_fallback/test_fallback.data/nohttps.yml
@ -1,8 +1,10 @@
 services:
-  nginx-proxy:
+  sut:
+    image: nginxproxy/nginx-proxy:test
+    volumes:
+      - /var/run/docker.sock:/tmp/docker.sock:ro
    environment:
      HTTPS_METHOD: nohttps
-
  http-only:
    image: web
    expose:
--- a/test/test_fallback/test_fallback.data/withdefault.certs/default.crt
+++ b/test/test_fallback/test_fallback.data/withdefault.certs/default.crt
--- a/test/test_fallback/test_fallback.data/withdefault.certs/default.key
+++ b/test/test_fallback/test_fallback.data/withdefault.certs/default.key
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`This directory contains tests that showcase scenarios known to break the expected behavior of nginx-proxy.`