def test_00_read_search_params_with_errors(self):
def check_error(request_params):
assert_raises(ValueError, ApiController._get_search_params, request_params)
# uri json
check_error(UnicodeMultiDict({'qjson': '{"q": illegal json}'}))
# posted json
check_error(UnicodeMultiDict({'{"q": illegal json}': u'1'}))
def test_00_read_search_params(self):
def check(request_params, expected_params):
params = ApiController._get_search_params(request_params)
assert_equal(params, expected_params)
# uri parameters
check(UnicodeMultiDict({
'q': '',
'ref': 'boris'
}), {
"q": "",
"ref": "boris"
})
# uri json
check(UnicodeMultiDict({'qjson': '{"q": "", "ref": "boris"}'}), {
"q": "",
"ref": "boris"
})
# posted json
check(UnicodeMultiDict({'{"q": "", "ref": "boris"}': u'1'}), {
"q": "",
"ref": "boris"
})
check(UnicodeMultiDict({'{"q": "", "ref": "boris"}': u''}), {
"q": "",
"ref": "boris"
})
# no parameters
check(UnicodeMultiDict({}), {})
def _set_request(self, request):
"""
Assign raw request data to the form
:arg request_data: raw request data (e.g. request.POST)
:type request_data: Dictionary (dotted or nested or dotted or MultiDict)
"""
self._request = request
request_data = getattr(request, self.method.upper())
# Decode request data according to the request's charset.
request_data = UnicodeMultiDict(
request_data, encoding=util.get_post_charset(request))
# Remove the sequence factory data from the request
for k in request_data.keys():
if '*' in k:
request_data.pop(k)
# We need the _request_data to be populated so sequences know how many
# items they have (i.e. .fields method on a sequence uses the number of
# values on the _request_data)
# Convert request data to a dottedish friendly representation
request_data = _unflatten_request_data(request_data)
self._request_data = dotted(request_data)
self._request_data = dotted(
self.widget.pre_parse_incoming_request_data(
self.structure, request_data))
def test_orgportals_show_exit_button(self):
params = UnicodeMultiDict({'author': 'John Doe'})
show_button = helpers.orgportals_show_exit_button(params)
assert show_button is False
params = UnicodeMultiDict({'q': 'test'})
show_button = helpers.orgportals_show_exit_button(params)
assert show_button is True
def GET(self):
"""
A MultiDict containing all the variables from the QUERY_STRING.
"""
env = self.environ
source = env.get('QUERY_STRING', '')
if 'webob._parsed_query_vars' in env:
vars, qs = env['webob._parsed_query_vars']
if qs == source:
return vars
def _update_get(_vars, key=None, value=None):
assert _vars is vars.multi
qs = urllib.urlencode(_vars.items())
env['QUERY_STRING'] = qs
env['webob._parsed_query_vars'] = (vars, qs)
if not source:
#@@xxxxx
vars = TrackableMultiDict(__tracker=_update_get, __name='GET')
else:
vars = TrackableMultiDict(parse_qsl(source,
keep_blank_values=True,
strict_parsing=False),
__tracker=_update_get,
__name='GET')
vars = UnicodeMultiDict(vars,
encoding=self.charset,
errors=self.unicode_errors)
env['webob._parsed_query_vars'] = (vars, source)
return vars
def _sub_post(self, condition):
post = super(Request, self).str_POST
if isinstance(post, NoVars):
return post
return UnicodeMultiDict(MultiDict(filter(condition, post.items())),
encoding=self.charset,
errors=self.unicode_errors,
decode_keys=self.decode_param_names)
def cookies(self):
"""
Like ``.str_cookies``, but may decode values and keys
"""
vars = self.str_cookies
if self.charset:
vars = UnicodeMultiDict(vars, encoding=self.charset,
errors=self.unicode_errors,
decode_keys=self.decode_param_names)
return vars
def params(self):
"""
Like ``.str_params``, but may decode values and keys
"""
params = self.str_params
if self.charset:
params = UnicodeMultiDict(params, encoding=self.charset,
errors=self.unicode_errors,
decode_keys=self.decode_param_names)
return params
def params(self):
"""
Like ``.str_params``, but decodes values and keys
"""
params = NestedMultiDict(self._str_GET, self._str_POST)
params = UnicodeMultiDict(params,
encoding=self.charset,
errors=self.unicode_errors,
decode_keys=self.decode_param_names)
return params
def GET(self):
"""
Like ``.str_GET``, but decodes values and keys
"""
vars = self._str_GET
vars = UnicodeMultiDict(vars,
encoding=self.charset,
errors=self.unicode_errors,
decode_keys=self.decode_param_names)
return vars
def _set_request(self, request):
"""
Assign raw request data to the form
:arg request_data: raw request data (e.g. request.POST)
:type request_data: Dictionary (dotted or nested or dotted or MultiDict)
"""
self._request = request
request_data = getattr(request, self.method.upper())
# Decode request data according to the request's charset.
request_data = UnicodeMultiDict(request_data,
encoding=util.get_post_charset(request))
# Remove the sequence factory data from the request
for k in request_data.keys():
if '*' in k:
request_data.pop(k)
# We need the _request_data to be populated so sequences know how many
# items they have (i.e. .fields method on a sequence uses the number of
# values on the _request_data)
# Convert request data to a dottedish friendly representation
request_data = _unflatten_request_data(request_data)
self._request_data = dotted(request_data)
self._request_data = dotted(self.widget.pre_parse_incoming_request_data(self.structure,request_data))
def POST(self):
"""
A MultiDict containing all the variables from a form
request. An empty dict-like object for non-form
requests.
Form requests are typically POST requests, however PUT requests
with an appropriate Content-Type are also supported.
All keys and values are unicode.
"""
env = self.environ
if self.method not in ('POST', 'PUT'):
return NoVars('Not a form request')
if 'webob._parsed_post_vars' in env:
vars, body_file = env['webob._parsed_post_vars']
if body_file is self.body_file_raw:
return vars
content_type = self.content_type
if ((self.method == 'PUT' and not content_type) or content_type
not in ('', 'application/x-www-form-urlencoded',
'multipart/form-data')):
# Not an HTML form submission
return NoVars('Not an HTML form submission (Content-Type: %s)' %
content_type)
if self.is_body_seekable:
self.body_file_raw.seek(0)
fs_environ = env.copy()
# FieldStorage assumes a missing CONTENT_LENGTH, but a
# default of 0 is better:
fs_environ.setdefault('CONTENT_LENGTH', '0')
fs_environ['QUERY_STRING'] = ''
fs = cgi.FieldStorage(fp=self.body_file,
environ=fs_environ,
keep_blank_values=True)
vars = MultiDict.from_fieldstorage(fs)
#ctype = self.content_type or 'application/x-www-form-urlencoded'
ctype = env.get('CONTENT_TYPE', 'application/x-www-form-urlencoded')
self.body_file = io.BufferedReader(FakeCGIBody(vars, ctype))
vars = UnicodeMultiDict(vars,
encoding=self.charset,
errors=self.unicode_errors)
env['webob._parsed_post_vars'] = (vars, self.body_file_raw)
return vars
def cookies(self):
"""
A dictionary of cookies as found in the request.
"""
env = self.environ
source = env.get('HTTP_COOKIE', '')
if 'webob._parsed_cookies' in env:
vars, var_source = env['webob._parsed_cookies']
if var_source == source:
return vars
vars = {}
if source:
cookies = Cookie(source)
for name in cookies:
vars[name] = cookies[name].value
#@@ decode directly
vars = UnicodeMultiDict(vars,
encoding=self.charset,
errors=self.unicode_errors)
env['webob._parsed_cookies'] = (vars, source)
return vars
def test_03_search_url_multiple_words(self):
fields = UnicodeMultiDict(MultiDict(url='e'))
fields.add('url', 'f')
urls = self.res_search(fields=fields)
assert set([self.ef]) == urls, urls
def test_03_search_url_multiple_words(self):
fields = UnicodeMultiDict(MultiDict(url='e'))
fields.add('url', 'f')
urls = self.res_search(fields=fields)
assert set([self.ef]) == urls, urls
def test_03_search_url_multiple_words(self):
fields = UnicodeMultiDict(MultiDict(url="e"))
fields.add("url", "f")
urls = self.res_search(fields=fields)
assert set([self.ef]) == urls, urls