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))
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 environment_needs_upgrade(self): """ Called when Trac checks whether the environment needs to be upgraded. Returns `True` if upgrade is needed, `False` otherwise. """ dbm = DatabaseManager(self.env) return dbm.get_database_version(db_version_key) != db_version
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 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')
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))
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 get_version(self, initial=False): """Return the current version of the database. If the optional argument `initial` is set to `True`, the version of the database used at the time of creation will be returned. In practice, for database created before 0.11, this will return `False` which is "older" than any db version number. :since: 0.11 :since 1.0.2: The lazily-evaluated attributes `database_version` and `database_initial_version` should be used instead. This method will be removed in release 1.3.1. """ dbm = DatabaseManager(self) return dbm.get_database_version("{0}database_version".format("initial_" if initial else ""))
def get_version(self, initial=False): """Return the current version of the database. If the optional argument `initial` is set to `True`, the version of the database used at the time of creation will be returned. In practice, for database created before 0.11, this will return `False` which is "older" than any db version number. :since: 0.11 :since 1.0.2: The lazily-evaluated attributes `database_version` and `database_initial_version` should be used instead. This method will be removed in release 1.3.1. """ dbm = DatabaseManager(self) return dbm.get_database_version( '{0}database_version'.format('initial_' if initial else ''))
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())