QA Automation Core Concepts

Concept Map

Here's how the core QA automation concepts connect to each other — from writing individual tests to running them in a CI/CD pipeline.

1. The Test Pyramid

The test pyramid (coined by Mike Cohn) is the most important concept in test automation strategy. It tells you how many tests of each type to write:

2. Test Types

Unit tests verify a single function or method in complete isolation. Dependencies are mocked or stubbed.

# Unit test example (pytest)
def test_calculate_discount():
    assert calculate_discount(100, 0.2) == 80.0
    assert calculate_discount(50, 0) == 50.0
    assert calculate_discount(100, 1) == 0.0

Integration tests verify that multiple components work together — e.g., your API handler talks to the database correctly.

# Integration test — hits a real (test) database
def test_create_user_saves_to_db(test_db):
    response = client.post("/users", json={"name": "Alice"})
    assert response.status_code == 201
    user = test_db.query(User).filter_by(name="Alice").first()
    assert user is not None

End-to-end (E2E) tests simulate a real user interacting with the full application through the browser.

# E2E test example (Playwright)
def test_user_can_login(page):
    page.goto("https://myapp.com/login")
    page.fill("#email", "[email protected]")
    page.fill("#password", "secret123")
    page.click("button[type='submit']")
    assert page.url == "https://myapp.com/dashboard"

3. Page Object Model (POM)

POM is a design pattern for UI test automation. Instead of scattering selectors across test files, you encapsulate each page's elements and actions in a class. When the UI changes, you update one place instead of dozens of tests.

# Page Object
class LoginPage:
    def __init__(self, page):
        self.page = page
        self.email = page.locator("#email")
        self.password = page.locator("#password")
        self.submit = page.locator("button[type='submit']")

    def login(self, email, password):
        self.email.fill(email)
        self.password.fill(password)
        self.submit.click()

# Test using the Page Object
def test_login(page):
    login = LoginPage(page)
    page.goto("/login")
    login.login("[email protected]", "secret123")
    assert page.url.endswith("/dashboard")

4. Assertions & Matchers

Assertions are the "checkpoints" in your tests — they compare what actually happened with what you expected. If an assertion fails, the test fails.

# Python (pytest)
assert result == 42
assert "error" not in response.text
assert len(users) > 0

# JavaScript (Jest/Playwright)
# expect(result).toBe(42)
# expect(response).not.toContain("error")
# expect(users.length).toBeGreaterThan(0)

5. Test Data Management

Tests need predictable inputs to produce predictable outputs. Strategies include:

• Fixtures — Predefined data loaded before tests (pytest fixtures, JUnit @BeforeEach)
• Factories — Generate test objects programmatically (Factory Boy, Faker)
• Database seeding — Populate a test DB with known state before each run
• Test isolation — Each test gets a clean slate (transactions rolled back, containers reset)

# pytest fixture for test data
import pytest

@pytest.fixture
def sample_user(test_db):
    user = User(name="Test User", email="[email protected]")
    test_db.add(user)
    test_db.commit()
    yield user
    test_db.delete(user)
    test_db.commit()

6. CI Integration

The ultimate goal of test automation is running tests on every code change — automatically. A typical CI pipeline:

1. Developer pushes code or opens a PR
2. CI server detects the change and starts the pipeline
3. Unit tests run first (fast — fail early)
4. Integration tests run next (moderate speed)
5. E2E tests run last (slow but high confidence)
6. Results are reported back to the PR as pass/fail status checks
7. If all tests pass, code is eligible for merge/deploy

# GitHub Actions example
name: Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with: { python-version: '3.12' }
      - run: pip install -r requirements-test.txt
      - run: pytest tests/unit/ --junitxml=unit-results.xml
      - run: pytest tests/integration/ --junitxml=integration-results.xml
      - run: pytest tests/e2e/ --junitxml=e2e-results.xml

7. Test Reporting & Metrics

Good test suites produce actionable reports. Key metrics to track: