15.4. Testcontainers for Python

Compose                          Testcontainers

compose.test.yaml                код теста
      │                                │
      ▼                                ▼
docker compose up  ──► тесты     pytest ──► библиотека ──► Docker API
      │                                              │
   окружение снаружи                        окружение изнутри

from testcontainers.postgres import PostgresContainer

with PostgresContainer("postgres:17-alpine") as postgres:
    url = postgres.get_connection_url()
    # container поднят, готовность дождалась библиотека
# здесь container уже удалён

@pytest.fixture(scope="function")   container на КАЖДЫЙ тест
@pytest.fixture(scope="module")     на файл
@pytest.fixture(scope="session")    один на весь прогон

container            → scope="session"   (дорого поднимать)
схема или транзакция → scope="function"  (дёшево создавать)

pytest ──(соединение)──► Ryuk ──► Docker API
   │
   × процесс убит
                          │
                          ▼
              соединение разорвано → Ryuk удаляет всё помеченное

container = PostgresContainer("postgres:17-alpine").with_reuse()

testcontainers.reuse.enable=true

url = postgres.get_connection_url()   # postgresql+psycopg2://...@localhost:49173/test

from testcontainers.core.waiting_utils import wait_for_logs

container = DockerContainer("myimage:1.0").with_exposed_ports(8080)
container.start()
wait_for_logs(container, "сервис готов", timeout=30)

mkdir -p /tmp/tcdemo && cd /tmp/tcdemo
mkdir -p src tests

cat > requirements.txt <<'EOF'
psycopg[binary]==3.3.4
EOF
cat > requirements-dev.txt <<'EOF'
pytest==9.1.1
# Версию закрепите по данным PyPI: здесь она намеренно не указана,
# поскольку не сверялась при написании урока
testcontainers[postgres]
EOF

cat > src/__init__.py <<'PY'
PY

cat > src/store.py <<'PY'
"""Хранилище событий на PostgreSQL."""
from __future__ import annotations

import psycopg

SCHEMA = """
CREATE TABLE IF NOT EXISTS events (
    id      SERIAL PRIMARY KEY,
    kind    TEXT NOT NULL,
    payload JSONB NOT NULL,
    at      TIMESTAMPTZ NOT NULL DEFAULT now()
);
"""


def init_schema(conn: psycopg.Connection) -> None:
    conn.execute(SCHEMA)
    conn.commit()


def add_event(conn: psycopg.Connection, kind: str, payload: dict) -> int:
    import json
    row = conn.execute(
        "INSERT INTO events (kind, payload) VALUES (%s, %s) RETURNING id",
        (kind, json.dumps(payload)),
    ).fetchone()
    return row[0]


def events_of_kind(conn: psycopg.Connection, kind: str) -> list[dict]:
    rows = conn.execute(
        "SELECT id, kind, payload FROM events WHERE kind = %s ORDER BY id",
        (kind,),
    ).fetchall()
    return [{"id": r[0], "kind": r[1], "payload": r[2]} for r in rows]


def count_events(conn: psycopg.Connection) -> int:
    return conn.execute("SELECT count(*) FROM events").fetchone()[0]
PY

cat > tests/conftest.py <<'PY'
"""Фикстуры Testcontainers.

Ключевое решение: container — на весь прогон (дорого поднимать),
изоляция — на каждый тест (дёшево создавать схему).
Обратный выбор замедлил бы прогон примерно в сто раз.
"""
from __future__ import annotations

import uuid

import psycopg
import pytest
from testcontainers.postgres import PostgresContainer

from src.store import init_schema


@pytest.fixture(scope="session")
def postgres():
    """Один container на весь прогон.

    Библиотека сама дожидается готовности: сначала строка в логе,
    затем реальное подключение. Писать healthcheck не требуется.
    """
    with PostgresContainer("postgres:17-alpine") as container:
        yield container


@pytest.fixture(scope="session")
def dsn(postgres) -> str:
    """Адрес с ФАКТИЧЕСКИМ портом: он случаен при каждом запуске."""
    return (
        f"postgresql://{postgres.username}:{postgres.password}"
        f"@{postgres.get_container_host_ip()}"
        f":{postgres.get_exposed_port(5432)}/{postgres.dbname}"
    )


@pytest.fixture(scope="session")
def connection(dsn: str):
    conn = psycopg.connect(dsn)
    try:
        yield conn
    finally:
        conn.close()


