def test_body(self):
resp = Response()
resp.finalize(None)
self.assertTrue(not resp.iterable)
resp = Response()
resp.file = BytesIO(b"Foobar")
resp.file_len = len("Foobar")
resp.finalize(None)
self.assertEqual(resp.headers['Content-Length'], str(len('Foobar')))
def test_default_renderers(self):
RenderFactory.create({})
@renderer('json')
def fake_on_get_json(request, response):
return {"Hello": "world"}
resp = Response()
rendered = fake_on_get_json(None, resp)
self.assertEqual(resp.headers['Content-Type'], 'application/json')
data = json.loads(rendered)
self.assertEqual(data['Hello'], 'world')
class json_obj(object):
def __init__(self, name):
self.name = name
def json(self, requst):
return {'name': self.name}
class not_json_obj(object):
pass
@renderer('json')
def fake_on_get_json_obj(request, response):
return json_obj('Foobar')
@renderer('json')
def fake_on_get_non_json_obj(request, response):
return not_json_obj()
@renderer('json')
def fake_on_return_response(request, response):
return Response("719 I am not a teapot")
@renderer('json', pad=True)
def test_secure_pad(request, response):
return {"foo": "bar"}
resp = Response()
rendered = fake_on_get_json_obj(None, resp)
self.assertEqual(resp.headers['Content-Type'], 'application/json')
data = json.loads(rendered)
self.assertEqual(data['name'], 'Foobar')
self.assertRaises(TypeError, fake_on_get_non_json_obj, None,
Response())
self.assertIsInstance(fake_on_return_response(None, None), Response)
resp = Response()
rendered = test_secure_pad(None, resp)
self.assertEqual(resp.headers['Content-Type'], 'application/json')
self.assertEqual(rendered, ")]}',\n" + json.dumps({"foo": "bar"}))
def simulate_request(app, method, path, querystring, body):
fake_env = {
'wsgi.input': StringIO(body),
'wsgi.errors': None,
'wsgi.url_scheme': 'https',
'CONTENT_LENGTH': len(body),
'PATH_INFO': path,
'SERVER_PORT': '8080',
'CONTENT_TYPE': 'application/x-www-form-urlencoded',
'HTTP_X_H_Test': 'Foobar',
'HTTP_CONTENT_TYPE': 'application/x-www-form-urlencoded',
'QUERY_STRING': querystring,
'HTTP_HOST': 'foobar.baz:8080',
'SERVER_NAME': 'foobar.baz',
'HTTP_FOO': 'bar',
'SCRIPT_NAME': '/some/script/dir',
'REQUEST_METHOD': method
}
resp = Response()
def start_response(status, headers, exc_info_=None):
resp.status = status
resp.headers = dict(headers)
global exc_info
exc_info = exc_info_
body = app(fake_env, start_response)
if exc_info:
raise exc_info[0](exc_info[1]) # No traceback because python3
body = body[0]
return resp, body.decode('utf-8')
def test_body(self):
resp = Response()
resp.finalize(None)
self.assertTrue(not resp.iterable)
resp = Response()
resp.file = BytesIO(b"Foobar")
resp.file_len = len("Foobar")
resp.finalize(None)
self.assertEqual(resp.headers['Content-Length'], str(len('Foobar')))
def test_set_cookie(self):
resp = Response()
resp.set_cookie("foo", "bar")
resp.set_cookie("bar",
"baz",
domain='foo.com',
secure=True,
comment='Hello world')
resp.set_cookie("foobar", "boofar", domain='.foo.com')
self.assertEqual(
reduce(lambda t, l: t + 1
if l[0] == 'Set-Cookie' else t, resp.wsgi_headers, 0), 3)
def _request(self, env, req):
""" Processes the request
Notes:
This method acts as a wrapper to ease exception handling
Args:
env: The wsgi environ variable
"""
resp = Response()
self._do_before(req, resp)
context = self.map.match(req.path, env)
if context is not None:
req.matchdict = context
if 'controller' in context and context[
'controller'] in self._controllers:
if hasattr(self._controllers[context['controller']],
context['action']):
cls = self._controllers[context['controller']]
controller = cls()
res = getattr(controller, context['action'])(req, resp)
else:
raise HTTPNotFound()
elif isinstance(context['action'], collections.Callable):
res = context['action'](req, resp)
else:
raise HTTPNotFound()
if isinstance(res, Response):
if isinstance(res, HTTPErrorResponse):
raise res
resp = res
elif res is not None:
resp.body = str(res)
else:
raise HTTPNotFound()
return resp
def test_file_templates(self):
RenderFactory.create({
'distill.document_root':
os.path.abspath(os.path.join(os.path.dirname(__file__), 'res'))
})
@renderer('test.mako')
def fake_on_get_json(request, response):
return {"user": "******"}
@renderer('test.mako')
def fake_on_get_string(request, response):
return "Hello world!"
resp = Response()
rendered = fake_on_get_json(None, resp)
self.assertEqual(resp.headers['Content-Type'], 'text/html')
self.assertEqual(rendered, 'Hello Foobar!')
resp = Response()
rendered = fake_on_get_string(None, resp)
self.assertEqual(rendered, 'Hello world!')
def _request(self, env, req):
""" Processes the request
Notes:
This method acts as a wrapper to ease exception handling
Args:
env: The wsgi environ variable
"""
resp = Response()
self._do_before(req, resp)
context = self.map.match(req.path, env)
if context is not None:
req.matchdict = context
if 'controller' in context and context['controller'] in self._controllers:
if hasattr(self._controllers[context['controller']], context['action']):
cls = self._controllers[context['controller']]
controller = cls()
res = getattr(controller, context['action'])(req, resp)
else:
raise HTTPNotFound()
elif callable(context['action']):
res = context['action'](req, resp)
else:
raise HTTPNotFound()
if isinstance(res, Response):
if isinstance(res, HTTPErrorResponse):
raise res
resp = res
elif res is not None:
resp.body = str(res)
else:
raise HTTPNotFound()
return resp
def test_add_renderer(self):
RenderFactory.create({})
class TextRenderer(object):
def __init__(self):
pass
def __call__(self, data, request, response):
response.headers['Content-Type'] = 'text/plain'
return str(data)
RenderFactory.add_renderer('text2', TextRenderer())
@renderer('text2')
def fake_on_get(request, response):
return "Hello world"
resp = Response()
rendered = fake_on_get(None, resp)
self.assertEqual(resp.headers['Content-Type'], 'text/plain')
self.assertEqual(rendered, 'Hello world')
def handle_ise(request, response):
print((response.description))
resp = Response()
resp.body = "Whoops"
return resp
def user(request, response):
resp = Response(headers={'X-Test': 'Foobar'})
resp.body = "Hello world"
return resp
def fake_on_return_response(request, response):
return Response("719 I am not a teapot")
def test_unencrypted_local_storage(self):
store = os.path.abspath(os.path.join(os.path.dirname(__file__),
'sess'))
if os.path.exists(store):
shutil.rmtree(store)
factory = UnencryptedLocalSessionStorage(
{'distill.sessions.directory': store})
self.assertTrue(os.path.exists(store))
class FakeApp(object):
settings = {}
map = None
fake_env = {
'wsgi.input': None,
'wsgi.errors': None,
'wsgi.url_scheme': 'https',
'CONTENT_LENGTH': '0',
'PATH_INFO': '/foo/bar',
'SERVER_PORT': '8080',
'CONTENT_TYPE': '',
'HTTP_X_H_Test': 'Foobar',
'HTTP_CONTENT_TYPE': '',
'QUERY_STRING': 'foo=bar&bar=baz',
'HTTP_HOST': 'foobar.baz:8080',
'SERVER_NAME': 'foobar.baz',
'HTTP_FOO': 'bar',
'SCRIPT_NAME': '/some/script/dir',
'REQUEST_METHOD': 'GET'
}
req = Request(fake_env, FakeApp)
resp = Response()
req.session = factory(req)
self.assertEqual(len(req.session), 0)
req.session['Foo'] = 'bar'
req.session['Bar'] = 'foo'
req.session.flash('test', 'test')
queue = req.session.peek_flash('test')
self.assertEqual(queue, ['test'])
self.assertIn('_f_test', req.session)
req.session.flash('test', 'test')
req.session.flash('test', 'test', allow_duplicate=False)
queue = req.session.pop_flash('test')
self.assertEqual(queue, ['test', 'test'])
self.assertNotIn('_f_test', req.session)
token = req.session.get_csrf_token()
self.assertEqual(req.session['__csrft__'], token)
req.session.new_csrf_token()
self.assertNotEqual(req.session.get_csrf_token(), token)
for f in req.resp_callbacks:
f(req, resp)
self.assertEqual(len(resp.headers), 1)
files = []
for (dirpath, dirnames, filenames) in os.walk(store):
files += filenames
break
req = Request(fake_env, FakeApp)
req.cookies['ssid'] = files[0]
resp = Response()
req.session = factory(req)
self.assertIn('Foo', req.session)
self.assertFalse(req.session.dirty)
req.session.save(resp)
req.session.changed()
self.assertTrue(req.session.dirty)
req.session['Foo'] = 'Bar'
req.session.invalidate()
self.assertTrue(req.session.invalid)
for f in req.resp_callbacks:
f(req, resp)
self.assertFalse(os.path.isfile(os.path.join(store, files[0])))
req = Request(fake_env, FakeApp)
req.cookies['ssid'] = files[0]
req.session = factory(req)
self.assertNotIn('ssid', req.cookies)
def test_finalize(self):
resp = Response()
resp.body = "Foobar"
resp.finalize(None)
self.assertEqual(resp.body, "Foobar")
self.assertEqual(resp.wsgi_headers,
[('Content-Length', str(len(resp.body)))])
resp = Response("404 Not Found")
resp.file = BytesIO(b"Foobar")
resp.finalize(None)
self.assertEqual([block for block in resp.iterable], [b'Foobar'])
resp = Response()
resp.file = BytesIO(b"Foobar")
resp.finalize(lambda f, blocksize: iter(lambda: f.read(8 * 1024), b''))
self.assertEqual([block for block in resp.iterable], [b'Foobar'])
def test_set_cookie(self):
resp = Response()
resp.set_cookie("foo", "bar")
resp.set_cookie("bar", "baz", domain='foo.com', secure=True, comment='Hello world')
resp.set_cookie("foobar", "boofar", domain='.foo.com')
self.assertEqual(reduce(lambda t, l: t + 1 if l[0] == 'Set-Cookie' else t, resp.wsgi_headers, 0), 3)
def test_finalize(self):
resp = Response()
resp.body = "Foobar"
resp.finalize(None)
self.assertEqual(resp.body, "Foobar")
self.assertEqual(resp.wsgi_headers, [('Content-Length', str(len(resp.body)))])
resp = Response("404 Not Found")
resp.file = BytesIO(b"Foobar")
resp.finalize(None)
self.assertEqual([block for block in resp.iterable], [b'Foobar'])
resp = Response()
resp.file = BytesIO(b"Foobar")
resp.finalize(lambda f, blocksize: iter(lambda: f.read(8 * 1024), b''))
self.assertEqual([block for block in resp.iterable], [b'Foobar'])