def test_default_links(self):
req = Request(abs_href=Href('http://example.org/trac.cgi'),
href=Href('/trac.cgi'),
base_path='/trac.cgi',
path_info='',
add_redirect_listener=lambda listener: None)
links = Chrome(self.env).prepare_request(req)['links']
self.assertEqual('/trac.cgi/wiki', links['start'][0]['href'])
self.assertEqual('/trac.cgi/search', links['search'][0]['href'])
self.assertEqual('/trac.cgi/wiki/TracGuide', links['help'][0]['href'])
self.assertEqual('/trac.cgi/chrome/common/css/trac.css',
links['stylesheet'][0]['href'])
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.req = Mock(base_path='',
chrome={},
args={},
session={},
abs_href=Href('/'),
href=Href('/'),
locale='',
perm=MockPerm(),
authname=None,
tz=None)
self.report_module = ReportModule(self.env)
def setUp(self):
self.env = EnvironmentStub(enable=[AutoWikify])
self.req = Mock(
authname='anonymous', perm=MockPerm(), tz=None, args={},
href=Href('/'), abs_href=Href('http://www.example.com/'))
self.autowikify = AutoWikify(self.env)
for name in (u'autowikify', u'あいうName', u'Nameあいう',
u'かきくけこ'):
page = WikiPage(self.env, name)
page.text = name
page.save('admin', '', '::1')
self.context = Context.from_request(self.req, WikiPage(self.env, name))
def _default_base_href(user=None, prefix=None, envname=None):
if envname not in (self.bh_install_project, None):
raise LookupError('Unknown environment ' + repr(envname))
# TODO: Does not generate /login ? Should it ?
parts = urllib2.urlparse.urlsplit(self.url)
if not user or user == 'anonymous':
global_href = Href('%s://%s/' % (parts[0], parts[1]))
else:
global_href = Href('%s://%s:%s@%s/' %
(parts[0], user, user, parts[1]))
# FIXME : Check that prefix is None is correct
return global_href if (prefix is None or prefix == GLOBAL_ENV) \
else Href(global_href('products', prefix))
def get_env_href(self, user=None, prefix=None, envname=None):
"""Default implementation just returning href object for global
environment and failing if product prefix is specified.
"""
if envname not in (self.bh_install_project, None):
raise LookupError('Unknown environment ' + repr(envname))
if prefix is not None:
self._fail_no_mp_setup()
parts = urllib2.urlparse.urlsplit(self.url)
if not user or user == 'anonymous':
return Href('%s://%s/' % (parts[0], parts[1]))
else:
return Href('%s://%s:%s@%s/' % (parts[0], user, user, parts[1]))
def setUp(self):
_BaseTestCase.setUp(self)
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.tag_twm = TagWikiMacros(self.env)
def test_nav_contributor_order(self):
class TestNavigationContributor1(Component):
implements(INavigationContributor)
def get_active_navigation_item(self, req):
return None
def get_navigation_items(self, req):
yield 'metanav', 'test1', 'Test 1'
class TestNavigationContributor2(Component):
implements(INavigationContributor)
def get_active_navigation_item(self, req):
return None
def get_navigation_items(self, req):
yield 'metanav', 'test2', 'Test 2'
req = Request(abs_href=Href('http://example.org/trac.cgi'),
href=Href('/trac.cgi'),
base_path='/trac.cgi',
path_info='/',
add_redirect_listener=lambda listener: None)
chrome = Chrome(self.env)
# Test with both items set in the order option
self.env.config.set('trac', 'metanav', 'test2, test1')
items = chrome.prepare_request(req)['nav']['metanav']
self.assertEqual('test2', items[0]['name'])
self.assertEqual('test1', items[1]['name'])
# Test with only test1 in the order options
self.env.config.set('trac', 'metanav', 'test1')
items = chrome.prepare_request(req)['nav']['metanav']
self.assertEqual('test1', items[0]['name'])
self.assertEqual('test2', items[1]['name'])
# Test with only test2 in the order options
self.env.config.set('trac', 'metanav', 'test2')
items = chrome.prepare_request(req)['nav']['metanav']
self.assertEqual('test2', items[0]['name'])
self.assertEqual('test1', items[1]['name'])
# Test with none in the order options (order corresponds to
# registration order)
self.env.config.set('trac', 'metanav', 'foo, bar')
items = chrome.prepare_request(req)['nav']['metanav']
self.assertEqual('test1', items[0]['name'])
self.assertEqual('test2', items[1]['name'])
def setUp(self):
""" Set up the testing environment. """
self.env = EnvironmentStub(enable=[CodeExample])
self.req = Mock(base_path='',
chrome={},
args={},
abs_href=Href('/'),
href=Href('/'),
session={},
perm=[],
authname=None,
tz=None,
locale='utf-8')
self.context = Context.from_request(self.req)
def wiki_setup(tc):
tc.env = EnvironmentStub(default_data=True,
enable=['trac.*', 'tractags.*'])
tc.env.path = tempfile.mkdtemp()
tc.db_mgr = DatabaseManager(tc.env)
tc.db = tc.env.get_db_cnx()
cursor = tc.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" % tc.db.like(),
('TAGS_%', ))
TagSetup(tc.env).upgrade_environment(tc.db)
now = datetime.now(utc)
wiki = WikiPage(tc.env)
wiki.name = 'TestPage'
wiki.text = '--'
wiki.save('joe', 'TagsPluginTestPage', '::1', now)
cursor = tc.db.cursor()
# Populate table with initial test data.
cursor.executemany(
"""
INSERT INTO tags
(tagspace, name, tag)
VALUES (%s,%s,%s)
""", [
('wiki', 'TestPage', '2ndtag'),
('wiki', 'TestPage', 'a.really?_\wild-thing'),
('wiki', 'TestPage', 'heavily-quoted'),
('wiki', 'TestPage', 'onetag'),
('wiki', 'TestPage', 'tagged'),
('wiki', 'TestPage', "single'quote"),
])
req = Mock(href=Href('/'),
abs_href=Href('http://www.example.com/'),
authname='anonymous',
perm=MockPerm(),
tz=utc,
args={},
locale=locale_en)
tc.env.href = req.href
tc.env.abs_href = req.abs_href
tc.context = Context.from_request(req)
# Enable big diff output.
tc.maxDiff = None
def test_nav_contributor(self):
class TestNavigationContributor(Component):
implements(INavigationContributor)
def get_active_navigation_item(self, req):
return None
def get_navigation_items(self, req):
yield 'metanav', 'test', 'Test'
req = Request(abs_href=Href('http://example.org/trac.cgi'),
href=Href('/trac.cgi'), path_info='/',
base_path='/trac.cgi',
add_redirect_listener=lambda listener: None)
nav = Chrome(self.env).prepare_request(req)['nav']
self.assertEqual({'name': 'test', 'label': 'Test', 'active': False},
nav['metanav'][0])
def __init__(self, default_data=False, enable=None):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
"""
ComponentManager.__init__(self)
Component.__init__(self)
self.systeminfo = []
import trac
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'stderr')
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
# -- logging
from trac.log import logger_handler_factory
self.log, self._log_handler = logger_handler_factory('test')
# -- database
self.dburi = get_dburi()
if self.dburi.startswith('sqlite'):
self.config.set('trac', 'database', 'sqlite::memory:')
self.db = InMemoryDatabase()
if default_data:
self.reset_db(default_data)
from trac.web.href import Href
self.href = Href('/trac.cgi')
self.abs_href = Href('http://example.org/trac.cgi')
self.known_users = []
translation.activate(Locale and Locale('en', 'US'))
def _prepare_env(self):
all_test_components = [
formatter.HelloWorldMacro, formatter.DivHelloWorldMacro,
formatter.TableHelloWorldMacro, formatter.DivCodeMacro,
formatter.DivCodeElementMacro, formatter.DivCodeStreamMacro,
formatter.NoneMacro, formatter.WikiProcessorSampleMacro,
formatter.SampleResolver
]
self.global_env = self._setup_test_env(
enable=['trac.*', 'multiproduct.*'] + all_test_components)
self._upgrade_mp(self.global_env)
self._load_product_from_data(self.global_env, self.default_product)
prefix = self.default_product
if self.mpctx:
prefix = self.mpctx.get('setup_product', prefix)
if prefix and prefix != self.default_product:
self._load_product_from_data(self.global_env, prefix)
if prefix:
self.env = ProductEnvironment(self.global_env, prefix
or self.default_product)
else:
self.env = self.global_env
self.env.path = ''
config = self.env.config
# -- intertrac support
config.set('intertrac', 'trac.title', "Trac's Trac")
config.set('intertrac', 'trac.url', "http://trac.edgewall.org")
config.set('intertrac', 't', 'trac')
config.set('intertrac', 'th.title', "Trac Hacks")
config.set('intertrac', 'th.url', "http://trac-hacks.org")
config.set('intertrac', 'th.compat', 'false')
# -- safe schemes
config.set(
'wiki', 'safe_schemes', 'file,ftp,http,https,svn,svn+ssh,'
'rfc-2396.compatible,rfc-2396+under_score')
req = Mock(href=Href('/'),
abs_href=Href('http://www.example.com/'),
authname='anonymous',
perm=MockPerm(),
tz=utc,
args={},
locale=locale_en,
lc_time=locale_en)
self.env.href = req.href
self.env.abs_href = req.abs_href
def test_quoted_id_with_var(self):
req = Mock(base_path='', chrome={}, args={}, session={},
abs_href=Href('/'), href=Href('/'), locale='',
perm=MockPerm(), authname=None, tz=None)
db = self.env.get_read_db()
name = """%s"`'%%%?"""
sql = 'SELECT 1 AS %s, $USER AS user' % db.quote(name)
rv = self.report_module.execute_paginated_report(req, 1, sql,
{'USER': '******'})
self.assertEqual(5, len(rv), repr(rv))
cols, results, num_items, missing_args, limit_offset = rv
self.assertEqual([name, 'user'], cols)
self.assertEqual([(1, 'joe')], results)
self.assertEqual([], missing_args)
self.assertEqual(None, limit_offset)
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', '')))
def test_navigation_item_customization(self):
class TestNavigationContributor1(Component):
implements(INavigationContributor)
def get_active_navigation_item(self, req):
return None
def get_navigation_items(self, req):
yield 'mainnav', 'test1', 'Test 1'
class TestNavigationContributor2(Component):
implements(INavigationContributor)
def get_active_navigation_item(self, req):
return None
def get_navigation_items(self, req):
yield 'mainnav', 'test2', 'Test 2'
class TestNavigationContributor3(Component):
implements(INavigationContributor)
def get_active_navigation_item(self, req):
return None
def get_navigation_items(self, req):
yield 'mainnav', 'test3', 'Test 3'
req = Request(abs_href=Href('http://example.org/trac.cgi'),
href=Href('/trac.cgi'),
base_path='/trac.cgi',
path_info='/',
add_redirect_listener=lambda listener: None)
self.env.config.set('mainnav', 'test2.href', 'testtwo')
self.env.config.set('mainnav', 'test3.label', 'Test Three')
self.env.config.set('mainnav', 'test3.href', 'testthree')
chrome = Chrome(self.env)
items = chrome.prepare_request(req)['nav']['mainnav']
item = self._get_navigation_item(items, 'test1')
self.assertEqual('Test 1', item['label'])
item = self._get_navigation_item(items, 'test2')
self.assertEqual(str(tag.a('Test 2', href='testtwo')),
str(item['label']))
item = self._get_navigation_item(items, 'test3')
self.assertEqual(str(tag.a('Test Three', href='testthree')),
str(item['label']))
def test_add_jquery_ui_timezone_list_has_z(self):
chrome = Chrome(self.env)
req = Request(href=Href('/trac.cgi'), lc_time='iso8601')
chrome.add_jquery_ui(req)
self.assertIn({
'value': 'Z',
'label': '+00:00'
}, req.chrome['script_data']['jquery_ui']['timezone_list'])
req = Request(href=Href('/trac.cgi'), lc_time=locale_en)
chrome.add_jquery_ui(req)
self.assertIn({
'value': 'Z',
'label': '+00:00'
}, req.chrome['script_data']['jquery_ui']['timezone_list'])
def test_process_edit_platform(self):
BuildConfig(self.env,
name='foo',
label='Foo',
path='branches/foo',
active=True).insert()
platform = TargetPlatform(self.env, config='foo', name='any')
platform.insert()
req = Mock(method='GET',
chrome={},
href=Href('/'),
perm=PermissionCache(self.env, 'joe'),
args={})
provider = BuildConfigurationsAdminPageProvider(self.env)
template_name, data = provider.render_admin_panel(
req, 'bitten', 'configs', 'foo/%d' % platform.id)
self.assertEqual('bitten_admin_configs.html', template_name)
assert 'platform' in data
platform = data['platform']
self.assertEqual(
{
'id': 1,
'exists': True,
'name': 'any',
'rules': [('', '')],
}, platform)
class TracForgeLoginModule(LoginModule):
"""Replacement for LoginModule to slave to another environment."""
master_path = Option('tracforge', 'master_path', doc='Path to master Trac')
master_env = property(lambda self: _open_environment(self.master_path))
master_href = property(lambda self: Href(self.master_env.base_url))
# INavigationContributor methods
def get_active_navigation_item(self, req):
return 'login'
def get_navigation_items(self, req):
if req.authname and req.authname != 'anonymous':
yield ('metanav', 'login', 'logged in as %s' % req.authname)
yield ('metanav', 'logout',
html.A('Logout', href=self.master_href.logout()))
else:
yield ('metanav', 'login',
html.A('Login', href=self.master_href.login()))
# IRequestHandler methods
def process_request(self, req):
if req.path_info.startswith('/login'):
if req.authname and req.authname != 'anonymous':
# Already logged in, reconstruct last path
req.redirect(req.href())
else:
# Safe, send to master
req.redirect(self.master_href.login())
raise TracError
# Internal methods
def _get_name_for_cookie(self, req, cookie):
return LoginModule(self.master_env)._get_name_for_cookie(req, cookie)
def test_process_add_config_cancel(self):
redirected_to = []
def redirect(url):
redirected_to.append(url)
raise RequestDone
req = Mock(method='POST',
perm=PermissionCache(self.env, 'joe'),
abs_href=Href('http://example.org/'),
redirect=redirect,
args={
'cancel': '',
'name': 'bar',
'label': 'Bar'
})
provider = BuildConfigurationsAdminPageProvider(self.env)
try:
provider.render_admin_panel(req, 'bitten', 'configs', '')
self.fail('Expected RequestDone')
except RequestDone:
self.assertEqual('http://example.org/admin/bitten/configs',
redirected_to[0])
configs = list(BuildConfig.select(self.env, include_inactive=True))
self.assertEqual(0, len(configs))
def test_add_optional_select(self):
# http://trac-hacks.org/ticket/1834
_redirect_url = ''
def redirect(url):
_redirect_url = url
raise RequestDone
req = Mock(perm=PermissionCache(self.env, 'admin'),
authname='admin',
chrome={},
href=Href('/'),
redirect=redirect,
method='POST',
args={
'add': True,
'name': "test",
'type': "select",
'label': "testing",
'options': "\r\none\r\ntwo"
})
try:
self.plugin.render_admin_panel(req, 'ticket', 'customfields', None)
except RequestDone, e:
self.assertEquals(
sorted(list(self.env.config.options('ticket-custom'))),
[(u'test', u'select'), (u'test.label', u'testing'),
(u'test.options', u'|one|two'), (u'test.order', u'1'),
(u'test.value', u'')])
def test_apply_optional_select(self):
# Reuse the added custom field that test verified to work
self.test_add_optional_select()
self.assertEquals('select',
self.env.config.get('ticket-custom', 'test'))
# Now check that details are maintained across order change
# that reads fields, deletes them, and creates them again
# http://trac-hacks.org/ticket/1834#comment:5
_redirect_url = ''
def redirect(url):
_redirect_url = url
raise RequestDone
req = Mock(perm=PermissionCache(self.env, 'admin'),
authname='admin',
chrome={},
href=Href('/'),
redirect=redirect,
method='POST',
args={
'apply': True,
'order_test': '2'
})
try:
self.plugin.render_admin_panel(req, 'ticket', 'customfields', None)
except RequestDone, e:
self.assertEquals(
sorted(list(self.env.config.options('ticket-custom'))),
[(u'test', u'select'), (u'test.label', u'testing'),
(u'test.options', u'|one|two'), (u'test.order', u'2'),
(u'test.value', u'')])
def test_order_with_mismatched_keys(self):
# http://trac-hacks.org/ticket/11540
self.api.create_custom_field({
'name': u'one',
'format': 'plain',
'value': '',
'label': u'One',
'type': u'text',
'order': 1
})
def redirect(url):
raise RequestDone
req = Mock(perm=PermissionCache(self.env, 'admin'),
authname='admin',
chrome={},
href=Href('/'),
redirect=redirect,
method='POST',
args={
'apply': True,
'order_two': '1'
})
try:
self.plugin.render_admin_panel(req, 'ticket', 'customfields', None)
except RequestDone, e:
pass
def test_create(self):
_redirect_url = ''
def redirect(url):
_redirect_url = url
raise RequestDone
req = Mock(perm=PermissionCache(self.env, 'admin'),
authname='admin',
chrome={},
href=Href('/'),
redirect=redirect,
method='POST',
args={
'add': True,
'name': "test",
'type': "textarea",
'label': "testing",
'format': "wiki",
'row': '9',
'columns': '42'
})
try:
self.plugin.render_admin_panel(req, 'ticket', 'customfields', None)
except RequestDone, e:
self.assertEquals(
sorted(list(self.env.config.options('ticket-custom'))),
[(u'test', u'textarea'), (u'test.cols', u'60'),
(u'test.format', u'wiki'), (u'test.label', u'testing'),
(u'test.options', u''), (u'test.order', u'1'),
(u'test.rows', u'5'), (u'test.value', u'')])
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.assertIsNone(self.module.authenticate(req))
def test_edit_optional_select(self):
self.test_add_optional_select()
self.assertEquals('select',
self.env.config.get('ticket-custom', 'test'))
_redirect_url = ''
def redirect(url):
_redirect_url = url
raise RequestDone
req = Mock(perm=PermissionCache(self.env, 'admin'),
authname='admin',
chrome={},
href=Href('/'),
redirect=redirect,
method='POST',
args={
'save': True,
'name': u'test',
'label': u'testing',
'type': u'select',
'value': u'',
'options': u'\r\none\r\ntwo'
})
try:
self.plugin.render_admin_panel(req, 'ticket', 'customfields',
'test')
except RequestDone, e:
self.assertEquals(
sorted(list(self.env.config.options('ticket-custom'))),
[(u'test', u'select'), (u'test.label', u'testing'),
(u'test.options', u'|one|two'), (u'test.order', u'2'),
(u'test.value', u'')])
def test_login_no_username(self):
req = Mock(incookie=Cookie(),
href=Href('/trac.cgi'),
remote_addr='127.0.0.1',
remote_user=None,
base_path='/trac.cgi')
self.assertRaises(TracError, self.module._do_login, req)
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='******',
authname='anonymous',
base_path='/trac.cgi')
self.module._do_login(req)
self.assertIn('trac_auth', outcookie, '"trac_auth" Cookie not set')
auth_cookie = outcookie['trac_auth'].value
self.assertEqual(
[('john', '127.0.0.1')],
self.env.db_query(
"SELECT name, ipnr FROM auth_cookie WHERE cookie=%s",
(auth_cookie, )))
def test_process_update_config_invalid_recipe(self):
BuildConfig(self.env,
name='foo',
label='Foo',
path='branches/foo',
active=True).insert()
req = Mock(method='POST',
perm=PermissionCache(self.env, 'joe'),
authname='joe',
chrome={'warnings': []},
href=Href('/'),
args={
'save': '',
'name': 'foo',
'recipe': '<build><step /></build>'
})
provider = BuildConfigurationsAdminPageProvider(self.env)
provider.render_admin_panel(req, 'bitten', 'configs', 'foo')
self.failUnless(req.chrome['warnings'], "No warnings?")
self.assertEquals(
req.chrome['warnings'],
['Invalid Recipe: Steps must have an "id" attribute.'])
def test_process_new_platform_no_name(self):
BuildConfig(self.env,
name='foo',
label='Foo',
path='branches/foo',
active=True).insert()
data = {}
req = Mock(method='POST',
chrome={},
hdf=data,
href=Href('/'),
perm=PermissionCache(self.env, 'joe'),
args={
'new': '',
'platform_name': ''
})
provider = BuildConfigurationsAdminPageProvider(self.env)
try:
provider.render_admin_panel(req, 'bitten', 'configs', 'foo')
self.fail("No TracError?")
except Exception, e:
self.assertEquals(e.message, 'Missing required field "name"')
self.assertEquals(e.title, 'Missing field')
def test_process_remove_platforms_no_selection(self):
BuildConfig(self.env,
name='foo',
label='Foo',
path='branches/foo',
active=True).insert()
platform = TargetPlatform(self.env, config='foo', name='any')
platform.insert()
redirected_to = []
def redirect(url):
redirected_to.append(url)
raise RequestDone
req = Mock(method='POST',
perm=PermissionCache(self.env, 'joe'),
abs_href=Href('http://example.org/'),
redirect=redirect,
authname='joe',
args={'remove': ''})
provider = BuildConfigurationsAdminPageProvider(self.env)
try:
provider.render_admin_panel(req, 'bitten', 'configs', 'foo')
self.fail('Expected TracError')
except TracError, e:
self.assertEqual('No platform selected', e.message)
