187 lines
6.1 KiB
Python
187 lines
6.1 KiB
Python
# Copyright 2013-2017 DataStax, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
try:
|
|
import unittest2 as unittest
|
|
except ImportError:
|
|
import unittest # noqa
|
|
|
|
from cassandra.util import OrderedMap, OrderedMapSerializedKey
|
|
from cassandra.cqltypes import EMPTY, UTF8Type, lookup_casstype
|
|
import six
|
|
|
|
class OrderedMapTest(unittest.TestCase):
|
|
def test_init(self):
|
|
a = OrderedMap(zip(['one', 'three', 'two'], [1, 3, 2]))
|
|
b = OrderedMap([('one', 1), ('three', 3), ('two', 2)])
|
|
c = OrderedMap(a)
|
|
builtin = {'one': 1, 'two': 2, 'three': 3}
|
|
self.assertEqual(a, b)
|
|
self.assertEqual(a, c)
|
|
self.assertEqual(a, builtin)
|
|
self.assertEqual(OrderedMap([(1, 1), (1, 2)]), {1: 2})
|
|
|
|
d = OrderedMap({'': 3}, key1='v1', key2='v2')
|
|
self.assertEqual(d[''], 3)
|
|
self.assertEqual(d['key1'], 'v1')
|
|
self.assertEqual(d['key2'], 'v2')
|
|
|
|
with self.assertRaises(TypeError):
|
|
OrderedMap('too', 'many', 'args')
|
|
|
|
def test_contains(self):
|
|
keys = ['first', 'middle', 'last']
|
|
|
|
om = OrderedMap()
|
|
|
|
om = OrderedMap(zip(keys, range(len(keys))))
|
|
|
|
for k in keys:
|
|
self.assertTrue(k in om)
|
|
self.assertFalse(k not in om)
|
|
|
|
self.assertTrue('notthere' not in om)
|
|
self.assertFalse('notthere' in om)
|
|
|
|
def test_keys(self):
|
|
keys = ['first', 'middle', 'last']
|
|
om = OrderedMap(zip(keys, range(len(keys))))
|
|
|
|
self.assertListEqual(list(om.keys()), keys)
|
|
|
|
def test_values(self):
|
|
keys = ['first', 'middle', 'last']
|
|
values = list(range(len(keys)))
|
|
om = OrderedMap(zip(keys, values))
|
|
|
|
self.assertListEqual(list(om.values()), values)
|
|
|
|
def test_items(self):
|
|
keys = ['first', 'middle', 'last']
|
|
items = list(zip(keys, range(len(keys))))
|
|
om = OrderedMap(items)
|
|
|
|
self.assertListEqual(list(om.items()), items)
|
|
|
|
def test_get(self):
|
|
keys = ['first', 'middle', 'last']
|
|
om = OrderedMap(zip(keys, range(len(keys))))
|
|
|
|
for v, k in enumerate(keys):
|
|
self.assertEqual(om.get(k), v)
|
|
|
|
self.assertEqual(om.get('notthere', 'default'), 'default')
|
|
self.assertIsNone(om.get('notthere'))
|
|
|
|
def test_equal(self):
|
|
d1 = {'one': 1}
|
|
d12 = {'one': 1, 'two': 2}
|
|
om1 = OrderedMap({'one': 1})
|
|
om12 = OrderedMap([('one', 1), ('two', 2)])
|
|
om21 = OrderedMap([('two', 2), ('one', 1)])
|
|
|
|
self.assertEqual(om1, d1)
|
|
self.assertEqual(om12, d12)
|
|
self.assertEqual(om21, d12)
|
|
self.assertNotEqual(om1, om12)
|
|
self.assertNotEqual(om12, om1)
|
|
self.assertNotEqual(om12, om21)
|
|
self.assertNotEqual(om1, d12)
|
|
self.assertNotEqual(om12, d1)
|
|
self.assertNotEqual(om1, EMPTY)
|
|
|
|
self.assertFalse(OrderedMap([('three', 3), ('four', 4)]) == d12)
|
|
|
|
def test_getitem(self):
|
|
keys = ['first', 'middle', 'last']
|
|
om = OrderedMap(zip(keys, range(len(keys))))
|
|
|
|
for v, k in enumerate(keys):
|
|
self.assertEqual(om[k], v)
|
|
|
|
with self.assertRaises(KeyError):
|
|
om['notthere']
|
|
|
|
def test_iter(self):
|
|
keys = ['first', 'middle', 'last']
|
|
values = list(range(len(keys)))
|
|
items = list(zip(keys, values))
|
|
om = OrderedMap(items)
|
|
|
|
itr = iter(om)
|
|
self.assertEqual(sum([1 for _ in itr]), len(keys))
|
|
self.assertRaises(StopIteration, six.next, itr)
|
|
|
|
self.assertEqual(list(iter(om)), keys)
|
|
self.assertEqual(list(six.iteritems(om)), items)
|
|
self.assertEqual(list(six.itervalues(om)), values)
|
|
|
|
def test_len(self):
|
|
self.assertEqual(len(OrderedMap()), 0)
|
|
self.assertEqual(len(OrderedMap([(1, 1)])), 1)
|
|
|
|
def test_mutable_keys(self):
|
|
d = {'1': 1}
|
|
s = set([1, 2, 3])
|
|
om = OrderedMap([(d, 'dict'), (s, 'set')])
|
|
|
|
def test_strings(self):
|
|
# changes in 3.x
|
|
d = {'map': 'inner'}
|
|
s = set([1, 2, 3])
|
|
self.assertEqual(repr(OrderedMap([('two', 2), ('one', 1), (d, 'value'), (s, 'another')])),
|
|
"OrderedMap([('two', 2), ('one', 1), (%r, 'value'), (%r, 'another')])" % (d, s))
|
|
|
|
self.assertEqual(str(OrderedMap([('two', 2), ('one', 1), (d, 'value'), (s, 'another')])),
|
|
"{'two': 2, 'one': 1, %r: 'value', %r: 'another'}" % (d, s))
|
|
|
|
def test_popitem(self):
|
|
item = (1, 2)
|
|
om = OrderedMap((item,))
|
|
self.assertEqual(om.popitem(), item)
|
|
self.assertRaises(KeyError, om.popitem)
|
|
|
|
def test_delitem(self):
|
|
om = OrderedMap({1: 1, 2: 2})
|
|
|
|
self.assertRaises(KeyError, om.__delitem__, 3)
|
|
|
|
del om[1]
|
|
self.assertEqual(om, {2: 2})
|
|
del om[2]
|
|
self.assertFalse(om)
|
|
|
|
self.assertRaises(KeyError, om.__delitem__, 1)
|
|
|
|
|
|
class OrderedMapSerializedKeyTest(unittest.TestCase):
|
|
def test_init(self):
|
|
om = OrderedMapSerializedKey(UTF8Type, 2)
|
|
self.assertEqual(om, {})
|
|
|
|
def test_normalized_lookup(self):
|
|
key_type = lookup_casstype('MapType(UTF8Type, Int32Type)')
|
|
protocol_version = 3
|
|
om = OrderedMapSerializedKey(key_type, protocol_version)
|
|
key_ascii = {'one': 1}
|
|
key_unicode = {u'two': 2}
|
|
om._insert_unchecked(key_ascii, key_type.serialize(key_ascii, protocol_version), object())
|
|
om._insert_unchecked(key_unicode, key_type.serialize(key_unicode, protocol_version), object())
|
|
|
|
# type lookup is normalized by key_type
|
|
# PYTHON-231
|
|
self.assertIs(om[{'one': 1}], om[{u'one': 1}])
|
|
self.assertIs(om[{'two': 2}], om[{u'two': 2}])
|
|
self.assertIsNot(om[{'one': 1}], om[{'two': 2}])
|