blob: e6b1cf8ad209ceb856f25cbb5617d4f99cc9d6b2 [file] [log] [blame]
# -*- coding: utf-8 -*-
import re
import six
from json import dumps
from webtest.compat import urlencode
class NoDefault(object):
"""Sentinel to uniquely represent no default value."""
def __repr__(self):
return '<NoDefault>'
NoDefault = NoDefault()
def json_method(method):
"""Do a %(method)s request. Very like the
:class:`~webtest.TestApp.%(lmethod)s` method.
``params`` are dumped to json and put in the body of the request.
Content-Type is set to ``application/json``.
Returns a :class:`webtest.TestResponse` object.
"""
def wrapper(self, url, params=NoDefault, **kw):
content_type = 'application/json'
if params is not NoDefault:
params = dumps(params, cls=self.JSONEncoder)
kw.update(
params=params,
content_type=content_type,
upload_files=None,
)
return self._gen_request(method, url, **kw)
subst = dict(lmethod=method.lower(), method=method)
wrapper.__doc__ = json_method.__doc__ % subst
wrapper.__name__ = str('%(lmethod)s_json' % subst)
return wrapper
def stringify(value):
if isinstance(value, six.text_type):
return value
elif isinstance(value, six.binary_type):
return value.decode('utf8')
else:
return str(value)
entity_pattern = re.compile(r"&(\w+|#\d+|#[xX][a-fA-F0-9]+);")
def encode_params(params, content_type):
if params is NoDefault:
return ''
if isinstance(params, dict) or hasattr(params, 'items'):
params = list(params.items())
if isinstance(params, (list, tuple)):
if content_type:
content_type = content_type.lower()
if 'charset=' in content_type:
charset = content_type.split('charset=')[1]
charset = charset.strip('; ').lower()
encoded_params = []
for k, v in params:
if isinstance(v, six.text_type):
v = v.encode(charset)
encoded_params.append((k, v))
params = encoded_params
params = urlencode(params, doseq=True)
return params
def make_pattern(pat):
"""Find element pattern can be a regex or a callable."""
if pat is None:
return None
if isinstance(pat, six.binary_type):
pat = pat.decode('utf8')
if isinstance(pat, six.text_type):
pat = re.compile(pat)
if hasattr(pat, 'search'):
return pat.search
if hasattr(pat, '__call__'):
return pat
raise ValueError(
"Cannot make callable pattern object out of %r" % pat)
class _RequestCookieAdapter(object):
"""
cookielib.CookieJar support for webob.Request
"""
def __init__(self, request):
self._request = request
self.origin_req_host = request.host
def is_unverifiable(self):
return True # sure? Why not?
@property
def unverifiable(self): # NOQA
# This is undocumented method that Python 3 cookielib uses
return True
def get_full_url(self):
return self._request.url
def get_host(self):
return self.origin_req_host
get_origin_req_host = get_host
def add_unredirected_header(self, key, header):
self._request.headers[key] = header
def has_header(self, key):
return key in self._request.headers
def get_type(self):
return self._request.scheme
@property
def type(self): # NOQA
# This is undocumented method that Python 3 cookielib uses
return self.get_type()
def header_items(self): # pragma: no cover
# This is unused on most python versions
return self._request.headers.items()
class _ResponseCookieAdapter(object):
"""
cookielib.CookieJar support for webob.Response
"""
def __init__(self, response):
self._response = response
def info(self):
return self
def getheaders(self, header):
return self._response.headers.getall(header)
def get_all(self, headers, default): # NOQA
# This is undocumented method that Python 3 cookielib uses
return self._response.headers.getall(headers)