Test containers with Docker in PyTest - Build an Automation Script

Verify application connects to a PostgreSQL database running in a Docker container

Preconditions (3)

Step 1: Start a PostgreSQL container using testcontainers in the test setup

Step 2: Wait until the database is ready to accept connections

Step 3: Connect to the PostgreSQL database using connection details from the container

Step 4: Create a test table and insert a sample record

Step 5: Query the inserted record to verify data is stored correctly

Step 6: Stop and remove the PostgreSQL container after the test

✅ Expected Result: The test should pass confirming that the application can connect to the PostgreSQL container, create and query data successfully.

Automation Requirements - pytest

Assertions Needed:

Assert that the inserted record is retrieved correctly from the database

Best Practices:

Use testcontainers Python library to manage Docker container lifecycle

Use explicit waits or retries to ensure database readiness

Use pytest fixtures for setup and teardown

Avoid hardcoding connection details; get them dynamically from the container

Keep tests isolated and clean up resources after test

Automated Solution

PyTest

import pytest
import psycopg2
from testcontainers.postgres import PostgresContainer

@pytest.fixture(scope='module')
def postgres_container():
    with PostgresContainer('postgres:15') as postgres:
        yield postgres


def test_postgres_connection(postgres_container):
    conn = psycopg2.connect(
        dbname=postgres_container.POSTGRES_DB,
        user=postgres_container.POSTGRES_USER,
        password=postgres_container.POSTGRES_PASSWORD,
        host=postgres_container.get_container_host_ip(),
        port=postgres_container.get_exposed_port(postgres_container.port)
    )
    cur = conn.cursor()
    cur.execute('CREATE TABLE test_table (id SERIAL PRIMARY KEY, name VARCHAR(50));')
    cur.execute("INSERT INTO test_table (name) VALUES ('testname') RETURNING id;")
    inserted_id = cur.fetchone()[0]
    conn.commit()

    cur.execute('SELECT name FROM test_table WHERE id = %s;', (inserted_id,))
    result = cur.fetchone()[0]

    cur.close()
    conn.close()

    assert result == 'testname'

This test uses the testcontainers library to start a PostgreSQL Docker container automatically before the test and stop it after.

The postgres_container fixture manages the container lifecycle with scope='module' so it runs once per test module.

Inside the test, it connects to the database using connection info provided by the container object, avoiding hardcoded values.

It creates a table, inserts a record, and queries it back to verify the database is working.

Assertions check that the retrieved data matches the inserted data.

This approach ensures the test is isolated, repeatable, and cleans up resources properly.

Common Mistakes - 4 Pitfalls

Hardcoding database connection details instead of using container properties

Not waiting for the database to be ready before connecting

Not cleaning up the container after tests

Using global or session scope for container without isolation

Bonus Challenge

Now add data-driven testing with 3 different names inserted and verified in the database

Show Hint

Practice

1. What is the main benefit of using test containers with Docker in pytest?

easy

A. They make tests run faster by skipping setup steps.

B. They replace the need for writing any test code.

C. They automatically fix bugs in the application code.

D. They provide real service environments during tests for better reliability.

Solution

1. Step 1: Understand test containers purpose

   Test containers run real services like databases inside Docker during tests.

2. Step 2: Identify benefit in pytest context

   This makes tests more reliable and realistic by using actual service environments.

3. Final Answer:

   They provide real service environments during tests for better reliability. -> Option D

4. Quick Check:

   Real service environment = Better test reliability [OK]

Hint: Remember: test containers run real services inside Docker [OK]

Common Mistakes:

• Thinking test containers replace writing tests
• Believing they fix code bugs automatically
• Assuming tests run faster by skipping setup

2. Which pytest fixture code correctly starts a Docker container for testing?

easy

A. def container():
container = docker.run('redis')
yield container
container.stop()

B. def container():
client = docker.from_env()
container = client.run('redis')
yield container
container.stop()

