Flask + Pytest + SQLAlchemy：使用flask-sqlalchemy运行pytest时无法创建和删除表

Question

when I run tests It succeeds to connect to the database, but it does not create tables. I think maybe there is a different way to create tables when I use flask-sqlalchemy, but I can't find the solution.

This is app.py

db = SQLAlchemy()
def create_app(config_name):
    app = Flask(__name__, template_folder='templates')
    app.wsgi_app = ProxyFix(app.wsgi_app)
    app.config.from_object(config_name)
    app.register_blueprint(api)
    db.init_app(app)

    @app.route('/ping')
    def health_check():
        return jsonify(dict(ok='ok'))

    @app.errorhandler(404)
    def ignore_error(err):
        return jsonify()

    app.add_url_rule('/urls', view_func=Shorty.as_view('urls'))
    return app

This is run.py

environment = environ['TINY_ENV']
config = config_by_name[environment]
app = create_app(config)


if __name__ == '__main__':
    app.run()

This is config.py

import os

basedir = os.path.abspath(os.path.dirname(__file__))


class Config:
    """
    set Flask configuration vars
    """
    # General config
    DEBUG = True
    TESTING = False
    # Database
    SECRET_KEY = os.environ.get('SECRET_KEY', 'my_precious_secret_key')
    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root@localhost:3306/tiny'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    SERVER_HOST = 'localhost'
    SERVER_PORT = '5000'


class TestConfig(Config):
    """
    config for test
    """
    TESTING = True
    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root@localhost:3306/test_tiny'

config_by_name = dict(
    test=TestConfig,
    local=Config
)

key = Config.SECRET_KEY

This is models.py

from datetime import datetime
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()


class URLS(db.Model):
    __tablename__ = 'urls'

    id = db.Column(db.Integer, primary_key=True)
    original_url = db.Column(db.String(400), nullable=False)
    short_url = db.Column(db.String(200), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow()

This is test config setting.

db = SQLAlchemy()


@pytest.fixture(scope='session')
def app():
    test_config = config_by_name['test']
    app = create_app(test_config)

    app.app_context().push()
    return app


@pytest.fixture(scope='session')
def client(app):
    return app.test_client()


@pytest.fixture(scope='session')
def init_db(app):
    db.init_app(app)
    db.create_all()
    yield db
    db.drop_all()

Answer 1

The following might be the problem that is preventing your code from running multiple times and/or preventing you from dropping/creating your tables. Regardless if it solves your problem, it is something one might not be aware of and quite important to keep in mind. :)

When you are running your tests multiple times, db.drop_all() might not be called (because one of your tests failed) and therefore, it might not be able to create the tables on the next run (since they are already existing). The problem lies in using a context manager without a try: finally: . (NOTE: Every fixture using yield is a context manager).

from contextlib import contextmanager

def test_foo(db):
    print('begin foo')
    raise RuntimeError()
    print('end foo')

@contextmanager
def get_db():
    print('before')
    yield 'DB object'
    print('after')

This code represents your code, but without using the functionality of pytest. Pytest is running it more or less like

try:
    with get_db(app) as db:
        test_foo(db)
except Exception as e:
    print('Test failed')

One would expect an output similar to:

before
begin_foo
after
Test failed

but we only get

before
begin_foo
Test failed

While the contextmanager is active ( yield has been executed), our test method is running. If an exception is raised during the execution of our test function, the execution is stopped WITHOUT running any code after the yield statement. To prevent this, we have to wrap our fixture / contextmanager in a try: ... finally: block. As finally is ALWAYS executed regardless of what has happened.

@contextmanager
def get_db():
    print('before')
    try:
        yield 'DB object'
    finally:
        print('after')

The code after the yield statement is now executed as expected.

before
begin foo
after
Test failed

If you want to learn more, see the relevant section in the contextmanager docs :

At the point where the generator yields, the block nested in the with statement is executed. The generator is then resumed after the block is exited. If an unhandled exception occurs in the block, it is reraised inside the generator at the point where the yield occurred. Thus, you can use a try…except…finally statement to trap the error (if any), or ensure that some cleanup takes place.