def upgrade_environment(self, db=None):
dbm = DatabaseManager(self.env)
if dbm.get_database_version(DB_NAME) is False:
dbm.create_tables(schema)
dbm.set_database_version(DB_VERSION, DB_NAME)
else:
dbm.upgrade(DB_VERSION, DB_NAME, 'coderev.upgrades')
def reset_db(self, default_data=None):
"""Remove all data from Trac tables, keeping the tables themselves.
:param default_data: after clean-up, initialize with default data
:return: True upon success
"""
from trac import db_default
tables = []
dbm = DatabaseManager(self)
try:
db_version = dbm.get_database_version()
except (TracError, self.db_exc.DatabaseError):
pass
else:
if db_version == db_default.db_version:
# same version, simply clear the tables (faster)
tables = dbm.reset_tables()
else:
# different version or version unknown, drop the tables
self.destroy_db()
if not tables:
dbm.init_db()
# Make sure the next db_query()/db_transaction() will create
# a new connection aware of the new data model - see #8518.
if self.dburi != 'sqlite::memory:':
dbm.shutdown()
if default_data:
dbm.insert_into_tables(db_default.get_data)
else:
dbm.set_database_version(db_default.db_version)
def upgrade_environment(self):
dbm = DatabaseManager(self.env)
if dbm.get_database_version(PLUGIN_NAME) == 0:
dbm.create_tables(SCHEMA)
dbm.set_database_version(PLUGIN_VERSION, PLUGIN_NAME)
else:
dbm.upgrade(PLUGIN_VERSION, PLUGIN_NAME,
'packagerepository.upgrades')
def _create_env(self, path, dburi):
env = Environment(path, True,
[('trac', 'database', dburi),
('trac', 'base_url', 'http://localhost/'),
('project', 'name', u'Pŕójéćŧ Ńáḿé')])
dbm = DatabaseManager(env)
dbm.set_database_version(21, 'initial_database_version')
att = Attachment(env, 'wiki', 'WikiStart')
att.insert('filename.txt', io.BytesIO('test'), 4)
env.shutdown()
def upgrade_environment(self):
dbm = DatabaseManager(self.env)
if dbm.get_database_version(db_version_key) == 0:
dbm.create_tables(schema)
else:
with self.env.db_transaction as db:
while current_ver + 1 <= db_version:
upgrade_map[current_ver + 1](self.env)
current_ver += 1
dbm.set_database_version(db_version, db_version_key)
def upgrade_environment(self):
dbm = DatabaseManager(self.env)
if dbm.get_database_version(db_version_key) == 0:
dbm.create_tables(schema)
with self.env.db_transaction as db:
db("INSERT into `system` values ('fullblog_infotext', '')")
else:
with self.env.db_transaction as db:
current_ver = 1
while current_ver + 1 <= db_version:
upgrade_map[current_ver + 1](self.env)
current_ver += 1
dbm.set_database_version(db_version, db_version_key)
def upgrade_environment(self):
"""
Actually perform an environment upgrade, but don't commit as
that is done by the common upgrade procedure when all plugins are done.
"""
dbm = DatabaseManager(self.env)
current_ver = dbm.get_database_version(db_version_key)
if current_ver == 0:
dbm.create_tables(schema.values())
else:
while current_ver + 1 <= db_version:
upgrade_map[current_ver + 1](self.env)
current_ver += 1
dbm.set_database_version(db_version, db_version_key)
def upgrade_environment(self):
"""
Actually perform an environment upgrade, but don't commit as
that is done by the common upgrade procedure when all plugins are done.
"""
dbm = DatabaseManager(self.env)
current_ver = dbm.get_database_version(db_version_key)
if current_ver == 0:
dbm.create_tables(schema.values())
else:
while current_ver + 1 <= db_version:
upgrade_map[current_ver + 1](self.env)
current_ver += 1
dbm.set_database_version(db_version, db_version_key)
class DatabaseManagerTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.dbm = DatabaseManager(self.env)
def tearDown(self):
self.env.reset_db()
def test_destroy_db(self):
"""Database doesn't exist after calling destroy_db."""
self.env.db_query("SELECT name FROM system")
self.assertIsNotNone(self.dbm._cnx_pool)
self.dbm.destroy_db()
self.assertIsNone(self.dbm._cnx_pool) # No connection pool
self.assertFalse(self.dbm.db_exists())
def test_get_column_names(self):
"""Get column names for the default database."""
for table in default_schema:
column_names = [col.name for col in table.columns]
self.assertEqual(column_names,
self.dbm.get_column_names(table.name))
def test_get_default_database_version(self):
"""Get database version for the default entry named
`database_version`.
"""
self.assertEqual(default_db_version, self.dbm.get_database_version())
def test_get_table_names(self):
"""Get table names for the default database."""
self.assertEqual(sorted(table.name for table in default_schema),
sorted(self.dbm.get_table_names()))
def test_set_default_database_version(self):
"""Set database version for the default entry named
`database_version`.
"""
new_db_version = default_db_version + 1
self.dbm.set_database_version(new_db_version)
self.assertEqual(new_db_version, self.dbm.get_database_version())
# Restore the previous version to avoid destroying the database
# on teardown
self.dbm.set_database_version(default_db_version)
self.assertEqual(default_db_version, self.dbm.get_database_version())
def test_set_get_plugin_database_version(self):
"""Get and set database version for an entry with an
arbitrary name.
"""
name = 'a_trac_plugin_version'
db_ver = 1
self.assertFalse(self.dbm.get_database_version(name))
self.dbm.set_database_version(db_ver, name)
self.assertEqual(db_ver, self.dbm.get_database_version(name))
class DatabaseManagerTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.dbm = DatabaseManager(self.env)
def tearDown(self):
self.env.reset_db()
def test_get_default_database_version(self):
"""Get database version for the default entry named
`database_version`.
"""
self.assertEqual(default_db_version, self.dbm.get_database_version())
def test_get_table_names(self):
"""Get table names for the default database."""
self.assertEqual(sorted(table.name for table in default_schema),
sorted(self.dbm.get_table_names()))
def test_set_default_database_version(self):
"""Set database version for the default entry named
`database_version`.
"""
new_db_version = default_db_version + 1
self.dbm.set_database_version(new_db_version)
self.assertEqual(new_db_version, self.dbm.get_database_version())
# Restore the previous version to avoid destroying the database
# on teardown
self.dbm.set_database_version(default_db_version)
self.assertEqual(default_db_version, self.dbm.get_database_version())
def test_set_get_plugin_database_version(self):
"""Get and set database version for an entry with an
arbitrary name.
"""
name = 'a_trac_plugin_version'
db_ver = 1
self.assertFalse(self.dbm.get_database_version(name))
self.dbm.set_database_version(db_ver, name)
self.assertEqual(db_ver, self.dbm.get_database_version(name))
class UpgradeTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(path=mkdtemp())
self.dbm = DatabaseManager(self.env)
with self.env.db_transaction:
self.dbm.drop_tables(new_schema)
self.dbm.create_tables(old_schema)
self.dbm.set_database_version(VERSION - 1)
def tearDown(self):
self.env.reset_db_and_disk()
def test_attachment_table_upgraded(self):
"""The ipnr column is removed from the attachment table."""
db42.do_upgrade(self.env, VERSION, None)
column_names = [col.name for col in new_attachment_schema.columns]
self.assertEqual(column_names, self.dbm.get_column_names('attachment'))
def test_wiki_table_upgraded(self):
"""The ipnr column is removed from the wiki table."""
db42.do_upgrade(self.env, VERSION, None)
column_names = [col.name for col in new_wiki_schema.columns]
self.assertEqual(column_names, self.dbm.get_column_names('wiki'))
def test_attachments_data_migrated(self):
"""Attachment data is migrated on table upgrade."""
now = to_utimestamp(datetime_now(utc))
attachment_column_names = \
[col.name for col in old_attachment_schema.columns]
attachment_data = (('ticket', '1', 'file1', 10, now, 'desc1', 'user1',
'::1'), ('wiki', 'WikiStart', 'file2', 20, now,
'desc2', 'user2', '::2'))
self.dbm.insert_into_tables(
(('attachment', attachment_column_names, attachment_data), ))
db42.do_upgrade(self.env, VERSION, None)
ipnr_col = attachment_column_names.index('ipnr')
i = 0
for i, data in enumerate(
self.env.db_query("""
SELECT * FROM attachment ORDER BY type
""")):
self.assertEqual(
attachment_data[i][:ipnr_col] +
attachment_data[i][ipnr_col + 1:], data)
self.assertEqual(len(attachment_data), i + 1)
def test_wiki_data_migrated(self):
"""Wiki data is migrated on table upgrade."""
now = to_utimestamp(datetime_now(utc))
wiki_column_names = \
[col.name for col in old_wiki_schema.columns]
wiki_data = (('TracGuide', 2, now, 'user2', '::4', 'The guide', 'Edit',
0), ('WikiStart', 1, now, 'user1', '::3', 'The page',
'Init', 1))
self.dbm.insert_into_tables((('wiki', wiki_column_names, wiki_data), ))
db42.do_upgrade(self.env, VERSION, None)
ipnr_col = wiki_column_names.index('ipnr')
i = 0
for i, data in enumerate(
self.env.db_query("""
SELECT * FROM wiki ORDER BY name
""")):
self.assertEqual(
wiki_data[i][:ipnr_col] + wiki_data[i][ipnr_col + 1:], data)
self.assertEqual(len(wiki_data), i + 1)
class DatabaseManagerTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.dbm = DatabaseManager(self.env)
def tearDown(self):
self.env.reset_db()
def test_destroy_db(self):
"""Database doesn't exist after calling destroy_db."""
with self.env.db_query as db:
db("SELECT name FROM " + db.quote('system'))
self.assertIsNotNone(self.dbm._cnx_pool)
self.dbm.destroy_db()
self.assertIsNone(self.dbm._cnx_pool) # No connection pool
scheme, params = parse_connection_uri(get_dburi())
if scheme != 'postgres' or params.get('schema', 'public') != 'public':
self.assertFalse(self.dbm.db_exists())
else:
self.assertEqual([], self.dbm.get_table_names())
def test_get_column_names(self):
"""Get column names for the default database."""
for table in default_schema:
column_names = [col.name for col in table.columns]
self.assertEqual(column_names,
self.dbm.get_column_names(table.name))
def test_get_default_database_version(self):
"""Get database version for the default entry named
`database_version`.
"""
self.assertEqual(default_db_version, self.dbm.get_database_version())
def test_get_table_names(self):
"""Get table names for the default database."""
self.assertEqual(sorted(table.name for table in default_schema),
sorted(self.dbm.get_table_names()))
def test_has_table(self):
self.assertIs(True, self.dbm.has_table('system'))
self.assertIs(True, self.dbm.has_table('wiki'))
self.assertIs(False, self.dbm.has_table('trac'))
self.assertIs(False, self.dbm.has_table('blah.blah'))
def test_no_database_version(self):
"""False is returned when entry doesn't exist"""
self.assertFalse(self.dbm.get_database_version('trac_plugin_version'))
def test_set_default_database_version(self):
"""Set database version for the default entry named
`database_version`.
"""
new_db_version = default_db_version + 1
self.dbm.set_database_version(new_db_version)
self.assertEqual(new_db_version, self.dbm.get_database_version())
self.assertEqual([('INFO', 'Upgraded database_version from 45 to 46')],
self.env.log_messages)
# Restore the previous version to avoid destroying the database
# on teardown
self.dbm.set_database_version(default_db_version)
self.assertEqual(default_db_version, self.dbm.get_database_version())
def test_set_get_plugin_database_version(self):
"""Get and set database version for an entry with an
arbitrary name.
"""
name = 'trac_plugin_version'
db_ver = 1
self.dbm.set_database_version(db_ver, name)
self.assertEqual([], self.env.log_messages)
self.assertEqual(db_ver, self.dbm.get_database_version(name))
# DB update will be skipped when new value equals database version
self.dbm.set_database_version(db_ver, name)
self.assertEqual([], self.env.log_messages)
def test_get_sequence_names(self):
sequence_names = []
if self.dbm.connection_uri.startswith('postgres'):
for table in default_schema:
for column in table.columns:
if column.name == 'id' and column.auto_increment:
sequence_names.append(table.name)
sequence_names.sort()
self.assertEqual(sequence_names, self.dbm.get_sequence_names())
def environment_created(self):
dbm = DatabaseManager(self.env)
dbm.create_tables(SCHEMA)
dbm.set_database_version(PLUGIN_VERSION, PLUGIN_NAME)
