347 lines
12 KiB
Python
347 lines
12 KiB
Python
"""
|
|
Tests for stuff in django.utils.datastructures.
|
|
"""
|
|
import collections.abc
|
|
import copy
|
|
import pickle
|
|
|
|
from django.test import SimpleTestCase
|
|
from django.utils.datastructures import (
|
|
CaseInsensitiveMapping, DictWrapper, ImmutableList, MultiValueDict,
|
|
MultiValueDictKeyError, OrderedSet,
|
|
)
|
|
|
|
|
|
class OrderedSetTests(SimpleTestCase):
|
|
|
|
def test_init_with_iterable(self):
|
|
s = OrderedSet([1, 2, 3])
|
|
self.assertEqual(list(s.dict.keys()), [1, 2, 3])
|
|
|
|
def test_remove(self):
|
|
s = OrderedSet()
|
|
self.assertEqual(len(s), 0)
|
|
s.add(1)
|
|
s.add(2)
|
|
s.remove(2)
|
|
self.assertEqual(len(s), 1)
|
|
self.assertNotIn(2, s)
|
|
|
|
def test_discard(self):
|
|
s = OrderedSet()
|
|
self.assertEqual(len(s), 0)
|
|
s.add(1)
|
|
s.discard(2)
|
|
self.assertEqual(len(s), 1)
|
|
|
|
def test_reversed(self):
|
|
s = reversed(OrderedSet([1, 2, 3]))
|
|
self.assertIsInstance(s, collections.abc.Iterator)
|
|
self.assertEqual(list(s), [3, 2, 1])
|
|
|
|
def test_contains(self):
|
|
s = OrderedSet()
|
|
self.assertEqual(len(s), 0)
|
|
s.add(1)
|
|
self.assertIn(1, s)
|
|
|
|
def test_bool(self):
|
|
# Refs #23664
|
|
s = OrderedSet()
|
|
self.assertFalse(s)
|
|
s.add(1)
|
|
self.assertTrue(s)
|
|
|
|
def test_len(self):
|
|
s = OrderedSet()
|
|
self.assertEqual(len(s), 0)
|
|
s.add(1)
|
|
s.add(2)
|
|
s.add(2)
|
|
self.assertEqual(len(s), 2)
|
|
|
|
def test_repr(self):
|
|
self.assertEqual(repr(OrderedSet()), 'OrderedSet()')
|
|
self.assertEqual(repr(OrderedSet([2, 3, 2, 1])), 'OrderedSet([2, 3, 1])')
|
|
|
|
|
|
class MultiValueDictTests(SimpleTestCase):
|
|
|
|
def test_repr(self):
|
|
d = MultiValueDict({'key': 'value'})
|
|
self.assertEqual(repr(d), "<MultiValueDict: {'key': 'value'}>")
|
|
|
|
def test_multivaluedict(self):
|
|
d = MultiValueDict({'name': ['Adrian', 'Simon'], 'position': ['Developer'], 'empty': []})
|
|
self.assertEqual(d['name'], 'Simon')
|
|
self.assertEqual(d.get('name'), 'Simon')
|
|
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
|
|
self.assertEqual(
|
|
list(d.items()),
|
|
[('name', 'Simon'), ('position', 'Developer'), ('empty', [])]
|
|
)
|
|
self.assertEqual(
|
|
list(d.lists()),
|
|
[('name', ['Adrian', 'Simon']), ('position', ['Developer']), ('empty', [])]
|
|
)
|
|
with self.assertRaisesMessage(MultiValueDictKeyError, "'lastname'"):
|
|
d.__getitem__('lastname')
|
|
self.assertIsNone(d.get('empty'))
|
|
self.assertEqual(d.get('empty', 'nonexistent'), 'nonexistent')
|
|
self.assertIsNone(d.get('lastname'))
|
|
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
|
|
self.assertEqual(d.getlist('lastname'), [])
|
|
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']), ['Adrian', 'Simon'])
|
|
d.setlist('lastname', ['Holovaty', 'Willison'])
|
|
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
|
|
self.assertEqual(list(d.values()), ['Simon', 'Developer', [], 'Willison'])
|
|
|
|
def test_appendlist(self):
|
|
d = MultiValueDict()
|
|
d.appendlist('name', 'Adrian')
|
|
d.appendlist('name', 'Simon')
|
|
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
|
|
|
|
def test_copy(self):
|
|
for copy_func in [copy.copy, lambda d: d.copy()]:
|
|
with self.subTest(copy_func):
|
|
d1 = MultiValueDict({'developers': ['Carl', 'Fred']})
|
|
self.assertEqual(d1['developers'], 'Fred')
|
|
d2 = copy_func(d1)
|
|
d2.update({'developers': 'Groucho'})
|
|
self.assertEqual(d2['developers'], 'Groucho')
|
|
self.assertEqual(d1['developers'], 'Fred')
|
|
|
|
d1 = MultiValueDict({'key': [[]]})
|
|
self.assertEqual(d1['key'], [])
|
|
d2 = copy_func(d1)
|
|
d2['key'].append('Penguin')
|
|
self.assertEqual(d1['key'], ['Penguin'])
|
|
self.assertEqual(d2['key'], ['Penguin'])
|
|
|
|
def test_deepcopy(self):
|
|
d1 = MultiValueDict({'a': [[123]]})
|
|
d2 = copy.copy(d1)
|
|
d3 = copy.deepcopy(d1)
|
|
self.assertIs(d1['a'], d2['a'])
|
|
self.assertIsNot(d1['a'], d3['a'])
|
|
|
|
def test_pickle(self):
|
|
x = MultiValueDict({'a': ['1', '2'], 'b': ['3']})
|
|
self.assertEqual(x, pickle.loads(pickle.dumps(x)))
|
|
|
|
def test_dict_translation(self):
|
|
mvd = MultiValueDict({
|
|
'devs': ['Bob', 'Joe'],
|
|
'pm': ['Rory'],
|
|
})
|
|
d = mvd.dict()
|
|
self.assertEqual(list(d), list(mvd))
|
|
for key in mvd:
|
|
self.assertEqual(d[key], mvd[key])
|
|
|
|
self.assertEqual({}, MultiValueDict().dict())
|
|
|
|
def test_getlist_doesnt_mutate(self):
|
|
x = MultiValueDict({'a': ['1', '2'], 'b': ['3']})
|
|
values = x.getlist('a')
|
|
values += x.getlist('b')
|
|
self.assertEqual(x.getlist('a'), ['1', '2'])
|
|
|
|
def test_internal_getlist_does_mutate(self):
|
|
x = MultiValueDict({'a': ['1', '2'], 'b': ['3']})
|
|
values = x._getlist('a')
|
|
values += x._getlist('b')
|
|
self.assertEqual(x._getlist('a'), ['1', '2', '3'])
|
|
|
|
def test_getlist_default(self):
|
|
x = MultiValueDict({'a': [1]})
|
|
MISSING = object()
|
|
values = x.getlist('b', default=MISSING)
|
|
self.assertIs(values, MISSING)
|
|
|
|
def test_getlist_none_empty_values(self):
|
|
x = MultiValueDict({'a': None, 'b': []})
|
|
self.assertIsNone(x.getlist('a'))
|
|
self.assertEqual(x.getlist('b'), [])
|
|
|
|
def test_setitem(self):
|
|
x = MultiValueDict({'a': [1, 2]})
|
|
x['a'] = 3
|
|
self.assertEqual(list(x.lists()), [('a', [3])])
|
|
|
|
def test_setdefault(self):
|
|
x = MultiValueDict({'a': [1, 2]})
|
|
a = x.setdefault('a', 3)
|
|
b = x.setdefault('b', 3)
|
|
self.assertEqual(a, 2)
|
|
self.assertEqual(b, 3)
|
|
self.assertEqual(list(x.lists()), [('a', [1, 2]), ('b', [3])])
|
|
|
|
def test_update_too_many_args(self):
|
|
x = MultiValueDict({'a': []})
|
|
msg = 'update expected at most 1 argument, got 2'
|
|
with self.assertRaisesMessage(TypeError, msg):
|
|
x.update(1, 2)
|
|
|
|
def test_update_no_args(self):
|
|
x = MultiValueDict({'a': []})
|
|
x.update()
|
|
self.assertEqual(list(x.lists()), [('a', [])])
|
|
|
|
def test_update_dict_arg(self):
|
|
x = MultiValueDict({'a': [1], 'b': [2], 'c': [3]})
|
|
x.update({'a': 4, 'b': 5})
|
|
self.assertEqual(list(x.lists()), [('a', [1, 4]), ('b', [2, 5]), ('c', [3])])
|
|
|
|
def test_update_multivaluedict_arg(self):
|
|
x = MultiValueDict({'a': [1], 'b': [2], 'c': [3]})
|
|
x.update(MultiValueDict({'a': [4], 'b': [5]}))
|
|
self.assertEqual(list(x.lists()), [('a', [1, 4]), ('b', [2, 5]), ('c', [3])])
|
|
|
|
def test_update_kwargs(self):
|
|
x = MultiValueDict({'a': [1], 'b': [2], 'c': [3]})
|
|
x.update(a=4, b=5)
|
|
self.assertEqual(list(x.lists()), [('a', [1, 4]), ('b', [2, 5]), ('c', [3])])
|
|
|
|
def test_update_with_empty_iterable(self):
|
|
for value in ['', b'', (), [], set(), {}]:
|
|
d = MultiValueDict()
|
|
d.update(value)
|
|
self.assertEqual(d, MultiValueDict())
|
|
|
|
def test_update_with_iterable_of_pairs(self):
|
|
for value in [(('a', 1),), [('a', 1)], {('a', 1)}]:
|
|
d = MultiValueDict()
|
|
d.update(value)
|
|
self.assertEqual(d, MultiValueDict({'a': [1]}))
|
|
|
|
def test_update_raises_correct_exceptions(self):
|
|
# MultiValueDict.update() raises equivalent exceptions to
|
|
# dict.update().
|
|
# Non-iterable values raise TypeError.
|
|
for value in [None, True, False, 123, 123.45]:
|
|
with self.subTest(value), self.assertRaises(TypeError):
|
|
MultiValueDict().update(value)
|
|
# Iterables of objects that cannot be unpacked raise TypeError.
|
|
for value in [b'123', b'abc', (1, 2, 3), [1, 2, 3], {1, 2, 3}]:
|
|
with self.subTest(value), self.assertRaises(TypeError):
|
|
MultiValueDict().update(value)
|
|
# Iterables of unpackable objects with incorrect number of items raise
|
|
# ValueError.
|
|
for value in ['123', 'abc', ('a', 'b', 'c'), ['a', 'b', 'c'], {'a', 'b', 'c'}]:
|
|
with self.subTest(value), self.assertRaises(ValueError):
|
|
MultiValueDict().update(value)
|
|
|
|
|
|
class ImmutableListTests(SimpleTestCase):
|
|
|
|
def test_sort(self):
|
|
d = ImmutableList(range(10))
|
|
|
|
# AttributeError: ImmutableList object is immutable.
|
|
with self.assertRaisesMessage(AttributeError, 'ImmutableList object is immutable.'):
|
|
d.sort()
|
|
|
|
self.assertEqual(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)')
|
|
|
|
def test_custom_warning(self):
|
|
d = ImmutableList(range(10), warning="Object is immutable!")
|
|
|
|
self.assertEqual(d[1], 1)
|
|
|
|
# AttributeError: Object is immutable!
|
|
with self.assertRaisesMessage(AttributeError, 'Object is immutable!'):
|
|
d.__setitem__(1, 'test')
|
|
|
|
|
|
class DictWrapperTests(SimpleTestCase):
|
|
|
|
def test_dictwrapper(self):
|
|
def f(x):
|
|
return "*%s" % x
|
|
d = DictWrapper({'a': 'a'}, f, 'xx_')
|
|
self.assertEqual(
|
|
"Normal: %(a)s. Modified: %(xx_a)s" % d,
|
|
'Normal: a. Modified: *a'
|
|
)
|
|
|
|
|
|
class CaseInsensitiveMappingTests(SimpleTestCase):
|
|
def setUp(self):
|
|
self.dict1 = CaseInsensitiveMapping({
|
|
'Accept': 'application/json',
|
|
'content-type': 'text/html',
|
|
})
|
|
|
|
def test_create_with_invalid_values(self):
|
|
msg = 'dictionary update sequence element #1 has length 4; 2 is required'
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
CaseInsensitiveMapping([('Key1', 'Val1'), 'Key2'])
|
|
|
|
def test_create_with_invalid_key(self):
|
|
msg = 'Element key 1 invalid, only strings are allowed'
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
CaseInsensitiveMapping([(1, '2')])
|
|
|
|
def test_list(self):
|
|
self.assertEqual(list(self.dict1), ['Accept', 'content-type'])
|
|
|
|
def test_dict(self):
|
|
self.assertEqual(dict(self.dict1), {'Accept': 'application/json', 'content-type': 'text/html'})
|
|
|
|
def test_repr(self):
|
|
dict1 = CaseInsensitiveMapping({'Accept': 'application/json'})
|
|
dict2 = CaseInsensitiveMapping({'content-type': 'text/html'})
|
|
self.assertEqual(repr(dict1), repr({'Accept': 'application/json'}))
|
|
self.assertEqual(repr(dict2), repr({'content-type': 'text/html'}))
|
|
|
|
def test_str(self):
|
|
dict1 = CaseInsensitiveMapping({'Accept': 'application/json'})
|
|
dict2 = CaseInsensitiveMapping({'content-type': 'text/html'})
|
|
self.assertEqual(str(dict1), str({'Accept': 'application/json'}))
|
|
self.assertEqual(str(dict2), str({'content-type': 'text/html'}))
|
|
|
|
def test_equal(self):
|
|
self.assertEqual(self.dict1, {'Accept': 'application/json', 'content-type': 'text/html'})
|
|
self.assertNotEqual(self.dict1, {'accept': 'application/jso', 'Content-Type': 'text/html'})
|
|
self.assertNotEqual(self.dict1, 'string')
|
|
|
|
def test_items(self):
|
|
other = {'Accept': 'application/json', 'content-type': 'text/html'}
|
|
self.assertEqual(sorted(self.dict1.items()), sorted(other.items()))
|
|
|
|
def test_copy(self):
|
|
copy = self.dict1.copy()
|
|
self.assertIs(copy, self.dict1)
|
|
self.assertEqual(copy, self.dict1)
|
|
|
|
def test_getitem(self):
|
|
self.assertEqual(self.dict1['Accept'], 'application/json')
|
|
self.assertEqual(self.dict1['accept'], 'application/json')
|
|
self.assertEqual(self.dict1['aCCept'], 'application/json')
|
|
self.assertEqual(self.dict1['content-type'], 'text/html')
|
|
self.assertEqual(self.dict1['Content-Type'], 'text/html')
|
|
self.assertEqual(self.dict1['Content-type'], 'text/html')
|
|
|
|
def test_in(self):
|
|
self.assertIn('Accept', self.dict1)
|
|
self.assertIn('accept', self.dict1)
|
|
self.assertIn('aCCept', self.dict1)
|
|
self.assertIn('content-type', self.dict1)
|
|
self.assertIn('Content-Type', self.dict1)
|
|
|
|
def test_del(self):
|
|
self.assertIn('Accept', self.dict1)
|
|
msg = "'CaseInsensitiveMapping' object does not support item deletion"
|
|
with self.assertRaisesMessage(TypeError, msg):
|
|
del self.dict1['Accept']
|
|
self.assertIn('Accept', self.dict1)
|
|
|
|
def test_set(self):
|
|
self.assertEqual(len(self.dict1), 2)
|
|
msg = "'CaseInsensitiveMapping' object does not support item assignment"
|
|
with self.assertRaisesMessage(TypeError, msg):
|
|
self.dict1['New Key'] = 1
|
|
self.assertEqual(len(self.dict1), 2)
|