def _run_test(self):
try:
database_resource = provision.DatabaseResource(
self.DRIVER, provision_new_database=True)
except exception.BackendNotAvailable:
self.skip("database not available")
schema_resource = provision.SchemaResource(database_resource,
self._gen_schema)
schema = schema_resource.getResource()
conn = schema.database.engine.connect()
engine = utils.NonCommittingEngine(conn)
with engine.connect() as conn:
rows = conn.execute(self.test_table.select())
self.assertEqual([], rows.fetchall())
trans = conn.begin()
conn.execute(self.test_table.insert(), {"x": 1, "y": 2})
trans.rollback()
rows = conn.execute(self.test_table.select())
self.assertEqual([], rows.fetchall())
trans = conn.begin()
conn.execute(self.test_table.insert(), {"x": 2, "y": 3})
trans.commit()
rows = conn.execute(self.test_table.select())
self.assertEqual([(2, 3)], rows.fetchall())
engine._dispose()
schema_resource.finishedWith(schema)
def resources_collection(cls, test):
# reimplement current oslo.db code.
# FIXME(zzzeek) The patterns here are up in the air enough
# that I think keeping this totally separate will give us the
# most leverage in being able to fix oslo.db in an upcoming
# release, then port neutron back to the working version.
driver = test.DRIVER
if driver not in test._database_resources:
try:
test._database_resources[driver] = \
provision.DatabaseResource(driver)
except oslodb_exception.BackendNotAvailable:
test._database_resources[driver] = None
database_resource = test._database_resources[driver]
if database_resource is None:
return []
key = (driver, None)
if test.BUILD_SCHEMA:
if key not in test._schema_resources:
test._schema_resources[key] = provision.SchemaResource(
database_resource,
cls._generate_schema_w_migrations
if test.BUILD_WITH_MIGRATIONS else cls._generate_schema,
teardown=False)
schema_resource = test._schema_resources[key]
return [('schema', schema_resource), ('db', database_resource)]
else:
return [('db', database_resource)]
def _init_resources(cls):
cls.schema_resource = provision.SchemaResource(
provision.DatabaseResource("sqlite"),
cls._generate_schema, teardown=False)
dependency_resources = {}
for name, resource in cls.schema_resource.resources:
dependency_resources[name] = resource.getResource()
cls.schema_resource.make(dependency_resources)
cls.engine = dependency_resources['database'].engine
def _init_resources(cls):
if cls._GLOBAL_RESOURCES:
return
else:
cls._GLOBAL_RESOURCES = True
cls.database_resource = provision.DatabaseResource("sqlite")
dependency_resources = {}
for name, resource in cls.database_resource.resources:
dependency_resources[name] = resource.getResource()
cls.engine = dependency_resources['backend'].engine
def _resources_for_driver(self, driver, schema_scope, generate_schema):
# testresources relies on the identity and state of the
# TestResourceManager objects in play to correctly manage
# resources, and it also hardcodes to looking at the
# ".resources" attribute on the test object, even though the
# setUpResources() function passes the list of resources in,
# so we have to code the TestResourceManager logic into the
# .resources attribute and ensure that the same set of test
# variables always produces the same TestResourceManager objects.
if driver not in self._database_resources:
try:
self._database_resources[driver] = \
provision.DatabaseResource(driver,
provision_new_database=True)
except exception.BackendNotAvailable as bne:
self._database_resources[driver] = None
self._db_not_available[driver] = str(bne)
database_resource = self._database_resources[driver]
if database_resource is None:
return []
if schema_scope:
key = (driver, schema_scope)
if key not in self._schema_resources:
schema_resource = provision.SchemaResource(
database_resource, generate_schema)
transaction_resource = provision.TransactionResource(
database_resource, schema_resource)
self._schema_resources[key] = \
transaction_resource
transaction_resource = self._schema_resources[key]
return [
('transaction_engine', transaction_resource),
('db', database_resource),
]
else:
key = (driver, None)
if key not in self._schema_resources:
self._schema_resources[key] = provision.SchemaResource(
database_resource, generate_schema, teardown=True)
schema_resource = self._schema_resources[key]
return [
('schema', schema_resource),
('db', database_resource)
]
def _test_new_db_is_provisioned_by_default(self, base_cls):
try:
provision.DatabaseResource(base_cls.FIXTURE.DRIVER)
except exception.BackendNotAvailable:
self.skipTest("Backend %s is not available" %
base_cls.FIXTURE.DRIVER)
class SomeTest(base_cls):
def runTest(self):
pass
st = SomeTest()
db_resource = dict(st.resources)['db']
self.assertTrue(db_resource.provision_new_database)
def _init_resources(cls):
# this is a classlevel version of what testresources
# does w/ the resources attribute as well as the
# setUpResources() step (which requires a test instance, that
# SqlFixture does not have). Because this is a SQLite memory
# database, we don't actually tear it down, so we can keep
# it running throughout all tests.
if cls._GLOBAL_RESOURCES:
return
else:
cls._GLOBAL_RESOURCES = True
cls.schema_resource = provision.SchemaResource(
provision.DatabaseResource("sqlite"),
cls._generate_schema, teardown=False)
dependency_resources = {}
for name, resource in cls.schema_resource.resources:
dependency_resources[name] = resource.getResource()
cls.schema_resource.make(dependency_resources)
cls.engine = dependency_resources['database'].engine
def _run_test(self):
try:
database_resource = provision.DatabaseResource(self.DRIVER)
except exception.BackendNotAvailable:
self.skip("database not available")
schema_resource = provision.SchemaResource(
database_resource, self._gen_schema)
transaction_resource = provision.TransactionResource(
database_resource, schema_resource)
engine = transaction_resource.getResource()
with engine.connect() as conn:
rows = conn.execute(self.test_table.select())
self.assertEqual([], rows.fetchall())
trans = conn.begin()
conn.execute(
self.test_table.insert(),
{"x": 1, "y": 2}
)
trans.rollback()
rows = conn.execute(self.test_table.select())
self.assertEqual([], rows.fetchall())
trans = conn.begin()
conn.execute(
self.test_table.insert(),
{"x": 2, "y": 3}
)
trans.commit()
rows = conn.execute(self.test_table.select())
self.assertEqual([(2, 3)], rows.fetchall())
transaction_resource.finishedWith(engine)
def _generate_database_resource(self, _enginefacade):
return provision.DatabaseResource(self.driver,
_enginefacade,
provision_new_database=True)
def _generate_database_resource(self, _enginefacade):
return provision.DatabaseResource(self.driver,
_enginefacade,
ad_hoc_url=self.url,
provision_new_database=False)