def setUp(self):
self.app = Zask(__name__)
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
self.db = sqlalchemy.SQLAlchemy(self.app)
self.Todo = make_todo_model(self.db)
self.db.create_all()
def testing_scope_session():
app = Zask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
app.config['DEBUG'] = False
db = sqlalchemy.SQLAlchemy(app)
endpoint = random_ipc_endpoint()
rpc = ZeroRPC(app, middlewares=None)
rpc.register_middleware(sqlalchemy.SessionMiddleware(db))
class Foo(object):
def create_foo(self, ctx):
ctx2 = _request_ctx.get_request_cxt()
assert ctx == ctx2
class Srv(rpc.Server):
def get_session(self):
ctx = _request_ctx.get_request_cxt()
foo = Foo()
foo.create_foo(ctx)
return str(db.session())
srv = Srv(pool_size=1)
srv.bind(endpoint)
gevent.spawn(srv.run)
client = rpc.Client(endpoint)
session1 = client.get_session(async=True)
session2 = client.get_session(async=True)
assert session1.get() != session2.get()
def test_app_bound(self):
db = sqlalchemy.SQLAlchemy(self.app)
Todo = make_todo_model(db)
db.create_all()
todo = Todo('Test', 'test')
db.session.add(todo)
db.session.commit()
self.assertEqual(len(Todo.query.all()), 1)
db.drop_all()
def test_single_name(self):
"""Single table inheritance should not set a new name."""
app = Zask(__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_default_session_scoping(self):
app = Zask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
fb = FOOBar()
db.session.add(fb)
assert fb in db.session
db.drop_all()
def test_mixin_name(self):
"""Primary key provided by mixin should still allow model to set tablename."""
app = Zask(__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_joined_name(self):
"""Model has a separate primary key; it should set a new name."""
app = Zask(__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 = Zask(__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 test_name(self):
app = Zask(__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_session_scoping_changing(self):
app = Zask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
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()
fb = FOOBar()
db.session.add(fb)
assert fb not in db.session # because a new scope is generated on each call
db.drop_all()
def test_complex_inheritance(self):
"""Joined table inheritance, but the new primary key is provided by a mixin, not directly on the class."""
app = Zask(__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 test_default_query_class(self):
app = Zask(__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), BaseQuery)
self.assertEqual(type(Child.query), BaseQuery)
self.assertTrue(isinstance(p.children, BaseQuery))
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 = Zask(__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)
})
# do the models in the same session?
foo = Foo()
bar = Bar()
baz = Baz()
db.session.add(foo)
db.session.add(bar)
db.session.add(baz)
assert foo in db.session
assert bar in db.session
assert baz in db.session
db.drop_all()
