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})
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_should_insert_as_map_values(self):
"""
This tests will attempt to insert a point, polygon, or line, as values of a map.
@since 3.20
@jira_ticket PYTHON-456
@test_category dse geometric
@expected_result geometric types should be able to be inserted and queried as values of a map.
"""
uuid_key = uuid1()
prepared = self.session.prepare(
"INSERT INTO tbl (k, m1) VALUES (?, ?)")
bound_statement = prepared.bind(
(uuid_key, OrderedMap(zip([1], [self.original_value]))))
self.session.execute(bound_statement)
self.validate('m1', uuid_key,
OrderedMap(zip([1], [self.original_value])))
def test_equal(self):
d1 = {'one': 1}
d12 = {'one': 1, 'two': 2}
od1 = OrderedMap({'one': 1})
od12 = OrderedMap([('one', 1), ('two', 2)])
od21 = OrderedMap([('two', 2), ('one', 1)])
self.assertEqual(od1, d1)
self.assertEqual(od12, d12)
self.assertEqual(od21, d12)
self.assertNotEqual(od1, od12)
self.assertNotEqual(od12, od1)
self.assertNotEqual(od12, od21)
self.assertNotEqual(od1, d12)
self.assertNotEqual(od12, d1)
self.assertNotEqual(od1, EMPTY)
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_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 deserialize_safe(cls, byts, protocol_version):
subkeytype, subvaltype = cls.subtypes
if protocol_version >= 3:
unpack = int32_unpack
length = 4
else:
unpack = uint16_unpack
length = 2
numelements = unpack(byts[:length])
p = length
themap = OrderedMap()
for _ in range(numelements):
key_len = unpack(byts[p:p + length])
p += length
keybytes = byts[p:p + key_len]
p += key_len
val_len = unpack(byts[p:p + length])
p += length
valbytes = byts[p:p + val_len]
p += val_len
key = subkeytype.from_binary(keybytes, protocol_version)
val = subvaltype.from_binary(valbytes, protocol_version)
themap._insert(key, val)
return themap
def deserialize_safe(cls, byts, protocol_version):
subkeytype, subvaltype = cls.subtypes
if protocol_version >= 3:
unpack = int32_unpack
length = 4
else:
unpack = uint16_unpack
length = 2
numelements = unpack(byts[:length])
p = length
themap = OrderedMap()
for _ in range(numelements):
key_len = unpack(byts[p:p + length])
p += length
keybytes = byts[p:p + key_len]
p += key_len
val_len = unpack(byts[p:p + length])
p += length
valbytes = byts[p:p + val_len]
p += val_len
key = subkeytype.from_binary(keybytes, protocol_version)
val = subvaltype.from_binary(valbytes, protocol_version)
themap._insert(key, val)
return themap
def get_collection_sample(collection_type, datatype):
"""
Helper method to access created sample data for collection types
"""
if collection_type == 'list':
return [get_sample(datatype), get_sample(datatype)]
elif collection_type == 'set':
return sortedset([get_sample(datatype)])
elif collection_type == 'map':
return OrderedMap([(get_sample(datatype), get_sample(datatype))])
elif collection_type == 'tuple':
return (get_sample(datatype),)
else:
raise Exception('Missing handling of non-primitive type {0}.'.format(collection_type))
def test_keys(self):
keys = ['first', 'middle', 'last']
om = OrderedMap(zip(keys, range(len(keys))))
self.assertListEqual(list(om.keys()), keys)
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')])
(b'A46\xa9', 'InetAddressType', '65.52.54.169'),
(b'*\x00\x13(\xe1\x02\xcc\xc0\x00\x00\x00\x00\x00\x00\x01"',
'InetAddressType', '2a00:1328:e102:ccc0::122'),
(b'\xe3\x81\xbe\xe3\x81\x97\xe3\x81\xa6', 'UTF8Type',
u'\u307e\u3057\u3066'),
(b'\xe3\x81\xbe\xe3\x81\x97\xe3\x81\xa6' * 1000, 'UTF8Type',
u'\u307e\u3057\u3066' * 1000),
(b'', 'UTF8Type', u''),
(b'\xff' * 16, 'UUIDType', UUID('ffffffff-ffff-ffff-ffff-ffffffffffff')),
(b'I\x15~\xfc\xef<\x9d\xe3\x16\x98\xaf\x80\x1f\xb4\x0b*', 'UUIDType',
UUID('49157efc-ef3c-9de3-1698-af801fb40b2a')),
(b'', 'UUIDType', None),
(b'', 'MapType(AsciiType, BooleanType)', None),
(b'', 'ListType(FloatType)', None),
(b'', 'SetType(LongType)', None),
(b'\x00\x00', 'MapType(DecimalType, BooleanType)', OrderedMap()),
(b'\x00\x00', 'ListType(FloatType)', []),
(b'\x00\x00', 'SetType(IntegerType)', sortedset()),
(b'\x00\x01\x00\x10\xafYC\xa3\xea<\x11\xe1\xabc\xc4,\x03"y\xf0',
'ListType(TimeUUIDType)',
[UUID(bytes=b'\xafYC\xa3\xea<\x11\xe1\xabc\xc4,\x03"y\xf0')]),
)
ordered_map_value = OrderedMap([(u'\u307fbob', 199), (u'', -1), (u'\\', 0)])
# these following entries work for me right now, but they're dependent on
# vagaries of internal python ordering for unordered types
marshalled_value_pairs_unsafe = (
(b'\x00\x03\x00\x06\xe3\x81\xbfbob\x00\x04\x00\x00\x00\xc7\x00\x00\x00\x04\xff\xff\xff\xff\x00\x01\\\x00\x04\x00\x00\x00\x00',
'MapType(UTF8Type, Int32Type)', ordered_map_value),
(b'\x00\x02\x00\x08@\x01\x99\x99\x99\x99\x99\x9a\x00\x08@\x14\x00\x00\x00\x00\x00\x00',
def test_can_insert_nested_collections(self):
"""
Test for inserting various types of nested COLLECTION_TYPES into tables and UDTs
"""
if self.cass_version < (2, 1, 3):
raise unittest.SkipTest(
"Support for nested collections was introduced in Cassandra 2.1.3"
)
c = TestCluster()
s = c.connect(self.keyspace_name, wait_for_all_pools=True)
s.encoder.mapping[tuple] = s.encoder.cql_encode_tuple
name = self._testMethodName
s.execute("""
CREATE TYPE %s (
m frozen<map<int,text>>,
t tuple<int,text>,
l frozen<list<int>>,
s frozen<set<int>>
)""" % name)
s.execute("""
CREATE TYPE %s_nested (
m frozen<map<int,text>>,
t tuple<int,text>,
l frozen<list<int>>,
s frozen<set<int>>,
u frozen<%s>
)""" % (name, name))
s.execute("""
CREATE TABLE %s (
k int PRIMARY KEY,
map_map map<frozen<map<int,int>>, frozen<map<int,int>>>,
map_set map<frozen<set<int>>, frozen<set<int>>>,
map_list map<frozen<list<int>>, frozen<list<int>>>,
map_tuple map<frozen<tuple<int, int>>, frozen<tuple<int>>>,
map_udt map<frozen<%s_nested>, frozen<%s>>,
)""" % (name, name, name))
validate = partial(self.insert_select_column, s, name)
validate(
'map_map',
OrderedMap([({
1: 1,
2: 2
}, {
3: 3,
4: 4
}), ({
5: 5,
6: 6
}, {
7: 7,
8: 8
})]))
validate(
'map_set',
OrderedMap([(set((1, 2)), set((3, 4))), (set((5, 6)), set(
(7, 8)))]))
validate('map_list', OrderedMap([([1, 2], [3, 4]), ([5, 6], [7, 8])]))
validate('map_tuple', OrderedMap([((1, 2), (3, )), ((4, 5), (6, ))]))
value = nested_collection_udt({
1: 'v1',
2: 'v2'
}, (3, 'v3'), [4, 5, 6, 7], set((8, 9, 10)))
key = nested_collection_udt_nested(value.m, value.t, value.l, value.s,
value)
key2 = nested_collection_udt_nested({3: 'v3'}, value.t, value.l,
value.s, value)
validate('map_udt', OrderedMap([(key, value), (key2, value)]))
c.shutdown()
def test_popitem(self):
item = (1, 2)
om = OrderedMap((item,))
self.assertEqual(om.popitem(), item)
self.assertRaises(KeyError, om.popitem)
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_values(self):
keys = ['first', 'middle', 'last']
values = list(range(len(keys)))
om = OrderedMap(zip(keys, values))
self.assertListEqual(list(om.values()), values)