def dummy_request(env, uname=None):
environ = {}
setup_testing_defaults(environ)
environ.update({
'REQUEST_METHOD' : 'GET',
'SCRIPT_NAME' : urlparse(str(env._abs_href())).path,
'trac.base_url' : str(env._abs_href()),
})
req = Request(environ, lambda *args, **kwds: None)
# Intercept redirection
req.redirect = lambda *args, **kwds: None
# Setup user information
if uname is not None :
environ['REMOTE_USER'] = req.authname = uname
rd = RequestDispatcher(env)
chrome = Chrome(env)
req.callbacks.update({
'authname': rd.authenticate,
'chrome': chrome.prepare_request,
'hdf': getattr(rd, '_get_hdf', None),
'lc_time': rd._get_lc_time,
'locale' : getattr(rd, '_get_locale', None),
'perm': rd._get_perm,
'session': rd._get_session,
'tz': rd._get_timezone,
'form_token': rd._get_form_token
})
return req
def dummy_request(env, cookies_from=None, query=None):
environ = {
'trac.base_url': env.base_url,
'wsgi.url_scheme': 'http',
'wsgi.input': BytesIO(),
'SCRIPT_NAME': '/trac.cgi',
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'example.org',
'SERVER_PORT': '80',
'HTTP_HOST': 'example.org',
}
if query:
environ['QUERY_STRING'] = urlencode(query)
if cookies_from:
outcookie = cookies_from.outcookie
cookie = '; '.join('%s=%s' % (name, morsel.value)
for name, morsel in outcookie.items())
environ['HTTP_COOKIE'] = cookie
start_response = mock.Mock(name='start_response')
req = Request(environ, start_response)
req.session = {}
req.chrome = {'warnings': [], 'notices': []}
req.redirect = mock.Mock(name='req.redirect', spec=())
req.authname = 'anonymous'
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")
enums_before = cursor.fetchall()
_exec(cursor, "select * from component")
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, content_type = ImportModule(env)._do_import(filename, sheet, req, filename, ImporterTestCase.TICKET_TIME)
#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")
tickets = cursor.fetchall()
_exec(cursor, "select * from ticket_custom")
tickets_custom = cursor.fetchall()
_exec(cursor, "select * from ticket_change")
tickets_change = cursor.fetchall()
_exec(cursor, "select * from enum")
enums = [f for f in set(cursor.fetchall()) - set(enums_before)]
_exec(cursor, "select * from component")
components = [f for f in set(cursor.fetchall()) - set(components_before)]
pp = pprint.PrettyPrinter(indent=4)
return pp.pformat([ tickets, tickets_custom, tickets_change, enums, components ])
def test_timezones(self):
self.out.config.set('irclogs', 'timezone', 'America/New_York')
self.out.update_index()
req = Request(self._make_environ(), None)
req.session = {'tz': 'America/New_York'}
req.perm = Mock(has_permission= lambda x: True)
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(20, len(results))
self.assertEqual((self.dt.hour-5+24)%24, results[0][2].hour)
def test_write_unicode(self):
buf = StringIO()
def write(data):
buf.write(data)
def start_response(status, headers):
return write
environ = self._make_environ(method='HEAD')
req = Request(environ, start_response)
req.send_header('Content-Type', 'text/plain;charset=utf-8')
req.write(u'Föö')
self.assertEqual('Föö', buf.getvalue())
def location(ua):
status_sent = []
headers_sent = {}
def start_response(status, headers):
status_sent.append(status)
headers_sent.update(dict(headers))
environ = self._make_environ(method='POST', HTTP_USER_AGENT=ua)
req = Request(environ, start_response,)
req.session = Mock(save=lambda: None)
self.assertRaises(RequestDone, req.redirect, url)
self.assertEqual('303 See Other', status_sent[0])
return headers_sent['Location']
def send_project_index(environ, start_response, parent_dir=None,
env_paths=None):
req = Request(environ, start_response)
loadpaths = [pkg_resources.resource_filename('trac', 'templates')]
if req.environ.get('trac.env_index_template'):
env_index_template = req.environ['trac.env_index_template']
tmpl_path, template = os.path.split(env_index_template)
loadpaths.insert(0, tmpl_path)
else:
template = 'index.html'
data = {'trac': {'version': TRAC_VERSION,
'time': user_time(req, format_datetime)},
'req': req}
if req.environ.get('trac.template_vars'):
for pair in req.environ['trac.template_vars'].split(','):
key, val = pair.split('=')
data[key] = val
try:
href = Href(req.base_path)
projects = []
for env_name, env_path in get_environments(environ).items():
try:
env = open_environment(env_path,
use_cache=not environ['wsgi.run_once'])
proj = {
'env': env,
'name': env.project_name,
'description': env.project_description,
'href': href(env_name)
}
except Exception as e:
proj = {'name': env_name, 'description': to_unicode(e)}
projects.append(proj)
projects.sort(lambda x, y: cmp(x['name'].lower(), y['name'].lower()))
data['projects'] = projects
loader = TemplateLoader(loadpaths, variable_lookup='lenient',
default_encoding='utf-8')
tmpl = loader.load(template)
stream = tmpl.generate(**data)
if template.endswith('.xml'):
output = stream.render('xml')
req.send(output, 'text/xml')
else:
output = stream.render('xhtml', doctype=DocType.XHTML_STRICT,
encoding='utf-8')
req.send(output, 'text/html')
except RequestDone:
pass
def test_write_unicode(self):
buf = StringIO()
def write(data):
buf.write(data)
def start_response(status, headers):
return write
environ = self._make_environ(method='HEAD')
req = Request(environ, start_response)
req.send_header('Content-Type', 'text/plain;charset=utf-8')
req.send_header('Content-Length', 0)
# anyway we're not supposed to send unicode, so we get a ValueError
self.assertRaises(ValueError, req.write, u'Föö')
def test_redirect(self):
status_sent = []
headers_sent = {}
def start_response(status, headers):
status_sent.append(status)
headers_sent.update(dict(headers))
environ = self._make_environ(method='HEAD')
req = Request(environ, start_response)
req.session = Mock(save=lambda: None)
self.assertRaises(RequestDone, req.redirect, '/trac/test')
self.assertEqual('302 Found', status_sent[0])
self.assertEqual('http://example.org/trac/test',
headers_sent['Location'])
def test_write_iterable(self):
buf = StringIO()
def write(data):
buf.write(data)
def start_response(status, headers):
return write
environ = self._make_environ(method='GET')
buf = StringIO()
req = Request(environ, start_response)
req.send_header('Content-Type', 'text/plain;charset=utf-8')
req.write(('Foo', 'bar', 'baz'))
self.assertEqual('Foobarbaz', buf.getvalue())
def _test_preview(self, env, filename):
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())
template, content_type = ImportModule(env)._do_preview(filename, 1, req)
#sys.stdout = tempstdout
#req.display(template, content_type or 'text/html')
#open('/tmp/out.html', 'w').write(req.hdf.render(template, None))
return str(req.hdf) + "\n"
def test_write_unicode(self):
buf = StringIO()
def write(data):
buf.write(data)
def start_response(status, headers):
return write
environ = self._make_environ(method="HEAD")
req = Request(environ, start_response)
req.send_header("Content-Type", "text/plain;charset=utf-8")
req.write(u"Föö")
self.assertEqual("Föö", buf.getvalue())
def test_index_and_search(self):
self.out.update_index()
req = Request(self._make_environ(), None)
req.session = {'tz': 'UTC'}
req.perm = Mock(has_permission= lambda x: True)
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(20, len(results))
self.assertEqual(self.dt.hour, results[0][2].hour)
req.session = {'tz': 'America/New_York'}
req.perm = Mock(has_permission= lambda x: True)
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(20, len(results))
est = timezone('America/New_York')
expect_dt = est.normalize(self.dt.astimezone(est))
sorted_results = sorted(results, key=operator.itemgetter(2))
self.assertEqual(expect_dt, sorted_results[0][2])
def test_update(self):
self.out.update_index()
req = Request(self._make_environ(), None)
req.session = {'tz': 'UTC'}
req.perm = Mock(has_permission= lambda x: True)
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(20, len(results))
self.out.update_index()
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(40, len(results))
self.out.update_index()
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(60, len(results))
self.out.update_index()
results = [i for i in self.out.get_search_results(req, ('hello',), ('irclogs',))]
self.assertEqual(80, len(results))
def my_redirect(*args, **kwords):
# Munge the cookie path
if 'trac_auth' in req.outcookie:
assert not self.uri_root.startswith('http'), 'The tracforge uri_root must be set to relative path'
req.outcookie['trac_auth']['path'] = self.uri_root
# Check to see if we should refer back to sibling Trac
referer = req.args.get('referer')
self.log.debug('TracForgeCookieMunger: Got referer as %r'%referer)
if referer:
parts = urlsplit(referer or '')
self.log.debug('TracForgeCookieMunger: parts=%s name=%r'%(parts,req.server_name))
if parts[2].startswith(self.uri_root) and (not parts[1] or parts[1] == req.server_name):
Request.redirect(req, referer)
old_redirect(req, *args, **kwords)
def _make_req(environ, start_response, args={}, arg_list=(), authname='admin',
form_token='A' * 40, chrome={'links': {}, 'scripts': []},
perm=MockPerm(), session={}, 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 = session
req.tz = tz
req.locale = locale
for name, value in kwargs.iteritems():
setattr(req, name, value)
return req
def test_saved_custom_query_redirect(self):
query = u'query:?type=résumé'
with self.env.db_transaction as db:
cursor = db.cursor()
cursor.execute("INSERT INTO report (title,query,description) "
"VALUES (%s,%s,%s)", ('redirect', query, ''))
id = db.get_last_id(cursor, 'report')
headers_sent = {}
def start_response(status, headers):
headers_sent.update(dict(headers))
environ = self._make_environ()
req = Request(environ, start_response)
req.authname = 'anonymous'
req.session = Mock(save=lambda: None)
self.assertRaises(RequestDone,
self.report_module._render_view, req, id)
self.assertEqual('http://example.org/trac/query?' + \
'type=r%C3%A9sum%C3%A9&report=' + str(id),
headers_sent['Location'])
def invoke(self, chgset):
# regular expressions
ticket_prefix = "(?:#|(?:ticket|issue|bug)[: ]?)"
if self.intertrac: # TODO: split to separate function?
# find intertrac links
intertrac = {}
aliases = {}
for key, value in self.env.config.options("intertrac"):
if "." in key:
name, type_ = key.rsplit(".", 1)
if type_ == "url":
intertrac[name] = value
else:
aliases.setdefault(value, []).append(key)
intertrac = dict([(value, [key] + aliases.get(key, [])) for key, value in intertrac.items()])
project = os.path.basename(self.env.path)
if "/%s" % project in intertrac: # TODO: checking using base_url for full paths:
ticket_prefix = "(?:%s):%s" % ("|".join(intertrac["/%s" % project]), ticket_prefix)
else: # hopefully sesible default:
ticket_prefix = "%s:%s" % (project, ticket_prefix)
ticket_reference = ticket_prefix + "[0-9]+"
ticket_command = r"(?P<action>[A-Za-z]*).?" "(?P<ticket>%s(?:(?:[, &]*|[ ]?and[ ]?)%s)*)" % (
ticket_reference,
ticket_reference,
)
ticket_command = r"%s%s%s" % (re.escape(self.envelope_open), ticket_command, re.escape(self.envelope_close))
command_re = re.compile(ticket_command, re.IGNORECASE)
ticket_re = re.compile(ticket_prefix + "([0-9]+)", re.IGNORECASE)
# other variables
msg = "(In [%s]) %s" % (chgset.rev, chgset.message)
now = chgset.date
supported_cmds = {} # TODO: this could become an extension point
supported_cmds.update(dict([(key, self._cmdClose) for key in self.cmd_close]))
supported_cmds.update(dict([(key, self._cmdRefs) for key in self.cmd_refs]))
cmd_groups = command_re.findall(msg)
tickets = {}
for cmd, tkts in cmd_groups:
func = supported_cmds.get(cmd.lower(), None)
if func:
for tkt_id in ticket_re.findall(tkts):
tickets.setdefault(tkt_id, []).append(func)
for tkt_id, cmds in tickets.iteritems():
try:
db = self.env.get_db_cnx()
ticket = Ticket(self.env, int(tkt_id), db)
for cmd in cmds:
cmd(ticket)
# determine comment sequence number
cnum = 0
tm = TicketModule(self.env)
for change in tm.grouped_changelog_entries(ticket, db):
if change["permanent"]:
cnum += 1
# validate the ticket
# fake a request
# XXX cargo-culted environ from
# http://trac.edgewall.org/browser/trunk/trac/web/tests/api.py
environ = {
"wsgi.url_scheme": "http",
"wsgi.input": StringIO(""),
"SERVER_NAME": "0.0.0.0",
"REQUEST_METHOD": "POST",
"SERVER_PORT": 80,
"SCRIPT_NAME": "/" + self.env.project_name,
"REMOTE_USER": chgset.author,
"QUERY_STRING": "",
}
req = Request(environ, None)
req.args["comment"] = msg
req.authname = chgset.author
req.perm = PermissionCache(self.env, req.authname)
for manipulator in tm.ticket_manipulators:
manipulator.validate_ticket(req, ticket)
msg = req.args["comment"]
ticket.save_changes(chgset.author, msg, now, db, cnum + 1)
db.commit()
tn = TicketNotifyEmail(self.env)
tn.notify(ticket, newticket=0, modtime=now)
except Exception, e:
message = "Unexpected error while processing ticket ID %s: %s" % (tkt_id, repr(e))
print >>sys.stderr, message
self.env.log.error("TicketChanger: " + message)
def _make_req(environ, start_response, args={}, arg_list=(), authname='admin',
form_token='A' * 40, chrome={'links': {}, 'scripts': []},
perm=MockPerm(), session={}, 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 = session
req.tz = tz
req.locale = locale
for name, value in kwargs.iteritems():
setattr(req, name, value)
return req
def test_qs_invalid_name_bytes(self):
environ = self._make_environ(**{'QUERY_STRING': '%FF=value'})
req = Request(environ, None)
self.assertRaises(HTTPBadRequest, lambda: req.arg_list)
def invoke(self, chgset):
# regular expressions
ticket_prefix = '(?:#|(?:ticket|issue|bug)[: ]?)'
if self.intertrac: # TODO: split to separate function?
# find intertrac links
intertrac = {}
aliases = {}
for key, value in self.env.config.options('intertrac'):
if '.' in key:
name, type_ = key.rsplit('.', 1)
if type_ == 'url':
intertrac[name] = value
else:
aliases.setdefault(value, []).append(key)
intertrac = dict([(value, [key] + aliases.get(key, []))
for key, value in intertrac.items()])
project = os.path.basename(self.env.path)
if '/%s' % project in intertrac: # TODO: checking using base_url for full paths:
ticket_prefix = '(?:%s):%s' % ('|'.join(
intertrac['/%s' % project]), ticket_prefix)
else: # hopefully sesible default:
ticket_prefix = '%s:%s' % (project, ticket_prefix)
ticket_reference = ticket_prefix + '[0-9]+'
ticket_command = (r'(?P<action>[A-Za-z]*).?'
'(?P<ticket>%s(?:(?:[, &]*|[ ]?and[ ]?)%s)*)' %
(ticket_reference, ticket_reference))
ticket_command = r'%s%s%s' % (re.escape(
self.envelope_open), ticket_command, re.escape(
self.envelope_close))
command_re = re.compile(ticket_command, re.IGNORECASE)
ticket_re = re.compile(ticket_prefix + '([0-9]+)', re.IGNORECASE)
# other variables
msg = "(In [%s]) %s" % (chgset.rev, chgset.message)
now = chgset.date
supported_cmds = {} # TODO: this could become an extension point
supported_cmds.update(
dict([(key, self._cmdClose) for key in self.cmd_close]))
supported_cmds.update(
dict([(key, self._cmdRefs) for key in self.cmd_refs]))
cmd_groups = command_re.findall(msg)
tickets = {}
for cmd, tkts in cmd_groups:
func = supported_cmds.get(cmd.lower(), None)
if func:
for tkt_id in ticket_re.findall(tkts):
tickets.setdefault(tkt_id, []).append(func)
for tkt_id, cmds in tickets.iteritems():
try:
db = self.env.get_db_cnx()
ticket = Ticket(self.env, int(tkt_id), db)
for cmd in cmds:
cmd(ticket)
# determine comment sequence number
cnum = 0
tm = TicketModule(self.env)
for change in tm.grouped_changelog_entries(ticket, db):
if change['permanent']:
cnum += 1
# validate the ticket
# fake a request
# XXX cargo-culted environ from
# http://trac.edgewall.org/browser/trunk/trac/web/tests/api.py
environ = {
'wsgi.url_scheme': 'http',
'wsgi.input': StringIO(''),
'SERVER_NAME': '0.0.0.0',
'REQUEST_METHOD': 'POST',
'SERVER_PORT': 80,
'SCRIPT_NAME': '/' + self.env.project_name,
'REMOTE_USER': chgset.author,
'QUERY_STRING': ''
}
req = Request(environ, None)
req.args['comment'] = msg
req.authname = chgset.author
req.perm = PermissionCache(self.env, req.authname)
for manipulator in tm.ticket_manipulators:
manipulator.validate_ticket(req, ticket)
msg = req.args['comment']
ticket.save_changes(chgset.author, msg, now, db, cnum + 1)
db.commit()
tn = TicketNotifyEmail(self.env)
tn.notify(ticket, newticket=0, modtime=now)
except Exception, e:
message = 'Unexpected error while processing ticket ID %s: %s' % (
tkt_id, repr(e))
print >> sys.stderr, message
self.env.log.error('TicketChanger: ' + message)
def test_is_authenticated_as_valid_user(self):
environ = _make_environ()
req = Request(environ, None)
req.authname = 'user'
self.assertTrue(req.is_authenticated)
def test_is_xhr_false(self):
environ = _make_environ()
req = Request(environ, None)
self.assertFalse(req.is_xhr)
def test_repr_with_path_and_query_string(self):
environ = _make_environ(QUERY_STRING='A=B', PATH_INFO='/path')
req = Request(environ, None)
self.assertEqual(repr(req), """<Request "GET '/path?A=B'">""")
def test_multiple_cookies(self):
environ = _make_environ(HTTP_COOKIE='key=value1; key=value2;')
req = Request(environ, None)
self.assertEqual('Set-Cookie: key=value1',
str(req.incookie).rstrip(';'))
def test_languages(self):
environ = _make_environ(HTTP_ACCEPT_LANGUAGE='en-us,en;q=0.5')
req = Request(environ, None)
self.assertEqual(['en-us', 'en'], req.languages)
def _make_req(environ, start_response, **kwargs):
req = Request(environ, start_response)
for name, value in kwargs.iteritems():
setattr(req, name, value)
return req
def _create_req(self, **kwargs):
def start_response(status, headers):
return lambda data: None
return Request(self._make_environ(**kwargs), start_response)
'trac.web.version': mod_wsgi_version
})
env.webfrontend = environ.get('trac.web.frontend')
if env.webfrontend:
env.systeminfo.append(
(env.webfrontend, environ['trac.web.version']))
except Exception, e:
env_error = e
run_once = environ['wsgi.run_once']
req = None
if env_error is None:
try:
req = bootstrap.create_request(env, environ, start_response) \
if env is not None else Request(environ, start_response)
except Exception, e:
log = environ.get('wsgi.errors')
if log:
log.write("[FAIL] [Trac] Entry point '%s' "
"Method 'create_request' Reason %s" %
(bootstrap_ep, repr(exception_to_unicode(e))))
if req is None:
req = RequestWithSession(environ, start_response)
translation.make_activable(lambda: req.locale, env.path if env else None)
try:
return _dispatch_request(req, env, env_error)
finally:
translation.deactivate()
if env and not run_once:
env.shutdown(threading._get_ident())
def test_repr_with_path(self):
environ = _make_environ(PATH_INFO='/path')
req = Request(environ, None)
self.assertEqual(repr(req), """<Request "GET '/path'">""")
def test_qs_invalid_name_bytes(self):
environ = _make_environ(QUERY_STRING='%FF=value')
req = Request(environ, None)
with self.assertRaises(HTTPBadRequest):
req.arg_list()
def test_is_xhr_true(self):
environ = _make_environ(HTTP_X_REQUESTED_WITH='XMLHttpRequest')
req = Request(environ, None)
self.assertTrue(req.is_xhr)
def test_base_url_nondefaultport(self):
environ = _make_environ(server_port=8080)
req = Request(environ, None)
self.assertEqual('http://example.org:8080/trac', req.base_url)
def test_is_authenticated_as_anonymous(self):
environ = _make_environ()
req = Request(environ, None)
req.authname = 'anonymous'
self.assertFalse(req.is_authenticated)
def test_base_url_https_nondefaultport(self):
environ = _make_environ(scheme='https', server_port=8443)
req = Request(environ, None)
self.assertEqual('https://example.org:8443/trac', req.base_url)
def test_base_url(self):
environ = _make_environ()
req = Request(environ, None)
self.assertEqual('http://example.org/trac', req.base_url)
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_base_url_https_host(self):
environ = _make_environ(scheme='https',
server_port=443,
HTTP_HOST='example.com')
req = Request(environ, None)
self.assertEqual('https://example.com/trac', req.base_url)
def test_base_url_https(self):
environ = self._make_environ(scheme='https', server_port=443)
req = Request(environ, None)
self.assertEqual('https://example.org/trac', req.base_url)
def test_base_url_proxy(self):
environ = _make_environ(HTTP_HOST='localhost',
HTTP_X_FORWARDED_HOST='example.com')
req = Request(environ, None)
self.assertEqual('http://localhost/trac', req.base_url)
def test_read(self):
environ = self._make_environ(**{'wsgi.input': StringIO('test input')})
req = Request(environ, None)
self.assertEqual('test input', req.read())
def test_invalid_cookies(self):
environ = _make_environ(HTTP_COOKIE='bad:key=value;')
req = Request(environ, None)
self.assertEqual('', str(req.incookie))
def test_read_size(self):
environ = self._make_environ(**{'wsgi.input': StringIO('test input')})
req = Request(environ, None)
self.assertEqual('test', req.read(size=4))
def test_read_size(self):
environ = _make_environ(**{'wsgi.input': io.BytesIO(b'test input')})
req = Request(environ, None)
self.assertEqual('test', req.read(size=4))
def test_base_url_host(self):
environ = self._make_environ(server_port=8080, HTTP_HOST='example.com')
req = Request(environ, None)
self.assertEqual('http://example.com/trac', req.base_url)
def send_project_index(environ,
start_response,
parent_dir=None,
env_paths=None):
req = Request(environ, start_response)
loadpaths = [pkg_resources.resource_filename('trac', 'templates')]
if req.environ.get('trac.env_index_template'):
env_index_template = req.environ['trac.env_index_template']
tmpl_path, template = os.path.split(env_index_template)
loadpaths.insert(0, tmpl_path)
else:
template = 'index.html'
data = {
'trac': {
'version': TRAC_VERSION,
'time': user_time(req, format_datetime)
},
'req': req
}
if req.environ.get('trac.template_vars'):
for pair in req.environ['trac.template_vars'].split(','):
key, val = pair.split('=')
data[key] = val
try:
href = Href(req.base_path)
projects = []
for env_name, env_path in get_environments(environ).items():
try:
env = open_environment(env_path,
use_cache=not environ['wsgi.run_once'])
proj = {
'env': env,
'name': env.project_name,
'description': env.project_description,
'href': href(env_name)
}
except Exception as e:
proj = {'name': env_name, 'description': to_unicode(e)}
projects.append(proj)
projects.sort(lambda x, y: cmp(x['name'].lower(), y['name'].lower()))
data['projects'] = projects
loader = TemplateLoader(loadpaths,
variable_lookup='lenient',
default_encoding='utf-8')
tmpl = loader.load(template)
stream = tmpl.generate(**data)
if template.endswith('.xml'):
output = stream.render('xml')
req.send(output, 'text/xml')
else:
output = stream.render('xhtml',
doctype=DocType.XHTML_STRICT,
encoding='utf-8')
req.send(output, 'text/html')
except RequestDone:
pass
def test_read_size(self):
environ = self._make_environ(**{"wsgi.input": StringIO("test input")})
req = Request(environ, None)
self.assertEqual("test", req.read(size=4))
