def test_iter_interfaces(self):
mapping = [('a', 1), ('b', 2), ('a', 2), ('d', 3),
('a', 1), ('a', 3), ('d', 4), ('c', 3)]
md = self.storage_class(mapping)
assert list(zip(md.keys(), md.listvalues())) == list(md.lists())
assert list(zip(md, iterlistvalues(md))) == list(iterlists(md))
assert list(zip(iterkeys(md), iterlistvalues(md))) == \
list(iterlists(md))
def test_iter_interfaces(self):
mapping = [('a', 1), ('b', 2), ('a', 2), ('d', 3),
('a', 1), ('a', 3), ('d', 4), ('c', 3)]
md = self.storage_class(mapping)
assert list(zip(md.keys(), md.listvalues())) == list(md.lists())
assert list(zip(md, iterlistvalues(md))) == list(iterlists(md))
assert list(zip(iterkeys(md), iterlistvalues(md))) == \
list(iterlists(md))
def test_iter_interfaces(self):
mapping = [
("a", 1),
("b", 2),
("a", 2),
("d", 3),
("a", 1),
("a", 3),
("d", 4),
("c", 3),
]
md = self.storage_class(mapping)
assert list(zip(md.keys(), md.listvalues())) == list(md.lists())
assert list(zip(md, iterlistvalues(md))) == list(iterlists(md))
assert list(zip(iterkeys(md), iterlistvalues(md))) == list(iterlists(md))
def test_iter_interfaces(self):
mapping = [
("a", 1),
("b", 2),
("a", 2),
("d", 3),
("a", 1),
("a", 3),
("d", 4),
("c", 3),
]
md = self.storage_class(mapping)
assert list(zip(md.keys(), md.listvalues())) == list(md.lists())
assert list(zip(md, iterlistvalues(md))) == list(iterlists(md))
assert list(zip(iterkeys(md), iterlistvalues(md))) == list(iterlists(md))
def test_iterables(self):
a = datastructures.MultiDict((("key_a", "value_a"),))
b = datastructures.MultiDict((("key_b", "value_b"),))
ab = datastructures.CombinedMultiDict((a, b))
assert sorted(ab.lists()) == [('key_a', ['value_a']), ('key_b', ['value_b'])]
assert sorted(ab.listvalues()) == [['value_a'], ['value_b']]
assert sorted(ab.keys()) == ["key_a", "key_b"]
assert sorted(iterlists(ab)) == [('key_a', ['value_a']), ('key_b', ['value_b'])]
assert sorted(iterlistvalues(ab)) == [['value_a'], ['value_b']]
assert sorted(iterkeys(ab)) == ["key_a", "key_b"]
def test_iterables(self):
a = datastructures.MultiDict((("key_a", "value_a"),))
b = datastructures.MultiDict((("key_b", "value_b"),))
ab = datastructures.CombinedMultiDict((a, b))
assert sorted(ab.lists()) == [("key_a", ["value_a"]), ("key_b", ["value_b"])]
assert sorted(ab.listvalues()) == [["value_a"], ["value_b"]]
assert sorted(ab.keys()) == ["key_a", "key_b"]
assert sorted(iterlists(ab)) == [("key_a", ["value_a"]), ("key_b", ["value_b"])]
assert sorted(iterlistvalues(ab)) == [["value_a"], ["value_b"]]
assert sorted(iterkeys(ab)) == ["key_a", "key_b"]
def test_iterables(self):
a = datastructures.MultiDict((("key_a", "value_a"),))
b = datastructures.MultiDict((("key_b", "value_b"),))
ab = datastructures.CombinedMultiDict((a,b))
self.assert_equal(sorted(ab.lists()), [('key_a', ['value_a']), ('key_b', ['value_b'])])
self.assert_equal(sorted(ab.listvalues()), [['value_a'], ['value_b']])
self.assert_equal(sorted(ab.keys()), ["key_a", "key_b"])
self.assert_equal(sorted(iterlists(ab)), [('key_a', ['value_a']), ('key_b', ['value_b'])])
self.assert_equal(sorted(iterlistvalues(ab)), [['value_a'], ['value_b']])
self.assert_equal(sorted(iterkeys(ab)), ["key_a", "key_b"])
def _iter_data(data):
"""Iterates over a dict or multidict yielding all keys and values.
This is used to iterate over the data passed to the
:class:`EnvironBuilder`.
"""
if isinstance(data, MultiDict):
for key, values in iterlists(data):
for value in values:
yield key, value
else:
for key, values in iteritems(data):
if isinstance(values, list):
for value in values:
yield key, value
else:
yield key, values
def _iter_data(data):
"""Iterates over a dict or multidict yielding all keys and values.
This is used to iterate over the data passed to the
:class:`EnvironBuilder`.
"""
if isinstance(data, MultiDict):
for key, values in iterlists(data):
for value in values:
yield key, value
else:
for key, values in iteritems(data):
if isinstance(values, list):
for value in values:
yield key, value
else:
yield key, values
def test_basic_interface(self):
d1 = datastructures.MultiDict([('foo', '1')])
d2 = datastructures.MultiDict([('bar', '2'), ('bar', '3')])
d = self.storage_class([d1, d2])
# lookup
self.assert_equal(d['foo'], '1')
self.assert_equal(d['bar'], '2')
self.assert_equal(d.getlist('bar'), ['2', '3'])
self.assert_equal(sorted(d.items()),
[('bar', '2'), ('foo', '1')])
self.assert_equal(sorted(d.items(multi=True)),
[('bar', '2'), ('bar', '3'), ('foo', '1')])
assert 'missingkey' not in d
assert 'foo' in d
# type lookup
self.assert_equal(d.get('foo', type=int), 1)
self.assert_equal(d.getlist('bar', type=int), [2, 3])
# get key errors for missing stuff
with self.assert_raises(KeyError):
d['missing']
# make sure that they are immutable
with self.assert_raises(TypeError):
d['foo'] = 'blub'
# copies are immutable
d = d.copy()
with self.assert_raises(TypeError):
d['foo'] = 'blub'
# make sure lists merges
md1 = datastructures.MultiDict((("foo", "bar"),))
md2 = datastructures.MultiDict((("foo", "blafasel"),))
x = self.storage_class((md1, md2))
self.assert_equal(list(iterlists(x)), [('foo', ['bar', 'blafasel'])])
def test_basic_interface(self):
d1 = datastructures.MultiDict([('foo', '1')])
d2 = datastructures.MultiDict([('bar', '2'), ('bar', '3')])
d = self.storage_class([d1, d2])
# lookup
self.assert_equal(d['foo'], '1')
self.assert_equal(d['bar'], '2')
self.assert_equal(d.getlist('bar'), ['2', '3'])
self.assert_equal(sorted(d.items()), [('bar', '2'), ('foo', '1')])
self.assert_equal(sorted(d.items(multi=True)), [('bar', '2'),
('bar', '3'),
('foo', '1')])
assert 'missingkey' not in d
assert 'foo' in d
# type lookup
self.assert_equal(d.get('foo', type=int), 1)
self.assert_equal(d.getlist('bar', type=int), [2, 3])
# get key errors for missing stuff
with self.assert_raises(KeyError):
d['missing']
# make sure that they are immutable
with self.assert_raises(TypeError):
d['foo'] = 'blub'
# copies are immutable
d = d.copy()
with self.assert_raises(TypeError):
d['foo'] = 'blub'
# make sure lists merges
md1 = datastructures.MultiDict((("foo", "bar"), ))
md2 = datastructures.MultiDict((("foo", "blafasel"), ))
x = self.storage_class((md1, md2))
self.assert_equal(list(iterlists(x)), [('foo', ['bar', 'blafasel'])])
def test_basic_interface(self):
d1 = datastructures.MultiDict([("foo", "1")])
d2 = datastructures.MultiDict([("bar", "2"), ("bar", "3")])
d = self.storage_class([d1, d2])
# lookup
self.assert_equal(d["foo"], "1")
self.assert_equal(d["bar"], "2")
self.assert_equal(d.getlist("bar"), ["2", "3"])
self.assert_equal(sorted(d.items()), [("bar", "2"), ("foo", "1")])
self.assert_equal(sorted(d.items(multi=True)), [("bar", "2"), ("bar", "3"), ("foo", "1")])
assert "missingkey" not in d
assert "foo" in d
# type lookup
self.assert_equal(d.get("foo", type=int), 1)
self.assert_equal(d.getlist("bar", type=int), [2, 3])
# get key errors for missing stuff
with self.assert_raises(KeyError):
d["missing"]
# make sure that they are immutable
with self.assert_raises(TypeError):
d["foo"] = "blub"
# copies are immutable
d = d.copy()
with self.assert_raises(TypeError):
d["foo"] = "blub"
# make sure lists merges
md1 = datastructures.MultiDict((("foo", "bar"),))
md2 = datastructures.MultiDict((("foo", "blafasel"),))
x = self.storage_class((md1, md2))
self.assert_equal(list(iterlists(x)), [("foo", ["bar", "blafasel"])])
def test_basic_interface(self):
d1 = datastructures.MultiDict([("foo", "1")])
d2 = datastructures.MultiDict([("bar", "2"), ("bar", "3")])
d = self.storage_class([d1, d2])
# lookup
assert d["foo"] == "1"
assert d["bar"] == "2"
assert d.getlist("bar") == ["2", "3"]
assert sorted(d.items()) == [("bar", "2"), ("foo", "1")]
assert sorted(d.items(multi=True)) == [("bar", "2"), ("bar", "3"),
("foo", "1")]
assert "missingkey" not in d
assert "foo" in d
# type lookup
assert d.get("foo", type=int) == 1
assert d.getlist("bar", type=int) == [2, 3]
# get key errors for missing stuff
with pytest.raises(KeyError):
d["missing"]
# make sure that they are immutable
with pytest.raises(TypeError):
d["foo"] = "blub"
# copies are mutable
d = d.copy()
d["foo"] = "blub"
# make sure lists merges
md1 = datastructures.MultiDict((("foo", "bar"), ))
md2 = datastructures.MultiDict((("foo", "blafasel"), ))
x = self.storage_class((md1, md2))
assert list(iterlists(x)) == [("foo", ["bar", "blafasel"])]
def test_basic_interface(self):
md = self.storage_class()
assert isinstance(md, dict)
mapping = [('a', 1), ('b', 2), ('a', 2), ('d', 3), ('a', 1), ('a', 3),
('d', 4), ('c', 3)]
md = self.storage_class(mapping)
# simple getitem gives the first value
assert md['a'] == 1
assert md['c'] == 3
with pytest.raises(KeyError):
md['e']
assert md.get('a') == 1
# list getitem
assert md.getlist('a') == [1, 2, 1, 3]
assert md.getlist('d') == [3, 4]
# do not raise if key not found
assert md.getlist('x') == []
# simple setitem overwrites all values
md['a'] = 42
assert md.getlist('a') == [42]
# list setitem
md.setlist('a', [1, 2, 3])
assert md['a'] == 1
assert md.getlist('a') == [1, 2, 3]
# verify that it does not change original lists
l1 = [1, 2, 3]
md.setlist('a', l1)
del l1[:]
assert md['a'] == 1
# setdefault, setlistdefault
assert md.setdefault('u', 23) == 23
assert md.getlist('u') == [23]
del md['u']
md.setlist('u', [-1, -2])
# delitem
del md['u']
with pytest.raises(KeyError):
md['u']
del md['d']
assert md.getlist('d') == []
# keys, values, items, lists
assert list(sorted(md.keys())) == ['a', 'b', 'c']
assert list(sorted(iterkeys(md))) == ['a', 'b', 'c']
assert list(sorted(itervalues(md))) == [1, 2, 3]
assert list(sorted(itervalues(md))) == [1, 2, 3]
assert list(sorted(md.items())) == [('a', 1), ('b', 2), ('c', 3)]
assert list(sorted(md.items(multi=True))) == \
[('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)]
assert list(sorted(iteritems(md))) == [('a', 1), ('b', 2), ('c', 3)]
assert list(sorted(iteritems(md, multi=True))) == \
[('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)]
assert list(sorted(md.lists())) == \
[('a', [1, 2, 3]), ('b', [2]), ('c', [3])]
assert list(sorted(iterlists(md))) == \
[('a', [1, 2, 3]), ('b', [2]), ('c', [3])]
# copy method
c = md.copy()
assert c['a'] == 1
assert c.getlist('a') == [1, 2, 3]
# copy method 2
c = copy(md)
assert c['a'] == 1
assert c.getlist('a') == [1, 2, 3]
# deepcopy method
c = md.deepcopy()
assert c['a'] == 1
assert c.getlist('a') == [1, 2, 3]
# deepcopy method 2
c = deepcopy(md)
assert c['a'] == 1
assert c.getlist('a') == [1, 2, 3]
# update with a multidict
od = self.storage_class([('a', 4), ('a', 5), ('y', 0)])
md.update(od)
assert md.getlist('a') == [1, 2, 3, 4, 5]
assert md.getlist('y') == [0]
# update with a regular dict
md = c
od = {'a': 4, 'y': 0}
md.update(od)
assert md.getlist('a') == [1, 2, 3, 4]
assert md.getlist('y') == [0]
# pop, poplist, popitem, popitemlist
assert md.pop('y') == 0
assert 'y' not in md
assert md.poplist('a') == [1, 2, 3, 4]
assert 'a' not in md
assert md.poplist('missing') == []
# remaining: b=2, c=3
popped = md.popitem()
assert popped in [('b', 2), ('c', 3)]
popped = md.popitemlist()
assert popped in [('b', [2]), ('c', [3])]
# type conversion
md = self.storage_class({'a': '4', 'b': ['2', '3']})
assert md.get('a', type=int) == 4
assert md.getlist('b', type=int) == [2, 3]
# repr
md = self.storage_class([('a', 1), ('a', 2), ('b', 3)])
assert "('a', 1)" in repr(md)
assert "('a', 2)" in repr(md)
assert "('b', 3)" in repr(md)
# add and getlist
md.add('c', '42')
md.add('c', '23')
assert md.getlist('c') == ['42', '23']
md.add('c', 'blah')
assert md.getlist('c', type=int) == [42, 23]
# setdefault
md = self.storage_class()
md.setdefault('x', []).append(42)
md.setdefault('x', []).append(23)
assert md['x'] == [42, 23]
# to dict
md = self.storage_class()
md['foo'] = 42
md.add('bar', 1)
md.add('bar', 2)
assert md.to_dict() == {'foo': 42, 'bar': 1}
assert md.to_dict(flat=False) == {'foo': [42], 'bar': [1, 2]}
# popitem from empty dict
with pytest.raises(KeyError):
self.storage_class().popitem()
with pytest.raises(KeyError):
self.storage_class().popitemlist()
# key errors are of a special type
with pytest.raises(BadRequestKeyError):
self.storage_class()[42]
# setlist works
md = self.storage_class()
md['foo'] = 42
md.setlist('foo', [1, 2])
assert md.getlist('foo') == [1, 2]
def test_basic_interface(self):
md = self.storage_class()
assert isinstance(md, dict)
mapping = [
("a", 1),
("b", 2),
("a", 2),
("d", 3),
("a", 1),
("a", 3),
("d", 4),
("c", 3),
]
md = self.storage_class(mapping)
# simple getitem gives the first value
assert md["a"] == 1
assert md["c"] == 3
with pytest.raises(KeyError):
md["e"]
assert md.get("a") == 1
# list getitem
assert md.getlist("a") == [1, 2, 1, 3]
assert md.getlist("d") == [3, 4]
# do not raise if key not found
assert md.getlist("x") == []
# simple setitem overwrites all values
md["a"] = 42
assert md.getlist("a") == [42]
# list setitem
md.setlist("a", [1, 2, 3])
assert md["a"] == 1
assert md.getlist("a") == [1, 2, 3]
# verify that it does not change original lists
l1 = [1, 2, 3]
md.setlist("a", l1)
del l1[:]
assert md["a"] == 1
# setdefault, setlistdefault
assert md.setdefault("u", 23) == 23
assert md.getlist("u") == [23]
del md["u"]
md.setlist("u", [-1, -2])
# delitem
del md["u"]
with pytest.raises(KeyError):
md["u"]
del md["d"]
assert md.getlist("d") == []
# keys, values, items, lists
assert list(sorted(md.keys())) == ["a", "b", "c"]
assert list(sorted(iterkeys(md))) == ["a", "b", "c"]
assert list(sorted(itervalues(md))) == [1, 2, 3]
assert list(sorted(itervalues(md))) == [1, 2, 3]
assert list(sorted(md.items())) == [("a", 1), ("b", 2), ("c", 3)]
assert list(sorted(md.items(multi=True))) == [
("a", 1),
("a", 2),
("a", 3),
("b", 2),
("c", 3),
]
assert list(sorted(iteritems(md))) == [("a", 1), ("b", 2), ("c", 3)]
assert list(sorted(iteritems(md, multi=True))) == [
("a", 1),
("a", 2),
("a", 3),
("b", 2),
("c", 3),
]
assert list(sorted(md.lists())) == [("a", [1, 2, 3]), ("b", [2]),
("c", [3])]
assert list(sorted(iterlists(md))) == [("a", [1, 2, 3]), ("b", [2]),
("c", [3])]
# copy method
c = md.copy()
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# copy method 2
c = copy(md)
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# deepcopy method
c = md.deepcopy()
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# deepcopy method 2
c = deepcopy(md)
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# update with a multidict
od = self.storage_class([("a", 4), ("a", 5), ("y", 0)])
md.update(od)
assert md.getlist("a") == [1, 2, 3, 4, 5]
assert md.getlist("y") == [0]
# update with a regular dict
md = c
od = {"a": 4, "y": 0}
md.update(od)
assert md.getlist("a") == [1, 2, 3, 4]
assert md.getlist("y") == [0]
# pop, poplist, popitem, popitemlist
assert md.pop("y") == 0
assert "y" not in md
assert md.poplist("a") == [1, 2, 3, 4]
assert "a" not in md
assert md.poplist("missing") == []
# remaining: b=2, c=3
popped = md.popitem()
assert popped in [("b", 2), ("c", 3)]
popped = md.popitemlist()
assert popped in [("b", [2]), ("c", [3])]
# type conversion
md = self.storage_class({"a": "4", "b": ["2", "3"]})
assert md.get("a", type=int) == 4
assert md.getlist("b", type=int) == [2, 3]
# repr
md = self.storage_class([("a", 1), ("a", 2), ("b", 3)])
assert "('a', 1)" in repr(md)
assert "('a', 2)" in repr(md)
assert "('b', 3)" in repr(md)
# add and getlist
md.add("c", "42")
md.add("c", "23")
assert md.getlist("c") == ["42", "23"]
md.add("c", "blah")
assert md.getlist("c", type=int) == [42, 23]
# setdefault
md = self.storage_class()
md.setdefault("x", []).append(42)
md.setdefault("x", []).append(23)
assert md["x"] == [42, 23]
# to dict
md = self.storage_class()
md["foo"] = 42
md.add("bar", 1)
md.add("bar", 2)
assert md.to_dict() == {"foo": 42, "bar": 1}
assert md.to_dict(flat=False) == {"foo": [42], "bar": [1, 2]}
# popitem from empty dict
with pytest.raises(KeyError):
self.storage_class().popitem()
with pytest.raises(KeyError):
self.storage_class().popitemlist()
# key errors are of a special type
with pytest.raises(BadRequestKeyError):
self.storage_class()[42]
# setlist works
md = self.storage_class()
md["foo"] = 42
md.setlist("foo", [1, 2])
assert md.getlist("foo") == [1, 2]
def stream_encode_multipart(values,
use_tempfile=True,
threshold=1024 * 500,
boundary=None,
charset='utf-8'):
"""Encode a dict of values (either strings or file descriptors or
:class:`FileStorage` objects.) into a multipart encoded string stored
in a file descriptor.
"""
if boundary is None:
boundary = '---------------WerkzeugFormPart_%s%s' % (time(), random())
_closure = [BytesIO(), 0, False]
if use_tempfile:
def write_binary(string):
stream, total_length, on_disk = _closure
if on_disk:
stream.write(string)
else:
length = len(string)
if length + _closure[1] <= threshold:
stream.write(string)
else:
new_stream = TemporaryFile('wb+')
new_stream.write(stream.getvalue())
new_stream.write(string)
_closure[0] = new_stream
_closure[2] = True
_closure[1] = total_length + length
else:
write_binary = _closure[0].write
def write(string):
write_binary(string.encode(charset))
if not isinstance(values, MultiDict):
values = MultiDict(values)
for key, values in iterlists(values):
for value in values:
write('--%s\r\nContent-Disposition: form-data; name="%s"' %
(boundary, key))
reader = getattr(value, 'read', None)
if reader is not None:
filename = getattr(value, 'filename',
getattr(value, 'name', None))
content_type = getattr(value, 'content_type', None)
if content_type is None:
content_type = filename and \
mimetypes.guess_type(filename)[0] or \
'application/octet-stream'
if filename is not None:
write('; filename="%s"\r\n' % filename)
else:
write('\r\n')
write('Content-Type: %s\r\n\r\n' % content_type)
while 1:
chunk = reader(16384)
if not chunk:
break
write_binary(chunk)
else:
if not isinstance(value, string_types):
value = str(value)
else:
value = to_bytes(value, charset)
write('\r\n\r\n')
write_binary(value)
write('\r\n')
write('--%s--\r\n' % boundary)
length = int(_closure[0].tell())
_closure[0].seek(0)
return _closure[0], length, boundary
def test_basic_interface(self):
md = self.storage_class()
assert isinstance(md, dict)
mapping = [
("a", 1),
("b", 2),
("a", 2),
("d", 3),
("a", 1),
("a", 3),
("d", 4),
("c", 3),
]
md = self.storage_class(mapping)
# simple getitem gives the first value
assert md["a"] == 1
assert md["c"] == 3
with pytest.raises(KeyError):
md["e"]
assert md.get("a") == 1
# list getitem
assert md.getlist("a") == [1, 2, 1, 3]
assert md.getlist("d") == [3, 4]
# do not raise if key not found
assert md.getlist("x") == []
# simple setitem overwrites all values
md["a"] = 42
assert md.getlist("a") == [42]
# list setitem
md.setlist("a", [1, 2, 3])
assert md["a"] == 1
assert md.getlist("a") == [1, 2, 3]
# verify that it does not change original lists
l1 = [1, 2, 3]
md.setlist("a", l1)
del l1[:]
assert md["a"] == 1
# setdefault, setlistdefault
assert md.setdefault("u", 23) == 23
assert md.getlist("u") == [23]
del md["u"]
md.setlist("u", [-1, -2])
# delitem
del md["u"]
with pytest.raises(KeyError):
md["u"]
del md["d"]
assert md.getlist("d") == []
# keys, values, items, lists
assert list(sorted(md.keys())) == ["a", "b", "c"]
assert list(sorted(iterkeys(md))) == ["a", "b", "c"]
assert list(sorted(itervalues(md))) == [1, 2, 3]
assert list(sorted(itervalues(md))) == [1, 2, 3]
assert list(sorted(md.items())) == [("a", 1), ("b", 2), ("c", 3)]
assert list(sorted(md.items(multi=True))) == [
("a", 1),
("a", 2),
("a", 3),
("b", 2),
("c", 3),
]
assert list(sorted(iteritems(md))) == [("a", 1), ("b", 2), ("c", 3)]
assert list(sorted(iteritems(md, multi=True))) == [
("a", 1),
("a", 2),
("a", 3),
("b", 2),
("c", 3),
]
assert list(sorted(md.lists())) == [("a", [1, 2, 3]), ("b", [2]), ("c", [3])]
assert list(sorted(iterlists(md))) == [("a", [1, 2, 3]), ("b", [2]), ("c", [3])]
# copy method
c = md.copy()
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# copy method 2
c = copy(md)
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# deepcopy method
c = md.deepcopy()
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# deepcopy method 2
c = deepcopy(md)
assert c["a"] == 1
assert c.getlist("a") == [1, 2, 3]
# update with a multidict
od = self.storage_class([("a", 4), ("a", 5), ("y", 0)])
md.update(od)
assert md.getlist("a") == [1, 2, 3, 4, 5]
assert md.getlist("y") == [0]
# update with a regular dict
md = c
od = {"a": 4, "y": 0}
md.update(od)
assert md.getlist("a") == [1, 2, 3, 4]
assert md.getlist("y") == [0]
# pop, poplist, popitem, popitemlist
assert md.pop("y") == 0
assert "y" not in md
assert md.poplist("a") == [1, 2, 3, 4]
assert "a" not in md
assert md.poplist("missing") == []
# remaining: b=2, c=3
popped = md.popitem()
assert popped in [("b", 2), ("c", 3)]
popped = md.popitemlist()
assert popped in [("b", [2]), ("c", [3])]
# type conversion
md = self.storage_class({"a": "4", "b": ["2", "3"]})
assert md.get("a", type=int) == 4
assert md.getlist("b", type=int) == [2, 3]
# repr
md = self.storage_class([("a", 1), ("a", 2), ("b", 3)])
assert "('a', 1)" in repr(md)
assert "('a', 2)" in repr(md)
assert "('b', 3)" in repr(md)
# add and getlist
md.add("c", "42")
md.add("c", "23")
assert md.getlist("c") == ["42", "23"]
md.add("c", "blah")
assert md.getlist("c", type=int) == [42, 23]
# setdefault
md = self.storage_class()
md.setdefault("x", []).append(42)
md.setdefault("x", []).append(23)
assert md["x"] == [42, 23]
# to dict
md = self.storage_class()
md["foo"] = 42
md.add("bar", 1)
md.add("bar", 2)
assert md.to_dict() == {"foo": 42, "bar": 1}
assert md.to_dict(flat=False) == {"foo": [42], "bar": [1, 2]}
# popitem from empty dict
with pytest.raises(KeyError):
self.storage_class().popitem()
with pytest.raises(KeyError):
self.storage_class().popitemlist()
# key errors are of a special type
with pytest.raises(BadRequestKeyError):
self.storage_class()[42]
# setlist works
md = self.storage_class()
md["foo"] = 42
md.setlist("foo", [1, 2])
assert md.getlist("foo") == [1, 2]
def test_basic_interface(self):
md = self.storage_class()
assert isinstance(md, dict)
mapping = [('a', 1), ('b', 2), ('a', 2), ('d', 3),
('a', 1), ('a', 3), ('d', 4), ('c', 3)]
md = self.storage_class(mapping)
# simple getitem gives the first value
self.assert_equal(md['a'], 1)
self.assert_equal(md['c'], 3)
with self.assert_raises(KeyError):
md['e']
self.assert_equal(md.get('a'), 1)
# list getitem
self.assert_equal(md.getlist('a'), [1, 2, 1, 3])
self.assert_equal(md.getlist('d'), [3, 4])
# do not raise if key not found
self.assert_equal(md.getlist('x'), [])
# simple setitem overwrites all values
md['a'] = 42
self.assert_equal(md.getlist('a'), [42])
# list setitem
md.setlist('a', [1, 2, 3])
self.assert_equal(md['a'], 1)
self.assert_equal(md.getlist('a'), [1, 2, 3])
# verify that it does not change original lists
l1 = [1, 2, 3]
md.setlist('a', l1)
del l1[:]
self.assert_equal(md['a'], 1)
# setdefault, setlistdefault
self.assert_equal(md.setdefault('u', 23), 23)
self.assert_equal(md.getlist('u'), [23])
del md['u']
md.setlist('u', [-1, -2])
# delitem
del md['u']
with self.assert_raises(KeyError):
md['u']
del md['d']
self.assert_equal(md.getlist('d'), [])
# keys, values, items, lists
self.assert_equal(list(sorted(md.keys())), ['a', 'b', 'c'])
self.assert_equal(list(sorted(iterkeys(md))), ['a', 'b', 'c'])
self.assert_equal(list(sorted(itervalues(md))), [1, 2, 3])
self.assert_equal(list(sorted(itervalues(md))), [1, 2, 3])
self.assert_equal(list(sorted(md.items())),
[('a', 1), ('b', 2), ('c', 3)])
self.assert_equal(list(sorted(md.items(multi=True))),
[('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)])
self.assert_equal(list(sorted(iteritems(md))),
[('a', 1), ('b', 2), ('c', 3)])
self.assert_equal(list(sorted(iteritems(md, multi=True))),
[('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)])
self.assert_equal(list(sorted(md.lists())),
[('a', [1, 2, 3]), ('b', [2]), ('c', [3])])
self.assert_equal(list(sorted(iterlists(md))),
[('a', [1, 2, 3]), ('b', [2]), ('c', [3])])
# copy method
c = md.copy()
self.assert_equal(c['a'], 1)
self.assert_equal(c.getlist('a'), [1, 2, 3])
# copy method 2
c = copy(md)
self.assert_equal(c['a'], 1)
self.assert_equal(c.getlist('a'), [1, 2, 3])
# update with a multidict
od = self.storage_class([('a', 4), ('a', 5), ('y', 0)])
md.update(od)
self.assert_equal(md.getlist('a'), [1, 2, 3, 4, 5])
self.assert_equal(md.getlist('y'), [0])
# update with a regular dict
md = c
od = {'a': 4, 'y': 0}
md.update(od)
self.assert_equal(md.getlist('a'), [1, 2, 3, 4])
self.assert_equal(md.getlist('y'), [0])
# pop, poplist, popitem, popitemlist
self.assert_equal(md.pop('y'), 0)
assert 'y' not in md
self.assert_equal(md.poplist('a'), [1, 2, 3, 4])
assert 'a' not in md
self.assert_equal(md.poplist('missing'), [])
# remaining: b=2, c=3
popped = md.popitem()
assert popped in [('b', 2), ('c', 3)]
popped = md.popitemlist()
assert popped in [('b', [2]), ('c', [3])]
# type conversion
md = self.storage_class({'a': '4', 'b': ['2', '3']})
self.assert_equal(md.get('a', type=int), 4)
self.assert_equal(md.getlist('b', type=int), [2, 3])
# repr
md = self.storage_class([('a', 1), ('a', 2), ('b', 3)])
assert "('a', 1)" in repr(md)
assert "('a', 2)" in repr(md)
assert "('b', 3)" in repr(md)
# add and getlist
md.add('c', '42')
md.add('c', '23')
self.assert_equal(md.getlist('c'), ['42', '23'])
md.add('c', 'blah')
self.assert_equal(md.getlist('c', type=int), [42, 23])
# setdefault
md = self.storage_class()
md.setdefault('x', []).append(42)
md.setdefault('x', []).append(23)
self.assert_equal(md['x'], [42, 23])
# to dict
md = self.storage_class()
md['foo'] = 42
md.add('bar', 1)
md.add('bar', 2)
self.assert_equal(md.to_dict(), {'foo': 42, 'bar': 1})
self.assert_equal(md.to_dict(flat=False), {'foo': [42], 'bar': [1, 2]})
# popitem from empty dict
with self.assert_raises(KeyError):
self.storage_class().popitem()
with self.assert_raises(KeyError):
self.storage_class().popitemlist()
# key errors are of a special type
with self.assert_raises(BadRequestKeyError):
self.storage_class()[42]
# setlist works
md = self.storage_class()
md['foo'] = 42
md.setlist('foo', [1, 2])
self.assert_equal(md.getlist('foo'), [1, 2])
def stream_encode_multipart(values, use_tempfile=True, threshold=1024 * 500,
boundary=None, charset='utf-8'):
"""Encode a dict of values (either strings or file descriptors or
:class:`FileStorage` objects.) into a multipart encoded string stored
in a file descriptor.
"""
if boundary is None:
boundary = '---------------WerkzeugFormPart_%s%s' % (time(), random())
_closure = [BytesIO(), 0, False]
if use_tempfile:
def write_binary(string):
stream, total_length, on_disk = _closure
if on_disk:
stream.write(string)
else:
length = len(string)
if length + _closure[1] <= threshold:
stream.write(string)
else:
new_stream = TemporaryFile('wb+')
new_stream.write(stream.getvalue())
new_stream.write(string)
_closure[0] = new_stream
_closure[2] = True
_closure[1] = total_length + length
else:
write_binary = _closure[0].write
def write(string):
write_binary(string.encode(charset))
if not isinstance(values, MultiDict):
values = MultiDict(values)
for key, values in iterlists(values):
for value in values:
write('--%s\r\nContent-Disposition: form-data; name="%s"' %
(boundary, key))
reader = getattr(value, 'read', None)
if reader is not None:
filename = getattr(value, 'filename',
getattr(value, 'name', None))
content_type = getattr(value, 'content_type', None)
if content_type is None:
content_type = filename and \
mimetypes.guess_type(filename)[0] or \
'application/octet-stream'
if filename is not None:
write('; filename="%s"\r\n' % filename)
else:
write('\r\n')
write('Content-Type: %s\r\n\r\n' % content_type)
while 1:
chunk = reader(16384)
if not chunk:
break
write_binary(chunk)
else:
if not isinstance(value, string_types):
value = str(value)
else:
value = to_bytes(value, charset)
write('\r\n\r\n')
write_binary(value)
write('\r\n')
write('--%s--\r\n' % boundary)
length = int(_closure[0].tell())
_closure[0].seek(0)
return _closure[0], length, boundary
