def setup_app(command, conf, vars):
"""Place any commands to setup tracking here"""
load_environment(conf.global_conf, conf.local_conf)
filename = os.path.split(conf.filename)[-1]
if filename == 'test.ini':
# Permanently drop any existing tables
log.info("Dropping existing tables...")
meta.Base.metadata.drop_all(bind=meta.engine, checkfirst=True)
log.info("Creating tables...")
# Create the tables if they don't already exist
meta.Base.metadata.create_all(bind=meta.engine)
log.info("Successfully set up.")
if filename == 'development.ini':
# load sample data during setup-app
db = SQLAlchemyFixture(env=model,
style=NamedDataStyle(),
engine=meta.engine)
data = db.data(PageviewsData)
log.info("Loading sample data...")
data.setup()
log.info("Successfully set up.")
def setup_app(command, conf, vars):
"""Place any commands to setup tracking here"""
load_environment(conf.global_conf, conf.local_conf)
filename = os.path.split(conf.filename)[-1]
if filename == 'test.ini':
# Permanently drop any existing tables
log.info("Dropping existing tables...")
meta.Base.metadata.drop_all(bind=meta.engine, checkfirst=True)
log.info("Creating tables...")
# Create the tables if they don't already exist
meta.Base.metadata.create_all(bind=meta.engine)
log.info("Successfully set up.")
if filename == 'development.ini':
# load sample data during setup-app
db = SQLAlchemyFixture(
env=model, style=NamedDataStyle(),
engine=meta.engine)
data = db.data(PageviewsData)
log.info("Loading sample data...")
data.setup()
log.info("Successfully set up.")
def install(app, *args):
engine = m.create_tables(app)
db = SQLAlchemyFixture(env=m, style=NamedDataStyle(), engine=engine)
data = db.data(*args)
data.setup()
db.dispose()
return data
def setUp(self):
if not conf.HEAVY_DSN:
raise SkipTest("conf.HEAVY_DSN not defined")
engine = create_engine(conf.HEAVY_DSN)
metadata.bind = engine
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
self.fixture = SQLAlchemyFixture(
env=globals(),
engine=metadata.bind,
style=NamedDataStyle(),
)
clear_mappers()
mapper(Category, categories)
mapper(Product, products, properties={
'category': relation(Category, backref='products')
})
mapper(Offer, offers, properties={
'product': relation(Product, backref='offers'),
'category': relation(Category, backref='offers')
})
def setUp(self):
# Create tables
models.db.create_all()
# Load data
fix = SQLAlchemyFixture(env=models, engine=models.db.engine)
self.data = fix.data(*test_data.all_data)
self.data.setup()
def setUp(self):
self.app = create_app('config/test.ini').test_client()
init_db()
# TODO move this to the proper place in the code
dbfixture = SQLAlchemyFixture(
env={'UserData': User},
engine=dailylog.db.engine)
self.data = dbfixture.data(UserData)
self.data.setup()
def setup_testdata(connectable):
dbfixture = SQLAlchemyFixture(engine=connectable or db.engine,
env={
'VerificationCodeData':
db_models.VerificationCode,
})
fixture_datas = [
dbfixture.data(VerificationCodeData),
]
return dbfixture, fixture_datas
def test_cannot_teardown_unloaded_fixture():
class CategoryData(DataSet):
class cars:
name = 'cars'
engine = create_engine(conf.LITE_DSN)
metadata.bind = engine
db = SQLAlchemyFixture(env=globals(), engine=metadata.bind)
data = db.data(CategoryData)
data.teardown()
def setUp(self):
db.create_all()
fixture = SQLAlchemyFixture( env=models,
style=TrimmedNameStyle(suffix="Data"),
session=db.session)
try:
self.data = fixture.data(*self.fixtures)
except TypeError:
raise Error('You need overide "fixtures = None" with the name of some real fixtures')
self.data.setup()
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
ScopedSession = scoped_session(get_transactional_session())
self.session = ScopedSession()
self.fixture = SQLAlchemyFixture(env={'CategoryData': Category},
engine=metadata.bind)
clear_mappers()
mapper(Category, categories)
def load_fixtures(self, *args):
# TODO: Check https://github.com/mitsuhiko/flask-sqlalchemy/pull/89
# and update version of Flask-Sqlalchemy
from api import models
from fixture import SQLAlchemyFixture
from fixture.style import NamedDataStyle
db = SQLAlchemyFixture(env=models,
style=NamedDataStyle(),
engine=self.engine)
data = db.data(*args)
data.setup()
db.dispose()
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
self.fixture = SQLAlchemyFixture(
# maps to a table object :
env={'CategoryData': categories},
engine=metadata.bind)
clear_mappers()
mapper(Category, categories)
def test_cannot_teardown_unloaded_fixture():
class CategoryData(DataSet):
class cars:
name = 'cars'
engine = create_engine(conf.LITE_DSN)
metadata.bind = engine
db = SQLAlchemyFixture(
env=globals(),
engine=metadata.bind
)
data = db.data(CategoryData)
data.teardown()
def setUp(self):
engine = create_engine(conf.LITE_DSN)
metadata.bind = engine
# metadata.bind.echo = True
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
# note the lack of explicit binding :
self.fixture = SQLAlchemyFixture(env={'CategoryData': Category}, )
clear_mappers()
# since categories is assigned to metadata, SA should handle binding for us
mapper(Category, categories)
def setUp(self):
if not conf.HEAVY_DSN:
raise SkipTest("conf.HEAVY_DSN not defined")
engine = create_engine(conf.HEAVY_DSN)
metadata.bind = engine
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
self.fixture = SQLAlchemyFixture(
env=globals(),
engine=metadata.bind,
style=NamedDataStyle(),
)
clear_mappers()
mapper(Category, categories)
mapper(Product, products, properties={
'category': relation(Category, backref='products')
})
mapper(Offer, offers, properties={
'product': relation(Product, backref='offers'),
'category': relation(Category, backref='offers')
})
def load_fixtures(sender, yes_i_know=False, drop=True, **kwargs):
"""Load fixtures.
Loads classes found in 'packages' to the database. Names of the fixture
classes should end with 'Data' suffix.
:param packages: packages with fixture classes to load
:param truncate_tables_first: if True truncates tables before loading
the fixtures
"""
from invenio.ext.sqlalchemy import db, models
from fixture import SQLAlchemyFixture
# Load SQLAlchemy models.
list(models)
models = dict((m.__name__ + 'Data', m) for m in db.Model.__subclasses__())
missing = set(fixtures.keys()) - set(models.keys())
if len(missing):
raise Exception(
'Cannot match models for the following fixtures classes {0}'.
format(missing))
print(">>> There are", len(fixtures.keys()), "tables to be loaded.")
SQLAlchemyFixture(env=models, engine=db.metadata.bind,
session=db.session).data(*fixtures.values()).setup()
db.session.commit()
def make_fixture():
"""A helper to create a database fixture.
"""
fixture = SQLAlchemyFixture(env=_all,
style=TrimmedNameStyle(suffix="Data"),
engine=session.session.get_engine())
return fixture
def setUp(self):
super(DBFixture, self).setUp()
self.dbfixture = SQLAlchemyFixture(engine=get_engine(),
env={'TreeNodeData': TreeNode})
self.data = self.dbfixture.data(TreeNodeData)
self.data.setup()
self.addCleanup(self.data.teardown)
class TestListView(TestCase):
"""Tests for DetailView."""
urls = 'tests.integration.views.generic.urls'
def setUp(self):
setup_environment()
self.fixture = SQLAlchemyFixture(
env=models,
session=session,
style=NamedDataStyle(),
)
def test_list_view(self):
"""Test the list view."""
with self.fixture.data(fixtures.PersonData) as data:
response = self.client.get('/people/')
self.assertEqual(response.status_code, 200)
self.assertIn(data.PersonData.John.name, response.content)
def test_list_view_allow_empty(self):
"""Test getting an empty list with allow_empty = True."""
response = self.client.get('/people/')
self.assertEqual(response.status_code, 200)
def test_list_view_404(self):
"""Test getting an empty list with allow_empty = False."""
response = self.client.get('/non_empty_people/')
self.assertEqual(response.status_code, 404)
def setUp(self):
super(DBFixture, self).setUp()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env={'AssetInfoData': AssetInfoModel})
self.data = self.dbfixture.data(AssetInfoData)
self.data.setup()
self.addCleanup(self.data.teardown)
def setUp(self):
setup_environment()
self.fixture = SQLAlchemyFixture(
env=models,
session=session,
style=NamedDataStyle(),
)
def create_fixture(self):
return SQLAlchemyFixture(
env = self.env,
style = NamedDataStyle(),
dataclass = MergedSuperSet,
# *load* data into the memory db :
engine = memmeta.bind
)
def setUp(self):
super(DBFixture, self).setUp()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env={'MpProviderData': Provider})
self.data = self.dbfixture.data(MpProviderData)
self.data.setup()
self.addCleanup(self.data.teardown)
def setUp(self):
super(DBFixture, self).setUp()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env={'DeviceStateData': DeviceState})
self.data = self.dbfixture.data(DeviceStateData)
BASE.metadata.create_all(get_engine())
self.data.setup()
self.addCleanup(self.data.teardown)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
metadata = MetaData()
metadata.bind = engine
DBSession.configure(bind=engine)
metadata.create_all()
dbfixture = SQLAlchemyFixture(env={
'WorkspaceData': Workspace,
'MapData': Map
},
engine=metadata.bind)
data = dbfixture.data(WorkspaceData, MapData)
data.setup()
def setUp(self):
super(DBFixture, self).setUp()
print get_engine()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env={'InOutData': InOutReason})
self.data = self.dbfixture.data(InOutData)
self.data.setup()
self.addCleanup(self.data.teardown)
def fixture_builder():
from invenio.modules.accounts.models import User, Usergroup, UserUsergroup
return SQLAlchemyFixture(env={
'UserData': User,
'UsergroupData': Usergroup,
'UserUsergroupData': UserUsergroup
},
engine=db.metadata.bind,
session=db.session)
def setUp(self):
super(DBFixture, self).setUp()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env={'AssetConsumeInfoData': AssetConsumeInfoModel})
self.data = self.dbfixture.data(AssetConsumeInfoData)
BASE.metadata.create_all(get_engine())
self.data.setup()
self.addCleanup(self.data.teardown)
def setUp(self):
super(DBFixture, self).setUp()
self.session = get_session()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env=dict(UserData=UserHstore)
)
self.data = self.dbfixture.data(UserData)
self.data.setup()
self.addCleanup(self.data.teardown)
def test_SQLAlchemyFixture_configured_with_bound_session_and_conn():
class StubConnection:
def begin(self):
pass
stub_conn = StubConnection()
class StubTransaction:
def add(self, engine):
pass
fake_out_bind = 1
class StubSession:
bind_to = fake_out_bind
def create_transaction(self):
return StubTransaction()
stub_session = StubSession()
f = SQLAlchemyFixture(
session=stub_session, connection=stub_conn)
f.begin()
eq_(f.session, stub_session)
eq_(f.connection, stub_conn)
def setup_app(command, conf, vars):
"""Place any commands to setup addressbook here"""
load_environment(conf.global_conf, conf.local_conf)
log.info("Creating tables")
# Create the tables if they don't already exist
meta.metadata.create_all(bind=meta.engine)
log.info("Successfully setup")
# load some initial data during setup-app :
db = SQLAlchemyFixture(
env=model, style=NamedDataStyle(),
engine=meta.engine)
data = db.data(PersonData)
log.info("Inserting initial data")
data.setup()
log.info("Done")
def setUp(self):
super(DBFixture, self).setUp()
self.engine = db_api.get_engine()
self.engine.connect()
self.dbfixture = SQLAlchemyFixture(engine=self.engine, env={"StoreStateMock": StoreState})
self.data = self.dbfixture.data(StoreStateMock)
self.session = db_api.get_session()
BASE.metadata.create_all(bind=self.engine)
self.data.setup()
self.addCleanup(self.data.teardown)
def test_SQLAlchemyFixture_configured_with_bound_session_and_conn():
class StubConnection:
def begin(self):
pass
stub_conn = StubConnection()
class StubTransaction:
def add(self, engine):
pass
fake_out_bind = 1
class StubSession:
bind_to = fake_out_bind
def create_transaction(self):
return StubTransaction()
stub_session = StubSession()
f = SQLAlchemyFixture(
session=stub_session, connection=stub_conn)
f.begin()
eq_(f.session, stub_session)
eq_(f.connection, stub_conn)
def test_with_engine_connection(self):
fixture = SQLAlchemyFixture(
# maps to a table object :
env={'CategoryData': categories},
# this should overwrite the default bind:
engine=self.litemeta.bind)
data = fixture.data(CategoryData)
data.setup()
rs = self.heavysession.query(Category).all()
assert rs == [], "unexpected records in HEAVY_DSN db: %s" % rs
rs = self.litesession.query(Category).all()
eq_(len(rs), 2)
data.teardown()
rs = self.litesession.query(Category).all()
eq_(len(rs), 0)
def load_fixtures(suffix='', truncate_tables_first=False):
from invenio.sqlalchemyutils import db
from fixture import SQLAlchemyFixture
from invenio.importutils import autodiscover_modules
if len(suffix) > 0:
related_name_re = ".+_fixtures_%s\.py" % (suffix, )
else:
related_name_re = ".+_fixtures\.py"
fixture_modules = autodiscover_modules(['invenio'],
related_name_re=related_name_re)
model_modules = autodiscover_modules(['invenio'],
related_name_re=".+_model\.py")
fixtures = dict((f, getattr(ff, f)) for ff in fixture_modules
for f in dir(ff) if f[-4:] == 'Data')
fixture_names = fixtures.keys()
models = dict((m + 'Data', getattr(mm, m)) for mm in model_modules
for m in dir(mm) if m + 'Data' in fixture_names)
dbfixture = SQLAlchemyFixture(env=models,
engine=db.metadata.bind,
session=db.session)
data = dbfixture.data(*fixtures.values())
if len(models) != len(fixtures):
print ">>> ERROR: There are", len(models), "tables and", len(
fixtures), "fixtures."
else:
print ">>> There are", len(models), "tables to be loaded."
if truncate_tables_first:
print ">>> Going to truncate following tables:",
print map(lambda t: t.__name__, models.values())
db.session.execute("TRUNCATE %s" % ('collectionname', ))
db.session.execute("TRUNCATE %s" % ('collection_externalcollection', ))
for m in models.values():
db.session.execute("TRUNCATE %s" % (m.__tablename__, ))
db.session.commit()
data.setup()
db.session.commit()
class DBFixture(fixtures.Fixture):
def setUp(self):
super(DBFixture, self).setUp()
print get_engine()
self.dbfixture = SQLAlchemyFixture(
engine=get_engine(),
env={'AssetTypeData': AssetTypeModel})
self.data = self.dbfixture.data(AssetTypeData)
self.data.setup()
self.addCleanup(self.data.teardown)
class BaseTest(DataTestCase):
datasets = [UserData, RegionData]
fixture = SQLAlchemyFixture(engine=metadata.bind,
env={
"UserData": UserTable,
"RegionData": RegionTable
})
@classmethod
def metadata(cls):
return metadata
def test_with_engine_connection(self):
fixture = SQLAlchemyFixture(
# maps to a table object :
env={'CategoryData':categories},
# this should overwrite the default bind:
engine = self.litemeta.bind
)
data = fixture.data(CategoryData)
data.setup()
rs = self.heavysession.query(Category).all()
assert rs==[], "unexpected records in HEAVY_DSN db: %s" % rs
rs = self.litesession.query(Category).all()
eq_(len(rs), 2)
data.teardown()
rs = self.litesession.query(Category).all()
eq_(len(rs), 0)
def load_fixtures(packages=['invenio.modules.*'], truncate_tables_first=False):
from invenio.base.utils import import_module_from_packages
from invenio.ext.sqlalchemy import db, models
from fixture import SQLAlchemyFixture
fixture_modules = list(import_module_from_packages('fixtures',
packages=packages))
model_modules = list(models)
fixtures = dict((f, getattr(ff, f)) for ff in fixture_modules
for f in dir(ff) if f[-4:] == 'Data')
fixture_names = fixtures.keys()
models = dict((m+'Data', getattr(mm, m)) for mm in model_modules
for m in dir(mm) if m+'Data' in fixture_names)
dbfixture = SQLAlchemyFixture(env=models, engine=db.metadata.bind,
session=db.session)
data = dbfixture.data(
*[f for (n, f) in iteritems(fixtures) if n in models]
)
if len(models) != len(fixtures):
print(
">>> ERROR: There are",
len(models),
"tables and",
len(fixtures),
"fixtures."
)
print(">>>", set(fixture_names) ^ set(models.keys()))
else:
print(">>> There are", len(models), "tables to be loaded.")
if truncate_tables_first:
print(">>> Going to truncate following tables:",
map(lambda t: t.__tablename__, models.values()))
db.session.execute("TRUNCATE %s" % ('collectionname', ))
db.session.execute("TRUNCATE %s" % ('collection_externalcollection', ))
for m in models.values():
db.session.execute("TRUNCATE %s" % (m.__tablename__, ))
db.session.commit()
data.setup()
db.session.commit()
def setUp(self):
if not env_supports.elixir:
raise SkipTest("elixir module not found")
import elixir
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
class CategoryEntity(elixir.Entity):
elixir.using_options(tablename=str(categories))
# save_on_init IS VERY IMPORTANT
elixir.using_mapper_options(save_on_init=False)
self.CategoryEntity = CategoryEntity
self.fixture = SQLAlchemyFixture(env={'CategoryData': CategoryEntity},
engine=metadata.bind)
elixir.metadata.bind = self.engine
elixir.setup_all()
class TestCollidingSessions(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
# self.conn = self.engine.connect()
metadata.bind = self.engine
# metadata.bind.echo = True
metadata.create_all()
# metadata.bind.echo = False
self.ScopedSession = scoped_session(get_transactional_session())
self.session = self.ScopedSession()
self.fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
engine=metadata.bind
)
clear_mappers()
mapper(Category, categories)
def tearDown(self):
metadata.drop_all()
self.session.close()
@attr(functional=1)
def test_setup_then_teardown(self):
eq_(self.session.query(Category).all(), [])
data = self.fixture.data(self.CategoryData)
data.setup()
self.session.clear()
cats = self.session.query(Category).order_by('name').all()
eq_(cats[0].name, 'cars')
eq_(cats[1].name, 'get free stuff')
# simulate the application running into some kind of error:
new_cat = Category()
new_cat.name = "doomed to non-existance"
self.session.save(new_cat)
self.session.rollback()
self.ScopedSession.remove()
data.teardown()
self.session.clear()
print [(c.id, c.name) for c in self.session.query(Category).all()]
eq_(list(self.session.query(Category)), [])
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
metadata = MetaData()
metadata.bind = engine
DBSession.configure(bind=engine)
metadata.create_all()
dbfixture = SQLAlchemyFixture(
env={
'WorkspaceData': Workspace,
'MapData': Map
},
engine=metadata.bind)
data = dbfixture.data(
WorkspaceData,
MapData
)
data.setup()
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
ScopedSession = scoped_session(get_transactional_session())
self.session = ScopedSession()
self.fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
engine=metadata.bind
)
clear_mappers()
mapper(Category, categories)
def setUp(self):
from fixture import SQLAlchemyFixture, NamedDataStyle
import sqlalchemy
from sqlalchemy.orm import (
mapper, relation, clear_mappers, sessionmaker, scoped_session)
from sqlalchemy import create_engine
metadata.bind = create_engine(conf.LITE_DSN)
metadata.create_all()
class options:
dsn = conf.LITE_DSN
env = ['fixture.examples.db.sqlalchemy_examples']
self.options = options
self.generator = DataSetGenerator(self.options, template=StubTemplate())
ScopedSession = scoped_session(sessionmaker(autoflush=False, transactional=True))
ScopedSession.mapper(Category, categories, save_on_init=False)
ScopedSession.mapper(Product, products, properties={
'category': relation(Category),
}, save_on_init=False)
ScopedSession.mapper(Offer, offers, properties={
'category': relation(Category, backref='products'),
'product': relation(Product)
}, save_on_init=False)
self.fixture = SQLAlchemyFixture(
env=sqlalchemy_examples,
style=NamedDataStyle(),
engine=metadata.bind)
self.data = self.fixture.data(self.CategoryData)
self.data.setup()
self.hnd = self.generator.get_handler(
"%s.Category" % (Category.__module__),
obj=Category,
connection=metadata.bind)
self.hnd.begin()
class TestCollidingSessions(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
# self.conn = self.engine.connect()
metadata.bind = self.engine
# metadata.bind.echo = True
metadata.create_all()
# metadata.bind.echo = False
self.ScopedSession = scoped_session(get_transactional_session())
self.session = self.ScopedSession()
self.fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
engine=metadata.bind
)
clear_mappers()
mapper(Category, categories)
def tearDown(self):
metadata.drop_all()
self.session.close()
@attr(functional=1)
def test_setup_then_teardown(self):
eq_(self.session.query(Category).all(), [])
data = self.fixture.data(self.CategoryData)
data.setup()
clear_session(self.session)
cats = self.session.query(Category).order_by('name').all()
eq_(cats[0].name, 'cars')
eq_(cats[1].name, 'get free stuff')
# simulate the application running into some kind of error:
new_cat = Category()
new_cat.name = "doomed to non-existance"
save_session(self.session, new_cat)
self.session.rollback()
self.ScopedSession.remove()
data.teardown()
clear_session(self.session)
print [(c.id, c.name) for c in self.session.query(Category).all()]
class TestElixir(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
if not env_supports.elixir:
raise SkipTest("elixir module not found")
import elixir
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
class CategoryEntity(elixir.Entity):
elixir.using_options(tablename=str(categories))
# save_on_init IS VERY IMPORTANT
elixir.using_mapper_options(save_on_init=False)
self.CategoryEntity = CategoryEntity
self.fixture = SQLAlchemyFixture(
env={'CategoryData':CategoryEntity},
engine=metadata.bind
)
elixir.metadata.bind = self.engine
elixir.setup_all()
def tearDown(self):
metadata.drop_all()
@attr(functional=1)
def test_setup_then_teardown(self):
try:
from elixir import session as elixir_session
except ImportError:
from elixir import objectstore as elixir_session
eq_(len(elixir_session.query(self.CategoryEntity).all()), 0)
data = self.fixture.data(self.CategoryData)
data.setup()
eq_(len(elixir_session.query(self.CategoryEntity).all()), 2)
data.teardown()
eq_(elixir_session.query(self.CategoryEntity).all(), [])
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
self.fixture = SQLAlchemyFixture(
# maps to a table object :
env={'CategoryData':categories},
engine=metadata.bind
)
clear_mappers()
mapper(Category, categories)
class TestElixir(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
if not env_supports.elixir:
raise SkipTest("elixir module not found")
import elixir
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
class CategoryEntity(elixir.Entity):
elixir.using_options(tablename=str(categories))
# save_on_init IS VERY IMPORTANT
elixir.using_mapper_options(save_on_init=False)
self.CategoryEntity = CategoryEntity
self.fixture = SQLAlchemyFixture(
env={'CategoryData':CategoryEntity},
engine=metadata.bind
)
elixir.metadata.bind = self.engine
elixir.setup_all()
def tearDown(self):
metadata.drop_all()
@attr(functional=1)
def test_setup_then_teardown(self):
try:
from elixir import session as elixir_session
except ImportError:
from elixir import objectstore as elixir_session
eq_(len(elixir_session.query(self.CategoryEntity).all()), 0)
data = self.fixture.data(self.CategoryData)
data.setup()
eq_(len(elixir_session.query(self.CategoryEntity).all()), 2)
data.teardown()
eq_(elixir_session.query(self.CategoryEntity).all(), [])
def fixture_builder():
from invenio_accounts.models import User, Usergroup, UserUsergroup
from invenio.modules.search.models import Collection, CollectionCollection, \
Externalcollection
return SQLAlchemyFixture(env={'UserData': User,
'UsergroupData': Usergroup,
'UserUsergroupData': UserUsergroup,
'CollectionData': Collection,
'ExternalcollectionData': Externalcollection,
'CollectionCollectionData':
CollectionCollection},
engine=db.metadata.bind,
session=db.session)
def install(*args):
dbfixture = SQLAlchemyFixture(
env={
'LocaleData': video_models.Locale,
'CategoryData': video_models.Category,
'CategoryTranslationData': video_models.CategoryTranslation,
'RockpackCoverArtData': RockpackCoverArt,
'SourceData': video_models.Source,
'UserData': User,
'ChannelData': video_models.Channel,
'ChannelLocaleMetaData': video_models.ChannelLocaleMeta,
'VideoData': video_models.Video,
'VideoInstanceData': video_models.VideoInstance,
'MoodData': video_models.Mood,
'ExternalTokenData': oauth_models.ExternalToken,
},
session=db.session,
)
data = dbfixture.data(*args)
with app.test_request_context():
data.setup()
db.session.commit()
class DBFixture(fixtures.Fixture):
def setUp(self):
super(DBFixture, self).setUp()
self.engine = db_api.get_engine()
self.engine.connect()
self.dbfixture = SQLAlchemyFixture(
engine=self.engine,
env={
"DeviceStateDS": DeviceState
}
)
self.data = self.dbfixture.data(DeviceStateDS)
self.session = db_api.get_session()
BASE.metadata.create_all(bind=self.engine)
self.data.setup()
self.addCleanup(self.data.teardown)
class DBFixture(fixtures.Fixture):
def setUp(self):
super(DBFixture, self).setUp()
self.engine = db_api.get_engine()
self.engine.connect()
self.dbfixture = SQLAlchemyFixture(
engine=self.engine,
env={
"AssetConsumeInfoMock": AssetConsumeInfoModel
}
)
self.data = self.dbfixture.data(AssetConsumeInfoMock)
self.session = db_api.get_session()
BASE.metadata.create_all(bind=self.engine)
self.data.setup()
self.addCleanup(self.data.teardown)
class TestQuerySessionMappedClass(HandlerQueryTest):
def setUp(self):
from fixture import SQLAlchemyFixture, NamedDataStyle
import sqlalchemy
from sqlalchemy.orm import (
mapper, relation, clear_mappers, sessionmaker, scoped_session)
from sqlalchemy import create_engine
metadata.bind = create_engine(conf.LITE_DSN)
metadata.create_all()
class options:
dsn = conf.LITE_DSN
env = ['fixture.examples.db.sqlalchemy_examples']
self.options = options
self.generator = DataSetGenerator(self.options, template=StubTemplate())
ScopedSession = scoped_session(sessionmaker(autoflush=False, transactional=True))
ScopedSession.mapper(Category, categories, save_on_init=False)
ScopedSession.mapper(Product, products, properties={
'category': relation(Category),
}, save_on_init=False)
ScopedSession.mapper(Offer, offers, properties={
'category': relation(Category, backref='products'),
'product': relation(Product)
}, save_on_init=False)
self.fixture = SQLAlchemyFixture(
env=sqlalchemy_examples,
style=NamedDataStyle(),
engine=metadata.bind)
self.data = self.fixture.data(self.CategoryData)
self.data.setup()
self.hnd = self.generator.get_handler(
"%s.Category" % (Category.__module__),
obj=Category,
connection=metadata.bind)
self.hnd.begin()
def tearDown(self):
from sqlalchemy.orm import clear_mappers
self.data.teardown()
metadata.drop_all()
clear_mappers()
def test_fixture_can_be_disposed():
from sqlalchemy.exceptions import InvalidRequestError
engine = create_engine(conf.LITE_DSN)
metadata.bind = engine
metadata.create_all()
Session = get_transactional_session()
session = Session()
fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
engine=metadata.bind
)
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
clear_mappers()
mapper(Category, categories)
data = fixture.data(CategoryData)
data.setup()
data.teardown()
fixture.dispose()
# cannot use fixture anymore :
try:
data.setup()
except InvalidRequestError:
pass
else:
assert False, "data.setup() did not raise InvalidRequestError after connection was disposed"
# a new instance of everything is needed :
metadata.create_all()
fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
engine=metadata.bind
)
data = fixture.data(CategoryData)
data.setup()
data.teardown()
class TestImplicitSABinding(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
engine = create_engine(conf.LITE_DSN)
metadata.bind = engine
# metadata.bind.echo = True
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
# note the lack of explicit binding :
self.fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
)
clear_mappers()
# since categories is assigned to metadata, SA should handle binding for us
mapper(Category, categories)
def tearDown(self):
# metadata.bind.echo = False
metadata.drop_all()
self.session.close()
@attr(functional=1)
def test_setup_then_teardown(self):
eq_(self.session.query(Category).all(), [])
data = self.fixture.data(self.CategoryData)
data.setup()
self.session.clear()
cats = self.session.query(Category).order_by('name').all()
eq_(cats[0].name, 'cars')
eq_(cats[1].name, 'get free stuff')
data.teardown()
self.session.clear()
eq_(list(self.session.query(Category)), [])
class TestQueryMappedClass(HandlerQueryTest):
def setUp(self):
from fixture import SQLAlchemyFixture, NamedDataStyle
import sqlalchemy
from sqlalchemy.orm import mapper, relation, clear_mappers
from sqlalchemy import create_engine
metadata.bind = create_engine(conf.LITE_DSN)
metadata.create_all()
class options:
dsn = conf.LITE_DSN
env = ['fixture.examples.db.sqlalchemy_examples']
self.options = options
self.generator = DataSetGenerator(self.options, template=StubTemplate())
mapper(Category, categories)
mapper(Product, products, properties={
'category': relation(Category),
})
mapper(Offer, offers, properties={
'category': relation(Category, backref='products'),
'product': relation(Product)
})
self.fixture = SQLAlchemyFixture(
env=sqlalchemy_examples,
style=NamedDataStyle(),
engine=metadata.bind)
self.data = self.fixture.data(self.CategoryData)
self.data.setup()
self.hnd = self.generator.get_handler(
"%s.Category" % (Category.__module__),
obj=Category,
connection=metadata.bind)
self.hnd.begin()
def tearDown(self):
from sqlalchemy.orm import clear_mappers
self.data.teardown()
metadata.drop_all()
clear_mappers()
class TestTableObjects(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
self.engine = create_engine(conf.LITE_DSN)
metadata.bind = self.engine
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
self.fixture = SQLAlchemyFixture(
# maps to a table object :
env={'CategoryData':categories},
engine=metadata.bind
)
clear_mappers()
mapper(Category, categories)
def tearDown(self):
metadata.drop_all()
self.session.close()
@attr(functional=1)
def test_setup_then_teardown(self):
eq_(self.session.query(Category).all(), [])
data = self.fixture.data(self.CategoryData)
data.setup()
self.session.clear()
cats = self.session.execute(categories.select()).fetchall()
eq_(cats[0].name, 'cars')
eq_(cats[1].name, 'get free stuff')
data.teardown()
self.session.clear()
eq_(self.session.execute(categories.select()).fetchall(), [])
class TestSetupTeardown(unittest.TestCase):
class CategoryData(DataSet):
class cars:
name = 'cars'
class free_stuff:
name = 'get free stuff'
def setUp(self):
engine = create_engine(conf.LITE_DSN)
metadata.bind = engine
metadata.create_all()
Session = get_transactional_session()
self.session = Session()
self.fixture = SQLAlchemyFixture(
env={'CategoryData':Category},
engine=metadata.bind
)
clear_mappers()
mapper(Category, categories)
def tearDown(self):
metadata.drop_all()
self.session.close()
@attr(functional=1)
def test_setup_then_teardown(self):
eq_(self.session.query(Category).all(), [])
data = self.fixture.data(self.CategoryData)
data.setup()
self.session.clear()
cats = self.session.query(Category).order_by('name').all()
eq_(cats[0].name, 'cars')
eq_(cats[1].name, 'get free stuff')
data.teardown()
self.session.clear()
eq_(list(self.session.query(Category)), [])
def setUpClass(cls):
SQLAlchemyTestCase.setUpClass()
cls.fixture = SQLAlchemyFixture(env=_all,
style=NamedDataStyle(),
engine=connection)
def fixture_builder():
from invenio_accounts.models import User
return SQLAlchemyFixture(env={'UserData': User}, engine=db.metadata.bind,
session=db.session)
