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 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 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()
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 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)
def setUp(self):
self.components = TestComponents()
def setUp(self):
self.dir = TempDirectory()
self.components = TestComponents()
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
))
