本文整理汇总了Python中trac.test.EnvironmentStub.db_query方法的典型用法代码示例。如果您正苦于以下问题:Python EnvironmentStub.db_query方法的具体用法?Python EnvironmentStub.db_query怎么用?Python EnvironmentStub.db_query使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类trac.test.EnvironmentStub
的用法示例。
在下文中一共展示了EnvironmentStub.db_query方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: ComponentTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class ComponentTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
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()
self.assertEqual([('Test', None, None)], self.env.db_query("""
SELECT name, owner, description FROM component
WHERE name='Test'"""))
# Use the same model object to update the component
component.owner = 'joe'
component.update()
self.assertEqual([('Test', 'joe', None)], self.env.db_query(
"SELECT name, owner, description FROM component WHERE name='Test'"))
示例2: StringsTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
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])
示例3: VersionTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class VersionTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
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()
self.assertEqual([('Test', 0, None)], self.env.db_query(
"SELECT name, time, description FROM version WHERE name='Test'"))
# Use the same model object to update the version
version.description = 'Some text'
version.update()
self.assertEqual([('Test', 0, 'Some text')], self.env.db_query(
"SELECT name, time, description FROM version WHERE name='Test'"))
示例4: ConnectionTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class ConnectionTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
def tearDown(self):
self.env.reset_db()
def test_get_last_id(self):
id1 = id2 = None
q = "INSERT INTO report (author) VALUES ('anonymous')"
with self.env.db_transaction as db:
cursor = db.cursor()
cursor.execute(q)
# Row ID correct before...
id1 = db.get_last_id(cursor, 'report')
self.assertNotEqual(0, id1)
db.commit()
cursor.execute(q)
# ... and after commit()
db.commit()
id2 = db.get_last_id(cursor, 'report')
self.assertEqual(id1 + 1, id2)
def test_update_sequence(self):
self.env.db_transaction(
"INSERT INTO report (id, author) VALUES (42, 'anonymous')")
with self.env.db_transaction as db:
cursor = db.cursor()
db.update_sequence(cursor, 'report', 'id')
self.env.db_transaction(
"INSERT INTO report (author) VALUES ('next-id')")
self.assertEqual(43, self.env.db_query(
"SELECT id FROM report WHERE author='next-id'")[0][0])
示例5: ConnectionTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class ConnectionTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.schema = [
Table('HOURS', key='ID')[
Column('ID', auto_increment=True),
Column('AUTHOR')],
Table('blog', key='bid')[
Column('bid', auto_increment=True),
Column('author')
]
]
self.env.global_databasemanager.drop_tables(self.schema)
self.env.global_databasemanager.create_tables(self.schema)
def tearDown(self):
self.env.global_databasemanager.drop_tables(self.schema)
self.env.reset_db()
def test_get_last_id(self):
q = "INSERT INTO report (author) VALUES ('anonymous')"
with self.env.db_transaction as db:
cursor = db.cursor()
cursor.execute(q)
# Row ID correct before...
id1 = db.get_last_id(cursor, 'report')
db.commit()
cursor.execute(q)
# ... and after commit()
db.commit()
id2 = db.get_last_id(cursor, 'report')
self.assertNotEqual(0, id1)
self.assertEqual(id1 + 1, id2)
def test_update_sequence_default_column(self):
with self.env.db_transaction as db:
db("INSERT INTO report (id, author) VALUES (42, 'anonymous')")
cursor = db.cursor()
db.update_sequence(cursor, 'report', 'id')
self.env.db_transaction(
"INSERT INTO report (author) VALUES ('next-id')")
self.assertEqual(43, self.env.db_query(
"SELECT id FROM report WHERE author='next-id'")[0][0])
def test_update_sequence_nondefault_column(self):
with self.env.db_transaction as db:
cursor = db.cursor()
cursor.execute(
"INSERT INTO blog (bid, author) VALUES (42, 'anonymous')")
db.update_sequence(cursor, 'blog', 'bid')
self.env.db_transaction(
"INSERT INTO blog (author) VALUES ('next-id')")
self.assertEqual(43, self.env.db_query(
"SELECT bid FROM blog WHERE author='next-id'")[0][0])
def test_identifiers_need_quoting(self):
"""Test for regression described in comment:4:ticket:11512."""
with self.env.db_transaction as db:
db("INSERT INTO %s (%s, %s) VALUES (42, 'anonymous')"
% (db.quote('HOURS'), db.quote('ID'), db.quote('AUTHOR')))
cursor = db.cursor()
db.update_sequence(cursor, 'HOURS', 'ID')
with self.env.db_transaction as db:
cursor = db.cursor()
cursor.execute(
"INSERT INTO %s (%s) VALUES ('next-id')"
% (db.quote('HOURS'), db.quote('AUTHOR')))
last_id = db.get_last_id(cursor, 'HOURS', 'ID')
self.assertEqual(43, last_id)
def test_get_table_names(self):
schema = default_schema + self.schema
with self.env.db_query as db:
self.assertEqual(sorted(table.name for table in schema),
sorted(db.get_table_names()))
def test_get_column_names(self):
schema = default_schema + self.schema
with self.env.db_transaction as db:
for table in schema:
db_columns = db.get_column_names(table.name)
self.assertEqual(len(table.columns), len(db_columns))
for column in table.columns:
self.assertIn(column.name, db_columns)
示例6: StringsTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class StringsTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
def tearDown(self):
self.env.reset_db()
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):
with self.env.db_query as db:
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])
def test_quoted_id_with_percent(self):
name = """%?`%s"%'%%"""
def test(logging=False):
with self.env.db_query as db:
cursor = db.cursor()
if logging:
cursor.log = self.env.log
cursor.execute('SELECT 1 AS ' + db.quote(name))
self.assertEqual(name, get_column_names(cursor)[0])
cursor.execute('SELECT %s AS ' + db.quote(name), (42,))
self.assertEqual(name, get_column_names(cursor)[0])
cursor.executemany("UPDATE system SET value=%s WHERE "
"1=(SELECT 0 AS " + db.quote(name) + ")",
[])
cursor.executemany("UPDATE system SET value=%s WHERE "
"1=(SELECT 0 AS " + db.quote(name) + ")",
[('42',), ('43',)])
test()
test(True)
def test_prefix_match_case_sensitive(self):
with self.env.db_transaction as db:
db.executemany("INSERT INTO system (name,value) VALUES (%s,1)",
[('blahblah',), ('BlahBlah',), ('BLAHBLAH',),
(u'BlähBlah',), (u'BlahBläh',)])
with self.env.db_query as db:
names = sorted(name for name, in db(
"SELECT name FROM system WHERE name %s"
% db.prefix_match(),
(db.prefix_match_value('Blah'),)))
self.assertEqual('BlahBlah', names[0])
self.assertEqual(u'BlahBläh', names[1])
self.assertEqual(2, len(names))
def test_prefix_match_metachars(self):
def do_query(prefix):
with self.env.db_query as db:
return [name for name, in db(
"SELECT name FROM system WHERE name %s "
"ORDER BY name" % db.prefix_match(),
(db.prefix_match_value(prefix),))]
values = ['foo*bar', 'foo*bar!', 'foo?bar', 'foo?bar!',
'foo[bar', 'foo[bar!', 'foo]bar', 'foo]bar!',
'foo%bar', 'foo%bar!', 'foo_bar', 'foo_bar!',
'foo/bar', 'foo/bar!', 'fo*ob?ar[fo]ob%ar_fo/obar']
with self.env.db_transaction as db:
db.executemany("INSERT INTO system (name,value) VALUES (%s,1)",
[(value,) for value in values])
self.assertEqual(['foo*bar', 'foo*bar!'], do_query('foo*'))
self.assertEqual(['foo?bar', 'foo?bar!'], do_query('foo?'))
self.assertEqual(['foo[bar', 'foo[bar!'], do_query('foo['))
self.assertEqual(['foo]bar', 'foo]bar!'], do_query('foo]'))
self.assertEqual(['foo%bar', 'foo%bar!'], do_query('foo%'))
self.assertEqual(['foo_bar', 'foo_bar!'], do_query('foo_'))
self.assertEqual(['foo/bar', 'foo/bar!'], do_query('foo/'))
#.........这里部分代码省略.........
示例7: WikiPageTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class WikiPageTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.env.path = tempfile.mkdtemp(prefix='trac-tempenv-')
def tearDown(self):
shutil.rmtree(self.env.path)
self.env.reset_db()
def test_new_page(self):
page = WikiPage(self.env)
self.assertFalse(page.exists)
self.assertIsNone(page.name)
self.assertEqual(0, page.version)
self.assertEqual('', page.text)
self.assertEqual(0, page.readonly)
self.assertEqual('', page.author)
self.assertEqual('', page.comment)
self.assertIsNone(page.time)
def test_existing_page(self):
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
self.env.db_transaction(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, to_utimestamp(t), 'joe', '::1', 'Bla bla',
'Testing', 0))
page = WikiPage(self.env, 'TestPage')
self.assertTrue(page.exists)
self.assertEqual('TestPage', page.name)
self.assertEqual(1, page.version)
self.assertIsNone(page.resource.version) # FIXME: Intentional?
self.assertEqual('Bla bla', page.text)
self.assertEqual(0, page.readonly)
self.assertEqual('joe', page.author)
self.assertEqual('Testing', page.comment)
self.assertEqual(t, page.time)
history = list(page.get_history())
self.assertEqual(1, len(history))
self.assertEqual((1, t, 'joe', 'Testing', '::1'), history[0])
page = WikiPage(self.env, 'TestPage', 1)
self.assertEqual(1, page.resource.version)
self.assertEqual(1, page.version)
resource = Resource('wiki', 'TestPage')
page = WikiPage(self.env, resource, 1)
self.assertEqual(1, page.version)
def test_create_page(self):
page = WikiPage(self.env)
page.name = 'TestPage'
page.text = 'Bla bla'
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
page.save('joe', 'Testing', '::1', t)
self.assertTrue(page.exists)
self.assertEqual(1, page.version)
self.assertEqual(1, page.resource.version)
self.assertEqual(0, page.readonly)
self.assertEqual('joe', page.author)
self.assertEqual('Testing', page.comment)
self.assertEqual(t, page.time)
self.assertEqual(
[(1, to_utimestamp(t), 'joe', '::1', 'Bla bla', 'Testing', 0)],
self.env.db_query("""
SELECT version, time, author, ipnr, text, comment, readonly
FROM wiki WHERE name=%s
""", ('TestPage',)))
listener = TestWikiChangeListener(self.env)
self.assertEqual(page, listener.added[0])
def test_update_page(self):
t = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
t2 = datetime(2002, 1, 1, 1, 1, 1, 0, utc)
self.env.db_transaction(
"INSERT INTO wiki VALUES(%s,%s,%s,%s,%s,%s,%s,%s)",
('TestPage', 1, to_utimestamp(t), 'joe', '::1', 'Bla bla',
'Testing', 0))
page = WikiPage(self.env, 'TestPage')
page.text = 'Bla'
page.save('kate', 'Changing', '192.168.0.101', t2)
self.assertEqual(2, page.version)
self.assertEqual(2, page.resource.version)
self.assertEqual(0, page.readonly)
self.assertEqual('kate', page.author)
self.assertEqual('Changing', page.comment)
self.assertEqual(t2, page.time)
with self.env.db_query as db:
rows = db("""
SELECT version, time, author, ipnr, text, comment, readonly
FROM wiki WHERE name=%s ORDER BY version
""", ('TestPage',))
#.........这里部分代码省略.........
示例8: MilestoneTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class MilestoneTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.env.path = os.path.join(tempfile.gettempdir(), 'trac-tempenv')
os.mkdir(self.env.path)
def tearDown(self):
shutil.rmtree(self.env.path)
self.env.reset_db()
def _create_milestone(self, **values):
milestone = Milestone(self.env)
for k, v in values.iteritems():
setattr(milestone, k, v)
return milestone
def test_new_milestone(self):
milestone = Milestone(self.env)
self.assertEqual(False, milestone.exists)
self.assertEqual(None, milestone.name)
self.assertEqual(None, milestone.due)
self.assertEqual(None, milestone.completed)
self.assertEqual('', milestone.description)
def test_new_milestone_empty_name(self):
"""
Verifies that specifying an empty milestone name results in the
milestone being correctly detected as non-existent.
"""
milestone = Milestone(self.env, '')
self.assertEqual(False, milestone.exists)
self.assertEqual(None, milestone.name)
self.assertEqual(None, milestone.due)
self.assertEqual(None, milestone.completed)
self.assertEqual('', milestone.description)
def test_existing_milestone(self):
self.env.db_transaction("INSERT INTO milestone (name) VALUES ('Test')")
milestone = Milestone(self.env, 'Test')
self.assertEqual(True, milestone.exists)
self.assertEqual('Test', milestone.name)
self.assertEqual(None, milestone.due)
self.assertEqual(None, milestone.completed)
self.assertEqual('', milestone.description)
def test_create_and_update_milestone(self):
milestone = Milestone(self.env)
milestone.name = 'Test'
milestone.insert()
self.assertEqual([('Test', 0, 0, '')], self.env.db_query("""
SELECT name, due, completed, description FROM milestone
WHERE name='Test'
"""))
# Use the same model object to update the milestone
milestone.description = 'Some text'
milestone.update()
self.assertEqual([('Test', 0, 0, 'Some text')], self.env.db_query("""
SELECT name, due, completed, description FROM milestone
WHERE name='Test'
"""))
def test_create_milestone_without_name(self):
milestone = Milestone(self.env)
self.assertRaises(TracError, milestone.insert)
def test_delete_milestone(self):
self.env.db_transaction("INSERT INTO milestone (name) VALUES ('Test')")
milestone = Milestone(self.env, 'Test')
milestone.delete()
self.assertEqual(False, milestone.exists)
self.assertEqual([],
self.env.db_query("SELECT * FROM milestone WHERE name='Test'"))
def test_delete_milestone_retarget_tickets(self):
self.env.db_transaction("INSERT INTO milestone (name) VALUES ('Test')")
tkt1 = Ticket(self.env)
tkt1.populate({'summary': 'Foo', 'milestone': 'Test'})
tkt1.insert()
tkt2 = Ticket(self.env)
tkt2.populate({'summary': 'Bar', 'milestone': 'Test'})
tkt2.insert()
milestone = Milestone(self.env, 'Test')
milestone.delete(retarget_to='Other')
self.assertEqual(False, milestone.exists)
self.assertEqual('Other', Ticket(self.env, tkt1.id)['milestone'])
self.assertEqual('Other', Ticket(self.env, tkt2.id)['milestone'])
def test_update_milestone(self):
self.env.db_transaction("INSERT INTO milestone (name) VALUES ('Test')")
milestone = Milestone(self.env, 'Test')
t1 = datetime(2001, 01, 01, tzinfo=utc)
#.........这里部分代码省略.........
示例9: TicketCommentDeleteTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class TicketCommentDeleteTestCase(TicketCommentTestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.env.config.set('ticket-custom', 'foo', 'text')
self.created = datetime(2001, 1, 1, 1, 0, 0, 0, utc)
self._insert_ticket('Test ticket', self.created,
owner='john', keywords='a, b, c', foo='initial')
self.t1 = self.created + timedelta(seconds=1)
self._modify_ticket('jack', 'Comment 1', self.t1, '1',
foo='change 1')
self.t2 = self.created + timedelta(seconds=2)
self._modify_ticket('john', 'Comment 2', self.t2, '1.2',
owner='jack', foo='change2')
self.t3 = self.created + timedelta(seconds=3)
self._modify_ticket('jim', 'Comment 3', self.t3, '3',
keywords='a, b', foo='change3')
self.t4 = self.created + timedelta(seconds=4)
self._modify_ticket('joe', 'Comment 4', self.t4, '4',
keywords='a', foo='change4')
def tearDown(self):
self.env.reset_db()
def test_delete_last_comment(self):
ticket = Ticket(self.env, self.id)
self.assertEqual('a', ticket['keywords'])
self.assertEqual('change4', ticket['foo'])
t = datetime.now(utc)
ticket.delete_change(cnum=4, when=t)
self.assertEqual('a, b', ticket['keywords'])
self.assertEqual('change3', ticket['foo'])
self.assertEqual(None, ticket.get_change(cnum=4))
self.assertNotEqual(None, ticket.get_change(cnum=3))
self.assertEqual(t, ticket.time_changed)
def test_delete_last_comment_when_custom_field_gone(self):
"""Regression test for http://trac.edgewall.org/ticket/10858"""
ticket = Ticket(self.env, self.id)
self.assertEqual('a', ticket['keywords'])
self.assertEqual('change4', ticket['foo'])
# we simulate the removal of the definition of the 'foo' custom field
self.env.config.remove('ticket-custom', 'foo')
del TicketSystem(self.env).fields
del TicketSystem(self.env).custom_fields
ticket = Ticket(self.env, self.id)
#
t = datetime.now(utc)
ticket.delete_change(cnum=4, when=t)
self.assertEqual('a, b', ticket['keywords'])
# 'foo' is no longer defined for the ticket
self.assertEqual(None, ticket['foo'])
# however, 'foo=change3' is still in the database
self.assertEqual([('change3',)], self.env.db_query("""
SELECT value FROM ticket_custom WHERE ticket=%s AND name='foo'
""", (self.id,)))
self.assertEqual(None, ticket.get_change(cnum=4))
self.assertNotEqual(None, ticket.get_change(cnum=3))
self.assertEqual(t, ticket.time_changed)
def test_delete_last_comment_by_date(self):
ticket = Ticket(self.env, self.id)
self.assertEqual('a', ticket['keywords'])
self.assertEqual('change4', ticket['foo'])
t = datetime.now(utc)
ticket.delete_change(cdate=self.t4, when=t)
self.assertEqual('a, b', ticket['keywords'])
self.assertEqual('change3', ticket['foo'])
self.assertEqual(None, ticket.get_change(cdate=self.t4))
self.assertNotEqual(None, ticket.get_change(cdate=self.t3))
self.assertEqual(t, ticket.time_changed)
def test_delete_mid_comment(self):
ticket = Ticket(self.env, self.id)
self.assertChange(ticket, 4, self.t4, 'joe',
comment=dict(author='joe', old='4', new='Comment 4'),
keywords=dict(author='joe', old='a, b', new='a'),
foo=dict(author='joe', old='change3', new='change4'))
t = datetime.now(utc)
ticket.delete_change(cnum=3, when=t)
self.assertEqual(None, ticket.get_change(cnum=3))
self.assertEqual('a', ticket['keywords'])
self.assertChange(ticket, 4, self.t4, 'joe',
comment=dict(author='joe', old='4', new='Comment 4'),
keywords=dict(author='joe', old='a, b, c', new='a'),
foo=dict(author='joe', old='change2', new='change4'))
self.assertEqual(t, ticket.time_changed)
def test_delete_mid_comment_by_date(self):
ticket = Ticket(self.env, self.id)
self.assertChange(ticket, 4, self.t4, 'joe',
comment=dict(author='joe', old='4', new='Comment 4'),
keywords=dict(author='joe', old='a, b', new='a'),
foo=dict(author='joe', old='change3', new='change4'))
t = datetime.now(utc)
ticket.delete_change(cdate=self.t3, when=t)
self.assertEqual(None, ticket.get_change(cdate=self.t3))
self.assertEqual('a', ticket['keywords'])
self.assertChange(ticket, 4, self.t4, 'joe',
comment=dict(author='joe', old='4', new='Comment 4'),
#.........这里部分代码省略.........
示例10: CacheTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class CacheTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.log = self.env.log
self.env.db_transaction.executemany(
"INSERT INTO repository (id, name, value) VALUES (%s, %s, %s)",
[(1, 'name', 'test-repos'),
(1, 'youngest_rev', '')])
def tearDown(self):
self.env.reset_db()
# Helpers
def get_repos(self, get_changeset=None, youngest_rev=1):
if get_changeset is None:
def no_changeset(rev):
raise NoSuchChangeset(rev)
get_changeset = no_changeset
return Mock(Repository, 'test-repos', {'name': 'test-repos', 'id': 1},
self.log,
get_changeset=get_changeset,
get_oldest_rev=lambda: 0,
get_youngest_rev=lambda: youngest_rev,
normalize_rev=lambda x: get_changeset(x).rev,
next_rev=(lambda x: int(x) < youngest_rev and x + 1 \
or None))
def preset_cache(self, *args):
"""Each arg is a (rev tuple, changes list of tuples) pair."""
with self.env.db_transaction as db:
for rev, changes in args:
db("""INSERT INTO revision (repos, rev, time, author, message)
VALUES (1,%s,%s,%s,%s)
""", rev)
if changes:
db.executemany("""
INSERT INTO node_change (repos, rev, path, node_type,
change_type, base_path,
base_rev)
VALUES (1, %s, %s, %s, %s, %s, %s)
""", [(rev[0],) + change for change in changes])
db("""UPDATE repository SET value=%s
WHERE id=1 AND name='youngest_rev'
""", (args[-1][0][0],))
# Tests
def test_initial_sync_with_empty_repos(self):
repos = self.get_repos()
cache = CachedRepository(self.env, repos, self.log)
cache.sync()
with self.env.db_query as db:
self.assertEqual([], db(
"SELECT rev, time, author, message FROM revision"))
self.assertEqual(0, db("SELECT COUNT(*) FROM node_change")[0][0])
def test_initial_sync(self):
t1 = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
t2 = datetime(2002, 1, 1, 1, 1, 1, 0, utc)
repos = self.get_repos(get_changeset=lambda x: changesets[int(x)],
youngest_rev=1)
changes = [('trunk', Node.DIRECTORY, Changeset.ADD, None, None),
('trunk/README', Node.FILE, Changeset.ADD, None, None)]
changesets = [Mock(Changeset, repos, 0, '', '', t1,
get_changes=lambda: []),
Mock(Changeset, repos, 1, 'Import', 'joe', t2,
get_changes=lambda: iter(changes))]
cache = CachedRepository(self.env, repos, self.log)
cache.sync()
with self.env.db_query as db:
rows = db("SELECT rev, time, author, message FROM revision")
self.assertEqual(len(rows), 2)
self.assertEqual(('0', to_utimestamp(t1), '', ''), rows[0])
self.assertEqual(('1', to_utimestamp(t2), 'joe', 'Import'),
rows[1])
rows = db("""
SELECT rev, path, node_type, change_type, base_path, base_rev
FROM node_change""")
self.assertEqual(len(rows), 2)
self.assertEqual(('1', 'trunk', 'D', 'A', None, None), rows[0])
self.assertEqual(('1', 'trunk/README', 'F', 'A', None, None),
rows[1])
def test_update_sync(self):
t1 = datetime(2001, 1, 1, 1, 1, 1, 0, utc)
t2 = datetime(2002, 1, 1, 1, 1, 1, 0, utc)
t3 = datetime(2003, 1, 1, 1, 1, 1, 0, utc)
self.preset_cache(
(('0', to_utimestamp(t1), '', ''), []),
(('1', to_utimestamp(t2), 'joe', 'Import'),
[('trunk', 'D', 'A', None, None),
('trunk/README', 'F', 'A', None, None)]),
)
repos = self.get_repos(get_changeset=lambda x: changesets[int(x)],
youngest_rev=2)
changes = [('trunk/README', Node.FILE, Changeset.EDIT, 'trunk/README',
#.........这里部分代码省略.........
示例11: TagModelTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class TagModelTestCase(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.check_perm = WikiTagProvider(self.env).check_permission
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()
# Populate table with initial test data.
self.env.db_transaction("""
INSERT INTO tags (tagspace, name, tag)
VALUES ('wiki', 'WikiStart', 'tag1')
""")
self.realm = 'wiki'
def tearDown(self):
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _revert_tractags_schema_init(self):
with self.env.db_transaction as db:
db("DROP TABLE IF EXISTS tags")
db("DROP TABLE IF EXISTS tags_change")
db("DELETE FROM system WHERE name='tags_version'")
db("DELETE FROM permission WHERE action %s" % db.like(),
('TAGS_%',))
def _tags(self):
tags = {}
for name, tag in self.env.db_query("""
SELECT name,tag FROM tags
"""):
if name in tags:
tags[name].add(tag)
else:
tags[name] = set([tag])
return tags
# Tests
def test_get_tags(self):
resource = Resource(self.realm, 'WikiStart')
self.assertEquals([tag for tag in resource_tags(self.env, resource)],
['tag1'])
def test_get_tagged_resource_no_perm(self):
self.perms.revoke_permission('anonymous', 'WIKI_VIEW')
perm = PermissionCache(self.env)
tags = set(['tag1'])
# Don't yield resource without permission - 'WIKI_VIEW' here.
self.assertEqual([(res, tags) for res, tags
in tagged_resources(self.env, self.check_perm, perm,
self.realm, tags)], [])
def test_get_tagged_resource(self):
perm = PermissionCache(self.env)
resource = Resource(self.realm, 'WikiStart')
tags = set(['tag1'])
self.assertEqual([(res, tags) for res, tags
in tagged_resources(self.env, self.check_perm, perm,
self.realm, tags)],
[(resource, tags)])
def test_reparent(self):
resource = Resource(self.realm, 'TaggedPage')
old_name = 'WikiStart'
tag_resource(self.env, resource, 'WikiStart', self.req.authname)
self.assertEquals(dict(TaggedPage=set(['tag1'])), self._tags())
def test_tag_changes(self):
# Add previously untagged resource.
resource = Resource(self.realm, 'TaggedPage')
tags = set(['tag1'])
tag_resource(self.env, resource, author=self.req.authname, tags=tags)
self.assertEquals(dict(TaggedPage=tags, WikiStart=tags), self._tags())
# Add new tag to already tagged resource.
resource = Resource(self.realm, 'WikiStart')
tags = set(['tag1', 'tag2'])
tag_resource(self.env, resource, author=self.req.authname, tags=tags)
self.assertEquals(dict(TaggedPage=set(['tag1']), WikiStart=tags),
self._tags())
# Exchange tags for already tagged resource.
tags = set(['tag1', 'tag3'])
tag_resource(self.env, resource, author=self.req.authname, tags=tags)
self.assertEquals(dict(TaggedPage=set(['tag1']), WikiStart=tags),
self._tags())
# Delete a subset of tags for already tagged resource.
tags = set(['tag3'])
tag_resource(self.env, resource, author=self.req.authname, tags=tags)
self.assertEquals(dict(TaggedPage=set(['tag1']), WikiStart=tags),
#.........这里部分代码省略.........
示例12: SessionTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class SessionTestCase(unittest.TestCase):
"""Unit tests for the persistent session support."""
def setUp(self):
self.env = EnvironmentStub()
def tearDown(self):
self.env.reset_db()
def test_new_session(self):
"""
Verify that a session cookie gets sent back to the client for a new
session.
"""
cookie = Cookie()
req = Mock(incookie=Cookie(), outcookie=cookie, authname='anonymous',
base_path='/')
session = Session(self.env, req)
self.assertEqual(session.sid, cookie['trac_session'].value)
self.assertEqual(0, self.env.db_query(
"SELECT COUNT(*) FROM session")[0][0])
def test_anonymous_session(self):
"""
Verify that session variables are stored in the database.
"""
incookie = Cookie()
incookie['trac_session'] = '123456'
outcookie = Cookie()
req = Mock(authname='anonymous', base_path='/', incookie=incookie,
outcookie=outcookie)
session = Session(self.env, req)
self.assertEquals('123456', session.sid)
self.failIf(outcookie.has_key('trac_session'))
def test_authenticated_session(self):
"""
Verifies that a session cookie does not get used if the user is logged
in, and that Trac expires the cookie.
"""
incookie = Cookie()
incookie['trac_session'] = '123456'
outcookie = Cookie()
req = Mock(authname='john', base_path='/', incookie=incookie,
outcookie=outcookie)
session = Session(self.env, req)
self.assertEqual('john', session.sid)
session['foo'] = 'bar'
session.save()
self.assertEquals(0, outcookie['trac_session']['expires'])
def test_session_promotion(self):
"""
Verifies that an existing anonymous session gets promoted to an
authenticated session when the user logs in.
"""
with self.env.db_transaction as db:
db("INSERT INTO session VALUES ('123456', 0, 0)")
incookie = Cookie()
incookie['trac_session'] = '123456'
outcookie = Cookie()
req = Mock(authname='john', base_path='/', incookie=incookie,
outcookie=outcookie)
session = Session(self.env, req)
self.assertEqual('john', session.sid)
session.save()
self.assertEqual([('john', 1)], self.env.db_query(
"SELECT sid, authenticated FROM session"))
def test_new_session_promotion(self):
"""
Verifies that even without a preexisting anonymous session,
an authenticated session will be created when the user logs in.
(same test as above without the initial INSERT)
"""
with self.env.db_transaction as db:
incookie = Cookie()
incookie['trac_session'] = '123456'
outcookie = Cookie()
req = Mock(authname='john', base_path='/', incookie=incookie,
outcookie=outcookie)
session = Session(self.env, req)
self.assertEqual('john', session.sid)
session.save()
self.assertEqual([('john', 1)], self.env.db_query(
"SELECT sid, authenticated FROM session"))
def test_add_anonymous_session_var(self):
"""
Verify that new variables are inserted into the 'session' table in the
database for an anonymous session.
"""
incookie = Cookie()
incookie['trac_session'] = '123456'
req = Mock(authname='anonymous', base_path='/', incookie=incookie,
outcookie=Cookie())
session = Session(self.env, req)
session['foo'] = 'bar'
#.........这里部分代码省略.........
示例13: LoginModuleTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class LoginModuleTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub()
self.module = LoginModule(self.env)
def tearDown(self):
self.env.reset_db()
def test_anonymous_access(self):
req = Mock(incookie=Cookie(), href=Href('/trac.cgi'),
remote_addr='127.0.0.1', remote_user=None,
base_path='/trac.cgi')
self.assertEqual(None, self.module.authenticate(req))
def test_unknown_cookie_access(self):
incookie = Cookie()
incookie['trac_auth'] = '123'
req = Mock(cgi_location='/trac', href=Href('/trac.cgi'),
incookie=incookie, outcookie=Cookie(),
remote_addr='127.0.0.1', remote_user=None,
base_path='/trac.cgi')
self.assertEqual(None, self.module.authenticate(req))
def test_known_cookie_access(self):
self.env.db_transaction("""
INSERT INTO auth_cookie (cookie, name, ipnr)
VALUES ('123', 'john', '127.0.0.1')""")
incookie = Cookie()
incookie['trac_auth'] = '123'
outcookie = Cookie()
req = Mock(incookie=incookie, outcookie=outcookie,
href=Href('/trac.cgi'), base_path='/trac.cgi',
remote_addr='127.0.0.1', remote_user=None)
self.assertEqual('john', self.module.authenticate(req))
self.failIf('auth_cookie' in req.outcookie)
def test_known_cookie_ip_check_enabled(self):
self.env.config.set('trac', 'check_auth_ip', 'yes')
self.env.db_transaction("""
INSERT INTO auth_cookie (cookie, name, ipnr)
VALUES ('123', 'john', '127.0.0.1')""")
incookie = Cookie()
incookie['trac_auth'] = '123'
outcookie = Cookie()
req = Mock(cgi_location='/trac', href=Href('/trac.cgi'),
incookie=incookie, outcookie=outcookie,
remote_addr='192.168.0.100', remote_user=None,
base_path='/trac.cgi')
self.assertEqual(None, self.module.authenticate(req))
self.failIf('trac_auth' not in req.outcookie)
def test_known_cookie_ip_check_disabled(self):
self.env.config.set('trac', 'check_auth_ip', 'no')
self.env.db_transaction("""
INSERT INTO auth_cookie (cookie, name, ipnr)
VALUES ('123', 'john', '127.0.0.1')""")
incookie = Cookie()
incookie['trac_auth'] = '123'
outcookie = Cookie()
req = Mock(incookie=incookie, outcookie=outcookie,
href=Href('/trac.cgi'), base_path='/trac.cgi',
remote_addr='192.168.0.100', remote_user=None)
self.assertEqual('john', self.module.authenticate(req))
self.failIf('auth_cookie' in req.outcookie)
def test_login(self):
outcookie = Cookie()
# remote_user must be upper case to test that by default, case is
# preserved.
req = Mock(cgi_location='/trac', href=Href('/trac.cgi'),
incookie=Cookie(), outcookie=outcookie,
remote_addr='127.0.0.1', remote_user='john',
authname='john', base_path='/trac.cgi')
self.module._do_login(req)
assert outcookie.has_key('trac_auth'), '"trac_auth" Cookie not set'
auth_cookie = outcookie['trac_auth'].value
self.assertEquals([('john', '127.0.0.1')], self.env.db_query(
"SELECT name, ipnr FROM auth_cookie WHERE cookie=%s",
(auth_cookie,)))
def test_login_ignore_case(self):
"""
Test that login is succesful when the usernames differ in case, but case
is ignored.
"""
self.env.config.set('trac', 'ignore_auth_case', 'yes')
outcookie = Cookie()
req = Mock(cgi_location='/trac', href=Href('/trac.cgi'),
incookie=Cookie(), outcookie=outcookie,
remote_addr='127.0.0.1', remote_user='John',
authname='anonymous', base_path='/trac.cgi')
self.module._do_login(req)
assert outcookie.has_key('trac_auth'), '"trac_auth" Cookie not set'
auth_cookie = outcookie['trac_auth'].value
self.assertEquals([('john', '127.0.0.1')], self.env.db_query(
#.........这里部分代码省略.........
示例14: WikiTagProviderTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class WikiTagProviderTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
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.perms = PermissionSystem(self.env)
self.tag_s = TagSystem(self.env)
self.tag_wp = WikiTagProvider(self.env)
# Populate table with initial test data.
self.env.db_transaction("""
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)
self.realm = 'wiki'
self.tags = ['tag1']
def tearDown(self):
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _revert_tractags_schema_init(self):
_revert_tractags_schema_init(self.env)
# Tests
def test_get_tags(self):
resource = Resource('wiki', 'WikiStart')
self.assertEquals([tag for tag in
self.tag_wp.get_resource_tags(self.req, resource)],
self.tags)
def test_exclude_template_tags(self):
# Populate table with more test data.
self.env.db_transaction("""
INSERT INTO tags (tagspace, name, tag)
VALUES ('wiki', 'PageTemplates/Template', 'tag2')
""")
tags = ['tag1', 'tag2']
self.assertEquals(self.tag_s.get_all_tags(self.req).keys(), self.tags)
self.env.config.set('tags', 'query_exclude_wiki_templates', False)
self.assertEquals(self.tag_s.get_all_tags(self.req).keys(), tags)
def test_set_tags_no_perms(self):
resource = Resource('wiki', 'TaggedPage')
self.assertRaises(PermissionError, self.tag_wp.set_resource_tags,
self.req, resource, self.tags)
def test_set_tags(self):
resource = Resource('wiki', 'TaggedPage')
self.req.perm = PermissionCache(self.env, username='editor')
# Shouldn't raise an error with appropriate permission.
self.tag_wp.set_resource_tags(self.req, resource, self.tags)
self.tag_wp.set_resource_tags(self.req, resource, ['tag2'])
# Check change records.
rows = self.env.db_query("""
SELECT author,oldtags,newtags FROM tags_change
WHERE tagspace=%s AND name=%s
ORDER by time DESC
""", ('wiki', 'TaggedPage'))
self.assertEqual(rows[0], ('editor', 'tag1', 'tag2'))
self.assertEqual(rows[1], ('editor', '', 'tag1'))
示例15: TicketTagProviderTestCase
# 需要导入模块: from trac.test import EnvironmentStub [as 别名]
# 或者: from trac.test.EnvironmentStub import db_query [as 别名]
class TicketTagProviderTestCase(unittest.TestCase):
def setUp(self):
self.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
self.env.path = tempfile.mkdtemp()
self.perms = PermissionSystem(self.env)
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.provider = TicketTagProvider(self.env)
self.realm = 'ticket'
self.tag_sys = TagSystem(self.env)
self.tags = ['tag1', 'tag2']
# Populate tables with initial test data.
self._create_ticket(self.tags)
# Mock an anonymous request.
self.anon_req = Mock()
self.anon_req.perm = PermissionCache(self.env)
self.req = Mock(authname='editor')
self.req.authname = 'editor'
self.req.perm = PermissionCache(self.env, username='editor')
def tearDown(self):
self.env.shutdown()
shutil.rmtree(self.env.path)
# Helpers
def _create_ticket(self, tags, **kwargs):
ticket = Ticket(self.env)
ticket['keywords'] = u' '.join(sorted(map(to_unicode, tags)))
ticket['summary'] = 'summary'
ticket['reporter'] = 'admin'
for name, value in kwargs.iteritems():
ticket[name] = value
ticket.insert()
return ticket
def _revert_tractags_schema_init(self):
with self.env.db_transaction as db:
db("DROP TABLE IF EXISTS tags")
db("DROP TABLE IF EXISTS tags_change")
db("DELETE FROM system WHERE name='tags_version'")
db("DELETE FROM permission WHERE action %s" % db.like(),
('TAGS_%',))
def _tags(self):
tags = {}
for name, tag in self.env.db_query("""
SELECT name,tag FROM tags
"""):
if name in tags:
tags[name].add(tag)
else:
tags[name] = set([tag])
return tags
# Tests
def test_get_tagged_resources(self):
# No tags, no restrictions, all resources.
self.assertEquals(
[r for r in
self.provider.get_tagged_resources(self.req, None)][0][1],
set(self.tags))
# Force fine-grained perm-check check for all tags, not just the one
# from query.
self.provider.fast_permcheck = False
self.assertEquals(
[r for r in
self.provider.get_tagged_resources(self.req,
set(self.tags[:1]))][0][1],
set(self.tags))
def test_get_tags(self):
resource = Resource('ticket', 2)
self.assertRaises(ResourceNotFound, self.provider.get_resource_tags,
self.req, resource)
self._create_ticket(self.tags)
self.assertEquals(
[tag for tag in
self.provider.get_resource_tags(self.req, resource)], self.tags)
#ignore_closed_tickets
def test_set_tags(self):
tags = ['tag3']
ticket = Ticket(self.env, 1)
ticket['keywords'] = tags[0]
# Tags get updated by TicketChangeListener method.
ticket.save_changes(self.req.authname)
self.assertEquals(self.tag_sys.get_all_tags(self.req).keys(), tags)
#.........这里部分代码省略.........