Jak si nastavit aplikace baňky se SQLAlchemy pro testování?

hlasů
24

Zdá se, že běžnou praxí v baňce spustit takto:

from flask import Flask
from flaskext.sqlalchemy import SQLAlchemy
app = Flask(__name__)
SQLALCHEMY_DATABASE_URI = 'something'
app.config.from_object(__name__)
db = SQLAlchemy(app)

A importovat a používat appi dbpo celém světě. Ale když vytvoříte dbtakhle, to chytne konfigurace z aplikace, a zdá se, že tato konfigurace nikdy nemůže být přepsána, jakmile se to stane. Tam jsou některé stránky na webu baňky se o výrobu továrny aplikace, ale to není jasné, jak se bude moci i nadále používat app, a dbvšude, když jsem to udělal.

Jak mohu napsat skript otestovat svou Flask přihlášku s jinou databází? Jak mám strukturovat svou žádost, aby to bylo možné? Musím použít moduleů?

Položena 17/02/2011 v 07:23
zdroj uživatelem
V jiných jazycích...                            


3 odpovědí

hlasů
6

Nebudete chtít, aby se připojení k db stane na dovozu čase. Jděte do toho a nakonfigurovat aplikaci při dovozu času, protože vždy můžete vyladit konfiguraci ve svých testech před pokusem otestovat nebo spustit aplikaci. V níže uvedeném příkladu budete mít své db připojení za některé funkce, které používají konfiguraci aplikace tak v unittest můžete skutečně změnit připojení k db, aby ukazoval na jiný soubor, a pak jít dopředu a explicitně připojit v nastavení.

Řekněme, že máte myapp balíček obsahující myapp.py, který vypadá takto:

# myapp/myapp.py
from __future__ import with_statement
from sqlite3 import dbapi2 as sqlite3
from contextlib import closing
from flask import Flask, request, session, g, redirect, url_for, abort, \
     render_template, flash

# configuration
DATABASE = '/tmp/flaskr.db'
DEBUG = True
SECRET_KEY = 'development key'
USERNAME = 'admin'
PASSWORD = 'default'

# create our little application :)
app = Flask(__name__)
app.config.from_object(__name__)
app.config.from_envvar('MYAPP_SETTINGS', silent=True)

def connect_db():
    """Returns a new connection to the database."""
    return sqlite3.connect(app.config['DATABASE'])


def init_db():
    """Creates the database tables."""
    with closing(connect_db()) as db:
        with app.open_resource('schema.sql') as f:
            db.cursor().executescript(f.read())
        db.commit()


@app.before_request
def before_request():
    """Make sure we are connected to the database each request."""
    g.db = connect_db()


@app.after_request
def after_request(response):
    """Closes the database again at the end of the request."""
    g.db.close()
    return response

@app.route('/')
def show_entries():
    cur = g.db.execute('select title, text from entries order by id desc')
    entries = [dict(title=row[0], text=row[1]) for row in cur.fetchall()]
    return render_template('show_entries.html', entries=entries)

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

Vaše testovací soubor myapp / test_myapp.py bude vypadat takto:

import os
import myapp
import unittest
import tempfile

class MyappTestCase(unittest.TestCase):

    def setUp(self):
        self.db_fd, myapp.app.config['DATABASE'] = tempfile.mkstemp()
        self.app = myapp.app.test_client()
        myapp.init_db()

    def tearDown(self):
        os.close(self.db_fd)
        os.unlink(myapp.app.config['DATABASE'])

    def test_empty_db(self):
        rv = self.app.get('/')
        assert 'No entries here so far' in rv.data

Samozřejmě, pokud byste chtěli použít SQLAlchemy budete muset aktualizovat connect_db a init_db funkce odpovídajícím způsobem, ale doufejme, že dostanete nápad.

Odpovězeno 20/02/2011 v 16:44
zdroj uživatelem

hlasů
9

Instinkt použít proměnné prostředí je správná. Nicméně, tam je nějaká nebezpečí běhu unit testy se špatným db. Také můžete chtít, aby connect_dbse každé žádosti a všude tam, kde chcete použít db. Můžete použít config adresáře a proměnné prostředí, které explicitně nastavit. To je nejlepší, co jsem přijít s tak daleko.

run.py
shell.py

config/__init__.py
config/test.py
config/postgres.py
...

main/__init__.py
main/someapp/__init__.py
main/someapp/models.py

...
main/tests/__init__.py
main/tests/testutils.py

tak, že konfigurační soubory mohou být:

# config/test.py
SQLALCHEMY_DATABASE_URI = "sqlite://"

a

# config/postgres.py
SQLALCHEMY_DATABASE_URI = 'postgresql://user:pw@localhost/somedb'

Takže mohu explicitně nastavit db ve svém základním TestCase:

import os
from flask.ext.testing import TestCase

os.environ["DIAG_CONFIG_MODULE"] = "config.test"
from main import app, db


class SQLAlchemyTest(TestCase):

    def create_app(self):
        return app

    def setUp(self):
        db.create_all()

    def tearDown(self):
        db.session.remove()
        db.drop_all()

Poté je main/__init__.pypro mě:

import os

from flask import Flask, render_template, g
from flask.ext.sqlalchemy import SQLAlchemy

# by default, let's use a DB we don't care about
# but, we can override if we want
config_obj = os.environ.get("DIAG_CONFIG_MODULE", "config.test")
app = Flask(__name__)
app.config.from_object(config_obj)
db = SQLAlchemy(app)

@app.before_request
def before_request():
    g.db = db
    g.app = app

# ...
@app.route('/', methods=['GET'])
def get():
    return render_template('home.html')
# ...    
from main.someapp.api import mod as someappmod
app.register_blueprint(someappmod)

Pak, v jiných souborech, kde vím, co config chci běžet, případně:

# run.py
import os
os.environ["DIAG_CONFIG_MODULE"] = "config.postgres"
from main import app
app.run(debug=True)

a

# shell.py
import os
os.environ["DIAG_CONFIG_MODULE"] = "config.postgres"

from main import app, db
from main.symdiag.models import *
from main.auth.models import *
print sorted(k for k in locals().keys() if not k.startswith("_"))
import IPython
IPython.embed()

Možná .. nejlepší doposud: P.

Odpovězeno 03/10/2012 v 01:26
zdroj uživatelem

hlasů
2

Za prvé, namísto instance Flask aplikace přímo ve skriptu, můžete použít továrnu aplikace . To znamená, že můžete vytvořit funkci, která vezme váš konfigurační soubor jako parametr a vrátí instanci objektu aplikace. Pak vytvořte objekt globální SQLAlchemy bez parametru, a vy jej nakonfigurovat při vytváření app, jak zde bylo vysvětleno .

db = SQLAlchemy()

def create_app(configfile):
    app = Flask(__name__)

    app.config.from_pyfile(config, silent=True)
    db.init_app(app)

    # create routes, etc.

    return app

Chcete-li spustit aplikaci, prostě něco jako:

app = create_app('config.py')
app.run()

Chcete-li spustit unittests, můžete udělat něco jako:

class Test(TestCase):
    def setUp(self):
        # init test database, etc.
        app = create_app('test_config.py')
        self.app = app.test_client()
    def tearDown(self):
        # delete test database, etc.

V mém případě, já jsem s použitím SQLAlchemy přímo scoped_session místo baňky-SQLAlchemy. Udělal jsem totéž, ale s nastavením Lazy SQLAlchemy .

Odpovězeno 18/01/2014 v 03:21
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more