def test_subsecond_accuracy(self):
Base = declarative_base()
class Sucktastic(Base):
__tablename__ = 'test'
id = Column(Integer, primary_key=True)
value = Column(DateTime)
register_session(metadata=Base.metadata)
with transaction.manager:
session = get_session()
session.add(Sucktastic(value=datetime(2001,1,1,10,1,2,3)))
session = get_session()
suck = session.query(Sucktastic).one()
if session.bind.name=='mysql':
# whoops, there goes our sub-second info
self.assertEqual(suck.value,datetime(2001,1,1,10,1,2))
else:
self.assertEqual(suck.value,datetime(2001,1,1,10,1,2,3))
session.rollback()
def test_get_in_view(self):
register_session('sqlite://')
register_session('sqlite://','foo')
# create the tables
session1 = get_session()
session2 = get_session('foo')
with transaction.manager:
self.Base.metadata.create_all(session1.bind)
self.Base.metadata.create_all(session2.bind)
# this is what you'd do in views:
session = get_session()
session.add(self.Model(id=1,name='foo'))
model1 = session.query(self.Model).one()
self.assertEqual(model1.id,1)
self.assertEqual(model1.name,'foo')
# or with a name...
session = get_session('foo')
session.add(self.Model(id=1,name='foo'))
model2 = session.query(self.Model).one()
self.assertEqual(model2.id,1)
self.assertEqual(model2.name,'foo')
# paranoia
self.failIf(model1 is model2)
def test_subsecond_accuracy(self):
Base = declarative_base()
class Sucktastic(Base):
__tablename__ = "test"
id = Column(Integer, primary_key=True)
value = Column(DateTime)
register_session(metadata=Base.metadata)
with transaction.manager:
session = get_session()
session.add(Sucktastic(value=datetime(2001, 1, 1, 10, 1, 2, 3)))
session = get_session()
suck = session.query(Sucktastic).one()
if session.bind.name == "mysql":
# whoops, there goes our sub-second info
self.assertEqual(suck.value, datetime(2001, 1, 1, 10, 1, 2))
else:
self.assertEqual(suck.value, datetime(2001, 1, 1, 10, 1, 2, 3))
session.rollback()
def test_get_in_view(self):
register_session('sqlite://')
register_session('sqlite://','foo')
# create the tables
session1 = get_session()
session2 = get_session('foo')
with transaction.manager:
self.Base.metadata.create_all(session1.bind)
self.Base.metadata.create_all(session2.bind)
# this is what you'd do in views:
session = get_session()
session.add(self.Model(id=1,name='foo'))
model1 = session.query(self.Model).one()
self.assertEqual(model1.id,1)
self.assertEqual(model1.name,'foo')
# or with a name...
session = get_session('foo')
session.add(self.Model(id=1,name='foo'))
model2 = session.query(self.Model).one()
self.assertEqual(model2.id,1)
self.assertEqual(model2.name,'foo')
# paranoia
self.failIf(model1 is model2)
def test_different_sessions_when_async(self):
register_session('sqlite://',
scoped=False, transactional=False)
s1 = get_session()
s2 = get_session()
self.assertNotEquals(id(s1),id(s2))
def test_different_sessions_when_async(self):
register_session('sqlite://',
scoped=False, transactional=False)
s1 = get_session()
s2 = get_session()
self.assertNotEquals(id(s1),id(s2))
def test_tricky_to_delete(self):
# respect any DB_URL set here so that
# we sure the real db here to make sure
# delete works across all our DB types...
db_path = (
os.environ.get('DB_URL', '').strip() or
'sqlite:///'+os.path.join(self.dir.path, 'test.db')
)
Base = sa_declarative_base()
class Model1(Base):
__tablename__ = 'model1'
id = Column(Integer, primary_key=True)
model2_id = Column(Integer, ForeignKey('model2.id'))
model2 = relationship("Model2")
class Model2(Base):
__tablename__ = 'model2'
id = Column('id', Integer, primary_key=True)
# create in one session
register_session(db_path,
name='create',
transactional=False,
metadata=Base.metadata)
m1 = Model1()
m2 = Model2()
m1.model2 = m2
session = get_session('create')
if db_path.startswith('sqlite:'):
session.execute('PRAGMA foreign_keys = ON')
session.add(m1)
session.add(m2)
session.commit()
compare(session.query(Model1).count(), 1)
compare(session.query(Model2).count(), 1)
session.rollback()
# now register another session which should
# blow the above away
register_session(db_path,name='read',
transactional=False,
metadata=Base.metadata)
session = get_session('read')
compare(session.query(Model1).count(), 0)
compare(session.query(Model2).count(), 0)
session.rollback()
def test_register(self):
register_session('sqlite://')
# create the tables
session = get_session()
self.Base.metadata.create_all(session.bind)
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
# this is what get_session goes:
session = getSiteManager().getUtility(ISession)
session.add(self.Model(id=1,name='foo'))
model = session.query(self.Model).one()
self.assertEqual(model.id,1)
self.assertEqual(model.name,'foo')
def test_register(self):
register_session('sqlite://')
# create the tables
session = get_session()
self.Base.metadata.create_all(session.bind)
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
# this is what get_session goes:
session = getSiteManager().getUtility(ISession)
session.add(self.Model(id=1,name='foo'))
model = session.query(self.Model).one()
self.assertEqual(model.id,1)
self.assertEqual(model.name,'foo')
def test_tricky_to_delete(self):
# respect any DB_URL set here so that
# we sure the real db here to make sure
# delete works across all our DB types...
db_path = (os.environ.get('DB_URL', '').strip()
or 'sqlite:///' + os.path.join(self.dir.path, 'test.db'))
Base = sa_declarative_base()
class Model1(Base):
__tablename__ = 'model1'
id = Column(Integer, primary_key=True)
model2_id = Column(Integer, ForeignKey('model2.id'))
model2 = relationship("Model2")
class Model2(Base):
__tablename__ = 'model2'
id = Column('id', Integer, primary_key=True)
# create in one session
register_session(db_path,
name='create',
transactional=False,
metadata=Base.metadata)
m1 = Model1()
m2 = Model2()
m1.model2 = m2
session = get_session('create')
if db_path.startswith('sqlite:'):
session.execute('PRAGMA foreign_keys = ON')
session.add(m1)
session.add(m2)
session.commit()
compare(session.query(Model1).count(), 1)
compare(session.query(Model2).count(), 1)
session.rollback()
# now register another session which should
# blow the above away
register_session(db_path,
name='read',
transactional=False,
metadata=Base.metadata)
session = get_session('read')
compare(session.query(Model1).count(), 0)
compare(session.query(Model2).count(), 0)
session.rollback()
def test_transaction(self):
register_session('sqlite://')
# functional
with transaction.manager:
session = get_session()
self.Base.metadata.create_all(session.bind)
session.add(self.Model(id=1,name='foo'))
compare(session.query(self.Model).count(), expected=1)
def test_no_transaction(self):
register_session('sqlite://',transactional=False)
# functional
session = get_session()
self.Base.metadata.create_all(session.bind)
session.add(self.Model(id=1,name='foo'))
session.commit()
compare(session.query(self.Model).count(), expected=1)
def test_no_transaction(self):
register_session('sqlite://',transactional=False)
# functional
session = get_session()
self.Base.metadata.create_all(session.bind)
session.add(self.Model(id=1,name='foo'))
session.commit()
compare(1,
session.scalar(self.Model.__table__.select().count()))
def test_no_transaction(self):
register_session('sqlite://',transactional=False)
# functional
session = get_session()
self.Base.metadata.create_all(session.bind)
session.add(self.Model(id=1,name='foo'))
session.commit()
compare(1,
session.scalar(self.Model.__table__.select().count()))
def test_functional_metadata(self):
Base = sa_declarative_base()
class Model(Base):
__tablename__ = 'model'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50))
register_session(transactional=False, metadata=Base.metadata)
session = get_session()
session.add(Model(name='foo'))
session.commit()
def test_transaction_no_session_usage(self):
register_session('sqlite://')
# functional
with transaction.manager:
session = get_session()
self.Base.metadata.create_all(session.bind)
session.execute(
self.Model.__table__.insert().values(name='test')
)
compare(session.query(self.Model).count(), expected=1)
def test_functional(self):
Base = sa_declarative_base()
class Model(Base):
__tablename__ = 'model'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50))
register_session(
transactional=False,
config=Config(Source(Model.__table__)))
session = get_session()
session.add(Model(name='foo'))
session.commit()
def test_transaction_no_session_usage(self):
register_session('sqlite://')
# functional
with transaction.manager:
session = get_session()
self.Base.metadata.create_all(session.bind)
session.execute(
self.Model.__table__.insert().values(name='test')
)
compare(1,
session.scalar(self.Model.__table__.select().count()))
def test_how_to_create(self):
register_session('sqlite://', transactional=False)
# at this stage we have no tables
session = get_session()
session.add(self.Model(name='foo'))
# so we get an error
with ShouldRaise(OperationalError):
session.commit()
# ...which we then need to abort:
session.rollback()
# if we know we have no tables, we can do:
self.Base.metadata.create_all(session.bind)
# now we can commit:
session.add(self.Model(name='foo'))
session.commit()
# ...and get stuff back:
self.assertEqual(1,session.query(self.Model).count())
def test_how_to_create(self):
register_session('sqlite://', transactional=False)
# at this stage we have no tables
session = get_session()
session.add(self.Model(name='foo'))
# so we get an error
with ShouldRaise(OperationalError):
session.commit()
# ...which we then need to abort:
session.rollback()
# if we know we have no tables, we can do:
self.Base.metadata.create_all(session.bind)
# now we can commit:
session.add(self.Model(name='foo'))
session.commit()
# ...and get stuff back:
self.assertEqual(1,session.query(self.Model).count())
def test_only_some_packages(self):
Base = sa_declarative_base()
class Model1(Base):
__tablename__ = 'model1'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50))
class Model2(Base):
__tablename__ = 'model2'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50))
register_session(transactional=False,
config=Config(Source(Model1.__table__)))
# only table1 should have been created!
compare([u'model1'],
Inspector.from_engine(get_session().bind).get_table_names())
def setUp(self):
register_session(transactional=False)
self.Base = declarative_base()
class Model(Common, self.Base):
id = Column(Integer, primary_key=True)
value = Column(Integer)
class AnotherModel(Common, self.Base):
id = Column(Integer, primary_key=True)
attr = Column(Integer)
other_id = Column(Integer, ForeignKey('model.id'))
other = relationship("Model", backref='another')
self.Model = Model
self.AnotherModel = AnotherModel
self.session = get_session()
self.addCleanup(self.session.rollback)
self.Base.metadata.create_all(self.session.bind)
def setUp(self):
register_session(transactional=False)
self.Base = declarative_base()
class Model(Common, self.Base):
id = Column(Integer, primary_key=True)
value = Column(Integer)
class AnotherModel(Common, self.Base):
id = Column(Integer, primary_key=True)
attr = Column(Integer)
other_id = Column(Integer, ForeignKey('model.id'))
other = relationship("Model", backref='another')
self.Model = Model
self.AnotherModel = AnotherModel
self.session = get_session()
self.addCleanup(self.session.rollback)
self.Base.metadata.create_all(self.session.bind)
def test_only_some_packages(self):
Base = sa_declarative_base()
class Model1(Base):
__tablename__ = 'model1'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50))
class Model2(Base):
__tablename__ = 'model2'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50))
register_session(
transactional=False,
config=Config(Source(Model1.__table__)))
# only table1 should have been created!
compare(
[u'model1'],
Inspector.from_engine(get_session().bind).get_table_names()
)
def setUp(self):
register_session(transactional=False)
self.session = get_session()
self.addCleanup(self.session.rollback)
Base.metadata.create_all(self.session.bind)
def setUp(self):
register_session(transactional=False)
self.session = get_session()
self.addCleanup(self.session.rollback)
Base.metadata.create_all(self.session.bind)
def run(self):
self.resulting_session = get_session()
def run(self):
self.resulting_session = get_session()