C. def container():
client = docker.from_env()
container = client.containers.run('redis', detach=True)
yield container
container.stop()

D. def container():
client = docker.from_env()
container = client.containers.run('redis')
container.start()
yield container
container.stop()

Solution

1. Step 1: Check correct Docker client usage

   Use docker.from_env() to get client, then client.containers.run() with detach=True to start container.

2. Step 2: Verify fixture lifecycle management

   Yield container for test, then stop container after test finishes.

3. Final Answer:

   def container(): client = docker.from_env() container = client.containers.run('redis', detach=True) yield container container.stop() -> Option C

4. Quick Check:

   Use client.containers.run with detach=True [OK]

Hint: Use client.containers.run with detach=True to start container [OK]

Common Mistakes:

• Calling client.run instead of client.containers.run
• Missing detach=True causing blocking call
• Not stopping container after test

3. Given this pytest fixture, what will be printed when running the test?

import pytest
import docker

@pytest.fixture
 def redis_container():
    client = docker.from_env()
    container = client.containers.run('redis:alpine', detach=True)
    yield container
    container.stop()

def test_redis_running(redis_container):
    print(redis_container.status)

medium

A. running

B. created

C. exited

D. paused

Solution

1. Step 1: Understand container lifecycle in fixture

   Container is started with detach=True, so status should be 'running' during test.

2. Step 2: Check printed status in test

   redis_container.status returns current container status, expected 'running' while test runs.

3. Final Answer:

   running -> Option A

4. Quick Check:

   Container started = status 'running' [OK]

Hint: Container status is 'running' while test uses it [OK]

Common Mistakes:

• Expecting 'created' before container starts
• Assuming container is 'exited' during test
• Confusing status with container image tag

4. Identify the error in this pytest fixture that manages a Docker container:

@pytest.fixture
def redis_container():
    client = docker.from_env()
    container = client.containers.run('redis', detach=True)
    yield container
    container.remove()

medium

A. Missing container.stop() before container.remove() to stop container properly.

B. Using container.remove() instead of container.delete() which is invalid.

C. Not specifying environment variables for Redis container causes failure.

D. Yielding container before starting it causes runtime error.

Solution

1. Step 1: Check container cleanup steps

   Container must be stopped before removal to avoid errors.

2. Step 2: Identify missing stop call

   Fixture calls container.remove() but misses container.stop() before it.

3. Final Answer:

   Missing container.stop() before container.remove() to stop container properly. -> Option A

4. Quick Check:

   Stop container before remove to clean up [OK]

Hint: Always stop container before removing it [OK]

Common Mistakes:

• Calling remove without stopping container
• Confusing remove() with non-existent delete()
• Assuming environment vars are mandatory for container start

5. You want to write a pytest fixture that starts a PostgreSQL container with Docker, waits until it is ready to accept connections, and then yields it for tests. Which approach correctly combines container management and readiness check?

hard

A. Start container without detach, yield immediately, and rely on test to wait for readiness.

B. Start container with detach=True, then poll container logs until 'database system is ready' appears before yielding.

C. Start container with detach=True and yield immediately without any readiness check.

D. Start container with detach=True, sleep fixed 1 second, then yield container.

Solution

1. Step 1: Manage container lifecycle properly

   Start PostgreSQL container detached to run in background during tests.

2. Step 2: Implement readiness check before yielding

   Poll container logs for 'database system is ready' message to ensure service is ready.

3. Step 3: Yield container after readiness confirmed

   This ensures tests run only after PostgreSQL is ready to accept connections.

4. Final Answer:

   Start container with detach=True, then poll container logs until 'database system is ready' appears before yielding. -> Option B

5. Quick Check:

   Wait for readiness log before yielding container [OK]

Hint: Wait for readiness log, don't guess with sleep [OK]

Common Mistakes:

• Yielding container before it is ready
• Using fixed sleep instead of log polling
• Starting container without detach causing blocking