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 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 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 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