Testing

🧪 Testing Flask REST APIs

Your Safety Net for Confident Code

The Story: Meet Your Code’s Best Friend

Imagine you’re a chef in a busy restaurant. Before serving any dish to customers, you taste it first. You check if the salt is right, if it’s cooked properly, if it looks good.

Testing your Flask app is exactly like tasting your food before serving it.

Without testing, you’re serving dishes blindfolded. With testing, you KNOW your app works before anyone uses it.

🎯 What We’ll Learn

graph TD
    A["Testing Flask Apps"] --> B["Test Client"]
    A --> C["pytest with Flask"]
    A --> D["Unit Testing Routes"]
    A --> E["Testing Database"]
    A --> F["Test Coverage"]

    style A fill:#667eea,color:#fff
    style B fill:#4ECDC4,color:#fff
    style C fill:#FF6B6B,color:#fff
    style D fill:#45B7D1,color:#fff
    style E fill:#96CEB4,color:#fff
    style F fill:#FFEAA7,color:#333

1. Testing Flask Applications

Why Test?

Think of tests like a checklist before a rocket launch:

✅ Does the engine work? ✅ Is the fuel loaded? ✅ Are all systems online?

Without checking, the rocket might explode! Same with your app.

Types of Tests

Simple Example

# Your Flask app (app.py)
from flask import Flask

app = Flask(__name__)

@app.route('/hello')
def hello():
    return 'Hello, World!'

# Your test (test_app.py)
def test_hello():
    # This checks if /hello works!
    response = app.test_client().get('/hello')
    assert response.data == b'Hello, World!'

That’s it! You wrote a test. If /hello ever breaks, this test will catch it.

2. The Test Client

Your Fake Browser

The test client is like a robot that pretends to be a user. It visits your app, clicks buttons, fills forms—without opening a real browser!

graph TD
    A["Test Client"] -->|GET /hello| B["Flask App"]
    B -->|Returns Response| A
    A -->|Check Response| C["Pass or Fail?"]

    style A fill:#FF6B6B,color:#fff
    style B fill:#4ECDC4,color:#fff
    style C fill:#FFEAA7,color:#333

Creating a Test Client

from flask import Flask

app = Flask(__name__)

# Get the test client
client = app.test_client()

# Now use it like a browser!
response = client.get('/hello')
response = client.post('/login',
    data={'user': 'sam'})

What Can Test Client Do?

Checking Responses

response = client.get('/hello')

# Check status code
assert response.status_code == 200

# Check the content
assert b'Hello' in response.data

# Check JSON responses
data = response.get_json()
assert data['message'] == 'success'

3. pytest with Flask

Why pytest?

pytest is like a super-powered test runner. It finds your tests, runs them, and tells you what passed or failed.

Think of it as your personal test assistant!

Install pytest

pip install pytest pytest-flask

Setting Up pytest

Create a special file called conftest.py. This is like a recipe book that pytest reads first.

# conftest.py
import pytest
from app import app as flask_app

@pytest.fixture
def app():
    """Create the Flask app for testing"""
    flask_app.config['TESTING'] = True
    return flask_app

@pytest.fixture
def client(app):
    """Create a test client"""
    return app.test_client()

What’s a Fixture?

A fixture is like a helper that prepares things before each test.

🍳 Analogy: Before cooking, you:

• Get your pan (the app)
• Get your spatula (the client)
• Preheat the oven (set config)

Fixtures do all this prep work automatically!

Writing Tests with pytest

# test_routes.py

def test_homepage(client):
    """Test that homepage loads"""
    response = client.get('/')
    assert response.status_code == 200

def test_not_found(client):
    """Test 404 for missing pages"""
    response = client.get('/does-not-exist')
    assert response.status_code == 404

Running Tests

# Run all tests
pytest

# Run with details
pytest -v

# Run one file
pytest test_routes.py

# Run one test
pytest test_routes.py::test_homepage

4. Unit Testing Routes

Testing Each Route Like a Chef Tests Each Dish

Every route in your app is like a different dish on the menu. Test each one!

GET Route Test

# app.py
@app.route('/users')
def get_users():
    return {'users': ['Alice', 'Bob']}

# test_routes.py
def test_get_users(client):
    response = client.get('/users')

    # Check it worked
    assert response.status_code == 200

    # Check the data
    data = response.get_json()
    assert 'users' in data
    assert 'Alice' in data['users']

POST Route Test

# app.py
@app.route('/users', methods=['POST'])
def create_user():
    data = request.get_json()
    return {'created': data['name']}, 201

# test_routes.py
def test_create_user(client):
    response = client.post('/users',
        json={'name': 'Charlie'})

    # 201 = Created successfully
    assert response.status_code == 201

    data = response.get_json()
    assert data['created'] == 'Charlie'

Testing Error Cases

Good tests also check what happens when things go WRONG!

def test_missing_data(client):
    """What if name is missing?"""
    response = client.post('/users',
        json={})  # No name!

    assert response.status_code == 400

def test_wrong_method(client):
    """What if wrong method used?"""
    response = client.delete('/users')
    assert response.status_code == 405

Route Testing Checklist

✅ Does the route return correct status code? ✅ Does it return correct data? ✅ Does it handle missing data? ✅ Does it handle wrong data types? ✅ Does it reject wrong HTTP methods?

5. Testing Database Operations

The Challenge

Testing with databases is tricky because:

• Tests should be independent (one test shouldn’t affect another)
• Tests should be fast (don’t use slow production database)
• Tests should be safe (don’t delete real data!)

Solution: Use a Test Database

