def ticket_changed(self, ticket, comment, author, old_values):
if old_values.keys() == ['cc'] and not comment and \
self.ignore_cc_changes:
return
announcer = AnnouncementSystem(ticket.env)
announcer.send(TicketChangeEvent('ticket', 'changed', ticket,
comment, author, old_values))
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
# Setup current announcer db schema tables.
self.an_sys = AnnouncementSystem(self.env)
self.an_sys.upgrade_environment()
def ticket_created(self, ticket):
announcer = AnnouncementSystem(ticket.env)
announcer.send(
TicketChangeEvent("ticket", "created", ticket,
author=ticket['reporter']
)
)
def ticket_changed(self, ticket, comment, author, old_values):
if old_values.keys() == ['cc'] and not comment and \
self.ignore_cc_changes:
return
announcer = AnnouncementSystem(ticket.env)
announcer.send(
TicketChangeEvent('ticket', 'changed', ticket, comment, author,
old_values))
def wiki_page_added(self, page):
history = list(page.get_history())[0]
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent("wiki", "created", page,
author=history[2], version=history[0]
)
)
def wiki_page_changed(self, page, version, t, comment, author, ipnr):
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent("wiki", "changed", page,
comment=comment, author=author, version=version,
timestamp=t, remote_addr=ipnr
)
)
def blog_comment_added(self, postname, number):
"""Called when Blog comment number N on post 'postname' is added."""
blog_post = BlogPost(self.env, postname, 0)
blog_comment = BlogComment(self.env, postname, number)
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(blog_post, 'comment created',
self.env.abs_href.blog(blog_post.name),
blog_comment))
def _notify(self, category, username, password=None, token=None):
try:
announcer = AnnouncementSystem(self.env)
announcer.send(
AccountChangeEvent(category, username, password, token)
)
except Exception, e:
self.log.exception("Failure creating announcement for account "
"event %s: %s", username, category)
def _notify(self, build, category):
self.log.info("BittenAnnouncedEventProducer invoked for build %r", build)
self.log.debug("build status: %s", build.status)
self.log.info("Creating announcement for build %r", build)
try:
announcer = AnnouncementSystem(self.env)
announcer.send(BittenAnnouncedEvent(build, category))
except Exception, e:
self.log.exception("Failure creating announcement for build " "%s: %s", build.id, e)
def _notify(self, category, username, password=None, token=None):
announcer = AnnouncementSystem(self.env)
try:
announcer.send(
AccountChangeEvent(category, username, password, token))
except Exception:
self.log.exception(
"Failure creating announcement for account "
"event %s: %s", username, category)
def _notify(self, build, category):
self.log.info('BittenAnnouncedEventProducer invoked for build %r', build)
self.log.debug('build status: %s', build.status)
self.log.info('Creating announcement for build %r', build)
try:
announcer = AnnouncementSystem(self.env)
announcer.send(BittenAnnouncedEvent(build, category))
except Exception, e:
self.log.exception("Failure creating announcement for build "
"%s: %s", build.id, e)
def wiki_page_changed(self, page, version, t, comment, author):
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent('wiki',
'changed',
page,
comment=comment,
author=author,
version=version,
timestamp=t))
class SubscriptionTestSetup(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
# Setup current announcer db schema tables.
self.an_sys = AnnouncementSystem(self.env)
self.an_sys.upgrade_environment()
def tearDown(self):
self.env.shutdown()
shutil.rmtree(self.env.path)
def blog_comment_added(self, postname, number):
"""Called when Blog comment number N on post 'postname' is added."""
blog_post = BlogPost(self.env, postname, 0)
blog_comment = BlogComment(self.env, postname, number)
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(
blog_post,
'comment created',
self.env.abs_href.blog(blog_post.name),
blog_comment
)
)
def blog_post_changed(self, postname, version):
"""Called when a new blog post 'postname' with 'version' is added.
version==1 denotes a new post, version>1 is a new version on existing
post.
"""
blog_post = BlogPost(self.env, postname, version)
action = 'post created'
if version > 1:
action = 'post changed'
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(blog_post, action,
self.env.abs_href.blog(blog_post.name)))
def blog_comment_deleted(self, postname, number, fields):
"""Called when blog post comment 'number' is deleted.
number==0 denotes all comments is deleted and fields will be empty.
(usually follows a delete of the blog post).
number>0 denotes a specific comment is deleted, and fields will contain
the values of the fields as they existed pre-delete.
"""
blog_post = BlogPost(self.env, postname, 0)
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(blog_post, 'comment deleted',
self.env.abs_href.blog(blog_post.name), fields))
def blog_post_deleted(self, postname, version, fields):
"""Called when a blog post is deleted:
version==0 means all versions (or last remaining) version is deleted.
Any version>0 denotes a specific version only.
Fields is a dict with the pre-existing values of the blog post.
If all (or last) the dict will contain the 'current' version
contents.
"""
blog_post = BlogPost(self.env, postname, version)
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(blog_post, 'post deleted',
self.env.abs_href.blog(blog_post.name)))
class SubscriptionTestSetup(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()
# Setup current announcer db schema tables.
self.an_sys = AnnouncementSystem(self.env)
self.an_sys.upgrade_environment(self.db)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
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()
# Setup current announcer db schema tables.
self.an_sys = AnnouncementSystem(self.env)
self.an_sys.upgrade_environment(self.db)
def blog_post_changed(self, postname, version):
"""Called when a new blog post 'postname' with 'version' is added.
version==1 denotes a new post, version>1 is a new version on existing
post.
"""
blog_post = BlogPost(self.env, postname, version)
action = 'post created'
if version > 1:
action = 'post changed'
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(
blog_post,
action,
self.env.abs_href.blog(blog_post.name)
)
)
def blog_post_deleted(self, postname, version, fields):
"""Called when a blog post is deleted:
version==0 means all versions (or last remaining) version is deleted.
Any version>0 denotes a specific version only.
Fields is a dict with the pre-existing values of the blog post.
If all (or last) the dict will contain the 'current' version
contents.
"""
blog_post = BlogPost(self.env, postname, version)
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(
blog_post,
'post deleted',
self.env.abs_href.blog(blog_post.name)
)
)
def blog_comment_deleted(self, postname, number, fields):
"""Called when blog post comment 'number' is deleted.
number==0 denotes all comments is deleted and fields will be empty.
(usually follows a delete of the blog post).
number>0 denotes a specific comment is deleted, and fields will contain
the values of the fields as they existed pre-delete.
"""
blog_post = BlogPost(self.env, postname, 0)
announcer = AnnouncementSystem(self.env)
announcer.send(
BlogChangeEvent(
blog_post,
'comment deleted',
self.env.abs_href.blog(blog_post.name),
fields
)
)
def __init__(self):
try:
schema_ver = AnnouncementSystem(self.env).get_schema_version()
if schema_ver > 2:
# Support only current db schema versions.
# For older ones at least information stored in
# 'session_attribute' is already handled by the
# respective user ID changer component for Trac core.
self.enabled = True
except AttributeError:
# Some older plugin version found.
pass
def verify(self, repository_id, path, revision=None, start=None):
"""Run svnadmin verify against a repository.
Pass revision as None or -1 to check all revisions.
"""
if revision < 0:
revision = None
self.log.info("Verifying %s at %s", repository_id, path)
if revision is not None:
cmdline = ["svnadmin","verify","-r",str(int(revision)),path]
level = "revision"
elif start is not None:
cmdline = ["svnadmin","verify", "-r","%d:HEAD" % start,path]
level = "partial"
else:
cmdline = ["svnadmin","verify",path]
level = "full"
self.log.debug(cmdline)
child = Popen(cmdline, bufsize=-1, stdin=PIPE, stdout=PIPE,
stderr=PIPE)
(out, err) = child.communicate()
self.log.debug(out)
if child.returncode == 0:
self.log.debug(err)
else:
self.log.warning("Failed svnadmin of %s", path)
self.log.warning(err)
@self.env.with_transaction()
def do_insert(db):
cursor = db.cursor()
cursor.execute("INSERT INTO svnverify_log (repository_id, type, result, log, time) VALUES (%s,%s,%s,%s,%s)",
(repository_id, level, child.returncode, err, to_utimestamp(datetime.now(utc))))
if child.returncode == 0:
return True
else:
announcer = AnnouncementSystem(self.env)
announcer.send(SVNVerifyFailEvent("integrity", "verifyfail", path,
log=err))
return False
def attachment_added(self, attachment):
parent = attachment.resource.parent
if parent.realm == "ticket":
ticket = Ticket(self.env, parent.id)
announcer = AnnouncementSystem(ticket.env)
announcer.send(
TicketChangeEvent("ticket", "attachment added", ticket,
attachment=attachment, author=attachment.author,
)
)
elif parent.realm == "wiki":
page = WikiPage(self.env, parent.id)
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent("wiki", "attachment added", page,
attachment=attachment, author=attachment.author,
)
)
def attachment_added(self, attachment):
parent = attachment.resource.parent
if parent.realm == 'ticket':
ticket = Ticket(self.env, parent.id)
announcer = AnnouncementSystem(ticket.env)
announcer.send(
TicketChangeEvent('ticket',
'attachment added',
ticket,
attachment=attachment,
author=attachment.author))
elif parent.realm == 'wiki':
page = WikiPage(self.env, parent.id)
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent('wiki',
'attachment added',
page,
attachment=attachment,
author=attachment.author))
def attachment_added(self, attachment):
parent = attachment.resource.parent
if parent.realm == 'ticket':
ticket = Ticket(self.env, parent.id)
announcer = AnnouncementSystem(ticket.env)
announcer.send(
TicketChangeEvent('ticket', 'attachment added', ticket,
attachment=attachment,
author=attachment.author))
elif parent.realm == 'wiki':
page = WikiPage(self.env, parent.id)
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent('wiki', 'attachment added', page,
attachment=attachment,
author=attachment.author))
def wiki_page_version_deleted(self, page):
announcer = AnnouncementSystem(page.env)
announcer.send(
WikiChangeEvent("wiki", "version deleted", page)
)
def mailinglistmessage_created(self, message):
"""Called when a mailinglistmessage is created."""
announcer = AnnouncementSystem(self.env)
announcer.send(MailinglistMessageEvent('mailinglist', 'created', message))
def wiki_page_changed(self, page, version, t, comment, author):
announcer = AnnouncementSystem(page.env)
announcer.send(WikiChangeEvent('wiki', 'changed', page,
comment=comment, author=author,
version=version, timestamp=t))
def wiki_page_deleted(self, page):
announcer = AnnouncementSystem(page.env)
announcer.send(WikiChangeEvent('wiki', 'deleted', page))
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.an_sys = AnnouncementSystem(self.env)
class AnnouncementSystemSetupTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*'])
self.env.path = tempfile.mkdtemp()
self.db_mgr = DatabaseManager(self.env)
self.an_sys = AnnouncementSystem(self.env)
def tearDown(self):
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _schema_init(self, schema=None):
# Current announcer schema is setup with enabled component anyway.
# Revert these changes for clean install testing.
with self.env.db_transaction as db:
db("DROP TABLE IF EXISTS subscriptions")
db("DROP TABLE IF EXISTS subscription")
db("DROP TABLE IF EXISTS subscription_attribute")
db("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):
db(stmt)
def _verify_curr_schema(self):
self.assertFalse(self.an_sys.environment_needs_upgrade())
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM subscription_attribute")
columns = [col[0] for col in cursor.cursor.description]
self.assertTrue('name' not in columns)
self.assertTrue('value' not in columns)
self.assertEquals(
['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
columns
)
with self.env.db_query as db:
cursor = db.cursor()
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):
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("""
SELECT value
FROM system
WHERE name='announcer_version'
""")
self.assertFalse(cursor.fetchone())
def test_new_install(self):
# Just do db table clean-up.
self._schema_init()
self.assertEquals(0, self.an_sys.get_schema_version())
self.assertTrue(self.an_sys.environment_needs_upgrade())
self.an_sys.upgrade_environment()
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.
with self.env.db_transaction as db:
cursor = 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())
target = 6
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade())
self.an_sys.upgrade_environment()
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.
with self.env.db_transaction as db:
cursor = 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())
target = 2
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade())
# 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.assertEquals(target, self.an_sys.get_schema_version())
self._verify_version_unregistered()
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM subscriptions")
columns = [col[0] for col in cursor.cursor.description]
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.
with self.env.db_transaction as db:
cursor = 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())
target = 3
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade())
# From r9116 - 25-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
# + table 'subscription', 'subscription_attribute'
self.an_sys.upgrade_environment()
self.assertEquals(target, self.an_sys.get_schema_version())
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.
with self.env.db_transaction as db:
cursor = 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())
target = 4
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade())
# 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.assertEquals(target, self.an_sys.get_schema_version())
# Check type of priority value.
with self.env.db_query as db:
cursor = 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.
with self.env.db_transaction as db:
cursor = 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())
target = 5
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade())
# From r9235 - 01-Oct-2010 for announcer-0.12.1 by Robert Corsaro.
# + 'subscription_attribute.authenticated'
self.an_sys.upgrade_environment()
self.assertEquals(target, self.an_sys.get_schema_version())
self._verify_version_unregistered()
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT * FROM subscription_attribute")
columns = [col[0] for col in cursor.cursor.description]
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.
with self.env.db_transaction as db:
cursor = 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())
target = 6
db_default.schema_version = target
self.assertTrue(self.an_sys.environment_needs_upgrade())
# Data migration and registration of unversioned schema.
self.an_sys.upgrade_environment()
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 setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'announcer.*'])
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 wiki_page_deleted(self, page):
announcer = AnnouncementSystem(page.env)
announcer.send(WikiChangeEvent('wiki', 'deleted', page))
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]
