def test_add(self):
cd = CookieDict()
cd.add(name='test', value='something', expires=60, path='/home', domain='test.com', secure=True, httponly=True, comment='Blah')
cookie = cd['test']
assert cookie.value == 'something'
assert cookie['expires'] == 60
assert cookie['path'] == '/home'
assert cookie['domain'] == 'test.com'
assert cookie['secure'] == True
assert cookie['httponly'] == True
def test_expire(self):
cd = CookieDict()
cd.add('test', 'something')
cd.add('blah', 'test')
cd.expire()
assert cd['test']['expires'] == -1
assert cd['blah']['expires'] == -1
def split_headers_server_vars(environ):
"""Splits the environ into headers and server pairs.
"""
headers = HeaderDict()
server = MultiDict()
cookies = CookieDict()
for key in environ:
if is_header(key):
headers.add(http_header(key), environ[key])
if key == 'HTTP_COOKIE':
cookies = CookieDict(environ[key])
cookies.modified = False
else:
server[key] = environ[key]
return headers, server, cookies
def __init__(self,
method,
get=None,
post=None,
files=None,
headers=None,
server=None,
cookies=None,
body=''):
"""Creates a new instance of the Request object.
Args:
method: The Http request method
get: A watson.datastructures.MultiDict containing GET variables
post: A watson.datastructures.MultiDict containing POST variables
files: A watson.datastructures.MultiDict containing FieldStorage objects
headers: A watson.http.headers.HeaderDict containing valid Http headers
server: A watson.datastructures.MultiDict containing server variables
cookies: A watson.http.cookies.CookieDict containing watson.http.cookies.TastyMorsel objects
body: The content of the request
"""
super(Request, self).__init__(body=body, headers=headers)
self._method = str(method).upper()
if self.method not in REQUEST_METHODS:
raise TypeError('Not a valid Http Request method.')
self._get = get or MultiDict()
self._post = post or MultiDict()
self._files = files or MultiDict()
self._server = server or MultiDict()
self._cookies = cookies or CookieDict()
self.headers = headers or HeaderDict()
def test_add(self):
cd = CookieDict()
cd.add(name='test',
value='something',
expires=60,
path='/home',
domain='test.com',
secure=True,
httponly=True,
comment='Blah')
cookie = cd['test']
assert cookie.value == 'something'
assert cookie['expires'] == 60
assert cookie['path'] == '/home'
assert cookie['domain'] == 'test.com'
assert cookie['secure']
assert cookie['httponly']
def test_expire(self):
cd = CookieDict()
cd.add('test', 'something')
cd.add('blah', 'test')
cd.expire()
assert cd['test']['expires'] == -1
assert cd['blah']['expires'] == -1
def __copy__(self):
return Request(self.method,
get=copy(self.get),
post=copy(self.post),
files=copy(self.files),
headers=HeaderDict(copy(self.headers)),
server=copy(self.server),
cookies=CookieDict(copy(self.cookies)),
body=copy(self.body))
def test_output(self):
cd = CookieDict()
cd.add('test', 'something')
cd.add('blah', 'test')
assert str(cd) == 'blah=test; Path=/\r\ntest=something; Path=/'
def test_delete(self):
cd = CookieDict()
cd.add('test', 'something')
cd.delete('test')
assert cd['test']['expires'] == -1
def test_output(self):
cd = CookieDict()
cd.add('test', 'something')
cd.add('blah', 'test')
assert str(cd) == 'blah=test; Path=/\r\ntest=something; Path=/'
def test_delete(self):
cd = CookieDict()
cd.add('test', 'something')
cd.delete('test')
assert cd['test']['expires'] == -1
def cookies(self):
"""Returns the cookies associated with the Response.
"""
if not self._cookies:
self.cookies = CookieDict()
return self._cookies
class Response(MessageMixin):
"""Provides a simple and usable interface for dealing with Http Responses.
See:
- http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html
Example:
.. code-block:: python
def app(environ, start_response):
response = Response(200, body='<h1>Hello World!</h1>')
response.headers.add('Content-Type', 'text/html', charset='utf-8')
response.cookies.add('something', 'test')
start_response(*response.start())
return [response()]
"""
_status_code = None
_cookies = None
_body = None
_prepared = False
def __init__(self, status_code=None, headers=None, body=None, version=None):
"""
Args:
status_code (int): The status code for the Response
headers (watson.http.headers.HeaderCollection): Valid response headers.
body (string): The content for the response
version (string): The Http version for the response
"""
self.status_code = status_code
self._headers = headers or HeaderCollection()
if version:
self.version = version
if body:
self.body = body
@property
def headers(self):
return self._headers
@headers.setter
def headers(self, headers):
if not isinstance(headers, HeaderCollection):
headers = HeaderCollection(headers)
self._headers = headers
@property
def raw_body(self):
if self._body:
return self._body
return b''
@property
def body(self):
"""Returns the decoded body based on the response encoding type.
"""
return self.raw_body.decode(self.encoding)
@body.setter
def body(self, body):
"""Set the body of the Request.
Args:
body (string): The body of the request.
"""
self._body = body.encode(self.encoding)
@property
def status_code(self):
"""The status code for the Response.
"""
return self._status_code or 200
@status_code.setter
def status_code(self, code):
"""
Args:
Code: an int representing the status code for the Response
"""
self._status_code = code
@property
def status_line(self):
"""The formatted status line including the status code and message.
"""
return (
'{0} {1}'.format(
self.status_code, STATUS_CODES.get(self.status_code)))
@property
def cookies(self):
"""Returns the cookies associated with the Response.
"""
if not self._cookies:
self.cookies = CookieDict()
return self._cookies
@cookies.setter
def cookies(self, cookies):
"""Sets the cookies associated with the Response.
Args:
cookies (CookieDict): The cookies to add to the response.
"""
self._cookies = cookies
@property
def encoding(self):
"""Retrieve the encoding for the response from the headers, defaults to
UTF-8.
"""
return self.headers.get_option('Content-Type', 'charset', 'utf-8')
def start(self):
"""Return the status_line and headers of the response for use in a WSGI
application.
Returns:
The status line and headers of the response.
"""
self._prepare()
return self.status_line, self.headers()
def raw(self):
"""Return the raw encoded output for the response.
"""
return str(self).encode(self.encoding)
def __str__(self):
self._prepare()
return 'HTTP/{0} {1}\r\n{2}\r\n\r\n{3}'.format(self.version,
self.status_line,
self.headers,
self.body)
def _prepare(self):
if not self._prepared:
if self._cookies:
for cookie, morsel in self.cookies.items():
self.headers.add('Set-Cookie', str(morsel))
self._prepared = True
def __call__(self, start_response):
"""Execute the start_response method and return the response body.
Args:
start_response (callable): The start_response function from a WSGI
callable.
"""
start_response(*self.start())
return [self.raw_body]
def cookies(self, cookies):
"""Sets the cookies associated with the Response.
"""
if not isinstance(cookies, CookieDict):
cookies = CookieDict(cookies)
self._cookies = cookies
def cookies(self):
"""Returns the cookies associated with the Response.
"""
if not self._cookies:
self._cookies = CookieDict()
return self._cookies