graph TD
    A["Production Database"] -->|Real users| B["Your Live App"]
    C["Test Database"] -->|Fake test data| D["Your Tests"]

    style A fill:#FF6B6B,color:#fff
    style B fill:#FF6B6B,color:#fff
    style C fill:#4ECDC4,color:#fff
    style D fill:#4ECDC4,color:#fff

Setting Up Test Database

# conftest.py
import pytest
from app import app, db

@pytest.fixture
def app_with_db():
    """App with test database"""
    app.config['TESTING'] = True
    app.config['SQLALCHEMY_DATABASE_URI'] = \
        'sqlite:///:memory:'  # In-memory DB!

    with app.app_context():
        db.create_all()  # Create tables
        yield app
        db.drop_all()    # Clean up after

@pytest.fixture
def client(app_with_db):
    return app_with_db.test_client()

Testing Create (INSERT)

def test_create_user_in_db(client):
    # Create a user
    response = client.post('/users',
        json={'name': 'Diana', 'email': 'diana@test.com'})

    assert response.status_code == 201

    # Verify it's in database
    response = client.get('/users/1')
    data = response.get_json()
    assert data['name'] == 'Diana'

Testing Read (SELECT)

def test_get_user_from_db(client):
    # First create a user
    client.post('/users',
        json={'name': 'Eve'})

    # Now read it back
    response = client.get('/users')
    data = response.get_json()

    assert len(data['users']) == 1
    assert data['users'][0]['name'] == 'Eve'

Testing Update (UPDATE)

def test_update_user(client):
    # Create user
    client.post('/users',
        json={'name': 'Frank'})

    # Update user
    response = client.put('/users/1',
        json={'name': 'Franklin'})

    assert response.status_code == 200

    # Verify change
    response = client.get('/users/1')
    assert response.get_json()['name'] == 'Franklin'

Testing Delete (DELETE)

def test_delete_user(client):
    # Create user
    client.post('/users',
        json={'name': 'Grace'})

    # Delete user
    response = client.delete('/users/1')
    assert response.status_code == 204

    # Verify it's gone
    response = client.get('/users/1')
    assert response.status_code == 404

Database Test Tips

6. Test Coverage

What Is Coverage?

Test coverage answers: “How much of my code is actually being tested?”

Think of it like a report card for your tests!

Your Code: 100 lines
Tests Run: 80 lines
Coverage: 80%

Why Coverage Matters

graph TD
    A["Low Coverage 30%"] -->|Many bugs hide| B["Scary!"]
    C["Good Coverage 80%"] -->|Most code tested| D["Confident!"]
    E["Perfect Coverage 100%"] -->|Everything tested| F["Amazing!"]

    style A fill:#FF6B6B,color:#fff
    style B fill:#FF6B6B,color:#fff
    style C fill:#FFEAA7,color:#333
    style D fill:#FFEAA7,color:#333
    style E fill:#4ECDC4,color:#fff
    style F fill:#4ECDC4,color:#fff

Install Coverage Tool

pip install pytest-cov

Running Coverage

# Run tests with coverage
pytest --cov=app

# See detailed report
pytest --cov=app --cov-report=term-missing

Understanding Coverage Report

Name           Stmts   Miss  Cover   Missing
--------------------------------------------
app.py            50     10    80%   45-54
routes.py         30      5    83%   20-24
--------------------------------------------
TOTAL             80     15    81%

Coverage Goals

Generate HTML Report

pytest --cov=app --cov-report=html

This creates a beautiful visual report you can open in your browser!

What to Focus On

Not all code needs 100% coverage. Focus on:

✅ Business logic (most important!) ✅ API routes ✅ Database operations ⚠️ Configuration files (less critical) ⚠️ Simple getters/setters (less critical)

🎉 Putting It All Together

Here’s a complete test file:

# conftest.py
import pytest
from app import create_app, db

@pytest.fixture
def app():
    app = create_app('testing')
    with app.app_context():
        db.create_all()
        yield app
        db.drop_all()

@pytest.fixture
def client(app):
    return app.test_client()

# test_api.py
class TestUserAPI:
    """All user-related tests"""

    def test_create_user(self, client):
        resp = client.post('/api/users',
            json={'name': 'Test'})
        assert resp.status_code == 201

    def test_get_users(self, client):
        # Setup
        client.post('/api/users',
            json={'name': 'Test'})

        # Test
        resp = client.get('/api/users')
        assert resp.status_code == 200
        assert len(resp.get_json()) == 1

    def test_invalid_user(self, client):
        resp = client.post('/api/users',
            json={})
        assert resp.status_code == 400

🚀 Quick Command Reference

# Install everything
pip install pytest pytest-flask pytest-cov

# Run all tests
pytest

# Run with details
pytest -v

# Run specific test
pytest test_api.py::test_create_user

# Check coverage
pytest --cov=app

# Coverage with missing lines
pytest --cov=app --cov-report=term-missing

# Generate HTML coverage report
pytest --cov=app --cov-report=html

🧠 Key Takeaways

1. Test Client = Your robot browser for testing
2. pytest = Super-powered test runner
3. Fixtures = Helpers that prep things before tests
4. Unit Tests = Test one thing at a time
5. Database Tests = Use separate test database
6. Coverage = Your testing report card

💪 You’ve Got This!

Testing might seem like extra work, but it’s actually a superpower:

• 🛡️ Protection from bugs
• 🚀 Confidence when deploying
• 📝 Documentation of how code works
• 😌 Peace of mind that things work

Every test you write is a shield protecting your app!

Now go forth and test with confidence! 🎉