@pytest.fixture
def db(connection):
    """Изоляция схемой — на каждый тест."""
    schema = f"t_{uuid.uuid4().hex[:12]}"
    connection.execute(f'CREATE SCHEMA "{schema}"')
    connection.execute(f'SET search_path TO "{schema}"')
    connection.commit()
    init_schema(connection)
    try:
        yield connection
    finally:
        connection.rollback()
        connection.execute(f'DROP SCHEMA "{schema}" CASCADE')
        connection.commit()
PY

cat > tests/test_store.py <<'PY'
"""Integration-тесты через Testcontainers."""
import pytest

from src.store import add_event, count_events, events_of_kind


def test_add_and_read(db):
    ident = add_event(db, "order.created", {"number": "N-1", "sum": 100})
    found = events_of_kind(db, "order.created")
    assert len(found) == 1
    assert found[0]["id"] == ident
    assert found[0]["payload"]["number"] == "N-1"


def test_jsonb_roundtrip(db):
    """JSONB — тип PostgreSQL; подделка его не воспроизведёт."""
    payload = {"вложенный": {"список": [1, 2, 3], "флаг": True}}
    add_event(db, "test", payload)
    assert events_of_kind(db, "test")[0]["payload"] == payload


def test_jsonb_query(db):
    """Запрос по полю JSONB выполняет БД."""
    add_event(db, "x", {"status": "ok"})
    add_event(db, "x", {"status": "fail"})
    row = db.execute(
        "SELECT count(*) FROM events WHERE payload->>'status' = 'ok'"
    ).fetchone()
    assert row[0] == 1


def test_ordering_by_id(db):
    for i in range(5):
        add_event(db, "seq", {"n": i})
    found = events_of_kind(db, "seq")
    assert [e["payload"]["n"] for e in found] == [0, 1, 2, 3, 4]


def test_isolation(db):
    """Схема на тест: данные прошлых тестов не видны."""
    assert count_events(db) == 0
PY
echo "  файлы созданы"

  файлы созданы

cd /tmp/tcdemo
cat > run.sh <<'SH'
#!/usr/bin/env bash
# Testcontainers требует доступ к Docker API из процесса тестов.
# Здесь socket монтируется в container с тестами.
set -uo pipefail

docker run --rm \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v "$PWD:/w" -w /w \
    --network host \
    -e PYTHONPATH=/w \
    -e TESTCONTAINERS_HOST_OVERRIDE=localhost \
    python:3.13-slim sh -c '
        pip install --quiet --no-cache-dir -r requirements.txt -r requirements-dev.txt \
            > /dev/null 2>&1
        python -m pytest tests/ -q --tb=short "$@"
    ' -- "$@"
SH
chmod +x run.sh

echo "═══ прогон тестов ═══"
timeout 300 ./run.sh 2>&1 | tail -6 | sed 's/^/  /'

echo "═══ что происходило ═══"
cat <<'TXT'
  1. pytest запросил фикстуру postgres (scope="session")
  2. Библиотека скачала образ postgres:17-alpine
  3. Запустила container с портом -p 0:5432 (случайный порт)
  4. Дождалась готовности встроенной стратегией
  5. Прогнала все тесты через ОДИН container
  6. Удалила container при завершении сеанса

  Ни healthcheck, ни compose-файла, ни ожидания вручную —
  всё это внутри библиотеки.
TXT

═══ прогон тестов ═══
  .....                                                                [100%]
  5 passed in 12.84s
═══ что происходило ═══
  1. pytest запросил фикстуру postgres (scope="session")
  2. Библиотека скачала образ postgres:17-alpine
  3. Запустила container с портом -p 0:5432 (случайный порт)
  4. Дождалась готовности встроенной стратегией
  5. Прогнала все тесты через ОДИН container
  6. Удалила container при завершении сеанса

  Ни healthcheck, ни compose-файла, ни ожидания вручную —
  всё это внутри библиотеки.

cd /tmp/tcdemo
cat > tests/conftest_function.py <<'PY'
"""ОШИБОЧНЫЙ вариант: container на каждый тест.

Изоляцию это даёт, но платит за неё в сто раз дороже необходимого:
PostgreSQL поднимается заново для каждого теста.
"""
from __future__ import annotations

