def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings['kotti.use_tables'].strip() or None
if tables:
if 'settings' not in tables:
tables += ' settings'
tables = [metadata.tables[name] for name in tables.split()]
if engine.dialect.name == 'mysql': # pragma: no cover
from sqlalchemy.dialects.mysql.base import LONGBLOB
File.__table__.c.data.type = LONGBLOB()
metadata.create_all(engine, tables=tables)
for populate in get_settings()['kotti.populators']:
populate()
commit()
return DBSession()
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = _resolve_dotted(get_settings())
tables = settings['kotti.use_tables'].strip() or None
if tables:
tables = [metadata.tables[name] for name in tables.split()]
_adjust_for_engine(engine)
# Allow migrations to set the 'head' stamp in case the database is
# initialized freshly:
if not engine.table_names():
stamp_heads()
metadata.create_all(engine, tables=tables)
if os.environ.get('KOTTI_DISABLE_POPULATORS', '0') not in TRUE_VALUES:
for populate in settings['kotti.populators']:
populate()
commit()
return DBSession
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings['kotti.use_tables'].strip() or None
if tables:
tables = [metadata.tables[name] for name in tables.split()]
if engine.dialect.name == 'mysql': # pragma: no cover
from sqlalchemy.dialects.mysql.base import LONGBLOB
File.__table__.c.data.type = LONGBLOB()
# Allow migrations to set the 'head' stamp in case the database is
# initialized freshly:
if not engine.table_names():
stamp_heads()
metadata.create_all(engine, tables=tables)
if os.environ.get('KOTTI_DISABLE_POPULATORS', '0') not in ('1', 'y'):
for populate in get_settings()['kotti.populators']:
populate()
commit()
return DBSession
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = _resolve_dotted(get_settings())
tables = settings['kotti.use_tables'].strip() or None
if tables:
tables = [metadata.tables[name] for name in tables.split()]
_adjust_for_engine(engine)
# Allow migrations to set the 'head' stamp in case the database is
# initialized freshly:
if not engine.table_names():
stamp_heads()
metadata.create_all(engine, tables=tables)
if os.environ.get('KOTTI_DISABLE_POPULATORS', '0') not in TRUE_VALUES:
for populate in settings['kotti.populators']:
populate()
commit()
return DBSession
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings['kotti.use_tables'].strip() or None
if tables:
tables = [metadata.tables[name] for name in tables.split()]
if engine.dialect.name == 'mysql': # pragma: no cover
from sqlalchemy.dialects.mysql.base import LONGBLOB
File.__table__.c.data.type = LONGBLOB()
# Allow migrations to set the 'head' stamp in case the database is
# initialized freshly:
if not engine.table_names():
stamp_heads()
metadata.create_all(engine, tables=tables)
if os.environ.get('KOTTI_DISABLE_POPULATORS', '0') not in ('1', 'y'):
for populate in get_settings()['kotti.populators']:
populate()
commit()
return DBSession
def content(connection, settings):
"""sets up some default content using Kotti's testing populator."""
import transaction
from kotti import DBSession
from kotti import metadata
from kotti.resources import get_root
if connection.in_transaction():
transaction.abort()
DBSession().close()
metadata.drop_all(connection.engine)
transaction.begin()
metadata.create_all(connection.engine)
# to create the default content with the correct workflow state
# the workflow must be initialized first; please note that these
# settings won't persist, though; use the `workflow` fixture if needed
from zope.configuration import xmlconfig
import kotti
xmlconfig.file("workflow.zcml", kotti, execute=True)
for populate in settings["kotti.populators"]:
populate()
# We set the path here since it's required for some integration
# tests, and because the 'content' fixture does not depend on
# 'event' and therefore the event handlers aren't fired for root
# otherwise:
get_root().path = "/"
transaction.commit()
def content(connection, settings):
""" sets up some default content using Kotti's testing populator.
"""
import transaction
from kotti import DBSession
from kotti import metadata
from kotti.resources import get_root
if connection.in_transaction():
transaction.abort()
DBSession().close()
metadata.drop_all(connection.engine)
transaction.begin()
metadata.create_all(connection.engine)
# to create the default content with the correct workflow state
# the workflow must be initialized first; please note that these
# settings won't persist, though; use the `workflow` fixture if needed
from zope.configuration import xmlconfig
import kotti
xmlconfig.file("workflow.zcml", kotti, execute=True)
for populate in settings["kotti.populators"]:
populate()
# We set the path here since it's required for some integration
# tests, and because the 'content' fixture does not depend on
# 'event' and therefore the event handlers aren't fired for root
# otherwise:
get_root().path = "/"
transaction.commit()
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.drop_all(engine)
metadata.create_all(engine)
for populate in get_settings()['kotti.populators']:
populate()
return DBSession()
def content(connection):
from transaction import commit
from kotti import metadata
metadata.drop_all(connection.engine)
metadata.create_all(connection.engine)
# to create the default content with the correct workflow state
# the workflow must be initialized first; please note that these
# settings won't persist, though; use the `workflow` fixture if needed
from zope.configuration import xmlconfig
import kotti
xmlconfig.file('workflow.zcml', kotti, execute=True)
for populate in settings()['kotti.populators']:
populate()
commit()
def content(connection):
""" sets up some default content using Kotti's testing populator.
"""
from transaction import commit
from kotti import metadata
metadata.drop_all(connection.engine)
metadata.create_all(connection.engine)
# to create the default content with the correct workflow state
# the workflow must be initialized first; please note that these
# settings won't persist, though; use the `workflow` fixture if needed
from zope.configuration import xmlconfig
import kotti
xmlconfig.file('workflow.zcml', kotti, execute=True)
for populate in settings()['kotti.populators']:
populate()
commit()
def connection():
# the following setup is based on `kotti.resources.initialize_sql`,
# except that it explicitly binds the session to a specific connection
# enabling us to use savepoints independent from the orm, thus allowing
# to `rollback` after using `transaction.commit`...
from transaction import commit
from sqlalchemy import create_engine
from kotti.testing import testing_db_url
from kotti import metadata, DBSession
engine = create_engine(testing_db_url())
connection = engine.connect()
DBSession.registry.clear()
DBSession.configure(bind=connection)
metadata.bind = engine
metadata.drop_all(engine)
metadata.create_all(engine)
for populate in settings()['kotti.populators']:
populate()
commit()
return connection
def tnc_connection():
# the following setup is based on `kotti.resources.initialize_sql`,
# except that it explicitly binds the session to a specific connection
# enabling us to use savepoints independent from the orm, thus allowing
# to `rollback` after using `transaction.commit`...
from transaction import commit
from sqlalchemy import create_engine
from kotti.testing import testing_db_url
from kotti import metadata, DBSession
engine = create_engine(testing_db_url())
connection = engine.connect()
DBSession.registry.clear()
DBSession.configure(bind=connection)
metadata.bind = engine
metadata.drop_all(engine)
metadata.create_all(engine)
for populate in tnc_settings()['kotti.populators']:
populate()
commit()
return connection
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings['kotti.use_tables'].strip() or None
if tables:
if 'settings' not in tables:
tables += ' settings'
tables = [metadata.tables[name] for name in tables.split()]
metadata.create_all(engine, tables=tables)
for populate in get_settings()['kotti.populators']:
populate()
return DBSession()
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings['kotti.use_tables'].strip() or None
if tables:
if 'settings' not in tables:
tables += ' settings'
tables = [metadata.tables[name] for name in tables.split()]
metadata.create_all(engine, tables=tables)
for populate in get_settings()['kotti.populators']:
populate()
commit()
return DBSession()
def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get("KOTTI_TEST_DB_STRING"):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings["kotti.use_tables"].strip() or None
if tables:
tables = [metadata.tables[name] for name in tables.split()]
if engine.dialect.name == "mysql": # pragma: no cover
from sqlalchemy.dialects.mysql.base import LONGBLOB
File.__table__.c.data.type = LONGBLOB()
# We disable the Node.path index for Mysql; in some conditions
# the index can't be created for columns even with 767 bytes,
# the maximum default size for column indexes
Node.__table__.indexes = set(index for index in Node.__table__.indexes if index.name != u"ix_nodes_path")
# Allow migrations to set the 'head' stamp in case the database is
# initialized freshly:
if not engine.table_names():
stamp_heads()
metadata.create_all(engine, tables=tables)
if os.environ.get("KOTTI_DISABLE_POPULATORS", "0") not in ("1", "y"):
for populate in get_settings()["kotti.populators"]:
populate()
commit()
return DBSession