def test_multiple_values(self):
formdata = MultiDict()
formdata.add('items', '1')
formdata.add('items', '2')
form = self.Form(formdata)
assert form.items.data == ['1', '2']
assert form.validate()
def test_multiple_values(self):
formdata = MultiDict()
formdata.add('items', '1')
formdata.add('items', '2')
form = self.Form(formdata)
assert form.items.data == ['1', '2']
assert form.validate()
def test_jsonify_multidict(self):
data = MultiDict()
data.add('a', 1)
data.add('a', 2)
data.add('b', 3)
json_data = jsonify.encode(data)
self.assertEqual('{"a": [1, 2], "b": 3}', json_data)
def test_parse_filter_params(self):
query_params = MultiDict()
query_params.add('type', 1)
query_params.add('type', 2)
query_params.add('test', 22)
res = parse_filter_params(query_params, self.filterable)
self.assertEqual({'type': [1, 2]}, res)
class Utility(object):
def __init__(self):
self.accept_headers = MultiDict()
self.deserializers = {}
def add_deserializer(self, content_type, callable):
self.deserializers[content_type] = callable
self.accept_headers.add('Accept', content_type)
def deserialize_request_body(self, request):
content_type = request.content_type
deserialized = None
request.response.headers.extend(self.accept_headers)
if content_type in self.deserializers:
try:
deserialized = self.deserializers[content_type](request)
except HTTPException as http_exc:
http_exc.headers.extend(self.accept_headers)
raise
else:
raise HTTPUnsupportedMediaType(content_type,
headers=self.accept_headers)
return deserialized
def build_params(self, request, facet_values):
'''
Build query parameters using the facet_values for this facet
and the request.
Returns: a list of (parameter, value) two-tuples
'''
params = MultiDict(request.params)
# removing all ..._facet parameters and add them again
current_facet_parameters = params.getall(self.request_key)
if self.request_key in params:
del params[self.request_key]
# readd all _facet parameters not related to us
for parameter in current_facet_parameters:
name, value = parameter.split(':')
if name != self.name:
params.add(self.request_key, parameter)
# add parameters for our facets
facet_values = list(set(facet_values))
for value in facet_values:
params.add(self.request_key, "%s:%s" % (self.name, value))
# sanitize and encode
items = ([(str(key), unicode(value).encode('utf-8')) for
(key, value) in params.items()])
return items
def build_params(self, request, facet_values):
'''
Build query parameters using the facet_values for this facet
and the request.
Returns: a list of (parameter, value) two-tuples
'''
params = MultiDict(request.params)
# removing all ..._facet parameters and add them again
current_facet_parameters = params.getall(self.request_key)
if self.request_key in params:
del params[self.request_key]
# readd all _facet parameters not related to us
for parameter in current_facet_parameters:
name, value = parameter.split(':')
if name != self.name:
params.add(self.request_key, parameter)
# add parameters for our facets
facet_values = list(set(facet_values))
for value in facet_values:
params.add(self.request_key, "%s:%s" % (self.name, value))
# sanitize and encode
items = ([(str(key), unicode(value).encode('utf-8'))
for (key, value) in params.items()])
return items
def create_request(self,
params=None,
environ=None,
matchdict=None,
headers=None,
path='/',
cookies=None,
post=None,
**kw):
if params and not isinstance(params, MultiDict):
mparams = MultiDict()
for k, v in params.items():
if isinstance(v, (list, tuple)):
[mparams.add(k, vv) for vv in v]
else:
mparams.add(k, v)
params = mparams
rv = DummyRequest(params,
environ,
headers,
path,
cookies,
post,
matchdict=(matchdict or {}),
**kw)
return rv
def test_diff(self):
"""The diff results page should have a header and a div for each message."""
fake_file_1 = FakeFieldStorage('added_deleted_changed_1.xml',
PfifXml.XML_ADDED_DELETED_CHANGED_1)
utils.set_file_for_test(StringIO(PfifXml.XML_ADDED_DELETED_CHANGED_2))
request = MultiDict({
'pfif_xml_file_1': fake_file_1,
'pfif_xml_url_2': 'fake_url',
'options': 'text_is_case_sensitive'
})
response = self.make_webapp_request(
request, handler_init_method=controller.DiffController)
response_str = response.out.getvalue()
# set the test file again because the first one will be at the end, and the
# xml parser doesn't have to seek(0) on it.
utils.set_file_for_test(StringIO(PfifXml.XML_ADDED_DELETED_CHANGED_2))
request.add('options', 'group_messages_by_record')
grouped_response = self.make_webapp_request(
request, handler_init_method=controller.DiffController)
grouped_response_str = grouped_response.out.getvalue()
# The header should have 'Diff' and 'Messages' in it along with the filename
# or url.
# The body should have each of five message types from pfif_object_diff
for message in [
'Diff', 'Messages', 'added_deleted_changed_1.xml', 'fake_url',
'extra', 'missing', 'field', 'record', 'Value', 'changed', 'A',
'B'
]:
self.assertTrue(
message in response_str and message in grouped_response_str,
'The diff was missing the '
'following message: ' + message + '. The diff: ' +
response_str)
class Utility(object):
def __init__(self):
self.accept_headers = MultiDict()
self.deserializers = {}
def add_deserializer(self, content_type, callable):
self.deserializers[content_type] = callable
self.accept_headers.add('Accept', content_type)
def deserialize_request_body(self, request):
content_type = request.content_type
deserialized = None
request.response.headers.extend(self.accept_headers)
if content_type in self.deserializers:
try:
deserialized = self.deserializers[content_type](request)
except HTTPException as http_exc:
http_exc.headers.extend(self.accept_headers)
raise
else:
raise HTTPUnsupportedMediaType(content_type,
headers=self.accept_headers)
return deserialized
def ignore_request_params_fields (request_params): result_data = MultiDict() for name, value in request_params.items(): if value != "IGNORE-THIS-FIELD": result_data.add(name, value) return result_data
def test_a_list_field_can_have_a_single_value(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first"]
def test_repeated_argument(self):
params = MultiDict(verb='a')
params.add('repeated', 'b')
params.add('repeated', 'b')
self.assertRaises(BadArgument,
views._check_params,
params,
['repeated'])
def test_a_list_field_can_have_a_single_value(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first"]
def _w(*args, **kwargs):
page = int(kwargs.pop(own_parameters["page"], 1))
real_items_per_page = int(
kwargs.pop(own_parameters['items_per_page'], items_per_page))
# Iterate over all of the named arguments expected by the function f
# if any of those arguments have values present in the kwargs dict,
# add the value to the positional args list, and remove it from the
# kwargs dict
argvars = inspect.getargspec(f)[0][1:]
if argvars:
args = list(args)
for i, var in enumerate(args):
if i >= len(argvars):
break
var = argvars[i]
if var in kwargs:
if i + 1 >= len(args):
args.append(kwargs[var])
else:
args[i + 1] = kwargs[var]
del kwargs[var]
res = f(*args, **kwargs)
if isinstance(res, dict) and name in res:
additional_parameters = MultiDict()
for key, value in request.params.iteritems():
if key not in own_parameters:
additional_parameters.add(key, value)
collection = res[name]
# Use CustomPage if our extra custom arg was provided
if items_first_page is not None:
page_class = CustomPage
else:
page_class = Page
page = page_class(collection,
page,
items_per_page=real_items_per_page,
items_first_page=items_first_page,
**additional_parameters.dict_of_lists())
# wrap the pager so that it will render
# the proper page-parameter
page.pager = partial(page.pager,
page_param=own_parameters["page"])
res[name] = page
# this is a bit strange - it appears
# as if c returns an empty
# string for everything it dosen't know.
# I didn't find that documented, so I
# just put this in here and hope it works.
if not hasattr(tmpl_context, 'paginators') or type(
tmpl_context.paginators) == str:
tmpl_context.paginators = Bunch()
tmpl_context.paginators[name] = page
return res
def test_it_keeps_only_last_value_for_non_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "first")
params.add("string_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("string_field") == ["second"]
def test_it_does_not_include_unknown_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "include_me")
params.add("unknown_field", "ignore_me")
parsed = validate_query_params(schema, params)
assert "unknown_field" not in parsed
def get_data(self, compact=True):
data = MultiDict(self.raw_data) # XXX
if compact:
compact_data = MultiDict()
for key, value in data.iteritems():
if value:
compact_data.add(key, value)
data = compact_data
return data
def get_data(self, compact=True):
data = MultiDict(self.raw_data) # XXX
if compact:
compact_data = MultiDict()
for key, value in data.iteritems():
if value:
compact_data.add(key, value)
data = compact_data
return data
def _w(*args, **kwargs):
page = int(kwargs.pop(own_parameters["page"], 1))
real_items_per_page = int(kwargs.pop(own_parameters["items_per_page"], items_per_page))
# Iterate over all of the named arguments expected by the function f
# if any of those arguments have values present in the kwargs dict,
# add the value to the positional args list, and remove it from the
# kwargs dict
argvars = inspect.getargspec(f)[0][1:]
if argvars:
args = list(args)
for i, var in enumerate(args):
if i >= len(argvars):
break
var = argvars[i]
if var in kwargs:
if i + 1 >= len(args):
args.append(kwargs[var])
else:
args[i + 1] = kwargs[var]
del kwargs[var]
res = f(*args, **kwargs)
if isinstance(res, dict) and name in res:
additional_parameters = MultiDict()
for key, value in request.params.iteritems():
if key not in own_parameters:
additional_parameters.add(key, value)
collection = res[name]
# Use CustomPage if our extra custom arg was provided
if items_first_page is not None:
page_class = CustomPage
else:
page_class = Page
page = page_class(
collection,
page,
items_per_page=real_items_per_page,
items_first_page=items_first_page,
**additional_parameters.dict_of_lists()
)
# wrap the pager so that it will render
# the proper page-parameter
page.pager = partial(page.pager, page_param=own_parameters["page"])
res[name] = page
# this is a bit strange - it appears
# as if c returns an empty
# string for everything it dosen't know.
# I didn't find that documented, so I
# just put this in here and hope it works.
if not hasattr(tmpl_context, "paginators") or type(tmpl_context.paginators) == str:
tmpl_context.paginators = Bunch()
tmpl_context.paginators[name] = page
return res
def test_it_keeps_all_values_for_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
params.add("list_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first", "second"]
def test_it_keeps_only_last_value_for_non_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "first")
params.add("string_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("string_field") == ["second"]
def test_it_does_not_include_unknown_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "include_me")
params.add("unknown_field", "ignore_me")
parsed = validate_query_params(schema, params)
assert "unknown_field" not in parsed
def test_it_keeps_all_values_for_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
params.add("list_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first", "second"]
def dict2mdict(values):
"convert dict to multidict"
muld = MultiDict()
for key in values:
if (key in BOOLFIELDS and (values[key] == '' or values[key] == 'False'
or values[key] is None)):
continue
muld.add(key, values[key])
return muld
def _dict_to_multidict(dict_):
"""Convert a validated query param dict back to a ``MultiDict``."""
result = MultiDict()
for key, value in dict_.items():
if isinstance(value, list):
for item in value:
result.add(key, item)
else:
result.add(key, value)
return result
def test_mf_search(self):
mdict = MultiDict()
mdict.add('SearchUser[email]', 'other')
request = testing.DummyRequest(mdict)
request.matchdict['objname'] = 'user'
response = mf_search(request)
#users = json.loads(response.body)
users = response
assert(len(users) == 1)
assert(users[0]['email'] == '*****@*****.**')
def dict2mdict(values):
"convert dict to multidict"
muld = MultiDict()
for key in values:
if (key in BOOLFIELDS and
(values[key] == '' or values[key] == 'False'
or values[key] is None)):
continue
muld.add(key, values[key])
return muld
def upload_request(self, files: dict, metadata=None, user=None):
if metadata is None:
metadata = '{}'
fields = MultiDict({'metadata': metadata})
for name, content in files.items():
fs = FieldStorage()
fs.file = BytesIO(content)
fs.filename = name
fields.add('file', fs)
return self.generic_request(post=fields, user=user)
def dummy_post(dbtransaction):
from pyramid.testing import DummyRequest
from webob.multidict import MultiDict
req = DummyRequest()
req.method = 'POST'
md = MultiDict()
md.add('title', 'dummy title')
md.add('text', 'dummy text')
req.POST = md
return req
def dummy_post(dbtransaction):
from pyramid.testing import DummyRequest
from webob.multidict import MultiDict
req = DummyRequest()
req.method = 'POST'
md = MultiDict()
md.add('title', 'dummy title')
md.add('text', 'dummy text')
req.POST = md
return req
def test_add_entry_view_POST(dbtransaction):
"""Test for add entry view dictionary."""
from pyramid.testing import DummyRequest
from webob.multidict import MultiDict
req = testing.DummyRequest()
req.method = "POST"
md = MultiDict()
md.add('title', 'test_title')
req.POST = md
dic = add_entry_view(req)
assert dic['form'].title.data == 'test_title'
def __make_request_params(kwargs):
params = MultiDict()
for key, val in kwargs.items():
assert isinstance(key, str)
if isinstance(val, str):
params[key] = val
else:
assert isinstance(val, (list, tuple))
for v in val:
assert isinstance(v, str)
params.add(key, v)
return params
def test_make_page_url():
purl = paginate.make_page_url("/articles", {}, 2)
eq_(purl, "/articles?page=2")
purl = paginate.make_page_url("/articles", {"foo": "bar"}, 2)
eq_(purl, "/articles?foo=bar&page=2")
params = {"foo": "bar", "page": "1"}
purl = paginate.make_page_url("/articles", params, 2)
eq_(purl, "/articles?foo=bar&page=2")
params = MultiDict({"foo": "bar", "page": "1"})
params.add("foo", "bar2")
purl = paginate.make_page_url("/articles", params, 2)
eq_(purl, "/articles?foo=bar&foo=bar2&page=2")
def test_remove_multiple_deterrent_attributes(self):
params = MultiDict({'pling_id':'pling_id_value',
'feedback_attribute':'deterrent',
'deterrent_value':'Cost',
'plingback_type':'automated_testing'})
params.add('deterrent_value', 'Transport')
tf = self.configure_triple_factory('/api/plingbacks',
params=params)
tf.add_attribute()
self.failUnless(len([x for x in tf.request.context.store]) == 2)
tf.remove_attribute('deterrent')
self.failUnless(len([x for x in tf.request.context.store]) == 0)
def test_make_page_url():
purl = paginate.make_page_url("/articles", {}, 2)
eq_(purl, "/articles?page=2")
purl = paginate.make_page_url("/articles", {"foo": "bar"}, 2)
eq_(purl, "/articles?foo=bar&page=2")
params = {"foo": "bar", "page": "1"}
purl = paginate.make_page_url("/articles", params, 2)
eq_(purl, "/articles?foo=bar&page=2")
params = MultiDict({"foo": "bar", "page": "1"})
params.add("foo", "bar2")
purl = paginate.make_page_url("/articles", params, 2)
eq_(purl, "/articles?foo=bar&foo=bar2&page=2")
def test_it_deserializes_params(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "test")
parsed = validate_query_params(schema, params)
assert parsed == {
"int_field": 0,
"string_field": "test",
"list_field": None,
"enum_field": "up",
}
def test_mf_edit_forbidden(self):
a_user = connection.User.find_one({'email': '*****@*****.**'})
mdict = MultiDict()
mdict.add('User[name]', 'Tommy')
request = testing.DummyRequest(mdict)
request.matchdict['objname'] = 'user'
request.matchdict['id'] = a_user['_id']
try:
mf_edit(request)
except HTTPForbidden:
pass
return
raise HTTPForbidden
def create_request(self, params=None, environ=None, matchdict=None,
headers=None, path='/', cookies=None, post=None, **kw):
if params and not isinstance(params, MultiDict):
mparams = MultiDict()
for k, v in params.items():
if hasattr(v, '__iter__'):
[mparams.add(k, vv) for vv in v]
else:
mparams.add(k, v)
params = mparams
rv = DummyRequest(params, environ, headers, path, cookies,
post, matchdict=(matchdict or {}), **kw)
return rv
def test_it_deserializes_params(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "test")
parsed = validate_query_params(schema, params)
assert parsed == {
"int_field": 0,
"string_field": "test",
"list_field": None,
"enum_field": "up",
}
def test_multidict():
d = MultiDict(a=1, b=2)
assert d['a'] == 1
assert d.getall('c') == []
d.add('a', 2)
assert d['a'] == 2
assert d.getall('a') == [1, 2]
d['b'] = 4
assert d.getall('b') == [4]
assert list(d.keys()) == ['a', 'a', 'b']
assert list(d.items()) == [('a', 1), ('a', 2), ('b', 4)]
assert d.mixed() == {'a': [1, 2], 'b': 4}
# test getone
# KeyError: "Multiple values match 'a': [1, 2]"
with pytest.raises(KeyError):
d.getone('a')
assert d.getone('b') == 4
# KeyError: "Key not found: 'g'"
with pytest.raises(KeyError):
d.getone('g')
assert d.dict_of_lists() == {'a': [1, 2], 'b': [4]}
assert 'b' in d
assert 'e' not in d
d.clear()
assert 'b' not in d
d['a'] = 4
d.add('a', 5)
e = d.copy()
assert 'a' in e
e.clear()
e['f'] = 42
d.update(e)
assert d == MultiDict([('a', 4), ('a', 5), ('f', 42)])
f = d.pop('a')
assert f == 4
assert d['a'] == 5
assert d.pop('g', 42) == 42
with pytest.raises(KeyError):
d.pop('n')
# TypeError: pop expected at most 2 arguments, got 3
with pytest.raises(TypeError):
d.pop(4, 2, 3)
d.setdefault('g', []).append(4)
assert d == MultiDict([('a', 5), ('f', 42), ('g', [4])])
def test_multidict():
d = MultiDict(a=1, b=2)
assert d['a'] == 1
assert d.getall('c') == []
d.add('a', 2)
assert d['a'] == 2
assert d.getall('a') == [1, 2]
d['b'] = 4
assert d.getall('b') == [4]
assert list(d.keys()) == ['a', 'a', 'b']
assert list(d.items()) == [('a', 1), ('a', 2), ('b', 4)]
assert d.mixed() == {'a': [1, 2], 'b': 4}
# test getone
# KeyError: "Multiple values match 'a': [1, 2]"
with pytest.raises(KeyError):
d.getone('a')
assert d.getone('b') == 4
# KeyError: "Key not found: 'g'"
with pytest.raises(KeyError):
d.getone('g')
assert d.dict_of_lists() == {'a': [1, 2], 'b': [4]}
assert 'b' in d
assert 'e' not in d
d.clear()
assert 'b' not in d
d['a'] = 4
d.add('a', 5)
e = d.copy()
assert 'a' in e
e.clear()
e['f'] = 42
d.update(e)
assert d == MultiDict([('a', 4), ('a', 5), ('f', 42)])
f = d.pop('a')
assert f == 4
assert d['a'] == 5
assert d.pop('g', 42) == 42
with pytest.raises(KeyError):
d.pop('n')
# TypeError: pop expected at most 2 arguments, got 3
with pytest.raises(TypeError):
d.pop(4, 2, 3)
d.setdefault('g', []).append(4)
assert d == MultiDict([('a', 5), ('f', 42), ('g', [4])])
def test_add_multiple_deterrent_attribute_with_js_list(self):
params = MultiDict({'pling_id':'pling_id_value',
'feedback_attribute':'deterrent',
'deterrent_value[]':'Cost',
'plingback_type':'automated_testing'})
params.add('deterrent_value[]', 'Transport')
tf = self.configure_triple_factory('/api/plingbacks',
params)
tf.add_attribute()
res = tf.request.context.query("SELECT ?val WHERE { ?pb <%s> ?val }" % (ns['PBO']['deterrent']))
self.failUnless('Cost' in [str(x) for x in res])
self.failUnless('Transport' in [str(x) for x in res])
self.failUnless(len([x for x in tf.request.context.store]) == 2)
def testGetPlayQueue(session):
md = MultiDict()
md.add("id", "tr-1")
md.add("id", "tr-2")
md.add("id", "tr-3")
md.add("current", "tr-2")
md.add("position", "32000")
cmd = buildCmd(session, SavePlayQueue, md)
checkResp(cmd.req, cmd())
cmd = buildCmd(session, GetPlayQueue, {})
resp = checkResp(cmd.req, cmd())
pq = resp.find("{http://subsonic.org/restapi}playQueue")
assert pq is not None
assert pq.get("changed")
assert pq.get("changedBy") == cmd.req.user_agent
assert pq.get("current") == "tr-2"
assert pq.get("position") == "32000"
assert pq.get("username") == "test"
for entry in pq.iter("{http://subsonic.org/restapi}entry"):
assert entry.get("album")
assert entry.get("artist")
assert entry.get("bitRate")
assert entry.get("contentType")
assert entry.get("discNumber")
assert entry.get("duration")
assert entry.get("isDir")
assert entry.get("isVideo")
def test_mf_edit(self):
a_user = connection.User.find_one({'email': '*****@*****.**'})
mdict = MultiDict()
mdict.add('User[name]', 'Alfred')
request = testing.DummyRequest(mdict)
request.matchdict['objname'] = 'user'
request.matchdict['id'] = a_user['_id']
response = mf_edit(request)
#res = json.loads(response.body)
res = response
assert(res['status'] == 0)
assert(res['object'] == 'user')
assert(res['user']['name'] == 'Alfred')
a_user = connection.User.find_one({'email': '*****@*****.**'})
assert(a_user['name'] == 'Alfred')
def test_mf_add(self):
# request = [("User[name]","sample"),
# ("User[email]","*****@*****.**")]
mdict = MultiDict()
mdict.add('User[email]', 'test@add')
mdict.add('User[name]', 'testadd')
request = testing.DummyRequest(mdict)
request.matchdict['objname'] = 'user'
response = mf_add(request)
#res = json.loads(response.body)
res = response
assert(res['status'] == 0)
assert(res['object'] == 'user')
assert(res['user']['email'] == 'test@add')
a_user = connection.User.find_one({'email': 'test@add'})
assert (a_user is not None)
def test_form_data_request() -> None:
"""Test that request.POST is used as the body in case of form-data."""
multi_dict = MultiDict()
multi_dict.add("key1", "value1")
multi_dict.add("key2", "value2.1")
multi_dict.add("key2", "value2.2")
pyramid_request = DummyRequest(path="/foo", post=multi_dict)
pyramid_request.matched_route = DummyRoute(name="foo", pattern="/foo")
pyramid_request.content_type = "multipart/form-data"
openapi_request = PyramidOpenAPIRequestFactory.create(pyramid_request)
assert openapi_request.body == {
"key1": "value1",
"key2": ["value2.1", "value2.2"]
}
def test_multidict():
d = MultiDict(a=1, b=2)
eq(d['a'], 1)
eq(d.getall('c'), [])
d.add('a', 2)
eq(d['a'], 2)
eq(d.getall('a'), [1, 2])
d['b'] = 4
eq(d.getall('b'), [4])
eq(list(d.keys()), ['a', 'a', 'b'])
eq(list(d.items()), [('a', 1), ('a', 2), ('b', 4)])
eq(d.mixed(), {'a': [1, 2], 'b': 4})
# test getone
# KeyError: "Multiple values match 'a': [1, 2]"
assert_raises(KeyError, d.getone, 'a')
eq(d.getone('b'), 4)
# KeyError: "Key not found: 'g'"
assert_raises(KeyError, d.getone, 'g')
eq(d.dict_of_lists(), {'a': [1, 2], 'b': [4]})
assert 'b' in d
assert 'e' not in d
d.clear()
assert 'b' not in d
d['a'] = 4
d.add('a', 5)
e = d.copy()
assert 'a' in e
e.clear()
e['f'] = 42
d.update(e)
eq(d, MultiDict([('a', 4), ('a', 5), ('f', 42)]))
f = d.pop('a')
eq(f, 4)
eq(d['a'], 5)
eq(d.pop('g', 42), 42)
assert_raises(KeyError, d.pop, 'n')
# TypeError: pop expected at most 2 arguments, got 3
assert_raises(TypeError, d.pop, 4, 2, 3)
d.setdefault('g', []).append(4)
eq(d, MultiDict([('a', 5), ('f', 42), ('g', [4])]))
def testSavePlayQueue(session):
md = MultiDict()
md.add("id", "tr-1")
md.add("id", "tr-2")
md.add("id", "tr-3")
md.add("current", "tr-2")
md.add("position", "32000")
cmd = buildCmd(session, SavePlayQueue, md)
checkResp(cmd.req, cmd())
def buildCmd(session, klass, params={}, username="******"):
request = testing.DummyRequest()
request.context = testing.DummyResource()
if isinstance(params, dict):
md = MultiDict()
for key, val in params.items():
md.add(key, val)
elif isinstance(params, MultiDict):
md = params
else:
raise Exception("Invalid params class type")
request.params = NestedMultiDict(md)
request.authed_user = models.getUserByName(session, username)
request.user_agent = "Test/1.0 (X11; Linux x86_64) Test/1.0 Test/1.0"
cmd = klass(None, request, session=session)
cmd.settings = {"mishmash.paths": "Music: test/music"}
return cmd
def test_addpackmod_view(self):
""" Ensure the add pack mod view works. """
# Create dummy mods
mod = create_mod(self.contributor, name='aMod').save()
mod2 = create_mod(self.contributor, name='bMod').save()
# Create dummy pack
pack = create_pack(self.contributor).save()
# Create request
data = MultiDict()
data.add('mods', mod.id)
data.add('mods', mod2.id)
request = matchrequest(id=pack.id, params=data)
# Run
self.makeOne(request).addpackmod()
# Check it
pack.reload()
self.assertIn(mod, pack['mods'])
self.assertIn(mod2, pack['mods'])
def add_to_parameters(key: object,
values: Union[list, object],
multidictio: MultiDict,
length: int = 1) -> MultiDict:
"""
this function add a parameter to the parameter multidict for SLV API calls
:param key: name of the parameter as str
:param values: value or values corresponding to that parameter. If multiple values format must be a list
:param multidictio: the parameter multidict
:param length: number of parameters
:return: the output parameter multidict
"""
if type(values) is list: # checking input types
for elt in values: # add several deviceId to param
multidictio.add(key, elt)
elif type(values): # checking input types
for i in range(0, length):
multidictio.add(key, values) # add only one deviceId to param
return multidictio
def _w(*args, **kwargs):
page = int(kwargs.pop(own_parameters["page"], 1))
real_items_per_page = int(
kwargs.pop(own_parameters['items_per_page'], items_per_page))
argvars = inspect.getargspec(f)[0][1:]
if argvars:
args = list(args)
for i, var in enumerate(args):
if i >= len(argvars):
break
var = argvars[i]
if var in kwargs:
args[i] = kwargs[var]
del kwargs[var]
res = f(*args, **kwargs)
if isinstance(res, dict) and name in res:
additional_parameters = MultiDict()
for key, value in request.str_params.iteritems():
if key not in own_parameters:
additional_parameters.add(key, value)
collection = res[name]
page = Page(collection,
page,
items_per_page=real_items_per_page,
**additional_parameters.dict_of_lists())
# wrap the pager so that it will render
# the proper page-parameter
page.pager = partial(page.pager,
page_param=own_parameters["page"])
res[name] = page
# this is a bit strange - it appears
# as if c returns an empty
# string for everything it dosen't know.
# I didn't find that documented, so I
# just put this in here and hope it works.
if not hasattr(c, 'paginators') or type(c.paginators) == str:
c.paginators = Bunch()
c.paginators[name] = page
return res
def _create_multidict(self):
result = MultiDict()
result.add('hub.mode', 'subscribe')
result.add('hub.challenge', 'secret')
result.add('hub.verify_token', self.verify_token)
return result
def get_data(self, compact=True):
'''
Returns data representing current state of the form. While
Form.raw_data may contain alien fields and invalid data, this method
returns only valid fields that belong to this form only. It's designed
to pass somewhere current state of the form (as query string or by
other means).
'''
# Dirty hack due to lame (more convenient in cost of flexibility)
# interface of Field.set_raw_value()
raw_data, self.raw_data = self.raw_data, MultiDict()
for field in self.fields:
raw_value = field.from_python(self.python_data[field.name])
field.set_raw_value(raw_value)
data, self.raw_data = self.raw_data, raw_data
if compact:
compact_data = MultiDict()
for key in data:
values = filter(None, data.getall(key))
for value in values:
compact_data.add(key, value)
data = compact_data
return data
def testDictToQs(self):
def echo(environ, start_response):
r = Request(environ)
return Response(r.query_string)(environ, start_response)
tc = testing.TestClient(pipeline=echo)
TM = u"\u2122"
d = MultiDict()
d.add("a", 1)
d.add("a", 2)
d.add("a", 3)
d.add("b", u"Nike %s" % TM)
tc.get("/", query_string=d)