import psycopg
import pytest
from testcontainers.postgres import PostgresContainer

from src.store import init_schema


@pytest.fixture(scope="function")          # ← вот здесь ошибка
def db():
    with PostgresContainer("postgres:17-alpine") as container:
        dsn = (
            f"postgresql://{container.username}:{container.password}"
            f"@{container.get_container_host_ip()}"
            f":{container.get_exposed_port(5432)}/{container.dbname}"
        )
        conn = psycopg.connect(dsn)
        init_schema(conn)
        try:
            yield conn
        finally:
            conn.close()
PY

cat > compare_scopes.sh <<'SH'
#!/usr/bin/env bash
# Сравнение scope="session" и scope="function" по времени.
set -uo pipefail

run_variant() {
    local label="$1" conftest="$2"
    cp "$conftest" tests/conftest.py
    local start end
    start="$(python3 -c 'import time; print(time.monotonic())')"
    timeout 600 ./run.sh > "/tmp/scope_$label.log" 2>&1
    local rc=$?
    end="$(python3 -c 'import time; print(time.monotonic())')"
    local seconds
    seconds="$(python3 -c "print(f'{$end - $start:.1f}')")"
    local containers
    containers="$(grep -c 'Pulling image\|Container started' "/tmp/scope_$label.log" 2>/dev/null || echo "?")"
    printf '  %-28s %8s с  (код %s)\n' "$label" "$seconds" "$rc"
    echo "$seconds"
}

cp tests/conftest.py /tmp/conftest_session_backup.py
SH
chmod +x compare_scopes.sh

echo "═══ сравнение областей действия ═══"
cp tests/conftest.py /tmp/conftest_session.py

measure_variant() {
    local label="$1"
    local start end
    start="$(python3 -c 'import time; print(time.monotonic())')"
    timeout 600 ./run.sh > "/tmp/v_$label.log" 2>&1
    end="$(python3 -c 'import time; print(time.monotonic())')"
    python3 -c "print(f'{$end - $start:.1f}')"
}

t_session="$(measure_variant session)"
printf '  %-30s %6s с\n' 'scope="session" (один container)' "$t_session"

cp tests/conftest_function.py tests/conftest.py
t_function="$(measure_variant function)"
printf '  %-30s %6s с\n' 'scope="function" (на каждый тест)' "$t_function"
cp /tmp/conftest_session.py tests/conftest.py

python3 -c "
s, f = $t_session, $t_function
n = 5
print(f'  на {n} тестах: разница {f - s:.1f} с, отношение {f / s:.1f}×')
print(f'  на 100 тестах ожидаемо: session ~{s:.0f} с, function ~{f / n * 100:.0f} с')
"

echo "═══ правильное сочетание ═══"
cat <<'TXT'
  container            scope="session"   поднимается один раз
  схема или транзакция scope="function"  создаётся на каждый тест

  Изоляция при этом полная: каждый тест видит свою схему.
  Ошибка «container на каждый тест ради изоляции» даёт ту же
  изоляцию за в сто раз большую цену.
TXT
rm -f tests/conftest_function.py compare_scopes.sh

═══ сравнение областей действия ═══
  scope="session" (один container)   12.9 с
  scope="function" (на каждый тест)  48.3 с
  на 5 тестах: разница 35.4 с, отношение 3.7×
  на 100 тестах ожидаемо: session ~13 с, function ~966 с
═══ правильное сочетание ═══
  container            scope="session"   поднимается один раз
  схема или транзакция scope="function"  создаётся на каждый тест

  Изоляция при этом полная: каждый тест видит свою схему.
  Ошибка «container на каждый тест ради изоляции» даёт ту же
  изоляцию за в сто раз большую цену.

cd /tmp/tcdemo
echo "═══ служебный container Ryuk ═══"
docker ps -a --filter 'ancestor=testcontainers/ryuk' \
    --format '  {{.Names}}  {{.Image}}  {{.Status}}' 2>/dev/null | head -3
echo "  (появляется во время прогона и исчезает после)"

echo "═══ проверка: убиваем процесс тестов ═══"
cat > slow_test.py <<'PY'
"""Тест, который висит достаточно долго, чтобы его прервать."""
import time

import pytest
from testcontainers.postgres import PostgresContainer


