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()