Why integration tests verify components together in PyTest - Framework Benefits

Framework Mode - Why integration tests verify components together

Folder Structure

project-root/
├── src/
│   └── app_code.py
├── tests/
│   ├── unit/
│   │   └── test_module_unit.py
│   ├── integration/
│   │   └── test_module_integration.py
│   ├── conftest.py
│   └── fixtures.py
├── pytest.ini
└── requirements.txt
    

This structure separates unit tests and integration tests clearly. Integration tests live in tests/integration/ to verify how components work together.

Test Framework Layers

• Test Layer: Contains unit and integration test scripts using pytest.
• Application Layer: The source code modules under src/.
• Fixtures & Utilities: Shared setup code in conftest.py and fixtures.py to prepare test data and environment.
• Configuration Layer: pytest.ini and environment variables to control test runs.

Configuration Patterns

Use pytest.ini to set default options like test paths and markers.

[pytest]
markers =
    integration: mark test as integration test
    unit: mark test as unit test
    

Use environment variables or conftest.py fixtures to configure database URLs, API endpoints, or credentials for integration tests.

Example fixture in conftest.py:

import pytest

@pytest.fixture(scope='session')
def db_connection():
    # Setup connection to test database
    conn = connect_to_test_db()
    yield conn
    conn.close()
    

Test Reporting and CI/CD Integration

Use pytest built-in reporting with options like --junitxml=report.xml to generate XML reports.

Integrate with CI/CD pipelines (GitHub Actions, Jenkins, GitLab CI) to run tests automatically on code changes.

Example GitHub Actions snippet:

name: Python Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.12'
      - name: Install dependencies
        run: pip install -r requirements.txt
      - name: Run tests
        run: pytest --junitxml=report.xml
      - name: Upload test report
        uses: actions/upload-artifact@v3
        with:
          name: test-report
          path: report.xml
    

Best Practices for Integration Testing Framework

• Clear Separation: Keep unit and integration tests in separate folders for clarity.
• Use Fixtures: Share setup and teardown code with pytest fixtures to avoid duplication.
• Test Real Interactions: Integration tests should verify how components communicate, not just isolated behavior.
• Isolate External Systems: Use test databases or mocks for external services to keep tests reliable.
• Mark Tests: Use pytest markers to easily select or skip integration tests during runs.

Self Check

Where in this folder structure would you add a new integration test for a feature that combines two modules?

Key Result

Integration tests verify how multiple components work together by testing their real interactions in a shared environment.

Practice

1. Why do integration tests verify components together in pytest?

easy

A. To check if different parts of the program work well together

B. To test a single function in isolation

C. To measure the speed of the program

D. To check the spelling in the code comments

Solution

1. Step 1: Understand the purpose of integration tests

   Integration tests focus on testing how different parts or components of a program work together as a group.

2. Step 2: Compare with other test types

   Unit tests check single functions alone, while integration tests check combined parts to find issues missed by unit tests.

3. Final Answer:

   To check if different parts of the program work well together -> Option A

4. Quick Check:

   Integration tests verify combined components = A [OK]

Hint: Integration tests check combined parts, not single functions [OK]

Common Mistakes:

• Confusing integration tests with unit tests
• Thinking integration tests check performance
• Assuming integration tests check code comments

2. Which pytest code snippet correctly shows an integration test combining two components?

easy

A. def test_multiply(): assert multiply(2, 3) == 6

B. def test_add(): assert add(2, 3) == 5

C. def test_subtract(): assert subtract(5, 3) == 2

D. def test_add_and_multiply(): assert multiply(add(2, 3), 4) == 20

Solution

1. Step 1: Identify integration test code

   Integration tests combine multiple components; here, add and multiply are used together in one test.

2. Step 2: Check other options

   Options A, B, and D test single functions alone, so they are unit tests, not integration tests.

3. Final Answer:

   def test_add_and_multiply(): assert multiply(add(2, 3), 4) == 20 -> Option D

4. Quick Check:

   Integration test combines functions = C [OK]

Hint: Integration test calls multiple functions together [OK]

Common Mistakes:

• Choosing unit tests as integration tests
• Ignoring combined function calls
• Not checking the assertion logic

3. Given the pytest integration test below, what will be the test result?

def test_process_order():
    order = create_order(5)
    result = process_payment(order)
    assert result == 'Success'

medium

A. Test fails because create_order is not defined

B. Test passes if process_payment returns 'Success' for order 5

C. Test passes regardless of process_payment output

D. Test fails due to syntax error

Solution

1. Step 1: Analyze the test logic

   The test calls create_order and then process_payment with the order. It asserts the result equals 'Success'.

2. Step 2: Understand test pass condition

   If process_payment(order) returns 'Success', the assertion passes and the test passes. Otherwise, it fails.

3. Final Answer:

   Test passes if process_payment returns 'Success' for order 5 -> Option B

4. Quick Check:

   Assertion matches output = B [OK]

Hint: Test passes only if assertion matches actual output [OK]

Common Mistakes:

• Assuming test passes without matching assertion
• Confusing undefined functions with test result
• Thinking syntax error exists without checking code

4. Identify the error in this pytest integration test code:

def test_user_login():
    user = create_user('alice')
    assert login(user) == True
    assert logout(user) = True

medium

A. No error, code is correct

B. Missing parentheses in function calls

C. Using single equals (=) instead of double equals (==) in last assertion

D. Using wrong function names for login and logout

Solution

1. Step 1: Check assertion syntax

   The last assertion uses single equals (=) which is assignment, not comparison. It should be double equals (==).

2. Step 2: Verify other code parts

   Function calls have parentheses and function names look consistent. So no other syntax errors.

3. Final Answer:

   Using single equals (=) instead of double equals (==) in last assertion -> Option C

4. Quick Check:

   Use '==' for comparison in assertions = D [OK]

Hint: Assertions need '==' not '=' for comparisons [OK]

Common Mistakes:

• Confusing assignment (=) with comparison (==)
• Ignoring syntax errors in assertions
• Assuming function names cause error without evidence

5. You have two components: fetch_data() returns data list, and process_data(data) filters it. Why is an integration test combining both important?

hard

A. To verify process_data works correctly with actual fetched data

B. To check if fetch_data returns correct data format alone

C. To test process_data independently with mock data

D. To measure how fast fetch_data runs

Solution

1. Step 1: Understand component roles

   fetch_data() gets data, process_data(data) filters it. Testing them together checks real interaction.

2. Step 2: Why integration test matters here

   Integration test ensures process_data handles actual data from fetch_data, catching issues missed by isolated tests.

3. Final Answer:

   To verify process_data works correctly with actual fetched data -> Option A

4. Quick Check:

   Integration test checks real data flow = A [OK]

Hint: Integration tests check real data flow between components [OK]

Common Mistakes:

• Testing components only in isolation
• Ignoring real data format in integration
• Confusing performance test with integration test