def setUp(self):
self._dbconn = qvarn.DatabaseConnection()
self._dbconn.set_sql(qvarn.SqliteAdapter())
vs = qvarn.VersionedStorage()
vs.set_resource_type(self.resource_type)
vs.start_version(u'first-version', None)
vs.add_prototype(self.prototype)
vs.add_prototype(qvarn.listener_prototype, auxtable=u'listener')
vs.add_prototype(qvarn.notification_prototype,
auxtable=u'notification')
with self._dbconn.transaction() as t:
vs.prepare_storage(t)
self.ro = qvarn.ReadOnlyStorage()
self.ro.set_item_prototype(self.resource_type, self.prototype)
self.wo = qvarn.WriteOnlyStorage()
self.wo.set_item_prototype(self.resource_type, self.prototype)
self.listener = qvarn.ListenerResource()
self.listener.set_top_resource_path(self.resource_type,
self.resource_type)
self.listener.prepare_resource(self._dbconn)
self.resource = qvarn.ListResource()
self.resource.set_path(self.resource_type)
self.resource.set_item_type(self.resource_type)
self.resource.set_item_prototype(self.prototype)
self.resource.set_listener(self.listener)
self.resource.prepare_resource(self._dbconn)
def test_prepares_a_single_version(self):
prototype_v1 = {
u'type': u'',
u'id': u'',
u'foo': u'',
}
called = []
def callback_v1(*args):
called.append(callback_v1)
sql = qvarn.SqliteAdapter()
dbconn = qvarn.DatabaseConnection()
dbconn.set_sql(sql)
vs = qvarn.VersionedStorage()
vs.set_resource_type(u'foo')
vs.start_version(u'v1', callback_v1)
vs.add_prototype(prototype_v1)
with dbconn.transaction() as t:
vs.prepare_storage(t)
self.assertEqual(called, [callback_v1])
def test_gets_and_puts_conn(self):
dummy = DummyAdapter()
dbconn = qvarn.DatabaseConnection()
dbconn.set_sql(dummy)
with dbconn.transaction():
pass
self.assertTrue(dummy.get_conn_was_first)
self.assertTrue(dummy.put_conn_was_second)
def test_updates_data_for_each_version(self):
prototype_v1 = {
u'type': u'',
u'id': u'',
u'foo': u'',
}
prototype_v2 = {
u'type': u'',
u'id': u'',
u'bar': u'', # note that foo is dropped
}
prototype_v3 = {
u'type': u'',
u'id': u'',
u'bar': u'',
u'foobar': u'', # added field, thus bar should be copied
}
called = []
resource_type = u'resource'
table_name = qvarn.table_name(resource_type=resource_type)
def callback_v1(t, temp_tables):
# Insert a row with an id. It should remain at end.
t.insert(table_name, {u'id': u'foo.id'})
called.append(callback_v1)
def callback_v2(t, temp_tables):
called.append(callback_v2)
def callback_v3(t, temp_tables):
called.append(callback_v3)
vs = qvarn.VersionedStorage()
vs.set_resource_type(resource_type)
vs.start_version(u'v1', callback_v1)
vs.add_prototype(prototype_v1)
vs.start_version(u'v2', callback_v2)
vs.add_prototype(prototype_v2)
vs.start_version(u'v3', callback_v3)
vs.add_prototype(prototype_v3)
sql = qvarn.SqliteAdapter()
dbconn = qvarn.DatabaseConnection()
dbconn.set_sql(sql)
with dbconn.transaction() as t:
vs.prepare_storage(t)
self.assertEqual(called, [callback_v1, callback_v2, callback_v3])
rows = t.select(table_name, [u'bar', u'foobar', u'id'], None)
self.assertEqual(
rows,
[{u'id': u'foo.id', u'bar': None, u'foobar': None}])
def setUp(self):
self.app = qvarn.BackendApplication()
self.app._dbconn = qvarn.DatabaseConnection()
self.app._dbconn.set_sql(qvarn.SqliteAdapter())
self.spec = yaml.safe_load(self.spec_text)
with self.app._dbconn.transaction() as t:
rts = qvarn.ResourceTypeStorage()
rts.prepare_tables(t)
rts.add_or_update_spec(t, self.spec, self.spec_text)
def _connect_to_storage(self, conf, specdir=None, prepare_storage=False):
'''Prepare the database for use.'''
dbtype = conf.get('database', 'type')
if dbtype == 'postgres':
args = {
'host': conf.get('database', 'host'),
'port': conf.get('database', 'port'),
'db_name': conf.get('database', 'name'),
'user': conf.get('database', 'user'),
'min_conn': conf.get('database', 'minconn'),
'max_conn': conf.get('database', 'maxconn'),
}
# Log all connection parameters except password.
log.log('connect-to-storage', **args)
password = conf.get('database', 'password')
sql = qvarn.PostgresAdapter(password=password, **args)
elif dbtype == 'sqlite':
dbfile = conf.get('database', 'file')
if dbfile:
log.log('connect-to-storage', dbtype=dbtype, dbfile=dbfile)
sql = qvarn.SqliteAdapter(dbfile)
else:
log.log('connect-to-storage', dbtype=dbtype)
sql = qvarn.SqliteAdapter()
# For in-momory sqlite we always want to prepare storage
prepare_storage = True
else:
raise ConfigurationError("Unknown database type: %r" % dbtype)
self._dbconn = qvarn.DatabaseConnection()
self._dbconn.set_sql(sql)
if prepare_storage:
specs_and_texts = self._load_specs_from_files(specdir)
self._add_resource_types_from_specs(s for s, t in specs_and_texts)
self._prepare_storage(self._conf)
self._store_resource_types(specs_and_texts)
# sanity check: were they stored successfully?
self._load_specs_from_db()
else:
specs = self._load_specs_from_db()
resources = self._add_resource_types_from_specs(specs)
self.add_routes(resources)
def _connect_to_storage(self, conf): # pragma: no cover
'''Prepare the database for use.'''
args = {
'host': conf.get('database', 'host'),
'port': conf.get('database', 'port'),
'db_name': conf.get('database', 'name'),
'user': conf.get('database', 'user'),
'min_conn': conf.get('database', 'minconn'),
'max_conn': conf.get('database', 'maxconn'),
}
# Log all connection parameters except password.
log.log('connect-to-storage', **args)
sql = qvarn.PostgresAdapter(password=conf.get('database', 'password'),
**args)
self._dbconn = qvarn.DatabaseConnection()
self._dbconn.set_sql(sql)
def setUp(self):
self.dbconn = qvarn.DatabaseConnection()
self.dbconn.set_sql(qvarn.SqliteAdapter())
vs = qvarn.VersionedStorage()
vs.set_resource_type(self.resource_type)
vs.start_version(u'1', None)
vs.add_prototype(self.prototype)
vs.add_prototype(self.subitem_prototype, subpath=self.subitem_name)
with self.dbconn.transaction() as t:
vs.prepare_storage(t)
self.wo = qvarn.WriteOnlyStorage()
self.wo.set_item_prototype(self.person[u'type'], self.prototype)
self.wo.set_subitem_prototype(self.person[u'type'], self.subitem_name,
self.subitem_prototype)
self.ro = qvarn.ReadOnlyStorage()
self.ro.set_item_prototype(self.person[u'type'], self.prototype)
self.ro.set_subitem_prototype(self.person[u'type'], self.subitem_name,
self.subitem_prototype)
def setUp(self):
self._dbconn = qvarn.DatabaseConnection()
self._dbconn.set_sql(qvarn.SqliteAdapter())
vs = qvarn.VersionedStorage()
vs.set_resource_type(self.resource_type)
vs.start_version(u'first-version')
vs.add_prototype(self.prototype)
with self._dbconn.transaction() as t:
vs.prepare_storage(t)
self.ro = qvarn.ReadOnlyStorage()
self.ro.set_item_prototype(self.resource_type, self.prototype)
self.wo = qvarn.WriteOnlyStorage()
self.wo.set_item_prototype(self.resource_type, self.prototype)
self.resource = qvarn.ListResource()
self.resource.set_path(self.resource_type)
self.resource.set_item_type(self.resource_type)
self.resource.set_item_prototype(self.prototype)
self.resource.set_listener(FakeListenerResource())
self.resource.prepare_resource(self._dbconn)
def transaction(self):
sql = qvarn.SqliteAdapter()
conn = qvarn.DatabaseConnection()
conn.set_sql(sql)
return conn.transaction()
def setUp(self):
sql = qvarn.SqliteAdapter()
self.dbconn = qvarn.DatabaseConnection()
self.dbconn.set_sql(sql)