def test_long_running():
    with PostgresContainer("postgres:17-alpine") as container:
        print(f"container поднят: {container.get_exposed_port(5432)}", flush=True)
        time.sleep(120)
PY

docker run -d --name tc-kill-demo \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v "$PWD:/w" -w /w --network host \
    -e TESTCONTAINERS_HOST_OVERRIDE=localhost \
    python:3.13-slim sh -c '
        pip install --quiet --no-cache-dir pytest testcontainers[postgres] \
            > /dev/null 2>&1
        python -m pytest slow_test.py -q -s
    ' > /dev/null 2>&1

echo "  ждём, пока поднимется PostgreSQL..."
for i in $(seq 1 40); do
    if docker logs tc-kill-demo 2>&1 | grep -q 'container поднят'; then
        break
    fi
    sleep 2
done
before="$(docker ps --filter 'ancestor=postgres:17-alpine' -q | wc -l)"
ryuk="$(docker ps --filter 'ancestor=testcontainers/ryuk' -q | wc -l)"
printf '  до убийства: postgres=%s ryuk=%s\n' "$before" "$ryuk"

echo "  убиваем процесс тестов сигналом KILL:"
docker kill -s KILL tc-kill-demo > /dev/null 2>&1
sleep 15
after="$(docker ps --filter 'ancestor=postgres:17-alpine' -q | wc -l)"
printf '  после убийства: postgres=%s\n' "$after"
docker rm -f tc-kill-demo > /dev/null 2>&1
rm -f slow_test.py

echo "═══ как это работает ═══"
cat <<'TXT'
  Ryuk — служебный container, который держит соединение
  с процессом тестов и следит за ним.

  Каждый созданный объект помечается меткой сеанса.
  Обрыв соединения → Ryuk удаляет всё с этой меткой.

  Это решает ровно ту задачу, для которой в Compose нужен trap
  ([урок 15.3]) — но работает даже при kill -9, когда никакой
  обработчик сигнала уже не сработает.

  Отключение (иногда требуется в ограниченных средах):
    TESTCONTAINERS_RYUK_DISABLED=true

  Цена отключения: объекты остаются при аварийном завершении.
TXT

═══ служебный container Ryuk ═══
  (появляется во время прогона и исчезает после)
═══ проверка: убиваем процесс тестов ═══
  ждём, пока поднимется PostgreSQL...
  до убийства: postgres=1 ryuk=1
  убиваем процесс тестов сигналом KILL:
  после убийства: postgres=0
═══ как это работает ═══
  Ryuk — служебный container, который держит соединение
  с процессом тестов и следит за ним.

  Каждый созданный объект помечается меткой сеанса.
  Обрыв соединения → Ryuk удаляет всё с этой меткой.

  Это решает ровно ту задачу, для которой в Compose нужен trap
  ([урок 15.3]) — но работает даже при kill -9, когда никакой
  обработчик сигнала уже не сработает.
  ...

cd /tmp/tcdemo
echo "═══ что даёт .with_reuse() ═══"
cat <<'TXT'
  container = PostgresContainer("postgres:17-alpine").with_reuse()

  Container не удаляется после прогона и подхватывается следующим.
  Экономия — секунды старта на каждом запуске.

  Требуется явное согласие в ~/.testcontainers.properties:
    testcontainers.reuse.enable=true

  Без этого файла флаг игнорируется.
TXT

echo "═══ что переиспользование ломает ═══"
python3 - <<'PY'
CASES = [
    ("Чистота состояния", "в базе остаются данные прошлого прогона",
     "изоляция схемой на тест — обязательна, а не желательна"),
    ("Воспроизводимость", "результат зависит от истории запусков",
     "тест может проходить только потому, что до него что-то создали"),
    ("Смена образа", "старый container не пересоздаётся автоматически",
     "обновили версию PostgreSQL — тесты идут на старой"),
    ("Работа в CI", "каждая задача получает свою машину",
     "переиспользовать нечего; выгоды ноль"),
]
print(f"  {'что ломается':<24} {'почему':<46} следствие")
print("  " + "─" * 108)
for what, why, effect in CASES:
    print(f"  {what:<24} {why:<46} {effect}")
print()
print("  Вывод: переиспользование — инструмент ЛОКАЛЬНОЙ разработки.")
print("  В CI оно бесполезно и создаёт ложную уверенность,")
print("  что тесты быстрые.")
PY

