class TracHoursByCommentTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'trachours.*'])
self.env.path = tempfile.mkdtemp()
setup = SetupTracHours(self.env)
setup.upgrade_environment(db=self.env.get_db_cnx())
self.hours_thp = TracHoursPlugin(self.env)
self.hours_thbc = TracHoursByComment(self.env)
self.ticket_system = TicketSystem(self.env)
def tearDown(self):
self.env.reset_db()
revert_trachours_schema_init(db=self.env.get_db_cnx())
shutil.rmtree(self.env.path)
def test_ticket_delete(self):
ticket = Ticket(self.env)
ticket['summary'] = 'ticket summary'
ticket.insert()
self.hours_thp.add_ticket_hours(ticket.id, 'user', 160)
self.hours_thp.add_ticket_hours(ticket.id, 'user', 1200)
ticket.delete()
hours = self.hours_thp.get_ticket_hours(ticket.id)
self.assertEqual([], hours)
class StringsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
def test_insert_unicode(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('test-unicode', u'ünicöde'))
db.commit()
cursor = db.cursor()
cursor.execute("SELECT value FROM system WHERE name='test-unicode'")
self.assertEqual([(u'ünicöde', )], cursor.fetchall())
def test_insert_empty(self):
from trac.util.text import empty
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('test-empty', empty))
db.commit()
cursor = db.cursor()
cursor.execute("SELECT value FROM system WHERE name='test-empty'")
self.assertEqual([(u'', )], cursor.fetchall())
def test_insert_markup(self):
from genshi.core import Markup
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('test-markup', Markup(u'<em>märkup</em>')))
db.commit()
cursor = db.cursor()
cursor.execute("SELECT value FROM system WHERE name='test-markup'")
self.assertEqual([(u'<em>märkup</em>', )], cursor.fetchall())
class TargetPlatformTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.env.path = tempfile.mkdtemp()
logs_dir = self.env.config.get("bitten", "logs_dir")
if os.path.isabs(logs_dir):
raise ValueError("Should not have absolute logs directory for temporary test")
logs_dir = os.path.join(self.env.path, logs_dir)
os.makedirs(logs_dir)
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in TargetPlatform._schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
db.commit()
def test_new(self):
platform = TargetPlatform(self.env)
self.assertEqual(False, platform.exists)
self.assertEqual([], platform.rules)
def test_insert(self):
platform = TargetPlatform(self.env, config='test', name='Windows XP')
platform.rules += [(Build.OS_NAME, 'Windows'), (Build.OS_VERSION, 'XP')]
platform.insert()
assert platform.exists
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("SELECT config,name FROM bitten_platform "
"WHERE id=%s", (platform.id,))
self.assertEqual(('test', 'Windows XP'), cursor.fetchone())
cursor.execute("SELECT propname,pattern,orderno FROM bitten_rule "
"WHERE id=%s", (platform.id,))
self.assertEqual((Build.OS_NAME, 'Windows', 0), cursor.fetchone())
self.assertEqual((Build.OS_VERSION, 'XP', 1), cursor.fetchone())
def test_fetch(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("INSERT INTO bitten_platform (config,name) "
"VALUES (%s,%s)", ('test', 'Windows'))
id = db.get_last_id(cursor, 'bitten_platform')
platform = TargetPlatform.fetch(self.env, id)
assert platform.exists
self.assertEqual('test', platform.config)
self.assertEqual('Windows', platform.name)
def test_select(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO bitten_platform (config,name) "
"VALUES (%s,%s)", [('test', 'Windows'),
('test', 'Mac OS X')])
platforms = list(TargetPlatform.select(self.env, config='test'))
self.assertEqual(2, len(platforms))
class _BaseTestCase(unittest.TestCase):
def setUp(self):
#self.basedir = os.path.realpath(tempfile.mkdtemp())
self.env = EnvironmentStub(enable=['trac.*', 'acct_mgr.*'])
self.env.config.set('account-manager', 'password_store',
'SessionStore')
self.store = SessionStore(self.env)
#self.env.path = os.path.join(self.basedir, 'trac-tempenv')
#os.mkdir(self.env.path)
def test_get_users(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO session_attribute "
"(sid,authenticated,name,value) "
"VALUES (%s,1,'password',%s)",
[('a', 'a'),
('b', 'b'),
('c', 'c')])
self.assertEqual(set(['a', 'b', 'c']), set(self.store.get_users()))
def test_has_user(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("INSERT INTO session_attribute "
"(sid,authenticated,name,value) "
"VALUES (%s,1,'password',%s)",
('bar', 'bar'))
self.assertFalse(self.store.has_user('foo'))
self.assertTrue(self.store.has_user('bar'))
def test_create_user(self):
self.assertFalse(self.store.has_user('foo'))
self.store.set_password('foo', 'password')
self.assertTrue(self.store.has_user('foo'))
def test_update_password(self):
self.store.set_password('foo', 'pass1')
self.assertFalse(self.store.check_password('foo', 'pass2'))
self.store.set_password('foo', 'pass2')
self.assertTrue(self.store.check_password('foo', 'pass2'))
self.store.set_password('foo', 'pass3', 'pass2')
self.assertTrue(self.store.check_password('foo', 'pass3'))
def test_delete_user(self):
self.store.set_password('foo', 'password')
self.assertTrue(self.store.has_user('foo'))
self.assertTrue(self.store.delete_user('foo'))
self.assertFalse(self.store.has_user('foo'))
def test_delete_nonexistant_user(self):
self.assertFalse(self.store.has_user('foo'))
self.assertFalse(self.store.delete_user('foo'))
def test_unicode_username_and_password(self):
username = u'\u4e60'
password = u'\u4e61'
self.store.set_password(username, password)
self.assertTrue(self.store.check_password(username, password))
class PlatformBuildTestCase(unittest.TestCase):
"""Tests that involve Builds, TargetPlatforms and BuildSteps"""
def setUp(self):
self.env = EnvironmentStub()
self.env.path = tempfile.mkdtemp()
logs_dir = self.env.config.get("bitten", "logs_dir")
if os.path.isabs(logs_dir):
raise ValueError("Should not have absolute logs directory for temporary test")
logs_dir = os.path.join(self.env.path, logs_dir)
os.makedirs(logs_dir)
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for schema in [Build._schema, TargetPlatform._schema, BuildStep._schema]:
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
db.commit()
def test_delete_platform_with_pending_builds(self):
"""Check that deleting a platform with pending builds removes those pending builds"""
db = self.env.get_db_cnx()
platform = TargetPlatform(self.env, config='test', name='Linux')
platform.insert()
build = Build(self.env, config='test', platform=platform.id, rev='42', rev_time=12039)
build.insert()
platform.delete()
pending = list(build.select(self.env, config='test', status=Build.PENDING))
self.assertEqual(0, len(pending))
class GetTestPlans(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
QaSetup(self.env).upgrade_environment(self.env.get_db_cnx())
cnx = self.env.get_db_cnx()
cursor = cnx.cursor()
sql = "INSERT INTO qa_testsuite(title, description) VALUES (%s, %s)"
cursor.execute(sql, ['tata', 'tete'])
cnx.commit()
def tearDown(self):
self.env.destroy_db()
del self.env
#def test_find_testplans(self):
# dummy = TestPlan( { 'title' : 'toto title', 'description' : 'toto descr'})
# dummy.title = 'test title'
# dummy.description = 'test description'
# dummy.save(self.env)
# self.assertEquals(dummy.tpid, 0)
@unittest.skip("demonstrating skipping")
def test_get_testsuites(self):
res = TestSuite.find(self.env, fields=['title', 'description'])
self.assertEquals(len(res), 1)
def test_invalid_testcase_shows_error(self):
tc = TestCase()
tc.description = 'test'
errors = tc.is_valid()
self.assertEquals(len(errors), 1)
class _BaseTestCase(unittest.TestCase):
def setUp(self):
#self.basedir = os.path.realpath(tempfile.mkdtemp())
self.env = EnvironmentStub(enable=['trac.*', 'acct_mgr.*'])
self.env.config.set('account-manager', 'password_store',
'SessionStore')
self.store = SessionStore(self.env)
#self.env.path = os.path.join(self.basedir, 'trac-tempenv')
#os.mkdir(self.env.path)
def test_get_users(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany(
"INSERT INTO session_attribute "
"(sid,authenticated,name,value) "
"VALUES (%s,1,'password',%s)", [('a', 'a'), ('b', 'b'),
('c', 'c')])
self.assertEqual(set(['a', 'b', 'c']), set(self.store.get_users()))
def test_has_user(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
"INSERT INTO session_attribute "
"(sid,authenticated,name,value) "
"VALUES (%s,1,'password',%s)", ('bar', 'bar'))
self.assertFalse(self.store.has_user('foo'))
self.assertTrue(self.store.has_user('bar'))
def test_create_user(self):
self.assertFalse(self.store.has_user('foo'))
self.store.set_password('foo', 'password')
self.assertTrue(self.store.has_user('foo'))
def test_update_password(self):
self.store.set_password('foo', 'pass1')
self.assertFalse(self.store.check_password('foo', 'pass2'))
self.store.set_password('foo', 'pass2')
self.assertTrue(self.store.check_password('foo', 'pass2'))
self.store.set_password('foo', 'pass3', 'pass2')
self.assertTrue(self.store.check_password('foo', 'pass3'))
def test_delete_user(self):
self.store.set_password('foo', 'password')
self.assertTrue(self.store.has_user('foo'))
self.assertTrue(self.store.delete_user('foo'))
self.assertFalse(self.store.has_user('foo'))
def test_delete_nonexistant_user(self):
self.assertFalse(self.store.has_user('foo'))
self.assertFalse(self.store.delete_user('foo'))
def test_unicode_username_and_password(self):
username = u'\u4e60'
password = u'\u4e61'
self.store.set_password(username, password)
self.assertTrue(self.store.check_password(username, password))
class DefaultPermissionStoreTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=[
perm.DefaultPermissionStore, perm.DefaultPermissionGroupProvider
])
self.store = perm.DefaultPermissionStore(self.env)
def test_simple_actions(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)",
[('john', 'WIKI_MODIFY'), ('john', 'REPORT_ADMIN'),
('kate', 'TICKET_CREATE')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN'],
self.store.get_user_permissions('john'))
self.assertEquals(['TICKET_CREATE'],
self.store.get_user_permissions('kate'))
def test_simple_group(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)",
[('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('john', 'dev')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN'],
self.store.get_user_permissions('john'))
def test_nested_groups(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)",
[('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('admin', 'dev'), ('john', 'admin')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN'],
self.store.get_user_permissions('john'))
def test_builtin_groups(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)",
[('authenticated', 'WIKI_MODIFY'),
('authenticated', 'REPORT_ADMIN'),
('anonymous', 'TICKET_CREATE')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN', 'TICKET_CREATE'],
self.store.get_user_permissions('john'))
self.assertEquals(['TICKET_CREATE'],
self.store.get_user_permissions('anonymous'))
def test_get_all_permissions(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)",
[('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('john', 'dev')])
expected = [('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('john', 'dev')]
for res in self.store.get_all_permissions():
self.failIf(res not in expected)
class DefaultPermissionStoreTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=[perm.DefaultPermissionStore,
perm.DefaultPermissionGroupProvider])
self.store = perm.DefaultPermissionStore(self.env)
def test_simple_actions(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)", [
('john', 'WIKI_MODIFY'), ('john', 'REPORT_ADMIN'),
('kate', 'TICKET_CREATE')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN'],
self.store.get_user_permissions('john'))
self.assertEquals(['TICKET_CREATE'], self.store.get_user_permissions('kate'))
def test_simple_group(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)", [
('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('john', 'dev')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN'],
self.store.get_user_permissions('john'))
def test_nested_groups(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)", [
('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('admin', 'dev'), ('john', 'admin')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN'],
self.store.get_user_permissions('john'))
def test_builtin_groups(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)", [
('authenticated', 'WIKI_MODIFY'),
('authenticated', 'REPORT_ADMIN'),
('anonymous', 'TICKET_CREATE')])
self.assertEquals(['WIKI_MODIFY', 'REPORT_ADMIN', 'TICKET_CREATE'],
self.store.get_user_permissions('john'))
self.assertEquals(['TICKET_CREATE'],
self.store.get_user_permissions('anonymous'))
def test_get_all_permissions(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES (%s,%s)", [
('dev', 'WIKI_MODIFY'), ('dev', 'REPORT_ADMIN'),
('john', 'dev')])
expected = [('dev', 'WIKI_MODIFY'),
('dev', 'REPORT_ADMIN'),
('john', 'dev')]
for res in self.store.get_all_permissions():
self.failIf(res not in expected)
class PermTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=[
perm.PermissionSystem, perm.DefaultPermissionStore,
TestPermissionRequestor
])
# Add a few groups
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES(%s,%s)",
[('employee', 'TEST_MODIFY'),
('developer', 'TEST_ADMIN'),
('developer', 'employee'), ('bob', 'developer')])
db.commit()
self.perm = perm.PermissionCache(self.env, 'bob')
def test_has_permission(self):
self.assertEqual(1, self.perm.has_permission('TEST_MODIFY'))
self.assertEqual(1, self.perm.has_permission('TEST_ADMIN'))
self.assertEqual(0, self.perm.has_permission('TRAC_ADMIN'))
def test_assert_permission(self):
self.perm.assert_permission('TEST_MODIFY')
self.perm.assert_permission('TEST_ADMIN')
self.assertRaises(perm.PermissionError, self.perm.assert_permission,
'TRAC_ADMIN')
class ConnectionTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.db = self.env.get_db_cnx()
def tearDown(self):
self.env.reset_db()
def test_get_last_id(self):
c = self.db.cursor()
q = "INSERT INTO report (author) VALUES ('anonymous')"
c.execute(q)
# Row ID correct before...
id1 = self.db.get_last_id(c, 'report')
self.assertNotEqual(0, id1)
self.db.commit()
c.execute(q)
self.db.commit()
# ... and after commit()
id2 = self.db.get_last_id(c, 'report')
self.assertEqual(id1 + 1, id2)
def test_update_sequence(self):
cursor = self.db.cursor()
cursor.execute("""
INSERT INTO report (id, author) VALUES (42, 'anonymous')
""")
self.db.commit()
self.db.update_sequence(cursor, 'report', 'id')
self.db.commit()
cursor.execute("INSERT INTO report (author) VALUES ('next-id')")
self.db.commit()
cursor.execute("SELECT id FROM report WHERE author='next-id'")
self.assertEqual(43, cursor.fetchall()[0][0])
class LogEntryTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
db = self.env.get_db_cnx()
cursor = db.cursor()
for table in schema:
for stmt in _to_sql(table):
cursor.execute(stmt)
def test_purge(self):
now = datetime.now()
oneweekago = time.mktime((now - timedelta(weeks=1)).timetuple())
onedayago = time.mktime((now - timedelta(days=1)).timetuple())
LogEntry(self.env, oneweekago, '/foo', 'john', False, '127.0.0.1',
'', 'Test', False, 5, []).insert()
LogEntry(self.env, onedayago, '/foo', 'anonymous', False, '127.0.0.1',
'', 'Test', True, -3, []).insert()
LogEntry.purge(self.env, days=4)
log = list(LogEntry.select(self.env))
self.assertEqual(1, len(log))
entry = log[0]
self.assertEqual('anonymous', entry.author)
class VersionTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.db = self.env.get_db_cnx()
def tearDown(self):
self.env.reset_db()
def test_exists_negative(self):
def get_fake_version():
return Version(self.env, "-1")
self.assertRaises(TracError, get_fake_version)
def test_exists(self):
"""
http://trac.edgewall.org/ticket/4247
"""
for v in Version.select(self.env):
self.assertEqual(v.exists, True)
def test_create_and_update(self):
version = Version(self.env)
version.name = "Test"
version.insert()
cursor = self.db.cursor()
cursor.execute("SELECT name,time,description FROM version " "WHERE name='Test'")
self.assertEqual(("Test", 0, None), cursor.fetchone())
# Use the same model object to update the version
version.description = "Some text"
version.update()
cursor.execute("SELECT name,time,description FROM version " "WHERE name='Test'")
self.assertEqual(("Test", 0, "Some text"), cursor.fetchone())
class StringsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
def test_insert_unicode(self):
self.env.db_transaction(
"INSERT INTO system (name,value) VALUES (%s,%s)",
('test-unicode', u'ünicöde'))
self.assertEqual([(u'ünicöde',)], self.env.db_query(
"SELECT value FROM system WHERE name='test-unicode'"))
def test_insert_empty(self):
from trac.util.text import empty
self.env.db_transaction(
"INSERT INTO system (name,value) VALUES (%s,%s)",
('test-empty', empty))
self.assertEqual([(u'',)], self.env.db_query(
"SELECT value FROM system WHERE name='test-empty'"))
def test_insert_markup(self):
from genshi.core import Markup
self.env.db_transaction(
"INSERT INTO system (name,value) VALUES (%s,%s)",
('test-markup', Markup(u'<em>märkup</em>')))
self.assertEqual([(u'<em>märkup</em>',)], self.env.db_query(
"SELECT value FROM system WHERE name='test-markup'"))
def test_quote(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('SELECT 1 AS %s' % \
db.quote(r'alpha\`\"\'\\beta``gamma""delta'))
self.assertEqual(r'alpha\`\"\'\\beta``gamma""delta',
get_column_names(cursor)[0])
class GetBlogPostsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
if hasattr(self.env, "db_transaction"):
with self.env.db_transaction as db:
FullBlogSetup(self.env).upgrade_environment(db)
else:
FullBlogSetup(self.env).upgrade_environment(self.env.get_db_cnx())
def tearDown(self):
self.env.destroy_db()
del self.env
def test_get_by_category(self):
bp = BlogPost(self.env, "one")
bp.update_fields({"title": "one", "body": "body", "author": "user", "categories": "about stuff"})
self.assertEquals([], bp.save("user"))
posts = get_blog_posts(self.env)
self.assertEquals(1, len(posts))
self.assertEquals("one", posts[0][0])
posts = get_blog_posts(self.env, category="non-existing")
self.assertEquals(0, len(posts))
posts = get_blog_posts(self.env, category="stuff")
self.assertEquals(1, len(posts))
self.assertEquals("one", posts[0][0])
self.assertEquals(get_blog_posts(self.env, category="about"), get_blog_posts(self.env, category="stuff"))
class ListTaggedMacroTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
setup.upgrade_environment(self.db)
self.tag_twm = TagWikiMacros(self.env)
def tearDown(self):
shutil.rmtree(self.env.path)
def test_empty_content(self):
req = Mock(path_info='/wiki/ListTaggedPage',
args={},
authname='user',
perm=PermissionCache(self.env, 'user'),
href=Href('/'),
abs_href='http://example.org/trac/',
chrome={},
session={},
locale='',
tz='')
context = Mock(env=self.env, href=Href('/'), req=req)
formatter = Mock(context=context, req=req)
self.assertTrue('No resources found' in str(
self.tag_twm.expand_macro(formatter, 'ListTagged', '')))
class GroupPostsByMonthTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
FullBlogSetup(self.env).upgrade_environment(self.env.get_db_cnx())
def tearDown(self):
self.env.destroy_db()
del self.env
def test_many_posts(self):
# 2 posts in one period
one = BlogPost(self.env, 'one')
one.update_fields({'title': 'one', 'body': 'body', 'author': 'user'})
self.assertEquals([], one.save('user'))
two = BlogPost(self.env, 'two')
two.update_fields({'title': 'two', 'body': 'body', 'author': 'user'})
self.assertEquals([], two.save('user'))
grouped = group_posts_by_month(get_blog_posts(self.env))
self.assertEquals(1, len(grouped))
# Add 1 post in another period
three = BlogPost(self.env, 'three')
three.update_fields({'title': 'three', 'body': 'body', 'author': 'user',
'publish_time': three.publish_time - datetime.timedelta(days=-100)})
self.assertEquals([], three.save('user'))
grouped = group_posts_by_month(get_blog_posts(self.env))
self.assertEquals(2, len(grouped))
self.assertEquals(1, len(grouped[0][1]))
self.assertEquals(2, len(grouped[1][1]))
self.assertEquals(type(grouped[0][0]), datetime.datetime)
self.assertEquals((one.name, one.version, one.publish_time, one.author, one.title, one.body, []), grouped[1][1][0])
def test_no_posts(self):
grouped = group_posts_by_month(get_blog_posts(self.env))
self.assertEquals([], grouped)
class AbstractWebUITestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'bitten.*'])
self.env.path = tempfile.mkdtemp()
# Create tables
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Set up permissions
self.env.config.set('trac', 'permission_store',
'DefaultPermissionStore')
# Hook up a dummy repository
self.repos = Mock(
get_node=lambda path, rev=None: Mock(get_history=lambda: [],
isdir=True),
normalize_path=lambda path: path,
sync=lambda: None,
)
self.repos.authz = Mock(has_permission=lambda path: True, assert_permission=lambda path: None)
self.env.get_repository = lambda authname=None: self.repos
def tearDown(self):
shutil.rmtree(self.env.path)
class AnnouncementSystemSendTestCase(unittest.TestCase):
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 tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Tests
def test_filter_added(self):
class DummySubscriptionFilter(Component):
"""Test implementation for checking the filter ExtensionPoint."""
implements(IAnnouncementSubscriptionFilter)
def filter_subscriptions(self, event, subscriptions):
"""Just a pass-through."""
return subscriptions
dummy = DummySubscriptionFilter(self.env)
self.assertTrue(dummy in self.an_sys.subscription_filters)
class ConnectionTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.db = self.env.get_db_cnx()
def tearDown(self):
self.env.reset_db()
def test_get_last_id(self):
c = self.db.cursor()
q = "INSERT INTO report (author) VALUES ('anonymous')"
c.execute(q)
# Row ID correct before...
id1 = self.db.get_last_id(c, 'report')
self.assertNotEqual(0, id1)
self.db.commit()
c.execute(q)
self.db.commit()
# ... and after commit()
id2 = self.db.get_last_id(c, 'report')
self.assertEqual(id1 + 1, id2)
def test_update_sequence(self):
cursor = self.db.cursor()
cursor.execute("""
INSERT INTO report (id, author) VALUES (42, 'anonymous')
""")
self.db.commit()
self.db.update_sequence(cursor, 'report', 'id')
self.db.commit()
cursor.execute("INSERT INTO report (author) VALUES ('next-id')")
self.db.commit()
cursor.execute("SELECT id FROM report WHERE author='next-id'")
self.assertEqual(43, cursor.fetchall()[0][0])
class GetBlogPostsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
if hasattr(self.env, 'db_transaction'):
with self.env.db_transaction as db:
FullBlogSetup(self.env).upgrade_environment(db)
else:
FullBlogSetup(self.env).upgrade_environment(self.env.get_db_cnx())
def tearDown(self):
self.env.destroy_db()
del self.env
def test_get_by_category(self):
bp = BlogPost(self.env, 'one')
bp.update_fields({
'title': 'one',
'body': 'body',
'author': 'user',
'categories': 'about stuff'
})
self.assertEquals([], bp.save('user'))
posts = get_blog_posts(self.env)
self.assertEquals(1, len(posts))
self.assertEquals('one', posts[0][0])
posts = get_blog_posts(self.env, category='non-existing')
self.assertEquals(0, len(posts))
posts = get_blog_posts(self.env, category='stuff')
self.assertEquals(1, len(posts))
self.assertEquals('one', posts[0][0])
self.assertEquals(get_blog_posts(self.env, category='about'),
get_blog_posts(self.env, category='stuff'))
class BaseModelTestCase(unittest.TestCase):
""" Inheritable base for model test case classes. """
# Override with iterable containing required schemas
schemas = None
def setUp(self):
self.env = EnvironmentStub()
self.env.path = tempfile.mkdtemp()
logs_dir = self.env.config.get("bitten", "logs_dir")
if os.path.isabs(logs_dir):
raise ValueError("Should not have absolute logs directory for temporary test")
logs_dir = os.path.join(self.env.path, logs_dir)
os.makedirs(logs_dir)
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for schema in self.schemas:
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
db.commit()
def tearDown(self):
shutil.rmtree(self.env.path)
class _BaseTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.perms = PermissionSystem(self.env)
self.req = Mock(authname='editor')
self.actions = ['TAGS_ADMIN', 'TAGS_MODIFY', 'TAGS_VIEW']
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for getting default permissions inserted.
self._revert_tractags_schema_init()
setup.upgrade_environment(self.db)
self.tag_s = tractags.api.TagSystem(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
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_%', ))
class AbstractWebUITestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'bitten.*'])
self.env.path = tempfile.mkdtemp()
# Create tables
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Set up permissions
self.env.config.set('trac', 'permission_store',
'DefaultPermissionStore')
# Hook up a dummy repository
self.repos = Mock(
get_node=lambda path, rev=None: Mock(get_history=lambda: [],
isdir=True),
normalize_path=lambda path: path,
normalize_rev=lambda rev: rev,
sync=lambda: None,
)
self.repos.authz = Mock(has_permission=lambda path: True,
assert_permission=lambda path: None)
self.env.get_repository = lambda authname=None: self.repos
def tearDown(self):
shutil.rmtree(self.env.path)
class GetBlogPostsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
FullBlogSetup(self.env).upgrade_environment(self.env.get_db_cnx())
def tearDown(self):
self.env.destroy_db()
del self.env
def test_get_by_category(self):
bp = BlogPost(self.env, 'one')
bp.update_fields({'title': 'one', 'body': 'body', 'author': 'user',
'categories': 'about stuff'})
self.assertEquals([], bp.save('user'))
posts = get_blog_posts(self.env)
self.assertEquals(1, len(posts))
self.assertEquals('one', posts[0][0])
posts = get_blog_posts(self.env, category='non-existing')
self.assertEquals(0, len(posts))
posts = get_blog_posts(self.env, category='stuff')
self.assertEquals(1, len(posts))
self.assertEquals('one', posts[0][0])
self.assertEquals(get_blog_posts(self.env, category='about'),
get_blog_posts(self.env, category='stuff'))
def make_trac_environment_with_plugin():
env = EnvironmentStub(
enable=["ticketref.*", TicketRefsPlugin, TicketRefsTemplate])
TicketRefsPlugin(env).upgrade_environment(env.get_db_cnx())
tref = TicketRefsPlugin(env)
tmpl = TicketRefsTemplate(env)
return env, tref, tmpl
class PermTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=[perm.PermissionSystem,
perm.DefaultPermissionStore,
TestPermissionRequestor])
# Add a few groups
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.executemany("INSERT INTO permission VALUES(%s,%s)", [
('employee', 'TEST_MODIFY'),
('developer', 'TEST_ADMIN'),
('developer', 'employee'),
('bob', 'developer')])
db.commit()
self.perm = perm.PermissionCache(self.env, 'bob')
def test_has_permission(self):
self.assertEqual(1, self.perm.has_permission('TEST_MODIFY'))
self.assertEqual(1, self.perm.has_permission('TEST_ADMIN'))
self.assertEqual(0, self.perm.has_permission('TRAC_ADMIN'))
def test_assert_permission(self):
self.perm.assert_permission('TEST_MODIFY')
self.perm.assert_permission('TEST_ADMIN')
self.assertRaises(perm.PermissionError,
self.perm.assert_permission, 'TRAC_ADMIN')
class AnnouncementSystemSendTestCase(unittest.TestCase):
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 tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Tests
def test_filter_added(self):
class DummySubscriptionFilter(Component):
"""Test implementation for checking the filter ExtensionPoint."""
implements(IAnnouncementSubscriptionFilter)
def filter_subscriptions(self, event, subscriptions):
"""Just a pass-through."""
return subscriptions
dummy = DummySubscriptionFilter(self.env)
self.assertTrue(dummy in self.an_sys.subscription_filters)
class ListTaggedMacroTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
setup.upgrade_environment(self.db)
self.tag_twm = TagWikiMacros(self.env)
def tearDown(self):
shutil.rmtree(self.env.path)
def test_empty_content(self):
req = Mock(path_info='/wiki/ListTaggedPage',
args={},
authname='user',
perm=PermissionCache(self.env, 'user'),
href=Href('/'),
abs_href='http://example.org/trac/',
chrome={},
session={},
locale='',
tz=''
)
context = Mock(env=self.env, href=Href('/'), req=req)
formatter = Mock(context=context, req=req)
self.assertTrue('No resources found' in
str(self.tag_twm.expand_macro(formatter,
'ListTagged', '')))
class _BaseTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for getting default permissions inserted.
self._revert_tractags_schema_init()
setup.upgrade_environment(self.db)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
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_%',))
def _insert_tags(self, tagspace, name, tags):
cursor = self.db.cursor()
args = [(tagspace, name, tag) for tag in tags]
cursor.executemany("INSERT INTO tags (tagspace,name,tag) "
"VALUES (%s,%s,%s)", args)
class ListTaggedMacroTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.req = Mock(path_info='/wiki/ListTaggedPage',
args={}, authname='user', perm=MockPerm(),
href=Href('/'),
abs_href=Href('http://example.org/trac/'),
chrome={}, session={}, locale='', tz='')
self.db = self.env.get_db_cnx()
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_%',))
setup = TagSetup(self.env)
setup.upgrade_environment(self.db)
self.tag_twm = TagWikiMacros(self.env)
def tearDown(self):
shutil.rmtree(self.env.path)
def test_empty_content(self):
context = Mock(env=self.env, href=Href('/'), req=self.req)
formatter = Mock(context=context, req=self.req)
self.assertTrue('No resources found' in
str(self.tag_twm.expand_macro(formatter,
'ListTagged', '')))
class _BaseTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.perms = PermissionSystem(self.env)
self.req = Mock(authname='editor')
self.actions = ['TAGS_ADMIN', 'TAGS_MODIFY', 'TAGS_VIEW']
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for getting default permissions inserted.
self._revert_tractags_schema_init()
setup.upgrade_environment(self.db)
self.tag_s = tractags.api.TagSystem(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
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_%',))
class ComponentTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.db = self.env.get_db_cnx()
def tearDown(self):
self.env.reset_db()
def test_exists_negative(self):
def get_fake_component():
return Component(self.env, "Shrubbery")
self.assertRaises(TracError, get_fake_component)
def test_exists(self):
"""
http://trac.edgewall.org/ticket/4247
"""
for c in Component.select(self.env):
self.assertEqual(c.exists, True)
def test_create_and_update(self):
component = Component(self.env)
component.name = "Test"
component.insert()
cursor = self.db.cursor()
cursor.execute("SELECT name,owner,description FROM component " "WHERE name='Test'")
self.assertEqual(("Test", None, None), cursor.fetchone())
# Use the same model object to update the component
component.owner = "joe"
component.update()
cursor.execute("SELECT name,owner,description FROM component " "WHERE name='Test'")
self.assertEqual(("Test", "joe", None), cursor.fetchone())
def env_stub_with_tables():
env = EnvironmentStub()
db = env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
return env
def env_stub_with_tables():
env = EnvironmentStub(enable=['trac.*', 'bitten.*'])
db = env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
return env
class BayesianFilterStrategyTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=[BayesianFilterStrategy])
self.env.config.set('spam-filter', 'bayes_karma', '10')
db = self.env.get_db_cnx()
cursor = db.cursor()
for table in schema:
for stmt in _to_sql(table):
cursor.execute(stmt)
self.strategy = BayesianFilterStrategy(self.env)
def test_karma_calculation_unsure(self):
bayes.Hammie = lambda x: Mock(score=lambda x: .5,
bayes=Mock(nham=1000, nspam=1000))
req = Mock(authname='anonymous', base_url='http://example.org/',
remote_addr='127.0.0.1')
self.assertEquals(None, self.strategy.test(req, 'John Doe', 'Spam'))
def test_karma_calculation_negative(self):
bayes.Hammie = lambda x: Mock(score=lambda x: .75,
bayes=Mock(nham=1000, nspam=1000))
req = Mock(authname='anonymous', base_url='http://example.org/',
remote_addr='127.0.0.1')
points, reasons = self.strategy.test(req, 'John Doe', 'Spam')
self.assertEquals(-5, points)
def test_karma_calculation_positive(self):
bayes.Hammie = lambda x: Mock(score=lambda x: .25,
bayes=Mock(nham=1000, nspam=1000))
req = Mock(authname='anonymous', base_url='http://example.org/',
remote_addr='127.0.0.1')
points, reasons = self.strategy.test(req, 'John Doe', 'Spam')
self.assertEquals(5, points)
def test_classifier_untrained(self):
req = Mock(authname='anonymous', base_url='http://example.org/',
remote_addr='127.0.0.1')
self.assertEqual(None, self.strategy.test(req, 'John Doe', 'Hammie'))
def test_classifier_basics(self):
req = Mock(authname='anonymous', base_url='http://example.org/',
remote_addr='127.0.0.1')
self.env.config.set('spam-filter', 'bayes_min_training', '1')
self.strategy.train(req, 'John Doe', 'Spam spam spammie', True)
self.strategy.train(req, 'John Doe', 'Ham ham hammie', False)
points, reasons = self.strategy.test(req, 'John Doe', 'Hammie')
assert points > 0, 'Expected positive karma'
points, reasons = self.strategy.test(req, 'John Doe', 'Spam')
assert points < 0, 'Expected negative karma'
class _BaseTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
# Current tractags schema is setup with enabled component anyway.
# Revert these changes for getting a clean setup.
self._revert_tractags_schema_init()
setup.upgrade_environment(self.db)
self.tag_s = TagSystem(self.env)
self.tag_rh = TagRequestHandler(self.env)
perms = PermissionSystem(self.env)
# Revoke default permissions, because more diversity is required here.
perms.revoke_permission('anonymous', 'TAGS_VIEW')
perms.revoke_permission('authenticated', 'TAGS_MODIFY')
perms.grant_permission('reader', 'TAGS_VIEW')
perms.grant_permission('writer', 'TAGS_MODIFY')
perms.grant_permission('admin', 'TAGS_ADMIN')
self.href = Href('/trac')
self.abs_href = Href('http://example.org/trac')
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _create_request(self, authname='anonymous', **kwargs):
kw = {'perm': PermissionCache(self.env, authname), 'args': {},
'callbacks': {}, 'path_info': '', 'form_token': None,
'href': self.env.href, 'abs_href': self.env.abs_href,
'tz': utc, 'locale': None, 'lc_time': None,
'session': DetachedSession(self.env, authname),
'authname': authname, 'chrome': {'notices': [], 'warnings': []},
'method': None, 'get_header': lambda v: None, 'is_xhr': False}
kw.update(kwargs)
def send(self, content, content_type='text/html', status=200):
raise RequestDone
return Mock(send=send, **kw)
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_%',))
class TestResultsSummarizerTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.env.path = ''
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def test_testcase_errors_and_failures(self):
config = Mock(name='trunk', path='/somewhere',
min_rev_time=lambda env: 0,
max_rev_time=lambda env: 1000)
step = Mock(name='foo')
build = Build(self.env, config=config.name, platform=1, rev=123,
rev_time=42)
build.insert()
report = Report(self.env, build=build.id, step=step.name,
category='test')
report.items += [{'fixture': 'test_foo',
'name': 'foo', 'file': 'foo.c',
'type': 'test', 'status': 'success'},
{'fixture': 'test_bar',
'name': 'bar', 'file': 'bar.c',
'type': 'test', 'status': 'error',
'traceback': 'Error traceback'},
{'fixture': 'test_baz',
'name': 'baz', 'file': 'baz.c',
'type': 'test', 'status': 'failure',
'traceback': 'Failure reason'}]
report.insert()
req = Mock(href=Href('trac'))
generator = TestResultsSummarizer(self.env)
template, data = generator.render_summary(req,
config, build, step, 'test')
self.assertEquals('bitten_summary_tests.html', template)
self.assertEquals(data['totals'],
{'ignore': 0, 'failure': 1, 'success': 1, 'error': 1})
for fixture in data['fixtures']:
if fixture.has_key('failures'):
if fixture['failures'][0]['status'] == 'error':
self.assertEquals('test_bar', fixture['name'])
self.assertEquals('Error traceback',
fixture['failures'][0]['traceback'])
if fixture['failures'][0]['status'] == 'failure':
self.assertEquals('test_baz', fixture['name'])
self.assertEquals('Failure reason',
fixture['failures'][0]['traceback'])
class TestResultsSummarizerTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.env.path = ''
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
def test_testcase_errors_and_failures(self):
config = Mock(name='trunk', path='/somewhere')
step = Mock(name='foo')
build = Build(self.env, config=config.name, platform=1, rev=123,
rev_time=42)
build.insert()
report = Report(self.env, build=build.id, step=step.name,
category='test')
report.items += [{'fixture': 'test_foo',
'name': 'foo', 'file': 'foo.c',
'type': 'test', 'status': 'success'},
{'fixture': 'test_bar',
'name': 'bar', 'file': 'bar.c',
'type': 'test', 'status': 'error',
'traceback': 'Error traceback'},
{'fixture': 'test_baz',
'name': 'baz', 'file': 'baz.c',
'type': 'test', 'status': 'failure',
'traceback': 'Failure reason'}]
report.insert()
req = Mock(href=Href('trac'))
generator = TestResultsSummarizer(self.env)
template, data = generator.render_summary(req,
config, build, step, 'test')
self.assertEquals('bitten_summary_tests.html', template)
self.assertEquals(data['totals'],
{'ignore': 0, 'failure': 1, 'success': 1, 'error': 1})
for fixture in data['fixtures']:
if fixture.has_key('failures'):
if fixture['failures'][0]['status'] == 'error':
self.assertEquals('test_bar', fixture['name'])
self.assertEquals('Error traceback',
fixture['failures'][0]['traceback'])
if fixture['failures'][0]['status'] == 'failure':
self.assertEquals('test_baz', fixture['name'])
self.assertEquals('Failure reason',
fixture['failures'][0]['traceback'])
class AbstractWebUITestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'bitten.*'])
self.env.path = tempfile.mkdtemp()
# Create tables
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
# Set up permissions
self.env.config.set('trac', 'permission_store',
'DefaultPermissionStore')
# Hook up a dummy repository
self.repos = Mock(
get_node=lambda path, rev=None: Mock(get_history=lambda: [],
isdir=True),
normalize_path=lambda path: path,
normalize_rev=lambda rev: rev,
sync=lambda: None,
resource=Resource('repository', None),
authz = Mock(has_permission=lambda path: True,
assert_permission=lambda path: None))
self.env.get_repository = lambda authname=None: self.repos # 0.11
try: # 0.12+
from trac.core import Component, implements
from trac.versioncontrol.api import IRepositoryConnector, \
IRepositoryProvider
class DummyRepos(Component):
implements(IRepositoryConnector, IRepositoryProvider)
def get_supported_types(self):
yield ('dummy', 9)
def get_repository(this, repos_type, repos_dir, params):
return self.repos # Note: 'this' vs 'self' usage
def get_repositories(self):
yield ('', {'dir': 'dummy_dir', 'type': 'dummy'})
self.dummy = DummyRepos
except ImportError:
self.dummy = None # not supported, will use get_repository()
def tearDown(self):
if self.dummy: # remove from components list + interfaces dict
self.env.__metaclass__._components.remove(self.dummy)
for key in self.env.__metaclass__._registry.keys():
if self.dummy in self.env.__metaclass__._registry[key]:
self.env.__metaclass__._registry[key].remove(self.dummy)
shutil.rmtree(self.env.path)
class SubscriberTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(
enable=['trac.*', 'announcer.subscribers.*'])
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)
class SubscriberTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(
enable=['trac.*', 'announcer.opt.subscribers.*'])
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)
class BittenNotifyBaseTest(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'bitten.notify.*'])
repos = Mock(get_changeset=lambda rev: Mock(author='author', rev=rev))
self.env.get_repository = lambda authname=None: repos
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
db.commit()
class BittenNotifyBaseTest(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'bitten.notify.*'])
repos = Mock(get_changeset=lambda rev: Mock(author='author', rev=rev))
self.env.get_repository = lambda authname=None: repos
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
db.commit()
class CalendarSystemTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'itteco.*'])
self.env.config.set('trac', 'permission_policies',
'CalendarSystem, DefaultPermissionPolicy')
self.itteco_env = IttecoEvnSetup(self.env)
self.itteco_env.upgrade_environment(self.env.get_db_cnx())
self.calendar_system = CalendarSystem(self.env)
self.perm_system = perm.PermissionSystem(self.env)
self.perm = perm.PermissionCache(self.env, 'testuser')
def tearDown(self):
self.env.reset_db()
def _create_calendar(self, name, username, type=CalendarType.Private):
calendar = Calendar(self.env, None, username)
calendar.theme = 1
calendar.type = type
id = calendar.insert()
return calendar
def test_permission_policies(self):
self.perm_system.grant_permission('testuser', 'CALENDAR_CREATE')
self.perm_system.grant_permission('testuser', 'CALENDAR_MODIFY')
self.perm_system.grant_permission('testuser', 'CALENDAR_VIEW')
self.perm_system.grant_permission('testuser', 'CALENDAR_DELETE')
self.assertTrue('CALENDAR_CREATE' in self.perm)
calendar = self._create_calendar('cal1', 'testuser')
c = calendar.resource
self.assertTrue('CALENDAR_MODIFY' in self.perm(c))
self.assertTrue('CALENDAR_VIEW' in self.perm(c))
self.assertTrue('CALENDAR_DELETE' in self.perm(c))
calendar2 = self._create_calendar('cal2', 'user1')
c2 = calendar2.resource
self.assertTrue('CALENDAR_VIEW' not in self.perm(c2), \
'There should be no access to private calendar of another user.')
calendar3 = self._create_calendar('cal3', 'user1', CalendarType.Shared)
c3 = calendar3.resource
self.assertTrue('CALENDAR_VIEW' in self.perm(c3), \
'There should view access to shared calendars.')
class TicketLinksTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'mastertickets.*'])
self.env.path = tempfile.mkdtemp()
self.req = Mock()
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)
class UtilTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
emailmap = {
'rcorsaro': '*****@*****.**',
'doki_pen': '*****@*****.**',
'csutton': '*****@*****.**',
'rreimer': '*****@*****.**'
}
db = self.env.get_db_cnx()
cursor = db.cursor()
for k, v in emailmap.iteritems():
cursor.execute("""
INSERT INTO session_attribute (sid, name, value)
VALUES (%s, 'email', %s)
""", (k, v))
def test_find_sid_by_email(self):
self.assertEquals(
'rcorsaro',
find_sid_by_email(self.env, '*****@*****.**')
)
self.assertEquals(
'rcorsaro',
find_sid_by_email(
self.env,
'"Robert Corsaro" <*****@*****.**>'
)
)
self.assertEquals(
'rcorsaro',
find_sid_by_email(
self.env,
'Robert Corsaro <*****@*****.**>'
)
)
self.assertEquals(
'*****@*****.**',
find_sid_by_email(
self.env,
'Joe Blow <*****@*****.**>'
)
)
self.assertEquals(
'csutton',
find_sid_by_email(
self.env,
'Joe Blow <*****@*****.**>'
)
)
class StringsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
def test_insert_unicode(self):
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('test-unicode', u'ünicöde'))
db.commit()
cursor = db.cursor()
cursor.execute("SELECT value FROM system WHERE name='test-unicode'")
self.assertEqual([(u'ünicöde',)], cursor.fetchall())
def test_insert_empty(self):
from trac.util.text import empty
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('test-empty', empty))
db.commit()
cursor = db.cursor()
cursor.execute("SELECT value FROM system WHERE name='test-empty'")
self.assertEqual([(u'',)], cursor.fetchall())
def test_insert_markup(self):
from genshi.core import Markup
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('INSERT INTO system (name,value) VALUES (%s,%s)',
('test-markup', Markup(u'<em>märkup</em>')))
db.commit()
cursor = db.cursor()
cursor.execute("SELECT value FROM system WHERE name='test-markup'")
self.assertEqual([(u'<em>märkup</em>',)], cursor.fetchall())
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)
class TagRPCTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.db = self.env.get_db_cnx()
setup = TagSetup(self.env)
# Current tractags schema is partially setup with enabled component.
# Revert these changes for getting a clean setup.
self._revert_tractags_schema_init()
setup.upgrade_environment(self.db)
self.perms = PermissionSystem(self.env)
self.tag_s = TagSystem(self.env)
cursor = self.db.cursor()
# Populate table with initial test data.
cursor.execute("""
INSERT INTO tags
(tagspace, name, tag)
VALUES ('wiki', 'WikiStart', 'tag1')
""")
self.req = Mock(authname='editor')
# Mock an anonymous request.
self.req.perm = PermissionCache(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
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_init(self):
TagRPC(self.env)
class GetTestPlans(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
QaSetup(self.env).upgrade_environment(self.env.get_db_cnx())
def tearDown(self):
self.env.destroy_db()
del self.env
def test_save(self):
# 2 posts in one period
testplan = TestPlan(self.env)
testplan.title = "test"
testplan.description = "test"
testplan.save()
self.assertEquals([], tesplan.tpid)
class _BaseTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'acct_mgr.api.*',
'acct_mgr.db.SessionStore', 'acct_mgr.pwhash.*',
'acct_mgr.htfile.HtDigestStore']
)
self.env.path = tempfile.mkdtemp()
self.perm = PermissionSystem(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)
class VoteSystemTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tracvote.*'])
self.env.path = tempfile.mkdtemp()
self.perm = PermissionSystem(self.env)
self.req = Mock()
self.db = self.env.get_db_cnx()
self.votes = VoteSystem(self.env)
# Current tracvotes schema is setup with enabled component anyway.
# Revert these changes for getting default permissions inserted.
self._revert_schema_init()
self.votes.upgrade_environment(self.db)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _revert_schema_init(self):
cursor = self.db.cursor()
cursor.execute("DROP TABLE IF EXISTS votes")
cursor.execute("DELETE FROM system WHERE name='vote_version'")
cursor.execute(
"DELETE FROM permission WHERE action %s" % self.db.like(),
('VOTE_%', ))
# Tests
def test_available_actions_no_perms(self):
self.assertTrue(_ACTIONS['view'] in PermissionCache(self.env))
self.assertFalse(_ACTIONS['modify'] in PermissionCache(self.env))
def test_available_actions_full_perms(self):
perm_map = dict(voter='VOTE_MODIFY', admin='TRAC_ADMIN')
for user in perm_map:
self.perm.grant_permission(user, perm_map[user])
for action in _ACTIONS.values():
self.assertTrue(
action in PermissionCache(self.env, username=user))
def test_resource_provider(self):
self.assertTrue(self.votes in Chrome(self.env).template_providers)
class GroupPostsByMonthTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
if hasattr(self.env, 'db_transaction'):
with self.env.db_transaction as db:
FullBlogSetup(self.env).upgrade_environment(db)
else:
FullBlogSetup(self.env).upgrade_environment(self.env.get_db_cnx())
def tearDown(self):
self.env.destroy_db()
del self.env
def test_many_posts(self):
# 2 posts in one period
one = BlogPost(self.env, 'one')
one.update_fields({'title': 'one', 'body': 'body', 'author': 'user'})
self.assertEquals([], one.save('user'))
two = BlogPost(self.env, 'two')
two.update_fields({'title': 'two', 'body': 'body', 'author': 'user'})
self.assertEquals([], two.save('user'))
grouped = group_posts_by_month(get_blog_posts(self.env))
self.assertEquals(1, len(grouped))
# Add 1 post in another period
three = BlogPost(self.env, 'three')
three.update_fields({
'title':
'three',
'body':
'body',
'author':
'user',
'publish_time':
three.publish_time - datetime.timedelta(days=-100)
})
self.assertEquals([], three.save('user'))
grouped = group_posts_by_month(get_blog_posts(self.env))
self.assertEquals(2, len(grouped))
self.assertEquals(1, len(grouped[0][1]))
self.assertEquals(2, len(grouped[1][1]))
self.assertEquals(type(grouped[0][0]), datetime.datetime)
self.assertEquals((one.name, one.version, one.publish_time, one.author,
one.title, one.body, []), grouped[1][1][0])
def test_no_posts(self):
grouped = group_posts_by_month(get_blog_posts(self.env))
self.assertEquals([], grouped)
class BittenNotifyBaseTest(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(
enable=['trac.*', 'bitten.notify.*', 'bitten.tests.notify.*'])
db = self.env.get_db_cnx()
cursor = db.cursor()
connector, _ = DatabaseManager(self.env)._get_connector()
for table in schema:
for stmt in connector.to_sql(table):
cursor.execute(stmt)
db.commit()
# Hook up a dummy repository
self.repos = Mock(
get_changeset=lambda rev: Mock(author='author', rev=rev),
normalize_rev=lambda rev: rev)
self.env.get_repository = lambda authname=None: self.repos # 0.11
try: # 0.12+
from trac.core import Component, implements
from trac.versioncontrol.api import IRepositoryConnector, \
IRepositoryProvider
class DummyRepos(Component):
implements(IRepositoryConnector, IRepositoryProvider)
def get_supported_types(self):
yield ('dummy', 9)
def get_repository(this, repos_type, repos_dir, params):
return self.repos # Note: 'this' vs 'self' usage
def get_repositories(self):
yield ('', {'dir': 'dummy_dir', 'type': 'dummy'})
self.dummy = DummyRepos
except ImportError:
self.dummy = None # not supported, will use get_repository()
def tearDown(self):
if self.dummy: # remove from components list + interfaces dict
self.env.__metaclass__._components.remove(self.dummy)
for key in self.env.__metaclass__._registry.keys():
if self.dummy in self.env.__metaclass__._registry[key]:
self.env.__metaclass__._registry[key].remove(self.dummy)
class WikiCalendarMacrosTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'wikicalendar.macros.*'])
self.env.path = tempfile.mkdtemp()
self.req = Mock()
self.db = self.env.get_db_cnx()
self.macros = WikiCalendarMacros(self.env)
def tearDown(self):
self.db.close()
# Really close db connections.
self.env.shutdown()
shutil.rmtree(self.env.path)
def test_resource_provider(self):
self.assertTrue(self.macros in Chrome(self.env).template_providers)
class FullBlogTestCaseTemplate(TestCase):
def setUp(self):
self.env = EnvironmentStub(enable=['trac.*', 'tracfullblog.*'])
# tables
if hasattr(self.env, 'db_transaction'):
with self.env.db_transaction as db:
FullBlogSetup(self.env).upgrade_environment(db)
else:
FullBlogSetup(self.env).upgrade_environment(self.env.get_db_cnx())
# permissions
self.env.config.set('trac', 'permission_store',
'DefaultPermissionStore')
self.env.config.set('trac', 'permission_policies',
'DefaultPermissionPolicy')
def tearDown(self):
self.env.destroy_db()
del self.env
