def test_is_xhr_true(self):
environ = _make_environ(HTTP_X_REQUESTED_WITH='XMLHttpRequest')
req = Request(environ, None)
self.assertTrue(req.is_xhr)
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_repr_with_path(self):
environ = _make_environ(**{'PATH_INFO': '/path'})
req = Request(environ, None)
self.assertEqual(repr(req), """<Request "GET '/path'">""")
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)
'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_is_authenticated_as_valid_user(self):
environ = _make_environ()
req = Request(environ, None)
req.authname = 'user'
self.assertTrue(req.is_authenticated)
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_invalid_cookies(self):
environ = self._make_environ(HTTP_COOKIE='bad:key=value;')
req = Request(environ, None)
self.assertEqual('', str(req.incookie))
def test_multiple_cookies(self):
environ = self._make_environ(HTTP_COOKIE='key=value1; key=value2;')
req = Request(environ, None)
self.assertEqual('Set-Cookie: key=value1',
str(req.incookie).rstrip(';'))
def test_read_size(self):
environ = _make_environ(**{'wsgi.input': io.BytesIO(b'test input')})
req = Request(environ, None)
self.assertEqual(b'test', req.read(size=4))
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_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 _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)
def test_is_xhr_false(self):
environ = _make_environ()
req = Request(environ, None)
self.assertFalse(req.is_xhr)
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_is_authenticated_as_anonymous(self):
environ = _make_environ()
req = Request(environ, None)
req.authname = 'anonymous'
self.assertFalse(req.is_authenticated)
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 test_base_url(self):
environ = _make_environ()
req = Request(environ, None)
self.assertEqual('http://example.org/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_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_languages(self):
environ = self._make_environ()
environ['HTTP_ACCEPT_LANGUAGE'] = 'en-us,en;q=0.5'
req = Request(environ, None)
self.assertEqual(['en-us', 'en'], req.languages)
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_qs_invalid_name_bytes(self):
environ = _make_environ(**{'QUERY_STRING': '%FF=value'})
req = Request(environ, None)
self.assertRaises(HTTPBadRequest, lambda: req.arg_list)
