Test d'unité Flask | Couverture de code | Test Python

Introduction

Dans ce laboratoire, nous allons apprendre à écrire des tests unitaires pour une application Flask. Nous utiliserons pytest et coverage pour tester et mesurer notre code. À la fin de ce laboratoire, vous comprendrez comment vous assurer que votre application fonctionne comme prévu et identifier les zones qui nécessitent des améliorations.

Note : Vous devez créer le fichier de code vous-même et l'exécuter dans l'environnement. Vous pouvez prévisualiser l'état du service Flask sur le Web 5000.

Installer Pytest et Coverage

Tout d'abord, nous devons installer pytest et coverage. Ce sont respectivement des outils de test et de mesure du code. Exécutez la commande suivante dans votre terminal pour installer :

pip install pytest coverage

Configuration et Fixtures

Ensuite, nous allons configurer des fixtures dans un fichier appelé conftest.py. Une fixture est une fonction qui est exécutée avant chaque fonction de test à laquelle elle est appliquée.

Dans cette étape, nous allons créer une base de données temporaire et la remplir avec des données pour les tests.

Voici le code à ajouter dans tests/conftest.py :

## tests/conftest.py

import os
import tempfile
import pytest
from flaskr import create_app
from flaskr.db import get_db, init_db

with open(os.path.join(os.path.dirname(__file__), 'data.sql'), 'rb') as f:
    _data_sql = f.read().decode('utf8')

@pytest.fixture
def app():
    db_fd, db_path = tempfile.mkstemp()

    app = create_app({
        'TESTING': True,
        'DATABASE': db_path,
    })

    with app.app_context():
        init_db()
        get_db().executescript(_data_sql)

    yield app

    os.close(db_fd)
    os.unlink(db_path)

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

@pytest.fixture
def runner(app):
    return app.test_cli_runner()

Écrire des tests pour la factory

Ensuite, nous allons écrire des tests pour la fonction factory qui est responsable de la création de l'application Flask. Ces tests garantissent que l'application se comporte comme prévu en fonction de la configuration qui lui est passée.

Voici le code à ajouter dans tests/test_factory.py :

## tests/test_factory.py

from flaskr import create_app

def test_config():
    assert not create_app().testing
    assert create_app({'TESTING': True}).testing

def test_hello(client):
    response = client.get('/hello')
    assert response.data == b'Hello, World!'

Tester la connexion à la base de données

Après avoir testé la factory, nous allons tester la connexion à la base de données. Ces tests garantissent que la connexion à la base de données est établie et fermée comme prévu.

Voici le code à ajouter dans tests/test_db.py :

## tests/test_db.py

import sqlite3
import pytest
from flaskr.db import get_db

def test_get_close_db(app):
    with app.app_context():
        db = get_db()
        assert db is get_db()

    with pytest.raises(sqlite3.ProgrammingError) as e:
        db.execute('SELECT 1')

    assert 'closed' in str(e.value)

Tester l'authentification

Ensuite, nous allons écrire des tests pour l'authentification des utilisateurs. Ces tests garantissent que les utilisateurs peuvent se connecter et se déconnecter comme prévu, et que des messages d'erreur appropriés sont affichés si nécessaire.

Voici le code à ajouter dans tests/test_auth.py :

## tests/test_auth.py

import pytest
from flask import g, session
from flaskr.db import get_db

def test_login(client, auth):
    assert client.get('/auth/login').status_code == 200
    response = auth.login()
    assert response.headers["Location"] == "/"

    with client:
        client.get('/')
        assert session['user_id'] == 1
        assert g.user['username'] == 'test'

Tester les articles de blog

Enfin, nous allons écrire des tests pour les articles de blog. Ces tests garantissent que les utilisateurs peuvent créer, mettre à jour et supprimer des articles de blog comme prévu.

Voici le code à ajouter dans tests/test_blog.py :

## tests/test_blog.py

import pytest
from flaskr.db import get_db

def test_create(client, auth, app):
    auth.login()
    assert client.get('/create').status_code == 200
    client.post('/create', data={'title': 'created', 'body': ''})

    with app.app_context():
        db = get_db()
        count = db.execute('SELECT COUNT(id) FROM post').fetchone()[0]
        assert count == 2

Exécuter les tests

Maintenant que nous avons écrit nos tests, nous pouvons les exécuter en utilisant la commande pytest :

pytest

Pour mesurer la couverture de code de vos tests, utilisez la commande coverage pour exécuter pytest :

coverage run -m pytest

Vous pouvez afficher un rapport de couverture simple dans le terminal avec la commande suivante :

coverage report

Sommaire

Dans ce laboratoire, nous avons appris à écrire des tests unitaires pour une application Flask en utilisant pytest et coverage. Ces outils nous aident à nous assurer que notre application fonctionne comme prévu et à identifier les zones qui nécessitent des améliorations. Écrire des tests pour votre code est une bonne pratique car cela vous aide à détecter les bugs avant qu'ils ne deviennent un problème.

Test d'unité Flask avec Pytest et Coverage