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