les tests flacon sql alchimie

Je dispose d'une application web sur le Flacon avec SqlAlchemy pour la modération des news, il a certaines méthodes de l'api pour gérer la modération des demandes, tels que les approuver, refuser actuellement sélectionné news, liste, etc. Je veux écrire des tests unitaires pour ces méthodes, et j'ai fait leur travail, mais je ne comprends pas, comment mettre en œuvre l'exécution de toutes les demandes qui je le fais à partir des cas de test dans un db session, afin que je puisse supprimer toutes les modifications de la base de données. Ou est-il un autre produit ou la bonne façon de le faire?
J'ai trouvé que peut-être j'ai besoin est "scoped_session" dans SqlAlchemy, mais tous mes tente de la mettre en œuvre ont échoué. Si c'est correct, s'il vous plaît, dites-moi où utiliser ces lignes de code (dans les paramètres, ou en cas de test set_up méthode).

from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import sessionmaker
session_factory = sessionmaker()
Session = scoped_session(session_factory)
êtes-vous à l'aide de sqlalchemy directement ou le flacon de sqlalchemy extension ?
sqlalchemy directement

OriginalL'auteur Ellochka Cannibal | 2013-07-22

  1. 16

    Je vous suggérons d'utiliser le En Flacon De Test extension. C'est un approuvé l'extension qui vous permet d'effectuer les tests unitaires que vous le désirez. Il a une section spécifique pour les SQLAlchemy.

    Tests avec SQLAlchemy

    Ce couvre un couple de points si vous utilisez le Flacon de Test avec SQLAlchemy. Il est supposé que vous êtes à l'aide de la Fiole-SQLAlchemy extension, mais si pas les exemples ne devrait pas être trop difficile de s'adapter à votre propre configuration particulière.

    D'abord, vous assurer que vous configurez la base de données URI à autre chose que votre base de données de production ! Deuxièmement, il est généralement une bonne idée de créer et de déposer vos tables lors de chaque essai, afin de s'assurer que le nettoyage des tests:"

    from flask.ext.testing import TestCase

from myapp import create_app, db

class MyTest(TestCase):

    SQLALCHEMY_DATABASE_URI = "sqlite://"
    TESTING = True

    def create_app(self):

        # pass in test configuration
        return create_app(self)

    def setUp(self):

        db.create_all()

    def tearDown(self):

        db.session.remove()
        db.drop_all()
    Je dois être en manque de quelque chose étant donné les upvotes sur cette question, mais ce n'est pas la mise en œuvre de create_app assez important ici? Liés à la documentation n'explique pas ce que myapp.create_app est censé faire (par exemple, en ce qui concerne la db).
    create_app je pense que c'est simplement censé renvoyer l'app dans votre app.py -- par exemple app = Flacon(nom). Parce que je ne veux pas une autre config pour les essais et pour la production, je viens d'importer l'application à partir de mon espace principal, puis le retourner dans les create_app, et il fonctionne très bien.

    OriginalL'auteur codegeek

  2. 10

    C'est la manière dont j'ai été l'exécution de tests unitaires récemment. Je suppose que depuis que vous êtes à l'aide de SQLAlchemy que vous êtes en utilisant un modèle de classes. Je suis aussi en supposant que tous vos tableaux sont définis comme SQLAlchemy classes de modèle.

    from flask import Flask
import unittest

from app import db
from app.models import Log
from constants import test_logs

class appDBTests(unittest.TestCase):

    def setUp(self):
        """
        Creates a new database for the unit test to use
        """
        self.app = Flask(__name__)
        db.init_app(self.app)
        with self.app.app_context():
            db.create_all()
            self.populate_db() # Your function that adds test data.

    def tearDown(self):
        """
        Ensures that the database is emptied for next unit test
        """
        self.app = Flask(__name__)
        db.init_app(self.app)
        with self.app.app_context():
            db.drop_all()

    Depuis que vous utilisez la même DB configurer votre application, ce qui permet de construire et de détruire une base de données de test avec chaque unité de test que vous exécutez.

    qu'est-ce que LimboDBTests ici ?
    Le nom du projet a été Limbes et je ne suis apparemment mal pour repérer les anciens noms.
    Pourquoi self.app = Flask(__name__) dans tearDown() à nouveau? Je ne pense pas que vous avez besoin de le faire à nouveau après la mise en setUp().
    Je pense que vous avez raison. Mais je n'ai pas vérifié cela.
    Cette réponse est à mon avis le meilleur. Vous utilisez une base de données de test et de ne pas l'exécuter sur le système de vie, aussi vous n'avez pas à modifier votre code de production pour l'installation d'une base de données de test (ce qui se passe avec "create_test_app" de @user2659443 & @codegeek)

    OriginalL'auteur AlexLordThorsen

  3. 6

    Concernant codegeek de la réponse à l'aide de Flacon de Test, j'ai du mal à comprendre ce createapp(). En flacon de SqlAlchemy Introduction dans des Contextes m'a fourni quelques pointeur sur la façon de lier SQLAlchemy objet dynamique à votre application. Dans ce cas, la liaison à l'application de test.

    En gros:

    1. Créer un flacon de sqlalchemy objet, mais ne passe pas dans l'objet application
    2. Dans le create_app fonction, créez votre application de test, et de lier dynamiquement les SQLAlchemy.

    Votre myapp.py:

    # don't pass in the app object yet
db = SQLAlchemy()

def create_test_app():
    app = Flask(__name__)
    app.config['TESTING'] = True
    app.config["SQLALCHEMY_DATABASE_URI"] = "xxxxxxtestdatabasexxx"
    # Dynamically bind SQLAlchemy to application
    db.init_app(app)
    app.app_context().push() # this does the binding
    return app

# you can create another app context here, say for production
def create_production_app():
    app = Flask(__name__)
    app.config["SQLALCHEMY_DATABASE_URI"] = "xxxxxxproductionxxxx"
    # Dynamically bind SQLAlchemy to application
    db.init_app(app)
    app.app_context().push()
    return app

    Vous pouvez alors suivre les codegeek de la solution comme indiqué dans le Flacon de la Documentation de Test

    from flask.ext.testing import TestCase
from myapp import create_app, db

class MyTest(TestCase):

    # I removed some config passing here
    def create_app(self):
        return create_test_app()

    def setUp(self):

        db.create_all()

    def tearDown(self):

        db.session.remove()
        db.drop_all()

    La bonne chose à propos de cette solution est que vous pouvez créer différentes applications et lier dynamiquement la SQLAlchemy objet à l'aide d'une fonction. Chaque application peut servir à différentes fins. Par exemple, l'un pour la production, et un pour les tests unitaires. Dans le cas de la production, vous pouvez appeler create_production_application() dans votre top niveau flacon d'application.

    Après l'échec de ré-initialiser ma base de données dans différents TestCase, vous devez appeler app_context.pop() dans tearDown de réinitialisation complète.

    OriginalL'auteur user2659443