echo "═══ проверка: файл согласия ═══"
if [ -f "$HOME/.testcontainers.properties" ]; then
    grep -c 'reuse.enable' "$HOME/.testcontainers.properties" 2>/dev/null \
        | sed 's/^/  строк с reuse.enable: /'
else
    echo "  ~/.testcontainers.properties отсутствует — переиспользование выключено"
fi

═══ что даёт .with_reuse() ═══
  container = PostgresContainer("postgres:17-alpine").with_reuse()

  Container не удаляется после прогона и подхватывается следующим.
  Экономия — секунды старта на каждом запуске.

  Требуется явное согласие в ~/.testcontainers.properties:
    testcontainers.reuse.enable=true

  Без этого файла флаг игнорируется.
═══ что переиспользование ломает ═══
  что ломается             почему                                         следствие
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Чистота состояния        в базе остаются данные прошлого прогона        изоляция схемой на тест — обязательна, а не желательна
  Воспроизводимость        результат зависит от истории запусков          тест может проходить только потому, что до него что-то создали
  Смена образа             старый container не пересоздаётся автоматически  обновили версию PostgreSQL — тесты идут на старой
  Работа в CI              каждая задача получает свою машину             переиспользовать нечего; выгоды ноль

  Вывод: переиспользование — инструмент ЛОКАЛЬНОЙ разработки.
  В CI оно бесполезно и создаёт ложную уверенность,
  что тесты быстрые.
═══ проверка: файл согласия ═══
  ~/.testcontainers.properties отсутствует — переиспользование выключено

cd /tmp/tcdemo
cat > tests/test_versions.py <<'PY'
"""То, что через Compose делается неудобно: проверка на нескольких
версиях зависимости в одном наборе тестов.

Каждая версия — свой container, поднимаемый параметризованной фикстурой.
"""
from __future__ import annotations

import psycopg
import pytest
from testcontainers.postgres import PostgresContainer

VERSIONS = ["postgres:16-alpine", "postgres:17-alpine"]


@pytest.fixture(scope="session", params=VERSIONS, ids=lambda v: v.split(":")[1])
def pg_any_version(request):
    with PostgresContainer(request.param) as container:
        yield container


@pytest.fixture
def conn_any(pg_any_version):
    dsn = (
        f"postgresql://{pg_any_version.username}:{pg_any_version.password}"
        f"@{pg_any_version.get_container_host_ip()}"
        f":{pg_any_version.get_exposed_port(5432)}/{pg_any_version.dbname}"
    )
    conn = psycopg.connect(dsn)
    try:
        yield conn
    finally:
        conn.close()


def test_server_version_reported(conn_any):
    row = conn_any.execute("SHOW server_version").fetchone()
    assert row[0], "версия сервера не получена"
    print(f"\n    сервер: {row[0]}")


def test_jsonb_supported_everywhere(conn_any):
    """Проверка совместимости: работает ли код на обеих версиях."""
    conn_any.execute("CREATE TEMP TABLE t (data JSONB)")
    conn_any.execute("""INSERT INTO t VALUES ('{"k": "v"}')""")
    row = conn_any.execute("SELECT data->>'k' FROM t").fetchone()
    assert row[0] == "v"
PY

echo "═══ прогон на двух версиях PostgreSQL ═══"
timeout 400 ./run.sh tests/test_versions.py -v 2>&1 \
    | grep -E 'сервер:|PASSED|passed|failed' | head -8 | sed 's/^/  /'

echo "═══ почему это трудно через Compose ═══"
cat <<'TXT'
  В Compose пришлось бы:
    · описать два сервиса db-16 и db-17
    · поднять оба на каждом прогоне, даже когда нужен один
    · передать тестам два разных DATABASE_URL
    · вручную сопоставить параметр теста с нужным сервисом

  Здесь это одна строка params=VERSIONS в фикстуре.

  Это и есть случай, где Testcontainers однозначно выигрывает:
  окружение зависит от параметра теста.
TXT
rm -f tests/test_versions.py

═══ прогон на двух версиях PostgreSQL ═══
      сервер: 16.10
  tests/test_versions.py::test_server_version_reported[16-alpine] PASSED
  tests/test_versions.py::test_jsonb_supported_everywhere[16-alpine] PASSED
      сервер: 17.6
  tests/test_versions.py::test_server_version_reported[17-alpine] PASSED
  tests/test_versions.py::test_jsonb_supported_everywhere[17-alpine] PASSED
  4 passed in 26.71s
