def test_csv_obfuscation(self):
class NoEmailView(MockPerm):
def has_permission(self,
action,
realm_or_resource=None,
id=False,
version=False):
return action != 'EMAIL_VIEW'
__contains__ = has_permission
query = Mock(get_columns=lambda: ['owner', 'reporter', 'cc'],
execute=lambda r: [{
'id': 1,
'owner': '*****@*****.**',
'reporter': '*****@*****.**',
'cc': '[email protected], cc2'
}],
time_fields=['time', 'changetime'])
req = Mock(href=self.env.href, perm=NoEmailView())
content, mimetype = QueryModule(self.env).export_csv(req, query)
self.assertEqual(
u'\uFEFFowner,reporter,cc\r\n'
u'joe@…,foo@…,"cc1@…, cc2"\r\n', content.decode('utf-8'))
req = Mock(href=self.env.href, perm=MockPerm())
content, mimetype = QueryModule(self.env).export_csv(req, query)
self.assertEqual(
u'\uFEFFowner,reporter,cc\r\n'
u'[email protected],[email protected],"[email protected], cc2"\r\n',
content.decode('utf-8'))
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.env.path = tempfile.mkdtemp()
self.req = Mock(base_path='/trac.cgi', chrome={}, args={}, session={},
abs_href=Href('/trac.cgi'), href=Href('/trac.cgi'),
locale='', perm=MockPerm(), authname='admin', tz=None)
self.bmsys = BookmarkSystem(self.env)
def setUp(self, enabled=None, create_req=False, enable_security=False):
if not enabled:
enabled = ['trac.*', 'bhsearch.*']
if not enable_security:
disabled = ['bhsearch.security.*']
else:
disabled = []
self.env = EnvironmentStub(enable=enabled, disable=disabled)
self.env.path = tempfile.mkdtemp('bhsearch-tempenv')
self.env.config.set('bhsearch', 'silence_on_error', "False")
if create_req:
self.req = Mock(
perm=MockPerm(),
chrome={
'logo': {},
'links': {}
},
href=Href("/main"),
base_path=BASE_PATH,
path_info='/bhsearch',
args=arg_list_to_args([]),
authname='x',
)
self.context = Mock(req=self.req)
# Test without multiproduct.
if hasattr(self.env, 'parent'):
del self.env.parent
def _make_req(environ,
start_response,
args={},
arg_list=(),
authname='admin',
form_token='A' * 40,
chrome={
'links': {},
'scripts': [],
'theme': 'theme.html',
'logo': '',
'nav': ''
},
perm=MockPerm(),
tz=utc,
locale=None,
**kwargs):
req = Request(environ, start_response)
req.args = args
req.arg_list = arg_list
req.authname = authname
req.form_token = form_token
req.chrome = chrome
req.perm = perm
req.session = FakeSession()
req.tz = tz
req.locale = locale
for name, value in kwargs.iteritems():
setattr(req, name, value)
return req
def main():
all_pages = sorted(
name for name in resource_listdir('trac.wiki', 'default-pages')
if not name.startswith('.'))
args = parse_args(all_pages)
if args.pages:
pages = sorted(args.pages)
else:
pages = all_pages
if args.download:
download_default_pages(pages, args.prefix, args.strict)
env = EnvironmentStub(disable=['trac.mimeview.pygments.*'])
load_components(env)
with env.db_transaction:
for name in all_pages:
wiki = WikiPage(env, name)
wiki.text = resource_string('trac.wiki', 'default-pages/' +
name).decode('utf-8')
if wiki.text:
wiki.save('trac', '')
else:
printout('%s: Skipped empty page' % name)
req = Mock(href=Href('/'),
abs_href=Href('http://localhost/'),
perm=MockPerm())
for name in pages:
wiki = WikiPage(env, name)
if not wiki.exists:
continue
context = web_context(req, wiki.resource)
out = DummyIO()
DefaultWikiChecker(env, context, name).format(wiki.text, out)
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()
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)
req = Mock(href=Href('/'),
abs_href=Href('http://www.example.com/'),
authname='anonymous',
perm=MockPerm(),
tz=utc,
args={},
locale=Locale.parse('en_US') if Locale else None)
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 main():
options, args = parse_args()
names = sorted(name
for name in resource_listdir('trac.wiki', 'default-pages')
if not name.startswith('.'))
if args:
args = sorted(set(names) & set(map(os.path.basename, args)))
else:
args = names
if options.download:
download_default_pages(args, options.prefix)
env = EnvironmentStub()
load_components(env)
with env.db_transaction:
for name in names:
wiki = WikiPage(env, name)
wiki.text = resource_string('trac.wiki', 'default-pages/' +
name).decode('utf-8')
if wiki.text:
wiki.save('trac', '')
else:
printout('%s: Skipped empty page' % name)
req = Mock(href=Href('/'),
abs_href=Href('http://localhost/'),
perm=MockPerm())
for name in args:
wiki = WikiPage(env, name)
if not wiki.exists:
continue
context = web_context(req, wiki.resource)
out = DummyIO()
DefaultWikiChecker(env, context, name).format(wiki.text, out)
def __init__(self,
title,
input,
correct,
file,
line,
setup=None,
teardown=None,
context=None):
unittest.TestCase.__init__(self, 'test')
self.title = title
self.input = input
self.correct = correct
self.file = file
self.line = line
self._setup = setup
self._teardown = teardown
self.req = Mock(href=Href('/'),
abs_href=Href('http://www.example.com/'),
chrome={},
session={},
authname='anonymous',
perm=MockPerm(),
tz=utc,
args={},
locale=locale_en,
lc_time=locale_en)
if context:
if isinstance(context, tuple):
context = web_context(self.req, *context)
else:
context = web_context(self.req, 'wiki', 'WikiStart')
self.context = context
def test_optional_email_registration(self):
user = '******'
passwd = 'test'
def redirect_noop(href):
"""Log relevant information for checking registration result."""
# print req.chrome['notices']
return
# A more complete mock of a request object is required for this test.
req = Mock(authname='anonymous',
method='POST',
args={
'action': 'create',
'username': user,
'name': 'Tester',
'password': passwd,
'password_confirm': passwd
},
chrome=dict(notices=[], warnings=[]),
href=self.env.abs_href,
path_info='/register',
perm=MockPerm(),
redirect=redirect_noop)
self.env.config.set('account-manager', 'verify_email', False)
# Successfully register the user.
# Note: This would have raised an AttributeError without graceful
# request checking for 'email'.
self.rmod.process_request(req)
# DEVEL: Check registration success more directly.
self.assertEqual(req.chrome['warnings'], [])
self.assertEqual([user], list(self.store.get_users()))
self.assertTrue(self.store.check_password(user, passwd))
def main():
names = sorted(name
for name in resource_listdir('trac.wiki', 'default-pages')
if not name.startswith('.'))
env = EnvironmentStub()
load_components(env)
with env.db_transaction:
for name in names:
wiki = WikiPage(env, name)
wiki.text = resource_string('trac.wiki', 'default-pages/' +
name).decode('utf-8')
if wiki.text:
wiki.save('trac', '')
else:
printout('%s: Skipped empty page' % name)
req = Mock(href=Href('/'),
abs_href=Href('http://trac.edgewall.org/'),
perm=MockPerm(),
chrome={})
for name in sys.argv[1:]:
name = os.path.basename(name)
wiki = WikiPage(env, name)
if not wiki.exists:
continue
context = web_context(req, wiki.resource, absurls=True)
rst = wiki2rest(env, context, wiki)
sys.stdout.write(rst)
def _create_request(self, authname='anonymous', **kwargs):
kw = {
'path_info': '/',
'perm': MockPerm(),
'args': _RequestArgs(),
'href': self.env.href,
'abs_href': self.env.abs_href,
'tz': utc,
'locale': None,
'lc_time': locale_en,
'session': DetachedSession(self.env, authname),
'authname': authname,
'chrome': {
'notices': [],
'warnings': []
},
'method': None,
'get_header': lambda v: None,
'is_xhr': False,
'form_token': None
}
if 'args' in kwargs:
kw['args'].update(kwargs.pop('args'))
kw.update(kwargs)
def redirect(url, permanent=False):
raise RequestDone
return Mock(add_redirect_listener=lambda x: [].append(x),
redirect=redirect,
**kw)
def _create_request(self):
languages = filter(None, [self.config.get('trac', 'default_language')])
if languages:
locale = _parse_locale(languages[0])
else:
locale = None
tzname = self.config.get('trac', 'default_timezone')
tz = get_timezone(tzname) or localtz
environ = {'REQUEST_METHOD': 'POST', 'REMOTE_ADDR': '127.0.0.1',
'SERVER_NAME': 'localhost', 'SERVER_PORT': '80',
'wsgi.url_scheme': 'http',
'trac.base_url': self.env.abs_href()}
if languages:
environ['HTTP_ACCEPT_LANGUAGE'] = ','.join(languages)
req = Request(environ, lambda *args, **kwargs: None)
req.arg_list = ()
req.args = {}
req.authname = 'anonymous'
req.session = FakeSession({'dateinfo': 'absolute'})
req.perm = MockPerm()
req.href = req.abs_href
req.locale = locale
req.lc_time = locale
req.tz = tz
req.chrome = {'notices': [], 'warnings': []}
return req
def _test_import(self, env, filename, sheet = 1):
req = Request({'SERVER_PORT': 0, 'SERVER_NAME': 'any', 'wsgi.url_scheme': 'any', 'wsgi.input': 'any', 'REQUEST_METHOD': 'GET' }, lambda x, y: _printme)
try:
from trac.test import MockPerm
req.perm = MockPerm()
except ImportError:
pass
req.authname = 'testuser'
#req.hdf = HDFWrapper([]) # replace by this if you want to generate HTML: req.hdf = HDFWrapper(loadpaths=chrome.get_all_templates_dirs())
db = env.get_db_cnx()
cursor = db.cursor()
_exec(cursor, "SELECT * FROM enum ORDER BY type, value, name")
enums_before = cursor.fetchall()
_exec(cursor, "SELECT * FROM component ORDER BY name")
components_before = cursor.fetchall()
#print enums_before
# when testing, always use the same time so that the results are comparable
#print "importing " + filename + " with tickettime " + str(ImporterTestCase.TICKET_TIME)
template, data, content_type = \
ImportModule(env)._do_import(filename, sheet, req, filename,
ImporterTestCase.TICKET_TIME, encoding='cp1252')
#sys.stdout = tempstdout
#req.display(template, content_type or 'text/html')
#open('/tmp/out.html', 'w').write(req.hdf.render(template, None))
_exec(cursor, "SELECT * FROM ticket ORDER BY id")
tickets = cursor.fetchall()
_exec(cursor, "SELECT * FROM ticket_custom ORDER BY ticket, name")
tickets_custom = cursor.fetchall()
_exec(cursor, "SELECT * FROM ticket_change")
tickets_change = cursor.fetchall()
_exec(cursor, "SELECT * FROM enum ORDER BY type, value, name")
enums = [f for f in set(cursor.fetchall()) - set(enums_before)]
_exec(cursor, "SELECT * FROM component ORDER BY name")
components = [f for f in set(cursor.fetchall()) - set(components_before)]
return self._pformat([ tickets, tickets_custom, tickets_change, enums, components ])
def _format_html(self, event):
ticket = event.target
short_changes = {}
long_changes = {}
chrome = Chrome(self.env)
for field, old_value in event.changes.items():
new_value = ticket[field]
if (new_value and '\n' in new_value) or \
(old_value and '\n' in old_value):
long_changes[field.capitalize()] = HTML(
"<pre>\n%s\n</pre>" % ('\n'.join(
diff_cleanup(
difflib.unified_diff(
wrap(old_value, cols=60).split('\n'),
wrap(new_value, cols=60).split('\n'),
lineterm='',
n=3)))))
else:
short_changes[field.capitalize()] = (old_value, new_value)
try:
req = Mock(href=Href(self.env.abs_href()),
abs_href=self.env.abs_href(),
authname=event.author,
perm=MockPerm(),
chrome=dict(warnings=[], notices=[]),
args={})
context = Context.from_request(req, event.realm, event.target.id)
formatter = HtmlFormatter(self.env, context, event.comment)
temp = formatter.generate(True)
except Exception, e:
self.log.error(exception_to_unicode(e, traceback=True))
temp = 'Comment in plain text: %s' % event.comment
def ticket_created(self, ticket):
"""Called when a ticket is created."""
# Add any tags unconditionally.
self.set_resource_tags(Mock(perm=MockPerm()), ticket, None)
if self.use_cache:
# Invalidate resource cache.
del self._tagged_resources
def create_trac_ctx(self, website_url, author_name, timezone_str, uri):
req = Mock(href=Href(uri),
abs_href=Href(website_url),
authname=author_name,
perm=MockPerm(),
tz=timezone_str,
args={})
context = Context.from_request(req, 'wiki', 'WikiStart')
env = EnvironmentStub(enable=['trac.*']) # + additional components
# -- macros support
env.path = ''
# -- intertrac support
env.config.set('intertrac', 'trac.title', 'Trac\'s Trac')
env.config.set('intertrac', 'trac.url',
website_url)
env.config.set('intertrac', 't', 'trac')
env.config.set('intertrac', 'th.title', 'Trac Hacks')
env.config.set('intertrac', 'th.url',
'http://trac-hacks.org')
env.config.set('intertrac', 'th.compat', 'false')
# -- safe schemes
env.config.set('wiki', 'safe_schemes',
'file,ftp,http,https,svn,svn+ssh,git,'
'rfc-2396.compatible,rfc-2396+under_score')
env.href = req.href
env.abs_href = req.abs_href
return (env, context)
def __init__(self,
title,
input,
correct,
file,
line,
setup=None,
teardown=None,
context=None):
unittest.TestCase.__init__(self, 'test')
self.title = title
self.input = input
self.correct = correct
self.file = file
self.line = line
self._setup = setup
self._teardown = teardown
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)
if context:
if isinstance(context, tuple):
context = web_context(req, *context)
else:
context = web_context(req, 'wiki', 'WikiStart')
self.context = context
all_test_components = [
HelloWorldMacro, DivHelloWorldMacro, TableHelloWorldMacro,
DivCodeMacro, DivCodeElementMacro, DivCodeStreamMacro, NoneMacro,
WikiProcessorSampleMacro, SampleResolver
]
self.env = EnvironmentStub(enable=['trac.*'] + all_test_components)
# -- macros support
self.env.path = ''
# -- intertrac support
self.env.config.set('intertrac', 'trac.title', "Trac's Trac")
self.env.config.set('intertrac', 'trac.url',
"http://trac.edgewall.org")
self.env.config.set('intertrac', 't', 'trac')
self.env.config.set('intertrac', 'th.title', "Trac Hacks")
self.env.config.set('intertrac', 'th.url', "http://trac-hacks.org")
self.env.config.set('intertrac', 'th.compat', 'false')
# -- safe schemes
self.env.config.set(
'wiki', 'safe_schemes', 'file,ftp,http,https,svn,svn+ssh,'
'rfc-2396.compatible,rfc-2396+under_score')
# TODO: remove the following lines in order to discover
# all the places were we should use the req.href
# instead of env.href
self.env.href = req.href
self.env.abs_href = req.abs_href
def ticket_changed(self, ticket, comment, author, old_values):
"""Called when a ticket is modified."""
# Sync only on change of ticket fields, that are exposed as tags.
if any(f in self.fields for f in old_values.keys()):
self.set_resource_tags(Mock(perm=MockPerm()), ticket, None)
if self.use_cache:
# Invalidate resource cache.
del self._tagged_resources
class Request(object):
locale = None
perm = MockPerm()
args = {}
def __init__(self, **kwargs):
self.chrome = {}
for k, v in kwargs.items():
setattr(self, k, v)
def format_to_html(req, env, text):
req = Mock(href=Href('/'),
abs_href=Href('http://www.example.com/'),
authname='anonymous',
perm=MockPerm(),
args={})
context = Context.from_request(req)
return trac.wiki.formatter.format_to_html(env, context, text)
def setUp(self):
self.req = Mock(
perm=MockPerm(),
chrome={'logo': {}},
href=Href("/main"),
base_path=BASE_PATH,
args=arg_list_to_args([]),
)
def ticket_created(self, ticket):
"""Called when a ticket is created."""
# Add any tags unconditionally.
self.set_resource_tags(
Mock(authname=ticket['reporter'], perm=MockPerm()), ticket, None,
ticket['time'])
if self.use_cache:
# Invalidate resource cache.
del self._tagged_resources
def wiki_page_renamed(self, page, old_name):
"""Called when a page has been renamed (since Trac 0.12)."""
self.log.debug("Moving wiki page tags from %s to %s",
old_name, page.name)
tag_sys = TagSystem(self.env)
# XXX Ugh. Hopefully this will be sufficient to fool any endpoints.
from trac.test import Mock, MockPerm
req = Mock(authname='anonymous', perm=MockPerm())
tag_sys.reparent_tags(req, Resource('wiki', page.name), old_name)
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.env.config.set('ticket-custom', 'hours_remaining', 'text')
self.env.config.set('estimation-tools', 'estimation_field',
'hours_remaining')
self.req = Mock(href=Href('/'),
abs_href=Href('http://www.example.com/'),
perm=MockPerm(),
authname='anonymous')
def _create_req(self, **kwargs):
data = dict(args={},
perm=MockPerm(),
href=Href('/'),
chrome={},
authname='trac',
tz=utc,
get_header=lambda name: None)
data.update(kwargs)
return Mock(**data)
def test_csv_escape(self):
query = Mock(get_columns=lambda: ['col1'],
execute=lambda r: [{'id': 1,
'col1': 'value, needs escaped'}],
time_fields=['time', 'changetime'])
content, mimetype = QueryModule(self.env).export_csv(
Mock(href=self.env.href, perm=MockPerm()),
query)
self.assertEqual('\xef\xbb\xbfcol1\r\n"value, needs escaped"\r\n',
content)
def Main(opts):
""" Cross your fingers and pray """
env = Environment(opts.envpath)
from tractags.api import TagSystem
tlist = opts.tags or split_tags(
env.config.get('blog', 'default_tag', 'blog'))
tags = TagSystem(env)
req = Mock(perm=MockPerm())
blog = tags.query(req, ' '.join(tlist + ['realm:wiki']))
cnx = env.get_db_cnx()
for resource, page_tags in list(blog):
try:
page = WikiPage(env, version=1, name=resource.id)
_, publish_time, author, _, _ = page.get_history().next()
if opts.deleteonly:
page.delete()
continue
categories = ' '.join([t for t in page_tags if t not in tlist])
page = WikiPage(env, name=resource.id)
for version, version_time, version_author, version_comment, \
_ in page.get_history():
# Currently the basename of the post url is used due to
# http://trac-hacks.org/ticket/2956
#name = resource.id.replace('/', '_')
name = resource.id
# extract title from text:
fulltext = page.text
match = _title_split_match(fulltext)
if match:
title = match.group(1)
fulltext = match.group(2)
else:
title = name
body = fulltext
print "Adding post %s, v%s: %s" % (name, version, title)
insert_blog_post(cnx, name, version, title, body, publish_time,
version_time, version_comment, version_author,
author, categories)
reparent_blog_attachments(env, resource.id, name)
continue
cnx.commit()
if opts.delete:
page.delete()
continue
except:
env.log.debug("Error loading wiki page %s" % resource.id,
exc_info=True)
print "Failed to add post %s, v%s: %s" % (name, version, title)
cnx.rollback()
cnx.close()
return 1
cnx.close()
return 0
def test_run_html_formatter(self):
wiki_content = "!WikiSyntax"
page = self.create_wiki("Dummy wiki", wiki_content)
from trac.mimeview.api import RenderingContext
context = RenderingContext(
page.resource,
href=Href('/'),
perm=MockPerm(),
)
context.req = None # 1.0 FIXME .req shouldn't be required by formatter
format_to_html(self.env, context, wiki_content)
def setUp(self):
self.env = EnvironmentStub()
self.req = Mock(href=self.env.href, perm=MockPerm())
self.mmodule = MilestoneModule(self.env)
self.terms = ['MilestoneAlpha', 'MilestoneBeta', 'MilestoneGamma']
for term in self.terms + [' '.join(self.terms)]:
m = Milestone(self.env)
m.name = term
m.due = datetime.now(utc)
m.description = random_sentence()
m.insert()
def setUp(self):
self.env = EnvironmentStub()
self.req = Mock(href=Href('/'),
abs_href=Href('http://example.org/'),
authname='anonymous',
tz=utc,
locale=locale_en,
lc_time=locale_en,
chrome={},
perm=MockPerm(),
session={})
