class TestDateTime(TestCase): # illustrative tests for the suck that is MySQL DateTime def setUp(self): self.components = TestComponents() def tearDown(self): self.components.uninstall() 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()
class TestDateTime(TestCase): # illustrative tests for the suck that is MySQL DateTime def setUp(self): self.components = TestComponents() def tearDown(self): self.components.uninstall() 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 setUp(self): self.components = TestComponents() self.Base = declarative_base() class Model(self.Base): __tablename__ = 'model' id = Column('id', Integer, primary_key=True) name = Column('name', String(50)) self.Model = Model
def test_atexit(self): m = Mock() with Replacer() as r: r.replace('atexit.register', m.register) c = TestComponents() expected = [call.register(c.atexit)] compare(expected, m.mock_calls) with catch_warnings(record=True) as w: c.atexit() self.assertTrue(len(w), 1) compare(str(w[0].message), ( # pragma: no branch "TestComponents instances not uninstalled by shutdown!" )) c.uninstall() compare(expected, m.mock_calls) # check re-running has no ill effects c.atexit() compare(expected, m.mock_calls)
def setUp(self): self.components = TestComponents() self.r = Replacer() self.m = Mock() self.r.replace('mortar_rdb.testing.real_register_session', self.m.realRegisterSession) self.r.replace('mortar_rdb.testing.create_engine', self.m.create_engine) # mock out for certainty # self.r.replace('mortar_rdb.testing.???',Mock()) # mock out for table destruction get_session = Mock() bind = get_session.return_value.bind bind.dialect.inspector.return_value = inspector = Mock() inspector.get_table_names.return_value = () self.r.replace('mortar_rdb.testing.get_session', get_session)
def test_atexit(self): c = TestComponents() self.assertTrue( TestComponents.atexit in [t[0] for t in atexit._exithandlers] ) with catch_warnings(record=True) as w: c.atexit() self.assertTrue(len(w), 1) compare(str(w[0].message), ( "TestComponents instances not uninstalled by shutdown!" )) c.uninstall() # check re-running has no ill effects c.atexit()
def setUp(self): self.components = TestComponents()
class TestRegisterSessionCalls(TestCase): def setUp(self): self.components = TestComponents() self.r = Replacer() self.m = Mock() self.r.replace('mortar_rdb.testing.real_register_session', self.m.realRegisterSession) self.r.replace('mortar_rdb.testing.create_engine', self.m.create_engine) # mock out for certainty # self.r.replace('mortar_rdb.testing.???',Mock()) # mock out for table destruction get_session = Mock() bind = get_session.return_value.bind bind.dialect.inspector.return_value = inspector = Mock() inspector.get_table_names.return_value = () self.r.replace('mortar_rdb.testing.get_session', get_session) def tearDown(self): self.r.restore() self.components.uninstall() def test_default_params(self): # ie: no DB_URL! self.r.replace('os.environ', dict()) register_session() compare([ ('create_engine', ('sqlite://', ), { 'poolclass': StaticPool, 'echo': False }), ('realRegisterSession', (None, u'', self.m.create_engine.return_value, False, True, True, None, None), {}), ], self.m.method_calls) def test_specified_params(self): register_session( url='x://', name='foo', echo=True, transactional=False, scoped=False, ) compare([ ('realRegisterSession', ('x://', u'foo', None, True, False, False, None, None), {}), ], self.m.method_calls) def test_echo_but_no_url(self): # make sure there's no DBURL self.r.replace('os.environ', dict()) register_session(echo=True) compare([ ('create_engine', ('sqlite://', ), { 'poolclass': StaticPool, 'echo': True }), ('realRegisterSession', (None, u'', self.m.create_engine.return_value, False, True, True, None, None), {}), ], self.m.method_calls) def test_engine_passed(self): engine = object() register_session(engine=engine, ) compare([ ('realRegisterSession', (None, u'', engine, False, True, True, None, None), {}), ], self.m.method_calls) def test_url_from_environment(self): self.r.replace('os.environ', dict(DB_URL='x://')) register_session() compare([ ('realRegisterSession', ('x://', u'', None, False, True, True, None, None), {}), ], self.m.method_calls) def test_empty_environment_url(self): self.r.replace('os.environ', dict(DB_URL='')) register_session() compare([ ('create_engine', ('sqlite://', ), { 'poolclass': StaticPool, 'echo': False }), ('realRegisterSession', ('', u'', self.m.create_engine.return_value, False, True, True, None, None), {}), ], self.m.method_calls) def test_engine_overrides_environment(self): self.r.replace('os.environ', dict(DB_URL='x://')) engine = object() register_session(engine=engine) compare([ ('realRegisterSession', (None, u'', engine, False, True, True, None, None), {}), ], self.m.method_calls) def test_extension(self): engine = object() extension = object() register_session(engine=engine, extension=extension) compare([ ('realRegisterSession', (None, u'', engine, False, True, True, None, extension), {}), ], self.m.method_calls)
class TestRegisterSessionFunctional(TestCase): def setUp(self): self.dir = TempDirectory() self.components = TestComponents() def tearDown(self): self.components.uninstall() self.dir.cleanup() 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_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_functional_echo_but_no_url(self): with Replacer() as r: # make sure there's no DB_URL r.replace('os.environ', dict()) # hoover up the logging ;-) with OutputCapture(): register_session(echo=True) 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_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())
class TestUtility(TestCase): def setUp(self): self.components = TestComponents() self.Base = declarative_base() class Model(self.Base): __tablename__ = 'model' id = Column('id', Integer, primary_key=True) name = Column('name', String(50)) self.Model = Model def tearDown(self): self.components.uninstall() 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_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_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(1, session.scalar(self.Model.__table__.select().count())) 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_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_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_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 setUp(self): self.dir = TempDirectory() self.components = TestComponents()
class TestRegisterSessionFunctional(TestCase): def setUp(self): self.dir = TempDirectory() self.components = TestComponents() def tearDown(self): self.components.uninstall() self.dir.cleanup() 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_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_functional_echo_but_no_url(self): with Replacer() as r: # make sure there's no DB_URL r.replace('os.environ', dict()) # hoover up the logging ;-) with OutputCapture(): register_session(echo=True) 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_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() )
class TestRegisterSessionCalls(TestCase): def setUp(self): self.components = TestComponents() self.r = Replacer() self.m = Mock() self.r.replace('mortar_rdb.testing.real_register_session', self.m.realRegisterSession) self.r.replace('mortar_rdb.testing.create_engine', self.m.create_engine) # mock out for certainty # self.r.replace('mortar_rdb.testing.???',Mock()) # mock out for table destruction get_session = Mock() bind = get_session.return_value.bind bind.dialect.inspector.return_value = inspector = Mock() inspector.get_table_names.return_value = () self.r.replace('mortar_rdb.testing.get_session', get_session) def tearDown(self): self.r.restore() self.components.uninstall() def test_default_params(self): # ie: no DB_URL! self.r.replace('os.environ',dict()) register_session() compare([ ('create_engine', ('sqlite://',), {'poolclass': StaticPool, 'echo': False}), ('realRegisterSession', (None, u'', self.m.create_engine.return_value, False, True, True, None), {}), ],self.m.method_calls) def test_specified_params(self): register_session( url='x://', name='foo', echo=True, transactional=False, scoped=False, ) compare([ ('realRegisterSession', ('x://', u'foo', None, True, False, False, None), {}), ],self.m.method_calls) def test_echo_but_no_url(self): # make sure there's no DBURL self.r.replace('os.environ',dict()) register_session(echo=True) compare([ ('create_engine', ('sqlite://',), {'poolclass': StaticPool, 'echo': True}), ('realRegisterSession', (None, u'', self.m.create_engine.return_value, False, True, True, None), {}), ],self.m.method_calls) def test_engine_passed(self): engine = object() register_session( engine=engine, ) compare([ ('realRegisterSession', (None, u'', engine, False, True, True, None), {}), ],self.m.method_calls) def test_url_from_environment(self): self.r.replace('os.environ',dict( DB_URL = 'x://' )) register_session() compare([ ('realRegisterSession', ('x://', u'', None, False, True, True, None), {}), ],self.m.method_calls) def test_empty_environment_url(self): self.r.replace('os.environ',dict( DB_URL = '' )) register_session() compare([ ('create_engine', ('sqlite://',), {'poolclass': StaticPool, 'echo': False}), ('realRegisterSession', ('', u'', self.m.create_engine.return_value, False, True, True, None), {}), ],self.m.method_calls) def test_engine_overrides_environment(self): self.r.replace('os.environ',dict( DB_URL = 'x://' )) engine = object() register_session(engine=engine) compare([ ('realRegisterSession', (None, u'', engine, False, True, True, None), {}), ],self.m.method_calls)