═══ почему это трудно через Compose ═══
  В Compose пришлось бы:
    · описать два сервиса db-16 и db-17
    · поднять оба на каждом прогоне, даже когда нужен один
    · передать тестам два разных DATABASE_URL
    · вручную сопоставить параметр теста с нужным сервисом

  Здесь это одна строка params=VERSIONS в фикстуре.
  ...

cd /tmp/tcdemo
cat > choose.py <<'PY'
"""Выбор между Compose и Testcontainers по свойствам проекта."""
from __future__ import annotations

CRITERIA = [
    ("Окружение одинаково для всех тестов", "compose", 2,
     "один файл проще кода в фикстурах"),
    ("Нужны разные версии зависимости", "testcontainers", 3,
     "окружение становится параметром теста"),
    ("Тесты запускают не только Python-разработчики", "compose", 2,
     "YAML читается без знания языка"),
    ("Зависимость нужна лишь части тестов", "testcontainers", 2,
     "поднимается по требованию, а не всегда"),
    ("Доступ к Docker socket из тестов недопустим", "compose", 3,
     "Testcontainers без доступа к API не работает"),
    ("То же окружение нужно для ручной работы", "compose", 2,
     "docker compose up поднимает то же самое"),
    ("Проект — библиотека, а не сервис", "testcontainers", 2,
     "у библиотеки нет своего окружения развёртывания"),
    ("Требуется гарантия очистки при kill -9", "testcontainers", 1,
     "Ryuk работает там, где trap уже не сработает"),
]


def decide(answers: dict[str, bool]) -> None:
    compose = testcontainers = 0
    print(f"  {'критерий':<46} {'ответ':<7} {'в пользу':<16} вес")
    print("  " + "─" * 84)
    for text, favours, weight, _ in CRITERIA:
        answer = answers.get(text, False)
        mark = "да" if answer else "нет"
        if answer:
            if favours == "compose":
                compose += weight
            else:
                testcontainers += weight
        print(f"  {text:<46} {mark:<7} {favours if answer else '—':<16} "
              f"{weight if answer else 0}")

    print()
    print(f"  Compose:        {compose}")
    print(f"  Testcontainers: {testcontainers}")
    print()
    if compose > testcontainers:
        print("  ВЫВОД: Compose")
    elif testcontainers > compose:
        print("  ВЫВОД: Testcontainers")
    else:
        print("  ВЫВОД: равный счёт — выбирайте то, что команда знает лучше")
    print()
    print("  Смешивать НЕ следует: два механизма поднятия окружения")
    print("  удваивают число мест, где что-то может пойти не так.")


if __name__ == "__main__":
    # Типичный веб-сервис: одно окружение, нужен и для ручной работы,
    # доступ к socket в CI ограничен
    decide({
        "Окружение одинаково для всех тестов": True,
        "Тесты запускают не только Python-разработчики": True,
        "Доступ к Docker socket из тестов недопустим": True,
        "То же окружение нужно для ручной работы": True,
    })
PY

echo "═══ выбор для типичного веб-сервиса ═══"
python3 choose.py

cd /tmp && rm -rf /tmp/tcdemo

═══ выбор для типичного веб-сервиса ═══
  критерий                                       ответ   в пользу         вес
  ────────────────────────────────────────────────────────────────────────────────────
  Окружение одинаково для всех тестов            да      compose          2
  Нужны разные версии зависимости                нет     —                0
  Тесты запускают не только Python-разработчики  да      compose          2
  Зависимость нужна лишь части тестов            нет     —                0
  Доступ к Docker socket из тестов недопустим    да      compose          3
  То же окружение нужно для ручной работы        да      compose          2
  Проект — библиотека, а не сервис               нет     —                0
  Требуется гарантия очистки при kill -9         нет     —                0

  Compose:        9
  Testcontainers: 0

  ВЫВОД: Compose

docker ps --filter 'ancestor=testcontainers/ryuk' --format '{{.Names}} {{.Status}}'
python -m pytest tests/ -q --durations=5
docker ps -a --filter 'label=org.testcontainers=true' | wc -l
cat ~/.testcontainers.properties 2>/dev/null || echo "переиспользование выключено"