Docker Basics for QA

Updated Aug 2026

Why Docker Matters for QA

Test environments are increasingly containerized. Docker provides isolated, reproducible environments that work the same on your laptop, in CI, and on a colleague's machine. Basic Docker skills are non-negotiable for modern QA work.

Core Concepts

Running Containers

Basic Commands

# Run a container (pull image if not local, start, attach)
docker run -d --name test-db \
  -e POSTGRES_PASSWORD=testpass \
  -e POSTGRES_DB=test_db \
  -p 5432:5432 \
  postgres:16

# Flag breakdown:
# -d              Run in background (detached)
# --name test-db  Give it a meaningful name
# -e KEY=VALUE    Set environment variables
# -p 5432:5432    Map host port to container port (host:container)
# postgres:16     Image name and tag

Managing Containers

# List running containers
docker ps

# List all containers (including stopped)
docker ps -a

# Stop a container
docker stop test-db

# Start a stopped container
docker start test-db

# Restart a container
docker restart test-db

# Remove a stopped container
docker rm test-db

# Stop and remove in one step
docker stop test-db && docker rm test-db

# Remove all stopped containers
docker container prune

Viewing Logs

# View all container logs
docker logs test-db

# View last 50 lines
docker logs test-db --tail 50

# Follow logs in real-time (like tail -f)
docker logs test-db --follow

# Logs with timestamps
docker logs test-db --timestamps

# Combine: last 50 lines + follow
docker logs test-db --tail 50 --follow

Executing Commands in Containers

# Open an interactive shell in a running container
docker exec -it test-db bash

# Run a specific command
docker exec test-db psql -U postgres -d test_db -c "SELECT count(*) FROM users;"

# Run a command in a running container (non-interactive)
docker exec test-db pg_isready

Common QA Containers

Database Containers

# PostgreSQL
docker run -d --name test-postgres \
  -e POSTGRES_PASSWORD=testpass \
  -e POSTGRES_DB=test_db \
  -p 5432:5432 \
  postgres:16

# MySQL
docker run -d --name test-mysql \
  -e MYSQL_ROOT_PASSWORD=testpass \
  -e MYSQL_DATABASE=test_db \
  -p 3306:3306 \
  mysql:8

# Redis
docker run -d --name test-redis \
  -p 6379:6379 \
  redis:7

# MongoDB
docker run -d --name test-mongo \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=testpass \
  -p 27017:27017 \
  mongo:7

Service Containers

# Mailpit (email testing -- catches all outgoing emails)
docker run -d --name test-mail \
  -p 1025:1025 \
  -p 8025:8025 \
  axllent/mailpit

# WireMock (API mocking)
docker run -d --name test-wiremock \
  -p 8080:8080 \
  wiremock/wiremock:latest

# Selenium Grid (browser testing)
docker run -d --name selenium-hub \
  -p 4442-4444:4442-4444 \
  selenium/hub:latest

Docker Compose for Test Environments

Docker Compose lets you define multi-container environments in a YAML file. This is the standard way to manage test environments that require multiple services.

Example: docker-compose.test.yml

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      NODE_ENV: test
      DATABASE_URL: postgres://postgres:testpass@db:5432/test_db
      REDIS_URL: redis://cache:6379
      MAIL_HOST: mail
      MAIL_PORT: 1025
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started

  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: testpass
      POSTGRES_DB: test_db
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

  cache:
    image: redis:7
    ports:
      - "6379:6379"

  mail:
    image: axllent/mailpit
    ports:
      - "1025:1025"
      - "8025:8025"

Compose Commands

# Start all services
docker compose -f docker-compose.test.yml up -d

# View logs from all services
docker compose -f docker-compose.test.yml logs -f

# View logs from a specific service
docker compose -f docker-compose.test.yml logs -f app

# Run tests against the environment
npm run test:integration

# Stop and remove everything (including volumes)
docker compose -f docker-compose.test.yml down -v

# Rebuild after code changes
docker compose -f docker-compose.test.yml up -d --build

Full Test Cycle with Compose

# One-command test cycle
docker compose -f docker-compose.test.yml up -d && \
  npm run test:integration ; \
  docker compose -f docker-compose.test.yml down -v

The semicolon (;) before down ensures cleanup happens even if tests fail.

Docker Troubleshooting for QA

Common Issues

Cleanup Commands

# Show disk usage by Docker
docker system df

# Remove all unused data (stopped containers, dangling images, unused networks)
docker system prune

# Remove all unused data including unused images (more aggressive)
docker system prune -a

# Remove specific types
docker container prune    # Stopped containers
docker image prune       # Dangling images
docker volume prune      # Unused volumes
docker network prune     # Unused networks

Docker in CI/CD

Most CI platforms support Docker natively. GitHub Actions uses the services keyword to run Docker containers alongside your tests:

services:
  postgres:
    image: postgres:16
    env:
      POSTGRES_PASSWORD: testpass
    ports:
      - 5432:5432
    options: >-
      --health-cmd pg_isready
      --health-interval 10s
      --health-timeout 5s
      --health-retries 5

This is equivalent to running docker run with the same parameters, but managed by the CI platform.

Hands-On Exercise

1. Run a PostgreSQL container and connect to it with psql (via docker exec)
2. Create a docker-compose.test.yml with an app, database, and Redis
3. Start the environment, run tests, and tear it down
4. Intentionally break a service and use docker logs to diagnose the issue
5. Check Docker disk usage on your machine and clean up unused resources
6. Add a healthcheck to your database service and verify it works with docker compose ps