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_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_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_with_name(self):
register_session('sqlite://','foo')
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'foo',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
registry = getSiteManager()
# check we don't register with no name:
with ShouldRaise(ComponentLookupError(ISession, u'')):
registry.getUtility(ISession)
# check we do with the right name
self.failUnless(isinstance(
registry.getUtility(ISession,'foo')(),
Session
))
def test_neither_engine_nor_url(self):
with ShouldRaise(
TypeError('Must specify engine or url, but not both')
):
register_session()
compare([],self.m.method_calls)
def test_echo_and_engine(self):
with ShouldRaise(
TypeError('Cannot specify echo if an engine is passed')
):
register_session(engine=self.m.engine2,echo=True)
compare([],self.m.method_calls)
def test_engine_and_url(self):
with ShouldRaise(
TypeError('Must specify engine or url, but not both')
):
register_session(url='mysql://',engine=self.m.engine2)
compare([],self.m.method_calls)
def test_register_with_name(self):
register_session('sqlite://','foo')
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'foo',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
registry = getSiteManager()
# check we don't register with no name:
with ShouldRaise(ComponentLookupError(ISession, u'')):
registry.getUtility(ISession)
# check we do with the right name
self.failUnless(isinstance(
registry.getUtility(ISession,'foo')(),
Session
))
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_transactional_but_not_scoped(self):
with ShouldRaise(
TypeError('Transactions can only be managed when using scoped sessions')
):
register_session(url='mysql://',
transactional=True,scoped=False)
compare([],self.m.method_calls)
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_logging_functional(self):
with LogCapture() as l:
register_session('sqlite://')
l.check((
'mortar_rdb',
'INFO',
"Registering session for sqlite:// with name "+empty_str
))
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_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_logging_functional(self):
with LogCapture() as l:
register_session('sqlite://')
l.check((
'mortar_rdb',
'INFO',
"Registering session for sqlite:// with name "+empty_str
))
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_logging_normal(self):
self.engine.url = make_url('sqlite://')
with LogCapture() as l:
register_session('sqlite://')
l.check((
'mortar_rdb',
'INFO',
"Registering session for sqlite:// with name "+empty_str
))
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_logging_name(self):
engine = create_engine('sqlite://')
self.engine.url=engine.url
with LogCapture() as l:
register_session('sqlite://','foo')
l.check((
'mortar_rdb',
'INFO',
"Registering session for sqlite:// with name 'foo'"
))
def test_logging_username_password_db_same(self):
self.engine.url=make_url('mysql://*****:*****@localhost/proj')
with LogCapture() as l:
register_session('sqlite://')
l.check((
'mortar_rdb',
'INFO',
"Registering session for "
"mysql://*****:*****@localhost/proj with name "+empty_str
))
def test_logging_password(self):
self.engine.url = make_url('mysql://*****:*****@localhost/db')
with LogCapture() as l:
register_session('sqlite://')
l.check((
'mortar_rdb',
'INFO',
"Registering session for "
"mysql://*****:*****@localhost/db with name "+empty_str
))
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_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_not_scoped(self):
register_session(url='mysql://foo',
scoped=False,transactional=False)
compare([
('create_engine', ('mysql://foo',), {'echo':None}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.Session,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
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_echo(self):
register_session(url='mysql://foo',echo=True)
compare([
('create_engine', ('mysql://foo',), {'echo':True}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine}),
('scoped_session', (self.Session,), {}),
('register', (self.ScopedSession,), {'initial_state': STATUS_CHANGED}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
def test_scoped_no_transactions(self):
self.m.engine2.url.password = '******'
register_session(engine=self.m.engine2,
scoped=True,transactional=False)
compare([
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.m.engine2}),
('scoped_session', (self.Session,), {}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
def test_engine(self):
self.m.engine2.url.password = '******'
register_session(engine=self.m.engine2)
compare([
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.m.engine2}),
('scoped_session', (self.Session,), {}),
('register', (self.ScopedSession,), {'initial_state': STATUS_CHANGED}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
def test_url(self):
register_session('mysql://foo')
compare([
('create_engine', ('mysql://foo',), {'echo':None}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine,
'extension': C(ZopeTransactionExtension)}),
('scoped_session', (self.Session,), {}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
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_different_sessions_per_thread(self):
register_session('sqlite://')
class TestThread(Thread):
def run(self):
self.resulting_session = get_session()
t1 = TestThread()
t1.start()
t2 = TestThread()
t2.start()
t1.join()
t2.join()
self.assertNotEquals(
id(t1.resulting_session),
id(t2.resulting_session),
)
def test_different_sessions_per_thread(self):
register_session('sqlite://')
class TestThread(Thread):
def run(self):
self.resulting_session = get_session()
t1 = TestThread()
t1.start()
t2 = TestThread()
t2.start()
t1.join()
t2.join()
self.assertNotEquals(
id(t1.resulting_session),
id(t2.resulting_session),
)
def test_no_twophase(self):
self.engine.dialect.name='postgresql'
register_session(url='postgres://foo',twophase=False)
compare([
('create_engine', ('postgres://foo',), {'echo':None}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine,
},),
('scoped_session', (self.Session,), {}),
('register', (self.ScopedSession,), {'initial_state': STATUS_CHANGED}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
def test_postgres(self):
self.engine.dialect.name='postgresql'
register_session(url='postgres://foo')
compare([
('create_engine', ('postgres://foo',), {'echo':None}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine,
'extension': C(ZopeTransactionExtension),
'twophase': True,
},),
('scoped_session', (self.Session,), {}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
def test_one_extension(self):
class TestExtension(SessionExtension):
pass
ext = TestExtension()
register_session('mysql://foo',extension=[ext],transactional=False)
compare([
('create_engine', ('mysql://foo',), {'echo':None}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine,
'extension': ext}),
('scoped_session', (self.Session,), {}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
def test_two_extensions_transactional_non_list(self):
class TestExtension1(SessionExtension):
pass
class TestExtension2(SessionExtension):
pass
ext1 = TestExtension1()
ext2 = TestExtension2()
register_session('mysql://foo',extension=(ext1,ext2))
compare([
('create_engine', ('mysql://foo',), {'echo':None}),
('sessionmaker',
(),
{'autocommit': False,
'autoflush': True,
'bind': self.engine,
'extension': [ext1,ext2,C(ZopeTransactionExtension)]}),
('scoped_session', (self.Session,), {}),
('getSiteManager', (), {}),
('registry.registerUtility',
(self.ScopedSession,),
{'name': u'',
'provided': ISession})
],self.m.method_calls)
