def to_sql(env, table):
""" Convenience function to get the to_sql for the active connector."""
from trac.db.api import DatabaseManager
dm = DatabaseManager(env)
if hasattr(dm, 'get_connector'): # Trac ~+1.3.2
dc = dm.get_connector()[0]
else:
dc = dm._get_connector()[0]
return dc.to_sql(table)
def upgrade_environment(self, db):
"""Each schema version should have its own upgrade module, named
upgrades/dbN.py, where 'N' is the version number (int).
"""
db_mgr = DatabaseManager(self.env)
schema_ver = self.get_schema_version(db)
cursor = db.cursor()
# Is this a new installation?
if not schema_ver:
# Perform a single-step install: Create plugin schema and
# insert default data into the database.
connector = db_mgr._get_connector()[0]
for table in db_default.schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
for table, cols, vals in db_default.get_data(db):
cursor.executemany(
"INSERT INTO %s (%s) VALUES (%s)" %
(table, ','.join(cols), ','.join(['%s' for c in cols])),
vals)
else:
# Perform incremental upgrades.
for i in range(schema_ver + 1, db_default.schema_version + 1):
name = 'db%i' % i
try:
upgrades = __import__('tractags.upgrades', globals(),
locals(), [name])
script = getattr(upgrades, name)
except AttributeError:
raise TracError(
_(
"No upgrade module for version %(num)i "
"(%(version)s.py)",
num=i,
version=name))
script.do_upgrade(self.env, i, cursor)
cursor.execute(
"""
UPDATE system
SET value=%s
WHERE name='tags_version'
""", (db_default.schema_version, ))
self.log.info("Upgraded TracTags db schema from version %d to %d" %
(schema_ver, db_default.schema_version))
TicketTagProvider(self.env)._fetch_tkt_tags(db)
self.log.info("Synchronized ticket attributes to tags table")
db.commit()
def upgrade_environment(self, db):
"""Each schema version should have its own upgrade module, named
upgrades/dbN.py, where 'N' is the version number (int).
"""
db_mgr = DatabaseManager(self.env)
schema_ver = self.get_schema_version(db)
cursor = db.cursor()
# Is this a new installation?
if not schema_ver:
# Perform a single-step install: Create plugin schema and
# insert default data into the database.
connector = db_mgr._get_connector()[0]
for table in db_default.schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
for table, cols, vals in db_default.get_data(db):
cursor.executemany("INSERT INTO %s (%s) VALUES (%s)" % (table,
','.join(cols),
','.join(['%s' for c in cols])), vals)
else:
# Perform incremental upgrades.
for i in range(schema_ver + 1, db_default.schema_version + 1):
name = 'db%i' % i
try:
upgrades = __import__('tractags.upgrades', globals(),
locals(), [name])
script = getattr(upgrades, name)
except AttributeError:
raise TracError(_("No upgrade module for version %(num)i "
"(%(version)s.py)", num=i, version=name))
script.do_upgrade(self.env, i, cursor)
cursor.execute("""
UPDATE system
SET value=%s
WHERE name='tags_version'
""", (db_default.schema_version,))
self.log.info("Upgraded TracTags db schema from version %d to %d"
% (schema_ver, db_default.schema_version))
TicketTagProvider(self.env)._fetch_tkt_tags(db)
self.log.info("Synchronized ticket attributes to tags table")
db.commit()
class EnvironmentSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.db = self.env.get_db_cnx()
self.votes = VoteSystem(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _schema_init(self, schema=None):
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS votes")
if schema:
connector = self.db_mgr._get_connector()[0]
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def _verify_curr_schema(self):
self.assertFalse(self.votes.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute('SELECT * FROM votes')
cols = get_column_names(cursor)
self.assertTrue('resource' not in cols)
self.assertEquals(['realm', 'resource_id', 'version', 'username',
'vote', 'time', 'changetime'], cols)
cursor.execute("""
SELECT value
FROM system
WHERE name='vote_version'
""")
schema_ver = int(cursor.fetchone()[0])
self.assertEquals(self.votes.schema_version, schema_ver)
def _verify_schema_unregistered(self):
cursor = self.db.cursor()
cursor.execute("""
SELECT value
FROM system
WHERE name='vote_version'
""")
self.assertFalse(cursor.fetchone())
# Tests
def test_new_install(self):
# Current tracvotes schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._schema_init()
self.assertEquals(0, self.votes.get_schema_version(self.db))
self.assertTrue(self.votes.environment_needs_upgrade(self.db))
self.votes.upgrade_environment(self.db)
self._verify_curr_schema()
def test_upgrade_v1_to_current(self):
# The initial db schema from r2963 - 02-Jan-2008 by Alec Thomas.
schema = [
Table('votes', key=('resource', 'username', 'vote'))[
Column('resource'),
Column('username'),
Column('vote', 'int'),
]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany("""
INSERT INTO votes
(resource,username,vote)
VALUES (%s,%s,%s)
""", (('ticket/1','user',-1), ('ticket/2','user',1),
('wiki/DeletedPage','user',-1), ('wiki/ExistingPage','user',1)))
# Resources must exist for successful data migration.
t = Ticket(self.env, db=self.db)
t['summary'] = 'test ticket'
t.insert()
w = WikiPage(self.env, 'ExistingPage')
w.text = 'content'
w.save('author', 'comment', '::1')
self._verify_schema_unregistered()
self.assertEquals(1, self.votes.get_schema_version(self.db))
self.assertTrue(self.votes.environment_needs_upgrade(self.db))
# Data migration and registration of unversioned schema.
self.votes.upgrade_environment(self.db)
self._verify_curr_schema()
cursor.execute('SELECT * FROM votes')
votes = cursor.fetchall()
t_votes = [id for realm,id,ver,u,v,t,c in votes if realm == 'ticket']
w_votes = [id for realm,id,ver,u,v,t,c in votes if realm == 'wiki']
self.assertTrue('1' in t_votes)
if resource_check:
self.assertFalse('2' in t_votes)
self.assertFalse('DeletedPage' in w_votes)
self.assertTrue('ExistingPage' in w_votes)
class TagSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.db = self.env.get_db_cnx()
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _get_cursor_description(self, cursor):
# Cursors don't look the same across Trac versions
if trac_version < '0.12':
return cursor.description
else:
return cursor.cursor.description
def _revert_tractags_schema_init(self):
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS tags")
cursor.execute("DROP TABLE IF EXISTS tags_change")
cursor.execute("DELETE FROM system WHERE name='tags_version'")
cursor.execute(
"DELETE FROM permission WHERE action %s" % self.db.like(),
('TAGS_%', ))
# Tests
def test_new_install(self):
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
self.assertEquals(0, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
self.assertEquals([], tags)
self.assertEquals(
['tagspace', 'name', 'tag'],
[col[0] for col in self._get_cursor_description(cursor)])
cursor.execute("""
SELECT value
FROM system
WHERE name='tags_version'
""")
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def test_upgrade_schema_v1(self):
# Ancient, unversioned schema - wiki only.
schema = [
Table('wiki_namespace')[Column('name'),
Column('namespace'),
Index(['name', 'namespace']), ]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
cursor = self.db.cursor()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Populate table with migration test data.
cursor.execute("""
INSERT INTO wiki_namespace
(name, namespace)
VALUES ('WikiStart', 'tag')
""")
cursor = self.db.cursor()
cursor.execute("SELECT * FROM wiki_namespace")
tags = cursor.fetchall()
self.assertEquals([('WikiStart', 'tag')], tags)
self.assertEquals(1, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
# Db content should be migrated.
self.assertEquals([('wiki', 'WikiStart', 'tag')], tags)
self.assertEquals(
['tagspace', 'name', 'tag'],
[col[0] for col in self._get_cursor_description(cursor)])
cursor.execute("""
SELECT value
FROM system
WHERE name='tags_version'
""")
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def test_upgrade_schema_v2(self):
# Just register a current, but unversioned schema.
schema = [
Table('tags', key=('tagspace', 'name',
'tag'))[Column('tagspace'),
Column('name'),
Column('tag'),
Index(['tagspace', 'name']),
Index(['tagspace', 'tag']), ]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
cursor = self.db.cursor()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Populate table with test data.
cursor.execute("""
INSERT INTO tags
(tagspace, name, tag)
VALUES ('wiki', 'WikiStart', 'tag')
""")
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
self.assertEquals([('wiki', 'WikiStart', 'tag')], tags)
self.assertEquals(2, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
# Db should be unchanged.
self.assertEquals([('wiki', 'WikiStart', 'tag')], tags)
self.assertEquals(
['tagspace', 'name', 'tag'],
[col[0] for col in self._get_cursor_description(cursor)])
cursor.execute("""
SELECT value
FROM system
WHERE name='tags_version'
""")
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def test_upgrade_schema_v3(self):
# Add table for tag change records to the schema.
schema = [
Table('tags', key=('tagspace', 'name',
'tag'))[Column('tagspace'),
Column('name'),
Column('tag'),
Index(['tagspace', 'name']),
Index(['tagspace', 'tag']), ]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
cursor = self.db.cursor()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Preset system db table with old version.
cursor.execute("""
INSERT INTO system
(name, value)
VALUES ('tags_version', '3')
""")
self.assertEquals(3, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags_change")
self.assertEquals(
['tagspace', 'name', 'time', 'author', 'oldtags', 'newtags'],
[col[0] for col in self._get_cursor_description(cursor)])
cursor.execute("""
SELECT value
FROM system
WHERE name='tags_version'
""")
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
class AnnouncementSystemSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.db = self.env.get_db_cnx()
self.an_sys = AnnouncementSystem(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _get_cursor_description(self, cursor):
# Cursors don't look the same across Trac versions
if trac_version < '0.12':
return cursor.description
else:
return cursor.cursor.description
def _schema_init(self, schema=None):
# Current announcer schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS subscriptions")
cursor.execute("DROP TABLE IF EXISTS subscription")
cursor.execute("DROP TABLE IF EXISTS subscription_attribute")
cursor.execute("DELETE FROM system WHERE name='announcer_version'")
if schema:
connector = self.db_mgr._get_connector()[0]
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def _verify_curr_schema(self):
self.assertFalse(self.an_sys.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM subscription_attribute")
columns = [col[0] for col in self._get_cursor_description(cursor)]
self.assertTrue('name' not in columns)
self.assertTrue('value' not in columns)
self.assertEquals(
['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
columns
)
cursor.execute("""
SELECT value
FROM system
WHERE name='announcer_version'
""")
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def _verify_version_unregistered(self):
cursor = self.db.cursor()
cursor.execute("""
SELECT value
FROM system
WHERE name='announcer_version'
""")
self.assertFalse(cursor.fetchone())
# Tests
def test_new_install(self):
# Just do db table clean-up.
self._schema_init()
self.assertEquals(0, self.an_sys.get_schema_version(self.db))
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
self.an_sys.upgrade_environment(self.db)
self._verify_curr_schema()
def test_upgrade_v1_to_current(self):
# The initial db schema from r3015 - 10-Jan-2008 by Stephen Hansen.
schema = [
Table('subscriptions', key='id')[
Column('id', auto_increment=True),
Column('sid'),
Column('enabled', type='int'),
Column('managed', type='int'),
Column('realm'),
Column('category'),
Column('rule'),
Column('destination'),
Column('format'),
Index(['id']),
Index(['realm', 'category', 'enabled']),
]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany("""
INSERT INTO session
(sid,authenticated,last_visit)
VALUES (%s,%s,%s)
""", (('somebody','0','0'), ('user','1','0')))
cursor.executemany("""
INSERT INTO session_attribute
(sid,authenticated,name,value)
VALUES (%s,1,%s,%s)
""", (('user','announcer_email_format_ticket','text/html'),
('user','announcer_specified_email','')))
cursor.executemany("""
INSERT INTO subscriptions
(sid,enabled,managed,
realm,category,rule,destination,format)
VALUES (%s,%s,0,%s,%s,%s,%s,%s)
""", (('somebody',1,'ticket','changed','1','1','email'),
('user',1,'ticket','attachment added','1','1','email')))
self.assertEquals(1, self.an_sys.get_schema_version(self.db))
target = 6
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
self.an_sys.upgrade_environment(self.db)
self._verify_curr_schema()
def test_upgrade_to_schema_v2(self):
# The initial db schema from r3015 - 10-Jan-2008 by Stephen Hansen.
schema = [
Table('subscriptions', key='id')[
Column('id', auto_increment=True),
Column('sid'),
Column('enabled', type='int'),
Column('managed', type='int'),
Column('realm'),
Column('category'),
Column('rule'),
Column('destination'),
Column('format'),
Index(['id']),
Index(['realm', 'category', 'enabled']),
]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany("""
INSERT INTO session
(sid,authenticated,last_visit)
VALUES (%s,%s,%s)
""", (('somebody','0','0'), ('user','1','0')))
cursor.executemany("""
INSERT INTO session_attribute
(sid,authenticated,name,value)
VALUES (%s,1,%s,%s)
""", (('user','announcer_email_format_ticket','text/html'),
('user','announcer_specified_email','')))
cursor.executemany("""
INSERT INTO subscriptions
(sid,enabled,managed,
realm,category,rule,destination,format)
VALUES (%s,%s,0,%s,%s,%s,%s,%s)
""", (('somebody',1,'ticket','changed','1','1','email'),
('user',1,'ticket','attachment added','1','1','email')))
self.assertEquals(1, self.an_sys.get_schema_version(self.db))
target = 2
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# Change from r3047 - 13-Jan-2008 for announcer-0.2 by Stephen Hansen.
# - 'subscriptions.destination', 'subscriptions.format'
# + 'subscriptions.authenticated', 'subscriptions.transport'
# 'subscriptions.managed' type='int' --> (default == char)
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
self._verify_version_unregistered()
cursor = self.db.cursor()
cursor.execute("SELECT * FROM subscriptions")
columns = [col[0] for col in self._get_cursor_description(cursor)]
self.assertEquals(['id', 'sid', 'authenticated', 'enabled', 'managed',
'realm', 'category', 'rule', 'transport'],
columns
)
def test_upgrade_to_schema_v3(self):
# Schema from r3047 - 13-Jan-2008 for announcer-0.2 by Stephen Hansen.
schema = [
Table('subscriptions', key='id')[
Column('id', auto_increment=True),
Column('sid'),
Column('authenticated', type='int'),
Column('enabled', type='int'),
Column('managed'),
Column('realm'),
Column('category'),
Column('rule'),
Column('transport'),
Index(['id']),
Index(['realm', 'category', 'enabled']),
]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany("""
INSERT INTO session_attribute
(sid,authenticated,name,value)
VALUES (%s,1,%s,%s)
""", (('user','announcer_email_format_ticket','text/html'),
('user','announcer_email_format_wiki','text/plain'),
('user','announcer_specified_email','')))
cursor.executemany("""
INSERT INTO subscriptions
(sid,authenticated,enabled,managed,
realm,category,rule,transport)
VALUES (%s,%s,1,%s,%s,%s,%s,%s)
""", (('user',1,'watcher','ticket','changed','1','email'),
('user',1,'watcher','wiki','*','WikiStart','email')))
self.assertEquals(2, self.an_sys.get_schema_version(self.db))
target = 3
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# From r9116 - 25-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
# + table 'subscription', 'subscription_attribute'
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
def test_upgrade_to_schema_v4(self):
# Schema from r9116 - 25-Sep-2010 for announcer-0.12.1 by R. Corsaro.
schema = [
Table('subscriptions', key='id')[
Column('id', auto_increment=True),
Column('sid'),
Column('authenticated', type='int'),
Column('enabled', type='int'),
Column('managed'),
Column('realm'),
Column('category'),
Column('rule'),
Column('transport'),
Index(['id']),
Index(['realm', 'category', 'enabled']),
],
Table('subscription', key='id')[
Column('id', auto_increment=True),
Column('time', type='int64'),
Column('changetime', type='int64'),
Column('class'),
Column('sid'),
Column('authenticated', type='int'),
Column('distributor'),
Column('format'),
Column('priority'),
Column('adverb')
],
Table('subscription_attribute', key='id')[
Column('id', auto_increment=True),
Column('sid'),
Column('class'),
Column('name'),
Column('value')
]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.execute("""
INSERT INTO subscription
(time,changetime,class,sid,authenticated,
distributor,format,priority,adverb)
VALUES ('0','0','GeneralWikiSubscriber','user','1',
'email','text/plain','1','always')
""")
cursor.executemany("""
INSERT INTO subscription_attribute
(sid,class,name,value)
VALUES (%s,%s,%s,%s)
""", (('somebody','GeneralWikiSubscriber','wiki', '*'),
('somebody','UserChangeSubscriber','wiki','created'),
('user','GeneralWikiSubscriber','wiki', 'TracWiki')))
self.assertEquals(3, self.an_sys.get_schema_version(self.db))
target = 4
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# From r9210 - 29-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
# - table 'subscriptions'
# 'subscription.priority' type=(default == char) --> 'int'
# 'subscription_attribute.name --> 'subscription_attribute.realm'
# 'subscription_attribute.value --> 'subscription_attribute.target'
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
# Check type of priority value.
cursor = self.db.cursor()
cursor.execute("SELECT priority FROM subscription")
for priority in cursor:
# Shouldn't raise an TypeError with appropriate column type.
result = priority[0] + 0
def test_upgrade_to_schema_v5(self):
# Schema from r9210 - 29-Sep-2010 for announcer-0.12.1 by R. Corsaro.
schema = [
Table('subscription', key='id')[
Column('id', auto_increment=True),
Column('time', type='int64'),
Column('changetime', type='int64'),
Column('class'),
Column('sid'),
Column('authenticated', type='int'),
Column('distributor'),
Column('format'),
Column('priority', type='int'),
Column('adverb')
],
Table('subscription_attribute', key='id')[
Column('id', auto_increment=True),
Column('sid'),
Column('class'),
Column('realm'),
Column('target')
]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany("""
INSERT INTO session
(sid,authenticated,last_visit)
VALUES (%s,%s,%s)
""", (('somebody','0','0'), ('user','1','0')))
cursor.executemany("""
INSERT INTO subscription_attribute
(sid,class,realm,target)
VALUES (%s,%s,%s,%s)
""", (('somebody','GeneralWikiSubscriber','wiki', '*'),
('somebody','UserChangeSubscriber','wiki','created'),
('user','GeneralWikiSubscriber','wiki', 'TracWiki')))
self.assertEquals(4, self.an_sys.get_schema_version(self.db))
target = 5
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# From r9235 - 01-Oct-2010 for announcer-0.12.1 by Robert Corsaro.
# + 'subscription_attribute.authenticated'
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
self._verify_version_unregistered()
cursor = self.db.cursor()
cursor.execute("SELECT * FROM subscription_attribute")
columns = [col[0] for col in self._get_cursor_description(cursor)]
self.assertTrue('name' not in columns)
self.assertTrue('value' not in columns)
self.assertEquals(
['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
columns
)
# Check authenticated attribute for session IDs.
subscriptions = [(row[1],(row[2])) for row in cursor]
for sub in subscriptions:
self.assertTrue((sub[0] == 'user' and sub[1] == 1) or sub[1] == 0)
def test_upgrade_to_schema_v6(self):
# Check data migration and registration of unversioned schema.
# Table definitions are identical to current schema here, see
# schema from r9235 - 01-Oct-2010 for announcer-0.12.1 by R. Corsaro.
self._schema_init(db_default.schema)
# Populate table with test data.
cursor = self.db.cursor()
if self.env.config.get('trac', 'database').startswith('sqlite'):
# Add dataset with CURRENT_TIMESTAMP strings.
cursor.execute("""
INSERT INTO subscription
(time,changetime,
class,sid,authenticated,
distributor,format,priority,adverb)
VALUES ('1970-01-01 00:00:00','2012-10-31 23:59:59',
'GeneralWikiSubscriber','user','1',
'email','text/plain','1','always')
""")
else:
cursor.execute("""
INSERT INTO subscription
(time,changetime,
class,sid,authenticated,
distributor,format,priority,adverb)
VALUES ('0','1351724399',
'GeneralWikiSubscriber','user','1',
'email','text/plain','1','always')
""")
cursor.execute("""
INSERT INTO subscription_attribute
(sid,authenticated,class,realm,target)
VALUES ('user','1','GeneralWikiSubscriber','wiki', 'TracWiki')
""")
self.assertEquals(5, self.an_sys.get_schema_version(self.db))
target = 6
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# Data migration and registration of unversioned schema.
self.an_sys.upgrade_environment(self.db)
self._verify_curr_schema()
cursor.execute("SELECT time,changetime FROM subscription")
for time in cursor:
# Shouldn't raise an TypeError with proper int/long values.
check = time[1] - time[0]
class AnnouncementSystemSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.db = self.env.get_db_cnx()
self.an_sys = AnnouncementSystem(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _get_cursor_description(self, cursor):
# Cursors don't look the same across Trac versions
if trac_version < '0.12':
return cursor.description
else:
return cursor.cursor.description
def _schema_init(self, schema=None):
# Current announcer schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS subscriptions")
cursor.execute("DROP TABLE IF EXISTS subscription")
cursor.execute("DROP TABLE IF EXISTS subscription_attribute")
cursor.execute("DELETE FROM system WHERE name='announcer_version'")
if schema:
connector = self.db_mgr._get_connector()[0]
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def _verify_curr_schema(self):
self.assertFalse(self.an_sys.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM subscription_attribute")
columns = [col[0] for col in self._get_cursor_description(cursor)]
self.assertTrue('name' not in columns)
self.assertTrue('value' not in columns)
self.assertEquals(
['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
columns)
cursor.execute("""
SELECT value
FROM system
WHERE name='announcer_version'
""")
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def _verify_version_unregistered(self):
cursor = self.db.cursor()
cursor.execute("""
SELECT value
FROM system
WHERE name='announcer_version'
""")
self.assertFalse(cursor.fetchone())
# Tests
def test_new_install(self):
# Just do db table clean-up.
self._schema_init()
self.assertEquals(0, self.an_sys.get_schema_version(self.db))
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
self.an_sys.upgrade_environment(self.db)
self._verify_curr_schema()
def test_upgrade_v1_to_current(self):
# The initial db schema from r3015 - 10-Jan-2008 by Stephen Hansen.
schema = [
Table('subscriptions',
key='id')[Column('id', auto_increment=True),
Column('sid'),
Column('enabled', type='int'),
Column('managed', type='int'),
Column('realm'),
Column('category'),
Column('rule'),
Column('destination'),
Column('format'),
Index(['id']),
Index(['realm', 'category', 'enabled']), ]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany(
"""
INSERT INTO session
(sid,authenticated,last_visit)
VALUES (%s,%s,%s)
""", (('somebody', '0', '0'), ('user', '1', '0')))
cursor.executemany(
"""
INSERT INTO session_attribute
(sid,authenticated,name,value)
VALUES (%s,1,%s,%s)
""", (('user', 'announcer_email_format_ticket', 'text/html'),
('user', 'announcer_specified_email', '')))
cursor.executemany(
"""
INSERT INTO subscriptions
(sid,enabled,managed,
realm,category,rule,destination,format)
VALUES (%s,%s,0,%s,%s,%s,%s,%s)
""", (('somebody', 1, 'ticket', 'changed', '1', '1', 'email'),
('user', 1, 'ticket', 'attachment added', '1', '1', 'email')))
self.assertEquals(1, self.an_sys.get_schema_version(self.db))
target = 6
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
self.an_sys.upgrade_environment(self.db)
self._verify_curr_schema()
def test_upgrade_to_schema_v2(self):
# The initial db schema from r3015 - 10-Jan-2008 by Stephen Hansen.
schema = [
Table('subscriptions',
key='id')[Column('id', auto_increment=True),
Column('sid'),
Column('enabled', type='int'),
Column('managed', type='int'),
Column('realm'),
Column('category'),
Column('rule'),
Column('destination'),
Column('format'),
Index(['id']),
Index(['realm', 'category', 'enabled']), ]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany(
"""
INSERT INTO session
(sid,authenticated,last_visit)
VALUES (%s,%s,%s)
""", (('somebody', '0', '0'), ('user', '1', '0')))
cursor.executemany(
"""
INSERT INTO session_attribute
(sid,authenticated,name,value)
VALUES (%s,1,%s,%s)
""", (('user', 'announcer_email_format_ticket', 'text/html'),
('user', 'announcer_specified_email', '')))
cursor.executemany(
"""
INSERT INTO subscriptions
(sid,enabled,managed,
realm,category,rule,destination,format)
VALUES (%s,%s,0,%s,%s,%s,%s,%s)
""", (('somebody', 1, 'ticket', 'changed', '1', '1', 'email'),
('user', 1, 'ticket', 'attachment added', '1', '1', 'email')))
self.assertEquals(1, self.an_sys.get_schema_version(self.db))
target = 2
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# Change from r3047 - 13-Jan-2008 for announcer-0.2 by Stephen Hansen.
# - 'subscriptions.destination', 'subscriptions.format'
# + 'subscriptions.authenticated', 'subscriptions.transport'
# 'subscriptions.managed' type='int' --> (default == char)
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
self._verify_version_unregistered()
cursor = self.db.cursor()
cursor.execute("SELECT * FROM subscriptions")
columns = [col[0] for col in self._get_cursor_description(cursor)]
self.assertEquals([
'id', 'sid', 'authenticated', 'enabled', 'managed', 'realm',
'category', 'rule', 'transport'
], columns)
def test_upgrade_to_schema_v3(self):
# Schema from r3047 - 13-Jan-2008 for announcer-0.2 by Stephen Hansen.
schema = [
Table('subscriptions',
key='id')[Column('id', auto_increment=True),
Column('sid'),
Column('authenticated', type='int'),
Column('enabled', type='int'),
Column('managed'),
Column('realm'),
Column('category'),
Column('rule'),
Column('transport'),
Index(['id']),
Index(['realm', 'category', 'enabled']), ]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany(
"""
INSERT INTO session_attribute
(sid,authenticated,name,value)
VALUES (%s,1,%s,%s)
""", (('user', 'announcer_email_format_ticket', 'text/html'),
('user', 'announcer_email_format_wiki', 'text/plain'),
('user', 'announcer_specified_email', '')))
cursor.executemany(
"""
INSERT INTO subscriptions
(sid,authenticated,enabled,managed,
realm,category,rule,transport)
VALUES (%s,%s,1,%s,%s,%s,%s,%s)
""", (('user', 1, 'watcher', 'ticket', 'changed', '1', 'email'),
('user', 1, 'watcher', 'wiki', '*', 'WikiStart', 'email')))
self.assertEquals(2, self.an_sys.get_schema_version(self.db))
target = 3
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# From r9116 - 25-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
# + table 'subscription', 'subscription_attribute'
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
def test_upgrade_to_schema_v4(self):
# Schema from r9116 - 25-Sep-2010 for announcer-0.12.1 by R. Corsaro.
schema = [
Table('subscriptions',
key='id')[Column('id', auto_increment=True),
Column('sid'),
Column('authenticated', type='int'),
Column('enabled', type='int'),
Column('managed'),
Column('realm'),
Column('category'),
Column('rule'),
Column('transport'),
Index(['id']),
Index(['realm', 'category', 'enabled']), ],
Table('subscription',
key='id')[Column('id', auto_increment=True),
Column('time', type='int64'),
Column('changetime', type='int64'),
Column('class'),
Column('sid'),
Column('authenticated', type='int'),
Column('distributor'),
Column('format'),
Column('priority'),
Column('adverb')],
Table('subscription_attribute',
key='id')[Column('id', auto_increment=True),
Column('sid'),
Column('class'),
Column('name'),
Column('value')]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.execute("""
INSERT INTO subscription
(time,changetime,class,sid,authenticated,
distributor,format,priority,adverb)
VALUES ('0','0','GeneralWikiSubscriber','user','1',
'email','text/plain','1','always')
""")
cursor.executemany(
"""
INSERT INTO subscription_attribute
(sid,class,name,value)
VALUES (%s,%s,%s,%s)
""", (('somebody', 'GeneralWikiSubscriber', 'wiki', '*'),
('somebody', 'UserChangeSubscriber', 'wiki', 'created'),
('user', 'GeneralWikiSubscriber', 'wiki', 'TracWiki')))
self.assertEquals(3, self.an_sys.get_schema_version(self.db))
target = 4
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# From r9210 - 29-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
# - table 'subscriptions'
# 'subscription.priority' type=(default == char) --> 'int'
# 'subscription_attribute.name --> 'subscription_attribute.realm'
# 'subscription_attribute.value --> 'subscription_attribute.target'
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
# Check type of priority value.
cursor = self.db.cursor()
cursor.execute("SELECT priority FROM subscription")
for priority in cursor:
# Shouldn't raise an TypeError with appropriate column type.
result = priority[0] + 0
def test_upgrade_to_schema_v5(self):
# Schema from r9210 - 29-Sep-2010 for announcer-0.12.1 by R. Corsaro.
schema = [
Table('subscription',
key='id')[Column('id', auto_increment=True),
Column('time', type='int64'),
Column('changetime', type='int64'),
Column('class'),
Column('sid'),
Column('authenticated', type='int'),
Column('distributor'),
Column('format'),
Column('priority', type='int'),
Column('adverb')],
Table('subscription_attribute',
key='id')[Column('id', auto_increment=True),
Column('sid'),
Column('class'),
Column('realm'),
Column('target')]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany(
"""
INSERT INTO session
(sid,authenticated,last_visit)
VALUES (%s,%s,%s)
""", (('somebody', '0', '0'), ('user', '1', '0')))
cursor.executemany(
"""
INSERT INTO subscription_attribute
(sid,class,realm,target)
VALUES (%s,%s,%s,%s)
""", (('somebody', 'GeneralWikiSubscriber', 'wiki', '*'),
('somebody', 'UserChangeSubscriber', 'wiki', 'created'),
('user', 'GeneralWikiSubscriber', 'wiki', 'TracWiki')))
self.assertEquals(4, self.an_sys.get_schema_version(self.db))
target = 5
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# From r9235 - 01-Oct-2010 for announcer-0.12.1 by Robert Corsaro.
# + 'subscription_attribute.authenticated'
self.an_sys.upgrade_environment(self.db)
self.assertEquals(target, self.an_sys.get_schema_version(self.db))
self._verify_version_unregistered()
cursor = self.db.cursor()
cursor.execute("SELECT * FROM subscription_attribute")
columns = [col[0] for col in self._get_cursor_description(cursor)]
self.assertTrue('name' not in columns)
self.assertTrue('value' not in columns)
self.assertEquals(
['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
columns)
# Check authenticated attribute for session IDs.
subscriptions = [(row[1], (row[2])) for row in cursor]
for sub in subscriptions:
self.assertTrue((sub[0] == 'user' and sub[1] == 1) or sub[1] == 0)
def test_upgrade_to_schema_v6(self):
# Check data migration and registration of unversioned schema.
# Table definitions are identical to current schema here, see
# schema from r9235 - 01-Oct-2010 for announcer-0.12.1 by R. Corsaro.
self._schema_init(db_default.schema)
# Populate table with test data.
cursor = self.db.cursor()
if self.env.config.get('trac', 'database').startswith('sqlite'):
# Add dataset with CURRENT_TIMESTAMP strings.
cursor.execute("""
INSERT INTO subscription
(time,changetime,
class,sid,authenticated,
distributor,format,priority,adverb)
VALUES ('1970-01-01 00:00:00','2012-10-31 23:59:59',
'GeneralWikiSubscriber','user','1',
'email','text/plain','1','always')
""")
else:
cursor.execute("""
INSERT INTO subscription
(time,changetime,
class,sid,authenticated,
distributor,format,priority,adverb)
VALUES ('0','1351724399',
'GeneralWikiSubscriber','user','1',
'email','text/plain','1','always')
""")
cursor.execute("""
INSERT INTO subscription_attribute
(sid,authenticated,class,realm,target)
VALUES ('user','1','GeneralWikiSubscriber','wiki', 'TracWiki')
""")
self.assertEquals(5, self.an_sys.get_schema_version(self.db))
target = 6
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade(self.db))
# Data migration and registration of unversioned schema.
self.an_sys.upgrade_environment(self.db)
self._verify_curr_schema()
cursor.execute("SELECT time,changetime FROM subscription")
for time in cursor:
# Shouldn't raise an TypeError with proper int/long values.
check = time[1] - time[0]
def _call_db5_upgrade(self):
dbm = DatabaseManager(self.env)
db_connector, _ = dbm._get_connector()
db = self.env.get_db_cnx()
self.assert_true(do_upgrade(self.env, 5, db.cursor(), db_connector))
db.commit()
def _call_db5_upgrade(self):
dbm = DatabaseManager(self.env)
db_connector, _ = dbm._get_connector()
db = self.env.get_db_cnx()
self.assert_true(do_upgrade(self.env, 5, db.cursor(), db_connector))
db.commit()
class EnvironmentSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.db = self.env.get_db_cnx()
self.votes = VoteSystem(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _schema_init(self, schema=None):
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS votes")
if schema:
connector = self.db_mgr._get_connector()[0]
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def _verify_curr_schema(self):
self.assertFalse(self.votes.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute('SELECT * FROM votes')
cols = get_column_names(cursor)
self.assertTrue('resource' not in cols)
self.assertEquals([
'realm', 'resource_id', 'version', 'username', 'vote', 'time',
'changetime'
], cols)
cursor.execute("""
SELECT value
FROM system
WHERE name='vote_version'
""")
schema_ver = int(cursor.fetchone()[0])
self.assertEquals(self.votes.schema_version, schema_ver)
def _verify_schema_unregistered(self):
cursor = self.db.cursor()
cursor.execute("""
SELECT value
FROM system
WHERE name='vote_version'
""")
self.assertFalse(cursor.fetchone())
# Tests
def test_new_install(self):
# Current tracvotes schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._schema_init()
self.assertEquals(0, self.votes.get_schema_version(self.db))
self.assertTrue(self.votes.environment_needs_upgrade(self.db))
self.votes.upgrade_environment(self.db)
self._verify_curr_schema()
def test_upgrade_v1_to_current(self):
# The initial db schema from r2963 - 02-Jan-2008 by Alec Thomas.
schema = [
Table('votes', key=('resource', 'username',
'vote'))[Column('resource'),
Column('username'),
Column('vote', 'int'), ]
]
self._schema_init(schema)
# Populate tables with test data.
cursor = self.db.cursor()
cursor.executemany(
"""
INSERT INTO votes
(resource,username,vote)
VALUES (%s,%s,%s)
""", (('ticket/1', 'user', -1), ('ticket/2', 'user', 1),
('wiki/DeletedPage', 'user', -1),
('wiki/ExistingPage', 'user', 1)))
# Resources must exist for successful data migration.
t = Ticket(self.env, db=self.db)
t['summary'] = 'test ticket'
t.insert()
w = WikiPage(self.env, 'ExistingPage')
w.text = 'content'
w.save('author', 'comment', '::1')
self._verify_schema_unregistered()
self.assertEquals(1, self.votes.get_schema_version(self.db))
self.assertTrue(self.votes.environment_needs_upgrade(self.db))
# Data migration and registration of unversioned schema.
self.votes.upgrade_environment(self.db)
self._verify_curr_schema()
cursor.execute('SELECT * FROM votes')
votes = cursor.fetchall()
t_votes = [
id for realm, id, ver, u, v, t, c in votes if realm == 'ticket'
]
w_votes = [
id for realm, id, ver, u, v, t, c in votes if realm == 'wiki'
]
self.assertTrue('1' in t_votes)
if resource_check:
self.assertFalse('2' in t_votes)
self.assertFalse('DeletedPage' in w_votes)
self.assertTrue('ExistingPage' in w_votes)
class TagSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=["trac.*"])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.db = self.env.get_db_cnx()
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _get_cursor_description(self, cursor):
# Cursors don't look the same across Trac versions
if trac_version < "0.12":
return cursor.description
else:
return cursor.cursor.description
def _revert_tractags_schema_init(self):
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS tags")
cursor.execute("DELETE FROM system WHERE name='tags_version'")
cursor.execute("DELETE FROM permission WHERE action %s" % self.db.like(), ("TAGS_%",))
# Tests
def test_new_install(self):
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
self.assertEquals(0, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
self.assertEquals([], tags)
self.assertEquals(["tagspace", "name", "tag"], [col[0] for col in self._get_cursor_description(cursor)])
cursor.execute(
"""
SELECT value
FROM system
WHERE name='tags_version'
"""
)
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def test_upgrade_schema_v1(self):
# Ancient, unversioned schema - wiki only.
schema = [Table("wiki_namespace")[Column("name"), Column("namespace"), Index(["name", "namespace"])]]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
cursor = self.db.cursor()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Populate table with migration test data.
cursor.execute(
"""
INSERT INTO wiki_namespace
(name, namespace)
VALUES ('WikiStart', 'tag')
"""
)
cursor = self.db.cursor()
cursor.execute("SELECT * FROM wiki_namespace")
tags = cursor.fetchall()
self.assertEquals([("WikiStart", "tag")], tags)
self.assertEquals(1, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
# Db content should be migrated.
self.assertEquals([("wiki", "WikiStart", "tag")], tags)
self.assertEquals(["tagspace", "name", "tag"], [col[0] for col in self._get_cursor_description(cursor)])
cursor.execute(
"""
SELECT value
FROM system
WHERE name='tags_version'
"""
)
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
def test_upgrade_schema_v2(self):
# Just register a current, but unversioned schema.
schema = [
Table("tags", key=("tagspace", "name", "tag"))[
Column("tagspace"),
Column("name"),
Column("tag"),
Index(["tagspace", "name"]),
Index(["tagspace", "tag"]),
]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
cursor = self.db.cursor()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Populate table with test data.
cursor.execute(
"""
INSERT INTO tags
(tagspace, name, tag)
VALUES ('wiki', 'WikiStart', 'tag')
"""
)
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
self.assertEquals([("wiki", "WikiStart", "tag")], tags)
self.assertEquals(2, setup.get_schema_version(self.db))
self.assertTrue(setup.environment_needs_upgrade(self.db))
setup.upgrade_environment(self.db)
self.assertFalse(setup.environment_needs_upgrade(self.db))
cursor = self.db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
# Db should be unchanged.
self.assertEquals([("wiki", "WikiStart", "tag")], tags)
self.assertEquals(["tagspace", "name", "tag"], [col[0] for col in self._get_cursor_description(cursor)])
cursor.execute(
"""
SELECT value
FROM system
WHERE name='tags_version'
"""
)
version = int(cursor.fetchone()[0])
self.assertEquals(db_default.schema_version, version)
class TagSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
def tearDown(self):
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _get_cursor_description(self, cursor):
# Cursors don't look the same across Trac versions
if trac_version < '0.12':
return cursor.description
else:
return cursor.cursor.description
def _revert_tractags_schema_init(self):
with self.env.db_transaction as db:
db("DROP TABLE IF EXISTS tags")
db("DROP TABLE IF EXISTS tags_change")
db("DELETE FROM system WHERE name='tags_version'")
db("DELETE FROM permission WHERE action %s" % db.like(),
('TAGS_%',))
def get_db_version(self):
for version, in self.env.db_query("""
SELECT value FROM system
WHERE name='tags_version'
"""):
return int(version)
# Tests
def test_new_install(self):
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
self.assertEquals(0, setup.get_schema_version())
self.assertTrue(setup.environment_needs_upgrade())
setup.upgrade_environment()
self.assertFalse(setup.environment_needs_upgrade())
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM tags")
cols = [col[0] for col in self._get_cursor_description(cursor)]
self.assertEquals([], cursor.fetchall())
self.assertEquals(['tagspace', 'name', 'tag'], cols)
self.assertEquals(db_default.schema_version, self.get_db_version())
def test_upgrade_schema_v1(self):
# Ancient, unversioned schema - wiki only.
schema = [
Table('wiki_namespace')[
Column('name'),
Column('namespace'),
Index(['name', 'namespace']),
]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
with self.env.db_transaction as db:
for table in schema:
for stmt in connector.to_sql(table):
db(stmt)
# Populate table with migration test data.
db("""INSERT INTO wiki_namespace (name, namespace)
VALUES ('WikiStart', 'tag')""")
tags = self.env.db_query("SELECT * FROM wiki_namespace")
self.assertEquals([('WikiStart', 'tag')], tags)
self.assertEquals(1, setup.get_schema_version())
self.assertTrue(setup.environment_needs_upgrade())
setup.upgrade_environment()
self.assertFalse(setup.environment_needs_upgrade())
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
cols = [col[0] for col in self._get_cursor_description(cursor)]
# Db content should be migrated.
self.assertEquals([('wiki', 'WikiStart', 'tag')], tags)
self.assertEquals(['tagspace', 'name', 'tag'], cols)
self.assertEquals(db_default.schema_version, self.get_db_version())
def test_upgrade_schema_v2(self):
# Just register a current, but unversioned schema.
schema = [
Table('tags', key=('tagspace', 'name', 'tag'))[
Column('tagspace'),
Column('name'),
Column('tag'),
Index(['tagspace', 'name']),
Index(['tagspace', 'tag']),
]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
with self.env.db_transaction as db:
for table in schema:
for stmt in connector.to_sql(table):
db(stmt)
# Populate table with test data.
db("""INSERT INTO tags (tagspace, name, tag)
VALUES ('wiki', 'WikiStart', 'tag')""")
tags = self.env.db_query("SELECT * FROM tags")
self.assertEquals([('wiki', 'WikiStart', 'tag')], tags)
self.assertEquals(2, setup.get_schema_version())
self.assertTrue(setup.environment_needs_upgrade())
setup.upgrade_environment()
self.assertFalse(setup.environment_needs_upgrade())
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM tags")
tags = cursor.fetchall()
cols = [col[0] for col in self._get_cursor_description(cursor)]
# Db should be unchanged.
self.assertEquals([('wiki', 'WikiStart', 'tag')], tags)
self.assertEquals(['tagspace', 'name', 'tag'], cols)
self.assertEquals(db_default.schema_version, self.get_db_version())
def test_upgrade_schema_v3(self):
# Add table for tag change records to the schema.
schema = [
Table('tags', key=('tagspace', 'name', 'tag'))[
Column('tagspace'),
Column('name'),
Column('tag'),
Index(['tagspace', 'name']),
Index(['tagspace', 'tag']),
]
]
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
self._revert_tractags_schema_init()
connector = self.db_mgr._get_connector()[0]
with self.env.db_transaction as db:
for table in schema:
for stmt in connector.to_sql(table):
db(stmt)
# Preset system db table with old version.
db("""INSERT INTO system (name, value)
VALUES ('tags_version', '3')""")
self.assertEquals(3, setup.get_schema_version())
self.assertTrue(setup.environment_needs_upgrade())
setup.upgrade_environment()
self.assertFalse(setup.environment_needs_upgrade())
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM tags_change")
cols = [col[0] for col in self._get_cursor_description(cursor)]
self.assertEquals(['tagspace', 'name', 'time', 'author',
'oldtags', 'newtags'], cols)
self.assertEquals(db_default.schema_version, self.get_db_version())
