def setUp(self):
self.app = app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
self.db = sqlalchemy.SQLAlchemy(app)
self.Todo = make_todo_model(self.db)
self.db.create_all()
def test_insert_update_delete(self):
# Ensure _SignalTrackingMapperExtension doesn't croak when
# faced with a vanilla SQLAlchemy session.
#
# Verifies that "AttributeError: 'SessionMaker' object has no attribute '_model_changes'"
# is not thrown.
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
Session = sessionmaker(bind=db.engine)
class QazWsx(db.Model):
id = db.Column(db.Integer, primary_key=True)
x = db.Column(db.String, default='')
db.create_all()
session = Session()
session.add(QazWsx())
session.flush() # issues an INSERT.
session.expunge_all()
qaz_wsx = session.query(QazWsx).first()
assert qaz_wsx.x == ''
qaz_wsx.x = 'test'
session.flush() # issues an UPDATE.
session.expunge_all()
qaz_wsx = session.query(QazWsx).first()
assert qaz_wsx.x == 'test'
session.delete(qaz_wsx) # issues a DELETE.
assert session.query(QazWsx).first() is None
def test_joined_inheritance_relation(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
class Relation(db.Model):
id = db.Column(db.Integer, primary_key=True)
base_id = db.Column(db.Integer, db.ForeignKey('base.id'))
name = db.Column(db.Unicode(20))
def __init__(self, name):
self.name = name
class Base(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.Unicode(20))
__mapper_args__ = {'polymorphic_on': type}
class SubBase(Base):
id = db.Column(db.Integer,
db.ForeignKey('base.id'),
primary_key=True)
__mapper_args__ = {'polymorphic_identity': u'sub'}
relations = db.relationship(Relation)
db.create_all()
base = SubBase()
base.relations = [Relation(name=u'foo')]
db.session.add(base)
db.session.commit()
base = base.query.one()
def test_app_bound(self):
db = sqlalchemy.SQLAlchemy(self.app)
Todo = make_todo_model(db)
db.create_all()
# If an app was passed to the SQLAlchemy constructor,
# the query property is always available.
todo = Todo('Test', 'test')
db.session.add(todo)
db.session.commit()
self.assertEqual(len(Todo.query.all()), 1)
def test(self):
"""Various SQLAlchemy objects are exposed as attributes.
"""
db = sqlalchemy.SQLAlchemy()
import sqlalchemy as sqlalchemy_lib
self.assertTrue(db.Column == sqlalchemy_lib.Column)
# The Query object we expose is actually our own subclass.
from flask.ext.sqlalchemy import BaseQuery
self.assertTrue(db.Query == BaseQuery)
def test_default_table_name(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
class BazBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
self.assertEqual(FOOBar.__tablename__, 'foo_bar')
self.assertEqual(BazBar.__tablename__, 'baz_bar')
def test_session_events(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
from sqlalchemy.event import listens_for
seen = []
register = listens_for(db.session, 'after_commit')
register(seen.append)
db.session.commit()
self.assertEqual(seen, [db.session()])
def test_single_name(self):
"""Single table inheritance should not set a new name."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Duck(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Mallard(Duck):
pass
self.assertEqual(Mallard.__tablename__, 'duck')
def test_no_app_bound(self):
db = sqlalchemy.SQLAlchemy()
db.init_app(self.app)
Todo = make_todo_model(db)
# If no app is bound to the SQLAlchemy instance, a
# request context is required to access Model.query.
self.assertRaises(RuntimeError, getattr, Todo, 'query')
with self.app.test_request_context():
db.create_all()
todo = Todo('Test', 'test')
db.session.add(todo)
db.session.commit()
self.assertEqual(len(Todo.query.all()), 1)
def test_mixin_name(self):
"""Primary key provided by mixin should still allow model to set tablename."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Base(object):
id = db.Column(db.Integer, primary_key=True)
class Duck(Base, db.Model):
pass
self.assertFalse(hasattr(Base, '__tablename__'))
self.assertEqual(Duck.__tablename__, 'duck')
def test_default_session_scoping(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
with app.test_request_context():
fb = FOOBar()
db.session.add(fb)
assert fb in db.session
def test_single_table_inheritance(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
class Base(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.Unicode(20))
__mapper_args__ = {'polymorphic_on': type}
class SubBase(Base):
__mapper_args__ = {'polymorphic_identity': 'sub'}
self.assertEqual(Base.__tablename__, 'base')
self.assertEqual(SubBase.__tablename__, 'base')
db.create_all()
def test_joined_name(self):
"""Model has a separate primary key; it should set a new name."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Duck(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Donald(Duck):
id = db.Column(db.Integer,
db.ForeignKey(Duck.id),
primary_key=True)
self.assertEqual(Donald.__tablename__, 'donald')
def test_abstract_name(self):
"""Abstract model should not set a name. Subclass should set a name."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
class Duck(Base):
pass
self.assertFalse(hasattr(Base, '__tablename__'))
self.assertEqual(Duck.__tablename__, 'duck')
def prepare_sqlapp(namespace, models, sqluri, from_spec_file=True):
my_settings = copy.deepcopy(BASE_SETTINGS)
parts = urlparse.urlparse(sqluri)
if parts.scheme == 'sqlite':
j.system.fs.createDir(parts.path)
sqluri = j.system.fs.joinPaths(sqluri, '%s.sqlite' % namespace)
my_settings['SQLALCHEMY_DATABASE_URI'] = sqluri
my_settings['SQLALCHEMY_ECHO'] = True
my_settings['IF_MATCH'] = False
my_settings['SQLALCHEMY_RECORD_QUERIES'] = True
if from_spec_file:
my_settings['DOMAIN'] = osis2sqlalchemy.generateDomainFromSpecFile(
namespace, models)
else:
my_settings['DOMAIN'] = osis2sqlalchemy.generateDomainFromModelFiles(
namespace, models)
db = flask_sqlalchemy.SQLAlchemy()
class SQL(_SQL):
driver = db
def init_app(self, app):
try:
# FIXME: dumb double initialisation of the
# driver because Eve sets it to None in __init__
self.driver = db
self.driver.app = app
self.driver.init_app(app)
except Exception as e:
raise ConnectionException(e)
self.register_schema(app)
app = Eve(validator=ValidatorSQL,
data=SQL,
settings=my_settings,
static_url_path=STATIC_PATH)
db = app.data.driver
common.Base.metadata.bind = db.engine
db.Model = common.Base
db.create_all()
swagger.expose_docs(app, STATIC_PATH)
hookevents(namespace, app)
return app
def test_name(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
class BazBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Ham(db.Model):
__tablename__ = 'spam'
id = db.Column(db.Integer, primary_key=True)
self.assertEqual(FOOBar.__tablename__, 'foo_bar')
self.assertEqual(BazBar.__tablename__, 'baz_bar')
self.assertEqual(Ham.__tablename__, 'spam')
def test_default_query_class(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
class Parent(db.Model):
id = db.Column(db.Integer, primary_key=True)
children = db.relationship("Child", backref = "parents", lazy='dynamic')
class Child(db.Model):
id = db.Column(db.Integer, primary_key=True)
parent_id = db.Column(db.Integer, db.ForeignKey('parent.id'))
p = Parent()
c = Child()
c.parent = p
self.assertEqual(type(Parent.query), sqlalchemy.BaseQuery)
self.assertEqual(type(Child.query), sqlalchemy.BaseQuery)
self.assertTrue(isinstance(p.children, sqlalchemy.BaseQuery))
def test_session_scoping_changing(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
def scopefunc():
return id(dict())
db = sqlalchemy.SQLAlchemy(app, session_options=dict(scopefunc=scopefunc))
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
with app.test_request_context():
fb = FOOBar()
db.session.add(fb)
assert fb not in db.session # because a new scope is generated on each call
def setUp(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
db = sqlalchemy.SQLAlchemy(app)
Todo = make_todo_model(db)
db.create_all()
@app.route('/')
def index():
return '\n'.join(x.title for x in Todo.query.all())
@app.route('/create', methods=['POST'])
def create():
db.session.add(Todo('Test one', 'test'))
if flask.request.form.get('fail'):
raise RuntimeError("Failing as requested")
return 'ok'
self.client = app.test_client()
def test_complex_inheritance(self):
"""Joined table inheritance, but the new primary key is provided by a mixin, not directly on the class."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Duck(db.Model):
id = db.Column(db.Integer, primary_key=True)
class IdMixin(object):
@declared_attr
def id(cls):
return db.Column(db.Integer,
db.ForeignKey(Duck.id),
primary_key=True)
class RubberDuck(IdMixin, Duck):
pass
self.assertEqual(RubberDuck.__tablename__, 'rubber_duck')
def app_factory(config):
app = flask.Flask(__name__)
app.config.from_object(config)
email_handler = handlers.SMTPHandler(config.EMAIL_SMTP_SERVER,
config.EMAIL_SENDER_ADDRESS,
config.EMAIL_RECIPIENT_ADDRESS,
"Failure @ "
"http://www.adamcunnington.info",
secure=())
email_handler.setFormatter(
logging.Formatter("Error Type: %(levelname)s\n"
"Location: %(pathname)s: "
"%(lineno)d\n"
"Module: %(module)s\n"
"Function: %(funcName)s\n"
"Time: %(asctime)s\n"
"%(message)s"))
email_handler.setLevel(logging.ERROR)
file_handler = handlers.FileHandler(
os.path.join(os.path.dirname(__file__), "..", ".log"))
file_handler.setFormatter(
logging.Formatter("%(asctime)s (%(levelname)s) "
"-> %(message)s "
"[in %(pathname)s: "
"%(lineno)d]"))
file_handler.setLevel(logging.WARNING)
for logger in (app.logger, logging.getLogger("sqlalchemy")):
for handler in (email_handler, file_handler):
logger.addHandler(handler)
if config.USE_API:
from .. import api
app.register_blueprint(api.user, subdomain="api")
app.register_blueprint(api.token)
flask.g.db = db = api.models.db
else:
from flask.ext import sqlalchemy
flask.g.db = db = sqlalchemy.SQLAlchemy()
db.initapp(app)
return app
def setUp(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
self.Todo = make_todo_model(db)
@app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.query.all())
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(form['title'], form['text'])
db.session.add(todo)
db.session.commit()
return 'added'
db.create_all()
self.app = app
self.db = db
import simplejson as json
from eve.io.base import ConnectionException, DataLayer
from eve.utils import config, debug_error_message, str_to_date
from flask import abort
from .__about__ import __version__ # noqa
from .parser import ParseError, parse, parse_dictionary, parse_sorting, sqla_op
from .structures import SQLAResultCollection
from .utils import (
dict_update, extract_sort_arg, rename_relationship_fields_in_dict,
rename_relationship_fields_in_sort_args, rename_relationship_fields_in_str,
sqla_object_to_dict, validate_filters,
)
db = flask_sqlalchemy.SQLAlchemy()
try:
string_type = basestring
except NameError:
# Python 3
string_type = str
class SQL(DataLayer):
"""
SQLAlchemy data access layer for Eve REST API.
"""
driver = db
serializers = {
'datetime': str_to_date,
def setUp(self):
self.app = app.app
models.db = sqlalchemy.SQLAlchemy(app)
models.db.create_all()
from flask import Flask
from flask.ext import sqlalchemy
from flask.ext import restless
from config import config
db = sqlalchemy.SQLAlchemy()
manager = restless.APIManager(flask_sqlalchemy_db=db)
def create_app(config_name):
from .model import User, Questionnaire
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
manager.init_app(app)
with app.app_context():
manager.create_api(User, methods=['GET', 'POST', 'DELETE'], app=app)
manager.create_api(Questionnaire,
methods=['GET', 'POST', 'DELETE'],
app=app)
return app
def test_connection_binds(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
assert db.session.connection()
app = Flask(__name__)
app.config.from_object('config')
import logging
stream_handler = logging.StreamHandler()
app.logger.addHandler(stream_handler)
app.logger.setLevel(logging.INFO)
if app.config['DEBUG']:
app.logger.setLevel(logging.DEBUG)
# Extensions
from flask.ext import assets, sqlalchemy, login
from flask.ext.babel import Babel, lazy_gettext as _
db = sqlalchemy.SQLAlchemy(app)
babel = Babel(app)
login_manager = login.LoginManager()
login_manager.login_view = "users.login"
login_manager.login_message = _("You must login to view this page.")
login_manager.localize_callback = unicode
login_manager.session_protection = "strong"
from app.users.models import User
login_manager.token_loader(User.from_auth_token)
login_manager.init_app(app)
webassets = assets.Environment(app)
# In the future, we may set this to False and build assets before deployment.
def test_basic_binds(self):
import tempfile
_, db1 = tempfile.mkstemp()
_, db2 = tempfile.mkstemp()
def _remove_files():
import os
try:
os.remove(db1)
os.remove(db2)
except IOError:
pass
atexit.register(_remove_files)
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['SQLALCHEMY_BINDS'] = {
'foo': 'sqlite:///' + db1,
'bar': 'sqlite:///' + db2
}
db = sqlalchemy.SQLAlchemy(app)
class Foo(db.Model):
__bind_key__ = 'foo'
__table_args__ = {"info": {"bind_key": "foo"}}
id = db.Column(db.Integer, primary_key=True)
class Bar(db.Model):
__bind_key__ = 'bar'
id = db.Column(db.Integer, primary_key=True)
class Baz(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
# simple way to check if the engines are looked up properly
self.assertEqual(db.get_engine(app, None), db.engine)
for key in 'foo', 'bar':
engine = db.get_engine(app, key)
connector = app.extensions['sqlalchemy'].connectors[key]
self.assertEqual(engine, connector.get_engine())
self.assertEqual(str(engine.url),
app.config['SQLALCHEMY_BINDS'][key])
# do the models have the correct engines?
self.assertEqual(db.metadata.tables['foo'].info['bind_key'], 'foo')
self.assertEqual(db.metadata.tables['bar'].info['bind_key'], 'bar')
self.assertEqual(db.metadata.tables['baz'].info.get('bind_key'), None)
# see the tables created in an engine
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app, 'foo'))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('foo' in metadata.tables)
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app, 'bar'))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('bar' in metadata.tables)
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('baz' in metadata.tables)
# do the session have the right binds set?
self.assertEqual(
db.get_binds(app), {
Foo.__table__: db.get_engine(app, 'foo'),
Bar.__table__: db.get_engine(app, 'bar'),
Baz.__table__: db.get_engine(app, None)
})
"""Creates the Flask object and database objects."""
import flask
from flask.ext import sqlalchemy
import config # Ensure that the import works. # noqa
flask_app = flask.Flask(__name__)
flask_app.config.from_object('config')
db = sqlalchemy.SQLAlchemy(flask_app)
def __init__(self, title, text)
self.title = title
self.text = text
self.done = False
self.pub_date = datetime.utcnow()
return Todo
class BasicAppTestCase(unittest.TestCase)
def setUp(self)
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
self.Todo = make_todo_model(db)
@app.route('')
def index()
return 'n'.join(x.title for x in self.Todo.query.all())
@app.route('add', methods=['POST'])
def add()
form = flask.request.form
todo = self.Todo(form['title'], form['text'])
db.session.add(todo)
db.session.commit()
return 'added'
db.create_all()
