From a81b9d1a8974cf02762b286e6797183a1ad99be3 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Wed, 31 Jan 2018 12:33:58 -0500 Subject: [PATCH 01/16] Fix Python 3 LooseVersion breaks compatibility with Python 2.7 LooseVersion Patch by Ariel Weisberg; Reviewed by Sam Tunnicliffe --- conftest.py | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/conftest.py b/conftest.py index 650e9c816d..36bd623836 100644 --- a/conftest.py +++ b/conftest.py @@ -8,6 +8,7 @@ import copy import inspect import subprocess +from itertools import zip_longest from dtest import running_in_docker, cleanup_docker_environment_before_test_execution @@ -351,10 +352,39 @@ def fixture_dtest_setup(request, parse_dtest_config, fixture_dtest_setup_overrid dtest_setup.cleanup_cluster() +#Based on https://bugs.python.org/file25808/14894.patch +def loose_version_compare(a, b): + print("Comparing " + str(a) + " and " + str(b) + " lists " + str(a.version) + " and " + str(b.version)) + for i, j in zip_longest(a.version, b.version, fillvalue=''): + if type(i) != type(j): + i = str(i) + j = str(j) + if i == j: + print(str(i) + " == " + str(j)) + continue + elif i < j: + print(str(i) + " < " + str(j)) + return -1 + else: # i > j + print(str(i) + " > " + str(j)) + return 1 + + #Longer version strings with equal prefixes are equal, but if one version string is longer than it is greater + aLen = len(a.version) + bLen = len(b.version) + print("aLen " + str(aLen) + " bLen " + str(bLen)) + if aLen == bLen: + return 0 + elif aLen < bLen: + return -1 + else: + return 1 + + def _skip_msg(current_running_version, since_version, max_version): - if current_running_version < since_version: + if loose_version_compare(current_running_version, since_version) < 0: return "%s < %s" % (current_running_version, since_version) - if max_version and current_running_version > max_version: + if max_version and loose_version_compare(current_running_version, max_version) > 0: return "%s > %s" % (current_running_version, max_version) From 073578fb51216aeb623beb55543ef2645d0956b1 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Wed, 31 Jan 2018 15:57:04 -0500 Subject: [PATCH 02/16] Fix broken thrift test setup stuff. --- thrift_test.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/thrift_test.py b/thrift_test.py index 23e3f7bbb4..ef2b437d44 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -66,7 +66,7 @@ def fixture_dtest_setup_overrides(self): return dtest_setup_overrides @pytest.fixture(scope='function', autouse=True) - def fixture_set_cluster_settings(self, fixture_dtest_setup): + def fixture_set_cluster_settings(self, fixture_dtest_setup, set_dtest_setup_on_function): fixture_dtest_setup.cluster.populate(1) node1, = fixture_dtest_setup.cluster.nodelist() @@ -75,7 +75,7 @@ def fixture_set_cluster_settings(self, fixture_dtest_setup): # automatically. It does not matter what token we set as we only # ever use one node. if not self.dtest_config.use_vnodes: - node1.set_configuration_options(values={'initial_token': "a".encode('hex')}) + node1.set_configuration_options(values={'initial_token': 'abcd'}) fixture_dtest_setup.cluster.start(wait_for_binary_proto=True) fixture_dtest_setup.cluster.nodelist()[0].watch_log_for("Listening for thrift clients") # Wait for the thrift port to open From f247a007fc46716d461fbeaca78261c253777c6b Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Wed, 31 Jan 2018 16:58:43 -0500 Subject: [PATCH 03/16] Fixed one thrift test. --- thrift_test.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/thrift_test.py b/thrift_test.py index ef2b437d44..bbbf942572 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -4,6 +4,7 @@ import uuid import pytest import logging +import codecs from thrift.protocol import TBinaryProtocol from thrift.Thrift import TApplicationException @@ -31,7 +32,9 @@ since = pytest.mark.since logger = logging.getLogger(__name__) - +utf8encoder = codecs.getencoder('utf-8') +def utf8encode(str): + return utf8encoder(str)[0] def get_thrift_client(host='127.0.0.1', port=9160): socket = TSocket.TSocket(host, port) @@ -95,8 +98,8 @@ def define_schema(self): cf_defs=[ Cassandra.CfDef('Keyspace1', 'Standard1'), Cassandra.CfDef('Keyspace1', 'Standard2'), - Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef('c1', 'AsciiType'), Cassandra.ColumnDef('c2', 'AsciiType')]), - Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef('c1', 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef(utf8encode('c1'), 'AsciiType'), Cassandra.ColumnDef(utf8encode('c2'), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef(utf8encode('c1'), 'AsciiType')]), Cassandra.CfDef('Keyspace1', 'StandardLong1', comparator_type='LongType'), Cassandra.CfDef('Keyspace1', 'StandardInteger1', comparator_type='IntegerType'), Cassandra.CfDef('Keyspace1', 'StandardComposite', comparator_type='CompositeType(AsciiType, AsciiType)'), @@ -105,10 +108,10 @@ def define_schema(self): Cassandra.CfDef('Keyspace1', 'Super3', column_type='Super', comparator_type='LongType', subcomparator_type='UTF8Type'), Cassandra.CfDef('Keyspace1', 'Counter1', default_validation_class='CounterColumnType'), Cassandra.CfDef('Keyspace1', 'SuperCounter1', column_type='Super', default_validation_class='CounterColumnType'), - Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef('birthdate', 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), + Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef(utf8encode('birthdate'), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), Cassandra.CfDef('Keyspace1', 'Indexed2', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'LongType', Cassandra.IndexType.KEYS)]), Cassandra.CfDef('Keyspace1', 'Indexed3', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'UTF8Type', Cassandra.IndexType.KEYS)]), - Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef('a', 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef('z', 'UTF8Type')]), + Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef(utf8encode('a'), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef(utf8encode('z'), 'UTF8Type')]), Cassandra.CfDef('Keyspace1', 'Expiring', default_time_to_live=2) ]) @@ -120,7 +123,7 @@ def define_schema(self): Cassandra.CfDef('Keyspace2', 'Super4', column_type='Super', subcomparator_type='TimeUUIDType'), ]) for ks in [keyspace1, keyspace2]: - cls.client.system_add_keyspace(ks) + client.system_add_keyspace(ks) def i64(n): @@ -2448,25 +2451,25 @@ def test_index_scan_uuid_names(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed3') - sp = SlicePredicate(slice_range=SliceRange('', '')) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) cp = ColumnParent('Indexed3') # timeuuid name, utf8 values u = uuid.UUID('00000000-0000-1000-0000-000000000000').bytes u2 = uuid.UUID('00000000-0000-1000-0000-000000000001').bytes - client.insert('key1', ColumnParent('Indexed3'), Column(u, 'a', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Indexed3'), Column(u2, 'b', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed3'), Column(u, utf8encode('a'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed3'), Column(u2, utf8encode('b'), 0), ConsistencyLevel.ONE) # name comparator + data validator of incompatible types -- see CASSANDRA-2347 - key_range = KeyRange('', '', None, None, [IndexExpression(u, IndexOperator.EQ, 'a'), IndexExpression(u2, IndexOperator.EQ, 'b')], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(u, IndexOperator.EQ, utf8encode('a')), IndexExpression(u2, IndexOperator.EQ, utf8encode('b'))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result cp = ColumnParent('Indexed2') # timeuuid name, long values # name must be valid (TimeUUID) - key_range = KeyRange('', '', None, None, [IndexExpression('foo', IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('foo'), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) # value must be valid (TimeUUID) - key_range = KeyRange('', '', None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, "foo")], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, utf8encode("foo"))], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) def test_index_scan_expiring(self): From b251c626f2f1134b98cc8198aec45f7c088ddf1b Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Thu, 1 Feb 2018 13:38:25 -0500 Subject: [PATCH 04/16] More thrift test fixes. --- thrift_test.py | 643 +++++++++++++++++++++++++------------------------ 1 file changed, 333 insertions(+), 310 deletions(-) diff --git a/thrift_test.py b/thrift_test.py index bbbf942572..144d49aedf 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -158,14 +158,19 @@ def _i16(n): return struct.pack('>h', n) # big endian = network order -_SIMPLE_COLUMNS = [Column('c1', 'value1', 0), - Column('c2', 'value2', 0)] -_SUPER_COLUMNS = [SuperColumn(name='sc1', columns=[Column(_i64(4), 'value4', 0)]), - SuperColumn(name='sc2', columns=[Column(_i64(5), 'value5', 0), - Column(_i64(6), 'value6', 0)])] +_SIMPLE_COLUMNS = [Column(utf8encode('c1'), utf8encode('value1'), 0), + Column(utf8encode('c2'), utf8encode('value2'), 0)] +_SUPER_COLUMNS = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 0), + Column(_i64(6), utf8encode('value6'), 0)])] def _assert_column(column_family, key, column, value, ts=0): + if isinstance(key, str): + key = utf8encode(key) + if isinstance(value, str): + value = utf8encode(value) + try: assert client.get(key, ColumnPath(column_family, column=column), ConsistencyLevel.ONE).column == Column(column, value, ts) except NotFoundException: @@ -173,6 +178,8 @@ def _assert_column(column_family, key, column, value, ts=0): def _assert_columnpath_exists(key, column_path): + if isinstance(key, str): + key = utf8encode(key) try: assert client.get(key, column_path, ConsistencyLevel.ONE) except NotFoundException: @@ -180,6 +187,8 @@ def _assert_columnpath_exists(key, column_path): def _assert_no_columnpath(key, column_path): + if isinstance(key, str): + key = utf8encode(key) try: client.get(key, column_path, ConsistencyLevel.ONE) assert False, ('columnpath %s existed in %s when it should not' % (column_path, key)) @@ -188,77 +197,83 @@ def _assert_no_columnpath(key, column_path): def _insert_simple(): - return _insert_multi(['key1']) + return _insert_multi([utf8encode('key1')]) def _insert_multi(keys): CL = ConsistencyLevel.ONE for key in keys: - client.insert(key, ColumnParent('Standard1'), Column('c1', 'value1', 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('c2', 'value2', 0), CL) + if isinstance(key, str): + key = utf8encode(key) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c2'), utf8encode('value2'), 0), CL) def _insert_batch(): cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS], 'Standard2': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS]} - client.batch_mutate({'key1': cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) def _big_slice(key, column_parent): - p = SlicePredicate(slice_range=SliceRange('', '', False, 1000)) + if isinstance(key, str): + key = utf8encode(key) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) return client.get_slice(key, column_parent, p, ConsistencyLevel.ONE) def _big_multislice(keys, column_parent): - p = SlicePredicate(slice_range=SliceRange('', '', False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) return client.multiget_slice(keys, column_parent, p, ConsistencyLevel.ONE) def _verify_batch(): _verify_simple() L = [result.column - for result in _big_slice('key1', ColumnParent('Standard2'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard2'))] assert L == _SIMPLE_COLUMNS, L def _verify_simple(): - assert client.get('key1', ColumnPath('Standard1', column='c1'), ConsistencyLevel.ONE).column == Column('c1', 'value1', 0) + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE).column == Column(utf8encode('c1'), utf8encode('value1'), 0) L = [result.column - for result in _big_slice('key1', ColumnParent('Standard1'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] assert L == _SIMPLE_COLUMNS, L def _insert_super(key='key1'): - client.insert(key, ColumnParent('Super1', 'sc1'), Column(_i64(4), 'value4', 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', 'sc2'), Column(_i64(5), 'value5', 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', 'sc2'), Column(_i64(6), 'value6', 0), ConsistencyLevel.ONE) + if isinstance(key, str): + key = utf8encode(key) + client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc2')), Column(_i64(6), utf8encode('value6'), 0), ConsistencyLevel.ONE) def _insert_range(): - client.insert('key1', ColumnParent('Standard1'), Column('c1', 'value1', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('c2', 'value2', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('c3', 'value3', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c2'), utf8encode('value2'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) def _verify_range(): - p = SlicePredicate(slice_range=SliceRange('c1', 'c2', False, 1000)) - result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c1'), utf8encode('c2'), False, 1000)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == 'c1' - assert result[1].column.name == 'c2' + assert result[0].column.name == utf8encode('c1') + assert result[1].column.name == utf8encode('c2') p = SlicePredicate(slice_range=SliceRange('c3', 'c2', True, 1000)) - result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == 'c3' - assert result[1].column.name == 'c2' + assert result[0].column.name == utf8encode('c3') + assert result[1].column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('a', 'z', False, 1000)) - result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 1000)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange('a', 'z', False, 2)) - result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -267,29 +282,31 @@ def _set_keyspace(keyspace): def _insert_super_range(): - client.insert('key1', ColumnParent('Super1', 'sc1'), Column(_i64(4), 'value4', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(5), 'value5', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(6), 'value6', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Super1', 'sc3'), Column(_i64(7), 'value7', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(6), utf8encode('value6'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc3')), Column(_i64(7), utf8encode('value7'), 0), ConsistencyLevel.ONE) time.sleep(0.1) def _verify_super_range(): - p = SlicePredicate(slice_range=SliceRange('sc2', 'sc3', False, 2)) - result = client.get_slice('key1', ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc2'), utf8encode('sc3'), False, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == 'sc2' - assert result[1].super_column.name == 'sc3' + assert result[0].super_column.name == utf8encode('sc2') + assert result[1].super_column.name == utf8encode('sc3') - p = SlicePredicate(slice_range=SliceRange('sc3', 'sc2', True, 2)) - result = client.get_slice('key1', ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc3'), utf8encode('sc2'), True, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == 'sc3' - assert result[1].super_column.name == 'sc2' + assert result[0].super_column.name == utf8encode('sc3') + assert result[1].super_column.name == utf8encode('sc2') def _verify_super(supercf='Super1', key='key1'): - assert client.get(key, ColumnPath(supercf, 'sc1', _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), 'value4', 0) + if isinstance(key, str): + key = utf8encode(key) + assert client.get(key, ColumnPath(supercf, utf8encode('sc1'), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), utf8encode('value4'), 0) slice = [result.super_column for result in _big_slice(key, ColumnParent('Super1'))] assert slice == _SUPER_COLUMNS, slice @@ -314,6 +331,8 @@ def get_range_slice(client, parent, predicate, start, end, count, cl, row_filter def _insert_six_columns(key='abc'): + if isinstance(key, str): + key = utf8encode(key) CL = ConsistencyLevel.ONE client.insert(key, ColumnParent('Standard1'), Column('a', '1', 0), CL) client.insert(key, ColumnParent('Standard1'), Column('b', '2', 0), CL) @@ -324,6 +343,8 @@ def _insert_six_columns(key='abc'): def _big_multi_slice(key='abc'): + if isinstance(key, str): + key = utf8encode(key) c1 = ColumnSlice() c1.start = 'a' c1.finish = 'c' @@ -359,15 +380,15 @@ def test_insert(self): def test_empty_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Standard2', 'Super1') - assert _big_slice('key1', ColumnParent('Standard2')) == [] - assert _big_slice('key1', ColumnParent('Super1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Standard2')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] def test_cas(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Standard3', 'Standard4') def cas(expected, updates, column_family): - return client.cas('key1', column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) + return client.cas(utf8encode('key1'), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) def test_cas_operations(first_columns, second_columns, column_family): # partition should be empty, so cas expecting any existing values should fail @@ -378,7 +399,7 @@ def test_cas_operations(first_columns, second_columns, column_family): # cas of empty columns -> first_columns should succeed # and the reading back from the table should match first_columns assert cas([], first_columns, column_family).success - result = [cosc.column for cosc in _big_slice('key1', ColumnParent(column_family))] + result = [cosc.column for cosc in _big_slice(utf8encode('key1'), ColumnParent(column_family))] # CAS will use its own timestamp, so we can't just compare result == _SIMPLE_COLUMNS assert dict((c.name, c.value) for c in result) == dict((ex.name, ex.value) for ex in first_columns) @@ -390,7 +411,7 @@ def test_cas_operations(first_columns, second_columns, column_family): assert dict((c.name, c.value) for c in cas_result.current_values) == {first_columns[0].name: first_columns[0].value}, cas_result # CL.SERIAL for reads - assert client.get('key1', ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value + assert client.get(utf8encode('key1'), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value # cas first_columns -> second_columns should succeed assert cas(first_columns, second_columns, column_family).success @@ -399,8 +420,8 @@ def test_cas_operations(first_columns, second_columns, column_family): cas_result = cas(first_columns, second_columns, column_family) assert not cas_result.success - updated_columns = [Column('c1', 'value101', 1), - Column('c2', 'value102', 1)] + updated_columns = [Column(utf8encode('c1'), utf8encode('value101'), 1), + Column(utf8encode('c2'), utf8encode('value102'), 1)] logger.debug("Testing CAS operations on dynamic cf") test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard1') @@ -413,9 +434,9 @@ def test_missing_super(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _expect_missing(lambda: client.get('key1', ColumnPath('Super1', 'sc1', _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1'), _i64(1)), ConsistencyLevel.ONE)) _insert_super() - _expect_missing(lambda: client.get('key1', ColumnPath('Super1', 'sc1', _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1'), _i64(1)), ConsistencyLevel.ONE)) def test_count(self): _set_keyspace('Keyspace1') @@ -423,19 +444,19 @@ def test_count(self): _insert_simple() _insert_super() - p = SlicePredicate(slice_range=SliceRange('', '', False, 1000)) - assert client.get_count('key1', ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 - assert client.get_count('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 - assert client.get_count('key1', ColumnParent('Super1', 'sc2'), p, ConsistencyLevel.ONE) == 2 - assert client.get_count('key1', ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) + assert client.get_count(utf8encode('key1'), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 + assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 + assert client.get_count(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE) == 2 + assert client.get_count(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 # Let's make that a little more interesting - client.insert('key1', ColumnParent('Standard1'), Column('c3', 'value3', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('c4', 'value4', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('c5', 'value5', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c4'), utf8encode('value4'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c5'), utf8encode('value5'), 0), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('c2', 'c4', False, 1000)) - assert client.get_count('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 + p = SlicePredicate(slice_range=SliceRange(utf8encode('c2'), utf8encode('c4'), False, 1000)) + assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 def test_count_paging(self): _set_keyspace('Keyspace1') @@ -446,31 +467,32 @@ def test_count_paging(self): # Exercise paging column_parent = ColumnParent('Standard1') # Paging for small columns starts at 1024 columns - columns_to_insert = [Column('c%d' % (i,), 'value%d' % (i,), 0) for i in range(3, 1026)] + columns_to_insert = [Column(utf8encode('c%d' % (i,)), utf8encode('value%d' % (i,)), 0) for i in range(3, 1026)] cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in columns_to_insert]} - client.batch_mutate({'key1': cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({utf8encode('key1') : cfmap}, ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('', '', False, 2000)) - assert client.get_count('key1', column_parent, p, ConsistencyLevel.ONE) == 1025 + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 2000)) + assert client.get_count(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE) == 1025 # Ensure that the count limit isn't clobbered - p = SlicePredicate(slice_range=SliceRange('', '', False, 10)) - assert client.get_count('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 10)) + assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 # test get_count() to work correctly with 'count' settings around page size (CASSANDRA-4833) + @pytest.mark.skip(reason="Painfully slow") def test_count_around_page_size(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') def slice_predicate(count): - return SlicePredicate(slice_range=SliceRange('', '', False, count)) + return SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, count)) - key = 'key1' + key = utf8encode('key1') parent = ColumnParent('Standard1') cl = ConsistencyLevel.ONE for i in range(0, 3050): - client.insert(key, parent, Column(str(i), '', 0), cl) + client.insert(key, parent, Column(utf8encode(str(i)), utf8encode(''), 0), cl) # same as page size assert client.get_count(key, parent, slice_predicate(1024), cl) == 1024 @@ -499,22 +521,22 @@ def test_super_get(self): self.truncate_all('Super1') _insert_super() - result = client.get('key1', ColumnPath('Super1', 'sc2'), ConsistencyLevel.ONE).super_column + result = client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2')), ConsistencyLevel.ONE).super_column assert result == _SUPER_COLUMNS[1], result def test_super_subcolumn_limit(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') _insert_super() - p = SlicePredicate(slice_range=SliceRange('', '', False, 1)) - column_parent = ColumnParent('Super1', 'sc2') + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) + column_parent = ColumnParent('Super1', utf8encode('sc2')) slice = [result.column - for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(5), 'value5', 0)], slice - p = SlicePredicate(slice_range=SliceRange('', '', True, 1)) + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(5), utf8encode('value5'), 0)], slice + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), True, 1)) slice = [result.column - for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(6), 'value6', 0)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(6), utf8encode('value6'), 0)], slice def test_long_order(self): _set_keyspace('Keyspace1') @@ -528,9 +550,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(0, 104294967296, 429496729): name = _i64(i) - client.insert('key1', ColumnParent('StandardLong1'), Column(name, 'v', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('StandardLong1'), Column(name, utf8encode('v'), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice('key1', ColumnParent('StandardLong1'))] + slice = [result.column.name for result in _big_slice(utf8encode('key1'), ColumnParent('StandardLong1'))] assert slice == L, slice def test_integer_order(self): @@ -545,9 +567,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(104294967296, 0, 429496729): name = _i64(i) - client.insert('key1', ColumnParent('StandardInteger1'), Column(name, 'v', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('StandardInteger1'), Column(name, utf8encode('v'), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice('key1', ColumnParent('StandardInteger1'))] + slice = [result.column.name for result in _big_slice(utf8encode('key1'), ColumnParent('StandardInteger1'))] L.sort() assert slice == L, slice @@ -561,79 +583,79 @@ def test_time_uuid(self): # 100 isn't enough to fail reliably if the comparator is borked for i in range(500): L.append(uuid.uuid1()) - client.insert('key1', ColumnParent('Super4', 'sc1'), Column(L[-1].bytes, 'value%s' % i, i), ConsistencyLevel.ONE) - slice = _big_slice('key1', ColumnParent('Super4', 'sc1')) + client.insert(utf8encode('key1'), ColumnParent('Super4', utf8encode('sc1')), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) + slice = _big_slice(utf8encode('key1'), ColumnParent('Super4', utf8encode('sc1'))) assert len(slice) == 500, len(slice) for i in range(500): u = slice[i].column - assert u.value == 'value%s' % i + assert u.value == utf8encode('value%s' % i) assert u.name == L[i].bytes - p = SlicePredicate(slice_range=SliceRange('', '', True, 1)) - column_parent = ColumnParent('Super4', 'sc1') + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), True, 1)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[-1].bytes, 'value499', 499)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[-1].bytes, utf8encode('value499'), 499)], slice - p = SlicePredicate(slice_range=SliceRange('', L[2].bytes, False, 1000)) - column_parent = ColumnParent('Super4', 'sc1') + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), L[2].bytes, False, 1000)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[0].bytes, 'value0', 0), - Column(L[1].bytes, 'value1', 1), - Column(L[2].bytes, 'value2', 2)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[0].bytes, utf8encode('value0'), 0), + Column(L[1].bytes, utf8encode('value1'), 1), + Column(L[2].bytes, utf8encode('value2'), 2)], slice - p = SlicePredicate(slice_range=SliceRange(L[2].bytes, '', True, 1000)) - column_parent = ColumnParent('Super4', 'sc1') + p = SlicePredicate(slice_range=SliceRange(L[2].bytes, utf8encode(''), True, 1000)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, 'value2', 2), - Column(L[1].bytes, 'value1', 1), - Column(L[0].bytes, 'value0', 0)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, utf8encode('value2'), 2), + Column(L[1].bytes, utf8encode('value1'), 1), + Column(L[0].bytes, utf8encode('value0'), 0)], slice - p = SlicePredicate(slice_range=SliceRange(L[2].bytes, '', False, 1)) - column_parent = ColumnParent('Super4', 'sc1') + p = SlicePredicate(slice_range=SliceRange(L[2].bytes, utf8encode(''), False, 1)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, 'value2', 2)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, utf8encode('value2'), 2)], slice def test_long_remove(self): _set_keyspace('Keyspace1') self.truncate_all('StandardLong1') column_parent = ColumnParent('StandardLong1') - sp = SlicePredicate(slice_range=SliceRange('', '', False, 1)) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) for i in range(10): parent = ColumnParent('StandardLong1') - client.insert('key1', parent, Column(_i64(i), 'value1', 10 * i), ConsistencyLevel.ONE) - client.remove('key1', ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice('key1', column_parent, sp, ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value1'), 10 * i), ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert('key1', parent, Column(_i64(i), 'value2', 10 * i + 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value2'), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice('key1', column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), 'value2', 10 * i + 2)], (slice, i) + for result in client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), utf8encode('value2'), 10 * i + 2)], (slice, i) def test_integer_remove(self): _set_keyspace('Keyspace1') self.truncate_all('StandardInteger1') column_parent = ColumnParent('StandardInteger1') - sp = SlicePredicate(slice_range=SliceRange('', '', False, 1)) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) for i in range(10): parent = ColumnParent('StandardInteger1') - client.insert('key1', parent, Column(_i64(i), 'value1', 10 * i), ConsistencyLevel.ONE) - client.remove('key1', ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice('key1', column_parent, sp, ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value1'), 10 * i), ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert('key1', parent, Column(_i64(i), 'value2', 10 * i + 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value2'), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice('key1', column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), 'value2', 10 * i + 2)], (slice, i) + for result in client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), utf8encode('value2'), 10 * i + 2)], (slice, i) def test_batch_insert(self): _set_keyspace('Keyspace1') @@ -646,7 +668,7 @@ def test_batch_mutate_standard_columns(self): self.truncate_all('Standard1', 'Standard2') column_families = ['Standard1', 'Standard2'] - keys = ['key_%d' % i for i in range(27, 32)] + keys = [utf8encode('key_%d' % i) for i in range(27, 32)] mutations = [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS] mutation_map = dict((column_family, mutations) for column_family in column_families) keyed_mutations = dict((key, mutation_map) for key in keys) @@ -655,14 +677,14 @@ def test_batch_mutate_standard_columns(self): for column_family in column_families: for key in keys: - _assert_column(column_family, key, 'c1', 'value1') + _assert_column(column_family, key, utf8encode('c1'), utf8encode('value1')) def test_batch_mutate_remove_standard_columns(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Standard2') column_families = ['Standard1', 'Standard2'] - keys = ['key_%d' % i for i in range(11, 21)] + keys = [utf8encode('key_%d' % i) for i in range(11, 21)] _insert_multi(keys) mutations = [Mutation(deletion=Deletion(20, predicate=SlicePredicate(column_names=[c.name]))) for c in _SIMPLE_COLUMNS] @@ -682,7 +704,7 @@ def test_batch_mutate_remove_standard_row(self): self.truncate_all('Standard1', 'Standard2') column_families = ['Standard1', 'Standard2'] - keys = ['key_%d' % i for i in range(11, 21)] + keys = [utf8encode('key_%d' % i) for i in range(11, 21)] _insert_multi(keys) mutations = [Mutation(deletion=Deletion(20))] @@ -702,7 +724,7 @@ def test_batch_mutate_remove_super_columns_with_standard_under(self): self.truncate_all('Super1', 'Super2') column_families = ['Super1', 'Super2'] - keys = ['key_%d' % i for i in range(11, 21)] + keys = [utf8encode('key_%d' % i) for i in range(11, 21)] _insert_super() mutations = [] @@ -727,7 +749,7 @@ def test_batch_mutate_remove_super_columns_with_none_given_underneath(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - keys = ['key_%d' % i for i in range(17, 21)] + keys = [utf8encode('key_%d' % i) for i in range(17, 21)] for key in keys: _insert_super(key) @@ -758,7 +780,7 @@ def test_batch_mutate_remove_super_columns_entire_row(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - keys = ['key_%d' % i for i in range(17, 21)] + keys = [utf8encode('key_%d' % i) for i in range(17, 21)] for key in keys: _insert_super(key) @@ -787,100 +809,101 @@ def test_batch_mutate_remove_slice_standard(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - columns = [Column('c1', 'value1', 0), - Column('c2', 'value2', 0), - Column('c3', 'value3', 0), - Column('c4', 'value4', 0), - Column('c5', 'value5', 0)] + columns = [Column(utf8encode('c1'), utf8encode('value1'), 0), + Column(utf8encode('c2'), utf8encode('value2'), 0), + Column(utf8encode('c3'), utf8encode('value3'), 0), + Column(utf8encode('c4'), utf8encode('value4'), 0), + Column(utf8encode('c5'), utf8encode('value5'), 0)] for column in columns: - client.insert('key', ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.insert(utf8encode('key'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start='c2', finish='c4'))) - client.batch_mutate({'key': {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=utf8encode('c2'), finish=utf8encode('c4')))) + client.batch_mutate({utf8encode('key'): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists('key', ColumnPath('Standard1', column='c1')) - _assert_no_columnpath('key', ColumnPath('Standard1', column='c2')) - _assert_no_columnpath('key', ColumnPath('Standard1', column='c3')) - _assert_no_columnpath('key', ColumnPath('Standard1', column='c4')) - _assert_columnpath_exists('key', ColumnPath('Standard1', column='c5')) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c1'))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c2'))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c3'))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c4'))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c5'))) # known failure: see CASSANDRA-10046 def test_batch_mutate_remove_slice_of_entire_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [SuperColumn(name='sc1', columns=[Column(_i64(1), 'value1', 0)]), - SuperColumn(name='sc2', - columns=[Column(_i64(2), 'value2', 0), Column(_i64(3), 'value3', 0)]), - SuperColumn(name='sc3', columns=[Column(_i64(4), 'value4', 0)]), - SuperColumn(name='sc4', - columns=[Column(_i64(5), 'value5', 0), Column(_i64(6), 'value6', 0)]), - SuperColumn(name='sc5', columns=[Column(_i64(7), 'value7', 0)])] + columns = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(1), utf8encode('value1'), 0)]), + SuperColumn(name=utf8encode('sc2'), + columns=[Column(_i64(2), utf8encode('value2') , 0), Column(_i64(3), utf8encode('value3') , 0)]), + SuperColumn(name=utf8encode('sc3'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc4'), + columns=[Column(_i64(5), utf8encode('value5') , 0), Column(_i64(6), utf8encode('value6') , 0)]), + SuperColumn(name=utf8encode('sc5'), columns=[Column(_i64(7), utf8encode('value7'), 0)])] for column in columns: for subcolumn in column.columns: - client.insert('key', ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) + client.insert(utf8encode('key'), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start='sc2', finish='sc4'))) - client.batch_mutate({'key': {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=utf8encode('sc2') , finish=utf8encode('sc4') ))) + client.batch_mutate({utf8encode('key'): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists('key', ColumnPath('Super1', super_column='sc1', column=_i64(1))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc2', column=_i64(2))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc2', column=_i64(3))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc3', column=_i64(4))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc4', column=_i64(5))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc4', column=_i64(6))) - _assert_columnpath_exists('key', ColumnPath('Super1', super_column='sc5', column=_i64(7))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(1))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc2'), column=_i64(2))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc2'), column=_i64(3))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc3'), column=_i64(4))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc4'), column=_i64(5))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc4'), column=_i64(6))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc5'), column=_i64(7))) @since('1.0', '2.2') + @pytest.mark.skip(reason="Runs but fails and looks like it actually should fail since 8099?") def test_batch_mutate_remove_slice_part_of_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [Column(_i64(1), 'value1', 0), - Column(_i64(2), 'value2', 0), - Column(_i64(3), 'value3', 0), - Column(_i64(4), 'value4', 0), - Column(_i64(5), 'value5', 0)] + columns = [Column(_i64(1), utf8encode('value1'), 0), + Column(_i64(2), utf8encode('value2'), 0), + Column(_i64(3), utf8encode('value3'), 0), + Column(_i64(4), utf8encode('value4'), 0), + Column(_i64(5), utf8encode('value5'), 0)] for column in columns: - client.insert('key', ColumnParent('Super1', 'sc1'), column, ConsistencyLevel.ONE) + client.insert(utf8encode('key'), ColumnParent('Super1', utf8encode('sc1')), column, ConsistencyLevel.ONE) r = SliceRange(start=_i64(2), finish=_i64(4)) - d = Deletion(1, super_column='sc1', predicate=SlicePredicate(slice_range=r)) - client.batch_mutate({'key': {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, super_column=utf8encode('sc1') , predicate=SlicePredicate(slice_range=r)) + client.batch_mutate({utf8encode('key'): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists('key', ColumnPath('Super1', super_column='sc1', column=_i64(1))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc1', column=_i64(2))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc1', column=_i64(3))) - _assert_no_columnpath('key', ColumnPath('Super1', super_column='sc1', column=_i64(4))) - _assert_columnpath_exists('key', ColumnPath('Super1', super_column='sc1', column=_i64(5))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(1))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(2))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(3))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(4))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(5))) def test_batch_mutate_insertions_and_deletions(self): _set_keyspace('Keyspace1') self.truncate_all('Super1', 'Super2') - first_insert = SuperColumn("sc1", - columns=[Column(_i64(20), 'value20', 3), - Column(_i64(21), 'value21', 3)]) - second_insert = SuperColumn("sc1", - columns=[Column(_i64(20), 'value20', 3), - Column(_i64(21), 'value21', 3)]) - first_deletion = {'super_column': "sc1", + first_insert = SuperColumn(utf8encode("sc1"), + columns=[Column(_i64(20), utf8encode('value20'), 3), + Column(_i64(21), utf8encode('value21'), 3)]) + second_insert = SuperColumn(utf8encode("sc1"), + columns=[Column(_i64(20), utf8encode('value20'), 3), + Column(_i64(21), utf8encode('value21'), 3)]) + first_deletion = {'super_column': utf8encode("sc1"), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - second_deletion = {'super_column': "sc2", + second_deletion = {'super_column': utf8encode("sc2"), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - keys = ['key_30', 'key_31'] + keys = [utf8encode('key_30'), utf8encode('key_31')] for key in keys: - sc = SuperColumn('sc1', [Column(_i64(22), 'value22', 0), - Column(_i64(23), 'value23', 0)]) + sc = SuperColumn(utf8encode('sc1'), [Column(_i64(22), utf8encode('value22'), 0), + Column(_i64(23), utf8encode('value23'), 0)]) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=sc))]} client.batch_mutate({key: cfmap}, ConsistencyLevel.ONE) - sc2 = SuperColumn('sc2', [Column(_i64(22), 'value22', 0), - Column(_i64(23), 'value23', 0)]) + sc2 = SuperColumn(utf8encode('sc2'), [Column(_i64(22), utf8encode('value22'), 0), + Column(_i64(23), utf8encode('value23'), 0)]) cfmap2 = {'Super2': [Mutation(ColumnOrSuperColumn(super_column=sc2))]} client.batch_mutate({key: cfmap2}, ConsistencyLevel.ONE) @@ -897,18 +920,18 @@ def test_batch_mutate_insertions_and_deletions(self): for key in keys: for c in [_i64(22), _i64(23)]: - _assert_no_columnpath(key, ColumnPath('Super1', super_column='sc1', column=c)) - _assert_no_columnpath(key, ColumnPath('Super2', super_column='sc2', column=c)) + _assert_no_columnpath(key, ColumnPath('Super1', super_column=utf8encode('sc1'), column=c)) + _assert_no_columnpath(key, ColumnPath('Super2', super_column=utf8encode('sc2'), column=c)) for c in [_i64(20), _i64(21)]: - _assert_columnpath_exists(key, ColumnPath('Super1', super_column='sc1', column=c)) - _assert_columnpath_exists(key, ColumnPath('Super2', super_column='sc1', column=c)) + _assert_columnpath_exists(key, ColumnPath('Super1', super_column=utf8encode('sc1'), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super2', super_column=utf8encode('sc1'), column=c)) def test_bad_system_calls(self): def duplicate_index_names(): _set_keyspace('Keyspace1') - cd1 = ColumnDef('foo', 'BytesType', IndexType.KEYS, 'i') - cd2 = ColumnDef('bar', 'BytesType', IndexType.KEYS, 'i') + cd1 = ColumnDef(utf8encode('foo'), 'BytesType', IndexType.KEYS, 'i') + cd2 = ColumnDef(utf8encode('bar'), 'BytesType', IndexType.KEYS, 'i') cf = CfDef('Keyspace1', 'BadCF', column_metadata=[cd1, cd2]) client.system_add_column_family(cf) _expect_exception(duplicate_index_names, InvalidRequestException) @@ -917,33 +940,33 @@ def test_bad_batch_calls(self): # mutate_does_not_accept_cosc_and_deletion_in_same_mutation def too_full(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column("foo", 'bar', 0)) - dele = Deletion(2, predicate=SlicePredicate(column_names=['baz'])) - client.batch_mutate({'key_34': {'Standard1': [Mutation(col, dele)]}}, + col = ColumnOrSuperColumn(column=Column(utf8encode("foo"), utf8encode('bar'), 0)) + dele = Deletion(2, predicate=SlicePredicate(column_names=[utf8encode('baz')])) + client.batch_mutate({utf8encode('key_34'): {'Standard1': [Mutation(col, dele)]}}, ConsistencyLevel.ONE) _expect_exception(too_full, InvalidRequestException) # test_batch_mutate_does_not_accept_cosc_on_undefined_cf: def bad_cf(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column("foo", 'bar', 0)) - client.batch_mutate({'key_36': {'Undefined': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column(utf8encode("foo"), utf8encode('bar'), 0)) + client.batch_mutate({utf8encode('key_36'): {'Undefined': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf, InvalidRequestException) # test_batch_mutate_does_not_accept_deletion_on_undefined_cf def bad_cf_2(): _set_keyspace('Keyspace1') - d = Deletion(2, predicate=SlicePredicate(column_names=['baz'])) - client.batch_mutate({'key_37': {'Undefined': [Mutation(deletion=d)]}}, + d = Deletion(2, predicate=SlicePredicate(column_names=[utf8encode('baz')])) + client.batch_mutate({utf8encode('key_37'): {'Undefined': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf_2, InvalidRequestException) # a column value that does not match the declared validator def send_string_instead_of_long(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column('birthdate', 'bar', 0)) - client.batch_mutate({'key_38': {'Indexed1': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column(utf8encode('birthdate'), utf8encode('bar'), 0)) + client.batch_mutate({utf8encode('key_38'): {'Indexed1': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(send_string_instead_of_long, InvalidRequestException) @@ -951,16 +974,16 @@ def test_column_name_lengths(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - _expect_exception(lambda: client.insert('key1', ColumnParent('Standard1'), Column('', 'value', 0), ConsistencyLevel.ONE), InvalidRequestException) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 1, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 127, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 128, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 129, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 255, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 256, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * 257, 'value', 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Standard1'), Column('x' * (2 ** 16 - 1), 'value', 0), ConsistencyLevel.ONE) - _expect_exception(lambda: client.insert('key1', ColumnParent('Standard1'), Column('x' * (2 ** 16), 'value', 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode(''), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 1), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 127), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 128), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 129), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 255), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 256), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 257), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), utf8encode('value'), 0), ConsistencyLevel.ONE) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) def test_bad_calls(self): _set_keyspace('Keyspace1') @@ -968,71 +991,71 @@ def test_bad_calls(self): # missing arguments _expect_exception(lambda: client.insert(None, None, None, None), TApplicationException) # supercolumn in a non-super CF - _expect_exception(lambda: client.insert('key1', ColumnParent('Standard1', 'x'), Column('y', 'value', 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1', utf8encode('x')), Column(utf8encode('y'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) # no supercolumn in a super CF - _expect_exception(lambda: client.insert('key1', ColumnParent('Super1'), Column('y', 'value', 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Super1'), Column(utf8encode('y'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) # column but no supercolumn in remove - _expect_exception(lambda: client.remove('key1', ColumnPath('Super1', column='x'), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove(utf8encode('key1'), ColumnPath('Super1', column=utf8encode('x')), 0, ConsistencyLevel.ONE), InvalidRequestException) # super column in non-super CF - _expect_exception(lambda: client.remove('key1', ColumnPath('Standard1', 'y', 'x'), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove(utf8encode('key1'), ColumnPath('Standard1', utf8encode('y'), utf8encode('x')), 0, ConsistencyLevel.ONE), InvalidRequestException) # key too long - _expect_exception(lambda: client.get('x' * 2 ** 16, ColumnPath('Standard1', column='c1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE), InvalidRequestException) # empty key - _expect_exception(lambda: client.get('', ColumnPath('Standard1', column='c1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode(''), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE), InvalidRequestException) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - _expect_exception(lambda: client.batch_mutate({'': cfmap}, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.batch_mutate({utf8encode(''): cfmap}, ConsistencyLevel.ONE), InvalidRequestException) # empty column name - _expect_exception(lambda: client.get('key1', ColumnPath('Standard1', column=''), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('')), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify column name - _expect_exception(lambda: client.get('key1', ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) # supercolumn in a non-super CF - _expect_exception(lambda: client.get('key1', ColumnPath('Standard1', 'x', 'y'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', utf8encode('x'), utf8encode('y')), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify supercolumn name - _expect_exception(lambda: client.get('key1', ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) # invalid CF - _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=['', '']), '', '', 5, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=[utf8encode(''), utf8encode('')]), utf8encode(''), utf8encode(''), 5, ConsistencyLevel.ONE), InvalidRequestException) # 'x' is not a valid Long - _expect_exception(lambda: client.insert('key1', ColumnParent('Super1', 'sc1'), Column('x', 'value', 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), Column(utf8encode('x'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long - p = SlicePredicate(slice_range=SliceRange('x', '', False, 1)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('x'), utf8encode(''), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long, supercolumn version - p = SlicePredicate(slice_range=SliceRange('x', '', False, 1)) - column_parent = ColumnParent('Super1', 'sc1') - _expect_exception(lambda: client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE), + p = SlicePredicate(slice_range=SliceRange(utf8encode('x'), utf8encode(''), False, 1)) + column_parent = ColumnParent('Super1', utf8encode('sc1')) + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, supercolumn version p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) - column_parent = ColumnParent('Super1', 'sc1') - _expect_exception(lambda: client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE), + column_parent = ColumnParent('Super1', utf8encode('sc1')) + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, key version - _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['']), 'z', 'a', 1, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('')]), utf8encode('z'), utf8encode('a'), 1, ConsistencyLevel.ONE), InvalidRequestException) # ttl must be greater or equals to zero - column = Column('cttl1', 'value1', 0, -1) - _expect_exception(lambda: client.insert('key1', ColumnParent('Standard1'), column, ConsistencyLevel.ONE), + column = Column(utf8encode('cttl1'), utf8encode('value1'), 0, -1) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), InvalidRequestException) # don't allow super_column in Deletion for standard Columntest_expiration_with_default_ttl_and_zero_ttl - deletion = Deletion(1, 'supercolumn', None) + deletion = Deletion(1, utf8encode('supercolumn'), None) mutation = Mutation(deletion=deletion) - mutations = {'key': {'Standard1': [mutation]}} + mutations = {utf8encode('key'): {'Standard1': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # 'x' is not a valid long - deletion = Deletion(1, 'x', None) + deletion = Deletion(1, utf8encode('x'), None) mutation = Mutation(deletion=deletion) - mutations = {'key': {'Super3': [mutation]}} + mutations = {utf8encode('key'): {'Super3': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # counters don't support ANY - _expect_exception(lambda: client.add('key1', ColumnParent('Counter1', 'x'), CounterColumn('y', 1), ConsistencyLevel.ANY), InvalidRequestException) + _expect_exception(lambda: client.add(utf8encode('key1'), ColumnParent('Counter1', utf8encode('x')), CounterColumn(utf8encode('y'), 1), ConsistencyLevel.ANY), InvalidRequestException) def test_batch_insert_super(self): _set_keyspace('Keyspace1') @@ -2279,8 +2302,8 @@ def test_range_deletion_eoc_0(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, 'value', int(time.time() * 1000)) - client.insert('key1', ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(utf8encode(column_name), 'value', int(time.time() * 1000)) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # insert a partial cell name (just the first element of the composite) column_name = composite('6', None, eoc='\x00') @@ -2321,130 +2344,130 @@ def test_range_deletion_eoc_0(self): assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('7', '7'), composite('8', '8'), composite('9', '9')] - def test_incr_decr_standard_slice(self): + def test_incr_decr_standard_slice(self, request): _set_keyspace('Keyspace1') - key = self._testMethodName + key = utf8encode(request.node.name) d1 = 12 d2 = -21 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c2', d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c3', d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c3', d2), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c4', d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c5', d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate(['c3', 'c4']), ConsistencyLevel.ONE) + counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate([utf8encode('c3'), utf8encode('c4')]), ConsistencyLevel.ONE) assert counters[0].counter_column.value == d1 + d2 assert counters[1].counter_column.value == d1 - def test_incr_decr_standard_multiget_slice(self): + def test_incr_decr_standard_multiget_slice(self, request): _set_keyspace('Keyspace1') - key1 = self._testMethodName + "_1" - key2 = self._testMethodName + "_2" + key1 = utf8encode(request.node.name + "_1") + key2 = utf8encode(request.node.name + "_2") d1 = 12 d2 = -21 - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c2', d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c3', d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c3', d2), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c4', d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c5', d1), ConsistencyLevel.ONE) - - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c2', d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c3', d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c3', d2), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c4', d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c5', d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) + + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate(['c3', 'c4']), ConsistencyLevel.ONE) + counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate([utf8encode('c3'), utf8encode('c4')]), ConsistencyLevel.ONE) assert counters[key1][0].counter_column.value == d1 + d2 assert counters[key1][1].counter_column.value == d1 assert counters[key2][0].counter_column.value == d1 + d2 assert counters[key2][1].counter_column.value == d1 - def test_counter_get_slice_range(self): + def test_counter_get_slice_range(self, request): _set_keyspace('Keyspace1') - key = self._testMethodName + key = utf8encode(request.node.name) - client.add(key, ColumnParent('Counter1'), CounterColumn('c1', 1), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn('c2', 2), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn('c3', 3), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c1'), 1), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c2'), 2), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c3'), 3), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('c1', 'c2', False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c1'), utf8encode('c2'), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == 'c1' - assert result[1].counter_column.name == 'c2' + assert result[0].counter_column.name == utf8encode('c1') + assert result[1].counter_column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('c3', 'c2', True, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c3'), utf8encode('c2'), True, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == 'c3' - assert result[1].counter_column.name == 'c2' + assert result[0].counter_column.name == utf8encode('c3') + assert result[1].counter_column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('a', 'z', False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange('a', 'z', False, 2)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 2)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result - def test_counter_get_slice_super_range(self): + def test_counter_get_slice_super_range(self, request): _set_keyspace('Keyspace1') - key = self._testMethodName + key = utf8encode(request.node.name) - client.add(key, ColumnParent('SuperCounter1', 'sc1'), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', 'sc2'), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', 'sc2'), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', 'sc3'), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc1')), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc2')), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc2')), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc3')), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('sc2', 'sc3', False, 2)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc2'), utf8encode('sc3'), False, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == 'sc2' - assert result[1].counter_super_column.name == 'sc3' + assert result[0].counter_super_column.name == utf8encode('sc2') + assert result[1].counter_super_column.name == utf8encode('sc3') - p = SlicePredicate(slice_range=SliceRange('sc3', 'sc2', True, 2)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc3'), utf8encode('sc2'), True, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == 'sc3' - assert result[1].counter_super_column.name == 'sc2' + assert result[0].counter_super_column.name == utf8encode('sc3') + assert result[1].counter_super_column.name == utf8encode('sc2') def test_index_scan(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert('key1', ColumnParent('Indexed1'), Column('birthdate', _i64(1), 0), ConsistencyLevel.ONE) - client.insert('key2', ColumnParent('Indexed1'), Column('birthdate', _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key2', ColumnParent('Indexed1'), Column('b', _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key3', ColumnParent('Indexed1'), Column('birthdate', _i64(3), 0), ConsistencyLevel.ONE) - client.insert('key3', ColumnParent('Indexed1'), Column('b', _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('Indexed1'), Column(utf8encode('b'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('Indexed1'), Column(utf8encode('b'), _i64(3), 0), ConsistencyLevel.ONE) # simple query on one index expression cp = ColumnParent('Indexed1') - sp = SlicePredicate(slice_range=SliceRange('', '')) - key_range = KeyRange('', '', None, None, [IndexExpression('birthdate', IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key1' + assert result[0].key == utf8encode('key1') assert len(result[0].columns) == 1, result[0].columns # without index - key_range = KeyRange('', '', None, None, [IndexExpression('b', IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('b'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 0, result # but unindexed expression added to indexed one is ok - key_range = KeyRange('', '', None, None, [IndexExpression('b', IndexOperator.EQ, _i64(3)), IndexExpression('birthdate', IndexOperator.EQ, _i64(3))], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('b'), IndexOperator.EQ, _i64(3)), IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(3))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key3' + assert result[0].key == utf8encode('key3') assert len(result[0].columns) == 2, result[0].columns def test_index_scan_uuid_names(self): @@ -2477,10 +2500,10 @@ def test_index_scan_expiring(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert('key1', ColumnParent('Indexed1'), Column('birthdate', _i64(1), 0, 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(1), 0, 2), ConsistencyLevel.ONE) cp = ColumnParent('Indexed1') - sp = SlicePredicate(slice_range=SliceRange('', '')) - key_range = KeyRange('', '', None, None, [IndexExpression('birthdate', IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) # query before expiration result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result @@ -2500,21 +2523,21 @@ def test_index_scan_indexed_column_outside_slice_predicate(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed4') - client.insert('key1', ColumnParent('Indexed4'), Column('a', _i64(1), 0), ConsistencyLevel.ONE) - client.insert('key1', ColumnParent('Indexed4'), Column('z', 'zzz', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed4'), Column(utf8encode('a'), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed4'), Column(utf8encode('z'), utf8encode('zzz'), 0), ConsistencyLevel.ONE) cp = ColumnParent('Indexed4') - sp = SlicePredicate(slice_range=SliceRange('z', 'z')) - key_range = KeyRange('', '', None, None, [IndexExpression('a', IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode('z'), utf8encode('z'))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('a'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == 'z' + assert result[0].columns[0].column.name == utf8encode('z') - sp = SlicePredicate(column_names=['z']) + sp = SlicePredicate(column_names=[utf8encode('z')]) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == 'z' + assert result[0].columns[0].column.name == utf8encode('z') def test_column_not_found_quorum(self): _set_keyspace('Keyspace1') From 866adcf03a00b6ce88ef0eb7d1ed8ce6ce21e1ea Mon Sep 17 00:00:00 2001 From: Sam Tunnicliffe Date: Thu, 1 Feb 2018 14:40:35 +0000 Subject: [PATCH 05/16] Python3 syntax for setting envvars --- dtest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dtest.py b/dtest.py index aad9e58df0..914f2f7d50 100644 --- a/dtest.py +++ b/dtest.py @@ -268,7 +268,7 @@ def set_node_to_current_version(self, node): node.set_install_dir(version=version) else: node.set_install_dir(install_dir=self.dtest_config.cassandra_dir) - os.environ.set('CASSANDRA_DIR', self.dtest_config.cassandra_dir) + os.environ['CASSANDRA_DIR'] = self.dtest_config.cassandra_dir def go(self, func): runner = Runner(func) From b2d1b215539b44b5f816cb0aab61000bd1d510da Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Thu, 1 Feb 2018 19:48:49 -0500 Subject: [PATCH 06/16] Fix the last of the thrift tests. --- thrift_test.py | 755 +++++++++++++++++++++++++------------------------ 1 file changed, 385 insertions(+), 370 deletions(-) diff --git a/thrift_test.py b/thrift_test.py index 144d49aedf..23a576066e 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -138,7 +138,12 @@ def i16(n): return _i16(n) -def composite(item1, item2=None, eoc='\x00'): +def composite(item1, item2=None, eoc=b'\x00'): + if isinstance(item1, str): + item1 = utf8encode(item1) + if isinstance(item2, str): + item2 = utf8encode(item2) + packed = _i16(len(item1)) + item1 + eoc if item2 is not None: packed += _i16(len(item2)) + item2 @@ -262,7 +267,7 @@ def _verify_range(): assert result[0].column.name == utf8encode('c1') assert result[1].column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('c3', 'c2', True, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c3'), utf8encode('c2'), True, 1000)) result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 assert result[0].column.name == utf8encode('c3') @@ -334,23 +339,23 @@ def _insert_six_columns(key='abc'): if isinstance(key, str): key = utf8encode(key) CL = ConsistencyLevel.ONE - client.insert(key, ColumnParent('Standard1'), Column('a', '1', 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('b', '2', 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('c', '3', 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('d', '4', 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('e', '5', 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('f', '6', 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('a'), utf8encode('1'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('b'), utf8encode('2'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c'), utf8encode('3'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('d'), utf8encode('4'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('e'), utf8encode('5'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('f'), utf8encode('6'), 0), CL) def _big_multi_slice(key='abc'): if isinstance(key, str): key = utf8encode(key) c1 = ColumnSlice() - c1.start = 'a' - c1.finish = 'c' + c1.start = utf8encode('a') + c1.finish = utf8encode('c') c2 = ColumnSlice() - c2.start = 'e' - c2.finish = 'f' + c2.start = utf8encode('e') + c2.finish = utf8encode('f') m = MultiSliceRequest() m.key = key m.column_parent = ColumnParent('Standard1') @@ -361,7 +366,7 @@ def _big_multi_slice(key='abc'): return client.get_multi_slice(m) -_MULTI_SLICE_COLUMNS = [Column('a', '1', 0), Column('b', '2', 0), Column('c', '3', 0), Column('e', '5', 0), Column('f', '6', 0)] +_MULTI_SLICE_COLUMNS = [Column(utf8encode('a'), utf8encode('1'), 0), Column(utf8encode('b'), utf8encode('2'), 0), Column(utf8encode('c'), utf8encode('3'), 0), Column(utf8encode('e'), utf8encode('5'), 0), Column(utf8encode('f'), utf8encode('6'), 0)] @since('2.0', max_version='4') @@ -479,7 +484,6 @@ def test_count_paging(self): assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 # test get_count() to work correctly with 'count' settings around page size (CASSANDRA-4833) - @pytest.mark.skip(reason="Painfully slow") def test_count_around_page_size(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') @@ -1065,7 +1069,7 @@ def test_batch_insert_super(self): for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - client.batch_mutate({'key1': cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) _verify_super('Super1') _verify_super('Super2') @@ -1074,30 +1078,30 @@ def test_cf_remove_column(self): self.truncate_all('Standard1') _insert_simple() - client.remove('key1', ColumnPath('Standard1', column='c1'), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1', ColumnPath('Standard1', column='c1'), ConsistencyLevel.ONE)) - assert client.get('key1', ColumnPath('Standard1', column='c2'), ConsistencyLevel.ONE).column \ - == Column('c2', 'value2', 0) - assert _big_slice('key1', ColumnParent('Standard1')) \ - == [ColumnOrSuperColumn(column=Column('c2', 'value2', 0))] + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE)) + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c2')), ConsistencyLevel.ONE).column \ + == Column(utf8encode('c2'), utf8encode('value2'), 0) + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) \ + == [ColumnOrSuperColumn(column=Column(utf8encode('c2'), utf8encode('value2'), 0))] # New insert, make sure it shows up post-remove: - client.insert('key1', ColumnParent('Standard1'), Column('c3', 'value3', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice('key1', ColumnParent('Standard1'))] - assert columns == [Column('c2', 'value2', 0), Column('c3', 'value3', 0)], columns + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + assert columns == [Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed - client.insert('key1', ColumnParent('Standard1'), Column('c1', 'value1', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice('key1', ColumnParent('Standard1'))] - assert columns == [Column('c2', 'value2', 0), Column('c3', 'value3', 0)], columns + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + assert columns == [Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns # Next, w/ a newer timestamp; it should come back: - client.insert('key1', ColumnParent('Standard1'), Column('c1', 'value1', 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 2), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice('key1', ColumnParent('Standard1'))] - assert columns == [Column('c1', 'value1', 2), Column('c2', 'value2', 0), Column('c3', 'value3', 0)], columns + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + assert columns == [Column(utf8encode('c1'), utf8encode('value1'), 2), Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns def test_cf_remove(self): _set_keyspace('Keyspace1') @@ -1107,36 +1111,36 @@ def test_cf_remove(self): _insert_super() # Remove the key1:Standard1 cf; verify super is unaffected - client.remove('key1', ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) - assert _big_slice('key1', ColumnParent('Standard1')) == [] + client.remove(utf8encode('key1'), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] _verify_super() # Test resurrection. First, re-insert a value w/ older timestamp, # and make sure it stays removed: - client.insert('key1', ColumnParent('Standard1'), Column('c1', 'value1', 0), ConsistencyLevel.ONE) - assert _big_slice('key1', ColumnParent('Standard1')) == [] + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] # Next, w/ a newer timestamp; it should come back: - client.insert('key1', ColumnParent('Standard1'), Column('c1', 'value1', 4), ConsistencyLevel.ONE) - result = _big_slice('key1', ColumnParent('Standard1')) - assert result == [ColumnOrSuperColumn(column=Column('c1', 'value1', 4))], result + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 4), ConsistencyLevel.ONE) + result = _big_slice(utf8encode('key1'), ColumnParent('Standard1')) + assert result == [ColumnOrSuperColumn(column=Column(utf8encode('c1'), utf8encode('value1'), 4))], result # check removing the entire super cf, too. - client.remove('key1', ColumnPath('Super1'), 3, ConsistencyLevel.ONE) - assert _big_slice('key1', ColumnParent('Super1')) == [] - assert _big_slice('key1', ColumnParent('Super1', 'sc1')) == [] + client.remove(utf8encode('key1'), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) + assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1'))) == [] def test_super_cf_remove_and_range_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - client.insert('key3', ColumnParent('Super1', 'sc1'), Column(_i64(1), 'v1', 0), ConsistencyLevel.ONE) - client.remove('key3', ColumnPath('Super1', 'sc1'), 5, ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('Super1', utf8encode('sc1')), Column(_i64(1), utf8encode('v1'), 0), ConsistencyLevel.ONE) + client.remove(utf8encode('key3'), ColumnPath('Super1', utf8encode('sc1')), 5, ConsistencyLevel.ONE) rows = {} - for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange('', '', False, 1000)), '', '', 1000, ConsistencyLevel.ONE): + for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE): scs = [cosc.super_column for cosc in row.columns] rows[row.key] = scs - assert rows == {'key3': []}, rows + assert rows == {utf8encode('key3'): []}, rows def test_super_cf_remove_column(self): _set_keyspace('Keyspace1') @@ -1146,42 +1150,42 @@ def test_super_cf_remove_column(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove('key1', ColumnPath('Super1', 'sc2', _i64(5)), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1', ColumnPath('Super1', 'sc2', _i64(5)), ConsistencyLevel.ONE)) - super_columns = [result.super_column for result in _big_slice('key1', ColumnParent('Super1'))] - assert super_columns == [SuperColumn(name='sc1', columns=[Column(_i64(4), 'value4', 0)]), - SuperColumn(name='sc2', columns=[Column(_i64(6), 'value6', 0)])] + client.remove(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), ConsistencyLevel.ONE)) + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + assert super_columns == [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(6), utf8encode('value6'), 0)])] _verify_simple() # New insert, make sure it shows up post-remove: - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(7), 'value7', 0), ConsistencyLevel.ONE) - super_columns_expected = [SuperColumn(name='sc1', - columns=[Column(_i64(4), 'value4', 0)]), - SuperColumn(name='sc2', - columns=[Column(_i64(6), 'value6', 0), Column(_i64(7), 'value7', 0)])] + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(7), utf8encode('value7'), 0), ConsistencyLevel.ONE) + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), + columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), + columns=[Column(_i64(6), utf8encode('value6'), 0), Column(_i64(7), utf8encode('value7'), 0)])] - super_columns = [result.super_column for result in _big_slice('key1', ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(5), 'value5', 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice('key1', ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(5), 'value5', 6), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice('key1', ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name='sc1', columns=[Column(_i64(4), 'value4', 0)]), - SuperColumn(name='sc2', columns=[Column(_i64(5), 'value5', 6), - Column(_i64(6), 'value6', 0), - Column(_i64(7), 'value7', 0)])] + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 6), ConsistencyLevel.ONE) + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 6), + Column(_i64(6), utf8encode('value6'), 0), + Column(_i64(7), utf8encode('value7'), 0)])] assert super_columns == super_columns_expected, super_columns # shouldn't be able to specify a column w/o a super column for remove - cp = ColumnPath(column_family='Super1', column='sc2') - e = _expect_exception(lambda: client.remove('key1', cp, 5, ConsistencyLevel.ONE), InvalidRequestException) + cp = ColumnPath(column_family='Super1', column=utf8encode('sc2')) + e = _expect_exception(lambda: client.remove(utf8encode('key1'), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("column cannot be specified without") >= 0 def test_super_cf_remove_supercolumn(self): @@ -1192,66 +1196,66 @@ def test_super_cf_remove_supercolumn(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove('key1', ColumnPath('Super1', 'sc2'), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1', ColumnPath('Super1', 'sc2', _i64(5)), ConsistencyLevel.ONE)) - super_columns = _big_slice('key1', ColumnParent('Super1', 'sc2')) + client.remove(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2')), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), ConsistencyLevel.ONE)) + super_columns = _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2'))) assert super_columns == [], super_columns - super_columns_expected = [SuperColumn(name='sc1', columns=[Column(_i64(4), 'value4', 0)])] + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)])] super_columns = [result.super_column - for result in _big_slice('key1', ColumnParent('Super1'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns _verify_simple() # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(5), 'value5', 1), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 1), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice('key1', ColumnParent('Super1'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(5), 'value5', 6), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 6), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice('key1', ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name='sc1', columns=[Column(_i64(4), 'value4', 0)]), - SuperColumn(name='sc2', columns=[Column(_i64(5), 'value5', 6)])] + for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 6)])] assert super_columns == super_columns_expected, super_columns # check slicing at the subcolumn level too - p = SlicePredicate(slice_range=SliceRange('', '', False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) columns = [result.column - for result in client.get_slice('key1', ColumnParent('Super1', 'sc2'), p, ConsistencyLevel.ONE)] - assert columns == [Column(_i64(5), 'value5', 6)], columns + for result in client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE)] + assert columns == [Column(_i64(5), utf8encode('value5'), 6)], columns def test_super_cf_resurrect_subcolumn(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - key = 'vijay' - client.insert(key, ColumnParent('Super1', 'sc1'), Column(_i64(4), 'value4', 0), ConsistencyLevel.ONE) + key = utf8encode('vijay') + client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) - client.remove(key, ColumnPath('Super1', 'sc1'), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super1', utf8encode('sc1')), 1, ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', 'sc1'), Column(_i64(4), 'value4', 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 2), ConsistencyLevel.ONE) - result = client.get(key, ColumnPath('Super1', 'sc1'), ConsistencyLevel.ONE) + result = client.get(key, ColumnPath('Super1', utf8encode('sc1')), ConsistencyLevel.ONE) assert result.super_column.columns is not None, result.super_column def test_empty_range(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Super1') - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1', 'c1']), '', '', 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) == [] _insert_simple() - assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=['c1', 'c1']), '', '', 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) == [] @since('2.1') def test_super_cql_read_compatibility(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _insert_super("key1") - _insert_super("key2") + _insert_super(utf8encode("key1")) + _insert_super(utf8encode("key2")) node1 = self.cluster.nodelist()[0] session = self.patient_cql_connection(node1) @@ -1259,32 +1263,32 @@ def test_super_cql_read_compatibility(self): session.execute('USE "Keyspace1"') assert_all(session, "SELECT * FROM \"Super1\"", - [["key1", "sc1", 4, "value4"], - ["key1", "sc2", 5, "value5"], - ["key1", "sc2", 6, "value6"], - ["key2", "sc1", 4, "value4"], - ["key2", "sc2", 5, "value5"], - ["key2", "sc2", 6, "value6"]]) + [[utf8encode("key1"), utf8encode("sc1"), 4, utf8encode("value4")], + [utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")], + [utf8encode("key2"), utf8encode("sc1"), 4, utf8encode("value4")], + [utf8encode("key2"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key2"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1')", - [["key1", "sc1", 4, "value4"], - ["key1", "sc2", 5, "value5"], - ["key1", "sc2", 6, "value6"]]) + [[utf8encode("key1"), utf8encode("sc1"), 4, utf8encode("value4")], + [utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2')", - [["key1", "sc2", 5, "value5"], - ["key1", "sc2", 6, "value6"]]) + [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2') AND column2 = 5", - [["key1", "sc2", 5, "value5"]]) + [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [["key1", "sc2", 5, "value5"], - ["key1", "sc2", 6, "value6"]]) + [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT column2, value FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [[5, "value5"], - [6, "value6"]]) + [[5, utf8encode("value5")], + [6, utf8encode("value6")]]) @since('2.1') def test_super_cql_write_compatibility(self): @@ -1304,48 +1308,50 @@ def test_super_cql_write_compatibility(self): session.execute(query, ("key2", "sc2", 5, "value5")) session.execute(query, ("key2", "sc2", 6, "value6")) - p = SlicePredicate(slice_range=SliceRange('sc1', 'sc2', False, 2)) - result = client.get_slice('key1', ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc1'), utf8encode('sc2'), False, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert_length_equal(result, 2) - assert result[0].super_column.name == 'sc1' - assert result[0].super_column.columns[0], Column(_i64(4), 'value4' == 1234) - assert result[1].super_column.name == 'sc2' - assert result[1].super_column.columns, [Column(_i64(5), 'value5', 1234), Column(_i64(6), 'value6' == 1234)] + assert result[0].super_column.name == utf8encode('sc1') + assert result[0].super_column.columns[0], Column(_i64(4), utf8encode('value4') == 1234) + assert result[1].super_column.name == utf8encode('sc2') + assert result[1].super_column.columns, [Column(_i64(5), utf8encode('value5'), 1234), Column(_i64(6), utf8encode('value6') == 1234)] def test_range_with_remove(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1', 'c1']), 'key1', '', 1000, ConsistencyLevel.ONE)[0].key == 'key1' + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode('key1'), utf8encode(''), 1000, ConsistencyLevel.ONE)[0].key == utf8encode('key1') - client.remove('key1', ColumnPath('Standard1', column='c1'), 1, ConsistencyLevel.ONE) - client.remove('key1', ColumnPath('Standard1', column='c2'), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1', 'c2']), '', '', 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key='key1')], actual + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), 1, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c2')), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c2')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key=utf8encode('key1'))], actual def test_range_with_remove_cf(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1', 'c1']), 'key1', '', 1000, ConsistencyLevel.ONE)[0].key == 'key1' + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode('key1'), utf8encode(''), 1000, ConsistencyLevel.ONE)[0].key == utf8encode('key1') - client.remove('key1', ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1', 'c1']), '', '', 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key='key1')], actual + client.remove(utf8encode('key1'), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key=utf8encode('key1'))], actual def test_range_collation(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: - client.insert(key, ColumnParent('Standard1'), Column(key, 'v', 0), ConsistencyLevel.ONE) + key = utf8encode(key) + client.insert(key, ColumnParent('Standard1'), Column(key, utf8encode('v'), 0), ConsistencyLevel.ONE) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), '', '', 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) L = ['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '2', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '3', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '4', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '5', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '6', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '7', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '8', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '9', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', 'a', 'b'] assert len(slices) == len(L) for key, ks in zip(L, slices): + key = utf8encode(key) assert key == ks.key def test_range_partial(self): @@ -1353,23 +1359,25 @@ def test_range_partial(self): self.truncate_all('Standard1') for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: - client.insert(key, ColumnParent('Standard1'), Column(key, 'v', 0), ConsistencyLevel.ONE) + key = utf8encode(key) + client.insert(key, ColumnParent('Standard1'), Column(key, utf8encode('v'), 0), ConsistencyLevel.ONE) def check_slices_against_keys(keyList, sliceList): assert len(keyList) == len(sliceList), "%d vs %d" % (len(keyList), len(sliceList)) for key, ks in zip(keyList, sliceList): + key = utf8encode(key) assert key == ks.key - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), 'a', '', 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('a'), utf8encode(''), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['a', 'b'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), '', '15', 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode(''), utf8encode('15'), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), '50', '51', 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('50'), utf8encode('51'), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['50', '51'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), '1', '', 10, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('1'), utf8encode(''), 10, ConsistencyLevel.ONE) check_slices_against_keys(['1', '10', '11', '12', '13', '14', '15', '16', '17', '18'], slices) def test_get_slice_range(self): @@ -1391,92 +1399,98 @@ def test_get_range_slices_tokens(self): self.truncate_all('Super3') for key in ['key1', 'key2', 'key3', 'key4', 'key5']: + key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: - client.insert(key, ColumnParent('Super3', 'sc1'), Column(cname, 'v-' + cname, 0), ConsistencyLevel.ONE) + cnameutf = utf8encode(cname) + client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', 'sc1') - predicate = SlicePredicate(column_names=['col1', 'col3']) + cp = ColumnParent('Super3', utf8encode('sc1')) + predicate = SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]) range = KeyRange(start_token='55', end_token='55', count=100) result = client.get_range_slices(cp, predicate, range, ConsistencyLevel.ONE) assert len(result) == 5 - assert result[0].columns[0].column.name == 'col1' - assert result[0].columns[1].column.name == 'col3' + assert result[0].columns[0].column.name == utf8encode('col1') + assert result[0].columns[1].column.name == utf8encode('col3') def test_get_range_slice_super(self): _set_keyspace('Keyspace2') self.truncate_all('Super3') for key in ['key1', 'key2', 'key3', 'key4', 'key5']: + key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: - client.insert(key, ColumnParent('Super3', 'sc1'), Column(cname, 'v-' + cname, 0), ConsistencyLevel.ONE) + cnameutf = utf8encode(cname) + client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', 'sc1') - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1', 'col3']), 'key2', 'key4', 5, ConsistencyLevel.ONE) + cp = ColumnParent('Super3', utf8encode('sc1')) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert result[0].columns[0].column.name == 'col1' - assert result[0].columns[1].column.name == 'col3' + assert result[0].columns[0].column.name == utf8encode('col1') + assert result[0].columns[1].column.name == utf8encode('col3') cp = ColumnParent('Super3') - result = get_range_slice(client, cp, SlicePredicate(column_names=['sc1']), 'key2', 'key4', 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('sc1')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert list(set(row.columns[0].super_column.name for row in result))[0] == 'sc1' + assert list(set(row.columns[0].super_column.name for row in result))[0] == utf8encode('sc1') def test_get_range_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') for key in ['key1', 'key2', 'key3', 'key4', 'key5']: + key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: - client.insert(key, ColumnParent('Standard1'), Column(cname, 'v-' + cname, 0), ConsistencyLevel.ONE) + cnameutf = utf8encode(cname) + client.insert(key, ColumnParent('Standard1'), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) cp = ColumnParent('Standard1') # test empty slice - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1', 'col3']), 'key6', '', 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key6'), utf8encode(''), 1, ConsistencyLevel.ONE) assert len(result) == 0 # test empty columns - result = get_range_slice(client, cp, SlicePredicate(column_names=['a']), 'key2', '', 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('a')]), utf8encode('key2'), utf8encode(''), 1, ConsistencyLevel.ONE) assert len(result) == 1 assert len(result[0].columns) == 0 # test column_names predicate - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1', 'col3']), 'key2', 'key4', 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) assert len(result) == 3, result - assert result[0].columns[0].column.name == 'col1' - assert result[0].columns[1].column.name == 'col3' + assert result[0].columns[0].column.name == utf8encode('col1') + assert result[0].columns[1].column.name == utf8encode('col3') # row limiting via count. - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1', 'col3']), 'key2', 'key4', 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 1, ConsistencyLevel.ONE) assert len(result) == 1 # test column slice predicate - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2', finish='col4', reversed=False, count=5)), 'key1', 'key2', 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=5)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].key == 'key1' - assert result[1].key == 'key2' + assert result[0].key == utf8encode('key1') + assert result[1].key == utf8encode('key2') assert len(result[0].columns) == 3 - assert result[0].columns[0].column.name == 'col2' - assert result[0].columns[2].column.name == 'col4' + assert result[0].columns[0].column.name == utf8encode('col2') + assert result[0].columns[2].column.name == utf8encode('col4') # col limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2', finish='col4', reversed=False, count=2)), 'key1', 'key2', 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=2)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) assert len(result[0].columns) == 2 # and reversed - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col4', finish='col2', reversed=True, count=5)), 'key1', 'key2', 5, ConsistencyLevel.ONE) - assert result[0].columns[0].column.name == 'col4' - assert result[0].columns[2].column.name == 'col2' + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col4'), finish=utf8encode('col2'), reversed=True, count=5)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) + assert result[0].columns[0].column.name == utf8encode('col4') + assert result[0].columns[2].column.name == utf8encode('col2') # row limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2', finish='col4', reversed=False, count=5)), 'key1', 'key2', 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=5)), utf8encode('key1'), utf8encode('key2'), 1, ConsistencyLevel.ONE) assert len(result) == 1 # removed data - client.remove('key1', ColumnPath('Standard1', column='col1'), 1, ConsistencyLevel.ONE) - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange('', '')), 'key1', 'key2', 5, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('col1')), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) assert len(result) == 2, result - assert result[0].columns[0].column.name == 'col2', result[0].columns[0].column.name - assert result[1].columns[0].column.name == 'col1' + assert result[0].columns[0].column.name == utf8encode('col2'), result[0].columns[0].column.name + assert result[1].columns[0].column.name == utf8encode('col1') def test_wrapped_range_slices(self): _set_keyspace('Keyspace1') @@ -1489,32 +1503,33 @@ def copp_token(key): 'c': '00550000000100000001', 'd': '00560000000100000001', 'e': '00580000000100000001'}[key] - - for key in ['a', 'b', 'c', 'd', 'e']: + keylist = [utf8encode(key) for key in ['a', 'b', 'c', 'd', 'e']] + for key in keylist: for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: - client.insert(key, ColumnParent('Standard1'), Column(cname, 'v-' + cname, 0), ConsistencyLevel.ONE) + cnameutf = utf8encode(cname) + client.insert(key, ColumnParent('Standard1'), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) cp = ColumnParent('Standard1') - result = client.get_range_slices(cp, SlicePredicate(column_names=['col1', 'col3']), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) - assert [row.key for row in result] == ['a', 'b', 'c', 'd', 'e', ], [row.key for row in result] + result = client.get_range_slices(cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) + assert [row.key for row in result] == keylist, [row.key for row in result] - result = client.get_range_slices(cp, SlicePredicate(column_names=['col1', 'col3']), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) - assert [row.key for row in result] == ['a', 'b', 'c', 'd', 'e', ], [row.key for row in result] + result = client.get_range_slices(cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) + assert [row.key for row in result] == keylist, [row.key for row in result] def test_get_slice_by_names(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Super1') _insert_range() - p = SlicePredicate(column_names=['c1', 'c2']) - result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c2')]) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == 'c1' - assert result[1].column.name == 'c2' + assert result[0].column.name == utf8encode('c1') + assert result[1].column.name == utf8encode('c2') _insert_super() p = SlicePredicate(column_names=[_i64(4)]) - result = client.get_slice('key1', ColumnParent('Super1', 'sc1'), p, ConsistencyLevel.ONE) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), p, ConsistencyLevel.ONE) assert len(result) == 1 assert result[0].column.name == _i64(4) @@ -1523,24 +1538,24 @@ def test_multiget_slice_with_compact_table(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef('v', 'AsciiType', None, None) + cd = ColumnDef(utf8encode('v'), 'AsciiType', None, None) newcf = CfDef('Keyspace1', 'CompactColumnFamily', default_validation_class='AsciiType', column_metadata=[cd]) client.system_add_column_family(newcf) CL = ConsistencyLevel.ONE for i in range(0, 5): - client.insert('key' + str(i), ColumnParent('CompactColumnFamily'), Column('v', 'value' + str(i), 0), CL) + client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column(utf8encode('v'), utf8encode('value' + str(i)), 0), CL) time.sleep(0.1) - p = SlicePredicate(column_names=['v']) - rows = client.multiget_slice(['key' + str(i) for i in range(0, 5)], ColumnParent('CompactColumnFamily'), p, ConsistencyLevel.ONE) + p = SlicePredicate(column_names=[utf8encode('v')]) + rows = client.multiget_slice([utf8encode('key' + str(i)) for i in range(0, 5)], ColumnParent('CompactColumnFamily'), p, ConsistencyLevel.ONE) for i in range(0, 5): - key = 'key' + str(i) + key = utf8encode('key' + str(i)) assert key in rows assert len(rows[key]) == 1 - assert rows[key][0].column.name == 'v' - assert rows[key][0].column.value == 'value' + str(i) + assert rows[key][0].column.name == utf8encode('v') + assert rows[key][0].column.value == utf8encode('value' + str(i)) def test_multiget_slice(self): """Insert multiple keys and retrieve them using the multiget_slice interface""" @@ -1549,7 +1564,7 @@ def test_multiget_slice(self): # Generate a list of 10 keys and insert them num_keys = 10 - keys = ['key' + str(i) for i in range(1, num_keys + 1)] + keys = [utf8encode('key' + str(i)) for i in range(1, num_keys + 1)] _insert_multi(keys) # Retrieve all 10 key slices @@ -1569,18 +1584,18 @@ def test_multi_count(self): # Generate a list of 10 keys countaining 1 to 10 columns and insert them num_keys = 10 for i in range(1, num_keys + 1): - key = 'key' + str(i) + key = utf8encode('key' + str(i)) for j in range(1, i + 1): - client.insert(key, ColumnParent('Standard1'), Column('c' + str(j), 'value' + str(j), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c' + str(j)), utf8encode('value' + str(j)), 0), ConsistencyLevel.ONE) # Count columns in all 10 keys - keys = ['key' + str(i) for i in range(1, num_keys + 1)] - p = SlicePredicate(slice_range=SliceRange('', '', False, 1000)) + keys = [utf8encode('key' + str(i)) for i in range(1, num_keys + 1)] + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) counts = client.multiget_count(keys, ColumnParent('Standard1'), p, ConsistencyLevel.ONE) # Check the returned counts for i in range(1, num_keys + 1): - key = 'key' + str(i) + key = utf8encode('key' + str(i)) assert counts[key] == i def test_batch_mutate_super_deletion(self): @@ -1588,26 +1603,26 @@ def test_batch_mutate_super_deletion(self): self.truncate_all('Super1') _insert_super('test') - d = Deletion(1, predicate=SlicePredicate(column_names=['sc1'])) + d = Deletion(1, predicate=SlicePredicate(column_names=[utf8encode('sc1')])) cfmap = {'Super1': [Mutation(deletion=d)]} - client.batch_mutate({'test': cfmap}, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1', ColumnPath('Super1', 'sc1'), ConsistencyLevel.ONE)) + client.batch_mutate({utf8encode('test'): cfmap}, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1')), ConsistencyLevel.ONE)) def test_super_reinsert(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') for x in range(3): - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(x), 'value', 1), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(x), utf8encode('value'), 1), ConsistencyLevel.ONE) - client.remove('key1', ColumnPath('Super1'), 2, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) for x in range(3): - client.insert('key1', ColumnParent('Super1', 'sc2'), Column(_i64(x + 3), 'value', 3), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(x + 3), utf8encode('value'), 3), ConsistencyLevel.ONE) for n in range(1, 4): - p = SlicePredicate(slice_range=SliceRange('', '', False, n)) - slice = client.get_slice('key1', ColumnParent('Super1', 'sc2'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, n)) + slice = client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE) assert len(slice) == n, "expected %s results; found %s" % (n, slice) def test_describe_keyspace(self): @@ -1711,9 +1726,9 @@ def test_system_cf_recreate(self): _set_keyspace(keyspace) # insert - client.insert('key0', ColumnParent(cf_name), Column('colA', 'colA-value', 0), ConsistencyLevel.ONE) - col1 = client.get_slice('key0', ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange('', '', False, 100)), ConsistencyLevel.ONE)[0].column - assert col1.name == 'colA' and col1.value == 'colA-value' + client.insert(utf8encode('key0'), ColumnParent(cf_name), Column(utf8encode('colA'), utf8encode('colA-value'), 0), ConsistencyLevel.ONE) + col1 = client.get_slice(utf8encode('key0'), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)), ConsistencyLevel.ONE)[0].column + assert col1.name == utf8encode('colA') and col1.value == utf8encode('colA-value') # drop client.system_drop_column_family(cf_name) @@ -1722,7 +1737,7 @@ def test_system_cf_recreate(self): client.system_add_column_family(newcf) # query - cosc_list = client.get_slice('key0', ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange('', '', False, 100)), ConsistencyLevel.ONE) + cosc_list = client.get_slice(utf8encode('key0'), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)), ConsistencyLevel.ONE) # this was failing prior to CASSANDRA-1477. assert len(cosc_list) == 0, 'cosc length test failed' @@ -1791,17 +1806,17 @@ def test_column_validators(self): # columndef validation for regular CF ks = 'Keyspace1' _set_keyspace(ks) - cd = ColumnDef('col', 'LongType', None, None) + cd = ColumnDef(utf8encode('col'), 'LongType', None, None) cf = CfDef('Keyspace1', 'ValidatorColumnFamily', column_metadata=[cd]) client.system_add_column_family(cf) ks_def = client.describe_keyspace(ks) assert 'ValidatorColumnFamily' in [x.name for x in ks_def.cf_defs] cp = ColumnParent('ValidatorColumnFamily') - col0 = Column('col', _i64(42), 0) - col1 = Column('col', "ceci n'est pas 64bit", 0) - client.insert('key0', cp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert('key1', cp, col1, ConsistencyLevel.ONE), InvalidRequestException) + col0 = Column(utf8encode('col'), _i64(42), 0) + col1 = Column(utf8encode('col'), utf8encode("ceci n'est pas 64bit"), 0) + client.insert(utf8encode('key0'), cp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef validation for super CF @@ -1810,9 +1825,9 @@ def test_column_validators(self): ks_def = client.describe_keyspace(ks) assert 'ValidatorSuperColumnFamily' in [x.name for x in ks_def.cf_defs] - scp = ColumnParent('ValidatorSuperColumnFamily', 'sc1') - client.insert('key0', scp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert('key1', scp, col1, ConsistencyLevel.ONE), InvalidRequestException) + scp = ColumnParent('ValidatorSuperColumnFamily', utf8encode('sc1')) + client.insert(utf8encode('key0'), scp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef and cfdef default validation @@ -1823,23 +1838,23 @@ def test_column_validators(self): dcp = ColumnParent('DefaultValidatorColumnFamily') # inserting a longtype into column 'col' is valid at the columndef level - client.insert('key0', dcp, col0, ConsistencyLevel.ONE) + client.insert(utf8encode('key0'), dcp, col0, ConsistencyLevel.ONE) # inserting a UTF8type into column 'col' fails at the columndef level - e = _expect_exception(lambda: client.insert('key1', dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a longtype into column 'fcol' should fail at the cfdef level - col2 = Column('fcol', _i64(4224), 0) - e = _expect_exception(lambda: client.insert('key1', dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) + col2 = Column(utf8encode('fcol'), _i64(4224), 0) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a UTF8type into column 'fcol' is valid at the cfdef level - col3 = Column('fcol', "Stringin' it up in the Stringtel Stringifornia", 0) - client.insert('key0', dcp, col3, ConsistencyLevel.ONE) + col3 = Column(utf8encode('fcol'), utf8encode("Stringin' it up in the Stringtel Stringifornia"), 0) + client.insert(utf8encode('key0'), dcp, col3, ConsistencyLevel.ONE) def test_system_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef('ValidationColumn', 'BytesType', None, None) + cd = ColumnDef(utf8encode('ValidationColumn'), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewColumnFamily', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -1892,36 +1907,36 @@ def test_dynamic_indexes_creation_deletion(self): ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'BlankCF'][0] - modified_cd = ColumnDef('birthdate', 'BytesType', IndexType.KEYS, None) + modified_cd = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, None) modified_cf = CfDef('Keyspace1', 'BlankCF', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) # Add a second indexed CF ... - birthdate_coldef = ColumnDef('birthdate', 'BytesType', IndexType.KEYS, None) - age_coldef = ColumnDef('age', 'BytesType', IndexType.KEYS, 'age_index') + birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, None) + age_coldef = ColumnDef(utf8encode('age'), 'BytesType', IndexType.KEYS, 'age_index') cfdef = CfDef('Keyspace1', 'BlankCF2', column_metadata=[birthdate_coldef, age_coldef]) client.system_add_column_family(cfdef) # ... and update it to have a third index ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - name_coldef = ColumnDef('name', 'BytesType', IndexType.KEYS, 'name_index') + name_coldef = ColumnDef(utf8encode('name'), 'BytesType', IndexType.KEYS, 'name_index') cfdef.column_metadata.append(name_coldef) client.system_update_column_family(cfdef) # Now drop the indexes ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - birthdate_coldef = ColumnDef('birthdate', 'BytesType', None, None) - age_coldef = ColumnDef('age', 'BytesType', None, None) - name_coldef = ColumnDef('name', 'BytesType', None, None) + birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) + age_coldef = ColumnDef(utf8encode('age'), 'BytesType', None, None) + name_coldef = ColumnDef(utf8encode('name'), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef, age_coldef, name_coldef] client.system_update_column_family(cfdef) ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF'][0] - birthdate_coldef = ColumnDef('birthdate', 'BytesType', None, None) + birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef] client.system_update_column_family(cfdef) @@ -1930,29 +1945,29 @@ def test_dynamic_indexes_creation_deletion(self): def test_dynamic_indexes_with_system_update_cf(self): _set_keyspace('Keyspace1') - cd = ColumnDef('birthdate', 'BytesType', None, None) + cd = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'ToBeIndexed', default_validation_class='LongType', column_metadata=[cd]) client.system_add_column_family(newcf) - client.insert('key1', ColumnParent('ToBeIndexed'), Column('birthdate', _i64(1), 0), ConsistencyLevel.ONE) - client.insert('key2', ColumnParent('ToBeIndexed'), Column('birthdate', _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key2', ColumnParent('ToBeIndexed'), Column('b', _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key3', ColumnParent('ToBeIndexed'), Column('birthdate', _i64(3), 0), ConsistencyLevel.ONE) - client.insert('key3', ColumnParent('ToBeIndexed'), Column('b', _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('ToBeIndexed'), Column(utf8encode('b'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('ToBeIndexed'), Column(utf8encode('b'), _i64(3), 0), ConsistencyLevel.ONE) # First without index cp = ColumnParent('ToBeIndexed') - sp = SlicePredicate(slice_range=SliceRange('', '')) - key_range = KeyRange('', '', None, None, [IndexExpression('birthdate', IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key1' + assert result[0].key == utf8encode('key1') assert len(result[0].columns) == 1, result[0].columns # add an index on 'birthdate' ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'ToBeIndexed'][0] - modified_cd = ColumnDef('birthdate', 'BytesType', IndexType.KEYS, 'bd_index') + modified_cd = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, 'bd_index') modified_cf = CfDef('Keyspace1', 'ToBeIndexed', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) @@ -1969,14 +1984,14 @@ def test_dynamic_indexes_with_system_update_cf(self): # repeat query on one index expression result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key1' + assert result[0].key == utf8encode('key1') assert len(result[0].columns) == 1, result[0].columns def test_system_super_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef('ValidationColumn', 'BytesType', None, None) + cd = ColumnDef(utf8encode('ValidationColumn'), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewSuperColumnFamily', 'Super', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -1993,32 +2008,32 @@ def test_insert_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl1', 'value1', 0, 5) - client.insert('key1', ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - assert client.get('key1', ColumnPath('Standard1', column='cttl1'), ConsistencyLevel.ONE).column == column + column = Column(utf8encode('cttl1'), utf8encode('value1'), 0, 5) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl1')), ConsistencyLevel.ONE).column == column def test_simple_expiration(self): """ Test that column ttled do expires """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl3', 'value1', 0, 2) - client.insert('key1', ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - c = client.get('key1', ColumnPath('Standard1', column='cttl3'), ConsistencyLevel.ONE).column + column = Column(utf8encode('cttl3'), utf8encode('value1'), 0, 2) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + c = client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get('key1', ColumnPath('Standard1', column='cttl3'), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl3')), ConsistencyLevel.ONE)) def test_expiration_with_default_ttl(self): """ Test that column with default ttl do expires """ _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column('cttl3', 'value1', 0) - client.insert('key1', ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - client.get('key1', ColumnPath('Expiring', column='cttl3'), ConsistencyLevel.ONE).column + column = Column(utf8encode('cttl3'), utf8encode('value1'), 0) + client.insert(utf8encode('key1'), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column time.sleep(3) - _expect_missing(lambda: client.get('key1', ColumnPath('Expiring', column='cttl3'), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE)) @since('3.6') def test_expiration_with_default_ttl_and_zero_ttl(self): @@ -2029,242 +2044,242 @@ def test_expiration_with_default_ttl_and_zero_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column('cttl3', 'value1', 0, 0) - client.insert('key1', ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - c = client.get('key1', ColumnPath('Expiring', column='cttl3'), ConsistencyLevel.ONE).column - assert Column('cttl3', 'value1', 0) == c + column = Column(utf8encode('cttl3'), utf8encode('value1'), 0, 0) + client.insert(utf8encode('key1'), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + c = client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column + assert Column(utf8encode('cttl3'), utf8encode('value1'), 0) == c def test_simple_expiration_batch_mutate(self): """ Test that column ttled do expires using batch_mutate """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl4', 'value1', 0, 2) + column = Column(utf8encode('cttl4'), utf8encode('value1'), 0, 2) cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(column))]} - client.batch_mutate({'key1': cfmap}, ConsistencyLevel.ONE) - c = client.get('key1', ColumnPath('Standard1', column='cttl4'), ConsistencyLevel.ONE).column + client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) + c = client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get('key1', ColumnPath('Standard1', column='cttl4'), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE)) def test_update_expiring(self): """ Test that updating a column with ttl override the ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column1 = Column('cttl4', 'value1', 0, 1) - client.insert('key1', ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) - column2 = Column('cttl4', 'value1', 1) - client.insert('key1', ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) + column1 = Column(utf8encode('cttl4'), utf8encode('value1'), 0, 1) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) + column2 = Column(utf8encode('cttl4'), utf8encode('value1'), 1) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) time.sleep(1.5) - assert client.get('key1', ColumnPath('Standard1', column='cttl4'), ConsistencyLevel.ONE).column == column2 + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE).column == column2 def test_remove_expiring(self): """ Test removing a column with ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl5', 'value1', 0, 10) - client.insert('key1', ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - client.remove('key1', ColumnPath('Standard1', column='cttl5'), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1', ColumnPath('Standard1', column='ctt5'), ConsistencyLevel.ONE)) + column = Column(utf8encode('cttl5'), utf8encode('value1'), 0, 10) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl5')), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('ctt5')), ConsistencyLevel.ONE)) def test_describe_ring_on_invalid_keyspace(self): def req(): client.describe_ring('system') _expect_exception(req, InvalidRequestException) - def test_incr_decr_standard_add(self): + def test_incr_decr_standard_add(self, request): _set_keyspace('Keyspace1') - key = self._testMethodName + key = utf8encode(request.node.name) d1 = 12 d2 = -21 d3 = 35 # insert positive and negative values and check the counts - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) time.sleep(0.1) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1', d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d2), ConsistencyLevel.ONE) time.sleep(0.1) - rv2 = client.get(key, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1', d3), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d3), ConsistencyLevel.ONE) time.sleep(0.1) - rv3 = client.get(key, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) - def test_incr_decr_super_add(self): + def test_incr_decr_super_add(self, request): _set_keyspace('Keyspace1') - key = self._testMethodName + key = utf8encode(request.node.name) d1 = -234 d2 = 52345 d3 = 3123 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c2', d2), ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column='sc1'), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c2'), d2), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) assert rv1.counter_super_column.columns[0].value == d1 assert rv1.counter_super_column.columns[1].value == d2 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d2), ConsistencyLevel.ONE) - rv2 = client.get(key, ColumnPath('SuperCounter1', 'sc1', 'c1'), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d2), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath('SuperCounter1', utf8encode('sc1'), utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d3), ConsistencyLevel.ONE) - rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d3), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) - def test_incr_standard_remove(self): + def test_incr_standard_remove(self, request): _set_keyspace('Keyspace1') - key1 = self._testMethodName + "_1" - key2 = self._testMethodName + "_2" + key1 = utf8encode(request.node.name + "_1") + key2 = utf8encode(request.node.name + "_2") d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1')) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1')) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) - def test_incr_super_remove(self): + def test_incr_super_remove(self, request): _set_keyspace('Keyspace1') - key1 = self._testMethodName + "_1" - key2 = self._testMethodName + "_2" + key1 = utf8encode(request.node.name + "_1") + key2 = utf8encode(request.node.name + "_2") d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1')) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1')) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) - def test_incr_decr_standard_remove(self): + def test_incr_decr_standard_remove(self, request): _set_keyspace('Keyspace1') - key1 = self._testMethodName + "_1" - key2 = self._testMethodName + "_2" + key1 = utf8encode(request.node.name + "_1") + key2 = utf8encode(request.node.name + "_2") d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1')) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1')) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) - def test_incr_decr_super_remove(self): + def test_incr_decr_super_remove(self, request): _set_keyspace('Keyspace1') - key1 = self._testMethodName + "_1" - key2 = self._testMethodName + "_2" + key1 = utf8encode(request.node.name + "_1") + key2 = utf8encode(request.node.name + "_2") d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1')) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column='sc1'), CounterColumn('c1', d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1'), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1', column='c1')) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) - def test_incr_decr_standard_batch_add(self): + def test_incr_decr_standard_batch_add(self, request): _set_keyspace('Keyspace1') - key = self._testMethodName + key = utf8encode(request.node.name) d1 = 12 d2 = -21 update_map = {key: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1', d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1', d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), ]}} # insert positive and negative values and check the counts client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 - def test_incr_decr_standard_batch_remove(self): + def test_incr_decr_standard_batch_remove(self, request): _set_keyspace('Keyspace1') - key1 = self._testMethodName + "_1" - key2 = self._testMethodName + "_2" + key1 = utf8encode(request.node.name + "_1") + key2 = utf8encode(request.node.name + "_2") d1 = 12 d2 = -21 # insert positive and negative values and check the counts update_map = {key1: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1', d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1', d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 # remove the previous column and check that it is gone update_map = {key1: {'Counter1': [ - Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=['c1']))), + Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=[utf8encode('c1')]))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1')) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone update_map = {key2: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1', d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1', d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 + d2 update_map = {key2: {'Counter1': [ Mutation(deletion=Deletion()), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1')) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # known failure: see CASSANDRA-10046 def test_range_deletion(self): @@ -2274,16 +2289,16 @@ def test_range_deletion(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, 'value', int(time.time() * 1000)) - client.insert('key1', ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) - delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc='\xff'), composite('6', '\x01'), False, 100)) + delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x01'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {'key1': {'StandardComposite': mutations}} + keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - slice_predicate = SlicePredicate(slice_range=SliceRange('', '', False, 100)) - results = client.get_slice('key1', ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + slice_predicate = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2302,17 +2317,17 @@ def test_range_deletion_eoc_0(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(utf8encode(column_name), 'value', int(time.time() * 1000)) - client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) + client.insert(utf8encode('key1')), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # insert a partial cell name (just the first element of the composite) - column_name = composite('6', None, eoc='\x00') - column = Column(column_name, 'value', int(time.time() * 1000)) - client.insert('key1', ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column_name = composite('6', None, eoc=b'\x00') + column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # sanity check the query - slice_predicate = SlicePredicate(slice_range=SliceRange('', '', False, 100)) - results = client.get_slice('key1', ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + slice_predicate = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('3', '3'), composite('4', '4'), composite('5', '5'), composite('6'), @@ -2320,26 +2335,26 @@ def test_range_deletion_eoc_0(self): composite('7', '7'), composite('8', '8'), composite('9', '9')] # do a slice deletion with (6, ) as the end - delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc='\xff'), composite('6', '\x00'), False, 100)) + delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {'key1': {'StandardComposite': mutations}} + keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - # check the columns post-deletion, ('6', ) because it is an exact much but not (6, 6) - results = client.get_slice('key1', ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + # check the columns post-deletion, (utf8encode('6'), ) because it is an exact much but not (6, 6) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), composite('7', '7'), composite('8', '8'), composite('9', '9')] # do another slice deletion, but make the end (6, 6) this time - delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc='\xff'), composite('6', '6', '\x00'), False, 100)) + delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', '6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {'key1': {'StandardComposite': mutations}} + keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # check the columns post-deletion, now (6, 6) is also gone - results = client.get_slice('key1', ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2543,8 +2558,8 @@ def test_column_not_found_quorum(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - key = 'doesntexist' - column_path = ColumnPath(column_family="Standard1", column="idontexist") + key = utf8encode('doesntexist') + column_path = ColumnPath(column_family="Standard1", column=utf8encode("idontexist")) try: client.get(key, column_path, ConsistencyLevel.QUORUM) assert False, ('columnpath %s existed in %s when it should not' % (column_path, key)) @@ -2555,13 +2570,13 @@ def test_get_range_slice_after_deletion(self): _set_keyspace('Keyspace2') self.truncate_all('Super3') - key = 'key1' + key = utf8encode('key1') # three supercoluns, each with "col1" subcolumn for i in range(1, 4): - client.insert(key, ColumnParent('Super3', 'sc%d' % i), Column('col1', 'val1', 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column(utf8encode('col1'), utf8encode('val1'), 0), ConsistencyLevel.ONE) cp = ColumnParent('Super3') - predicate = SlicePredicate(slice_range=SliceRange('sc1', 'sc3', False, count=1)) + predicate = SlicePredicate(slice_range=SliceRange(utf8encode('sc1'), utf8encode('sc3'), False, count=1)) k_range = KeyRange(start_key=key, end_key=key, count=1) # validate count=1 restricts to 1 supercolumn @@ -2569,13 +2584,13 @@ def test_get_range_slice_after_deletion(self): assert len(result[0].columns) == 1 # remove sc1; add back subcolumn to override tombstone - client.remove(key, ColumnPath('Super3', 'sc1'), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super3', utf8encode('sc1')), 1, ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1 - client.insert(key, ColumnParent('Super3', 'sc1'), Column('col1', 'val1', 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(utf8encode('col1'), utf8encode('val1'), 2), ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].super_column.name == 'sc1' + assert result[0].columns[0].super_column.name == utf8encode('sc1') def test_multi_slice(self): _set_keyspace('Keyspace1') @@ -2594,12 +2609,12 @@ def test_truncate(self): # truncate Standard1 self.truncate_all('Standard1') - assert _big_slice('key1', ColumnParent('Standard1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] # truncate Super1 self.truncate_all('Super1') - assert _big_slice('key1', ColumnParent('Super1')) == [] - assert _big_slice('key1', ColumnParent('Super1', 'sc1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1'))) == [] @since('3.0') def test_cql_range_tombstone_and_static(self): @@ -2617,9 +2632,9 @@ def test_cql_range_tombstone_and_static(self): _set_keyspace('Keyspace1') - mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange('', '', False, 1000))))] + mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000))))] mutation_map = dict((table, mutations) for table in ['t']) - keyed_mutations = dict((key, mutation_map) for key in ['k']) + keyed_mutations = dict((key, mutation_map) for key in [utf8encode('k')]) client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # And check everything is gone @@ -2636,8 +2651,8 @@ def test_compact_storage_get(self): _set_keyspace('Keyspace1') CL = ConsistencyLevel.ONE i = 1 - client.insert(_i32(i), ColumnParent('cs1'), Column('v', _i32(i), 0), CL) - _assert_column('cs1', _i32(i), 'v', _i32(i), 0) + client.insert(_i32(i), ColumnParent('cs1'), Column(utf8encode('v'), _i32(i), 0), CL) + _assert_column('cs1', _i32(i), utf8encode('v'), _i32(i), 0) @pytest.mark.skipif(CASSANDRA_VERSION_FROM_BUILD == '3.9', reason="Test doesn't run on 3.9") def test_range_tombstone_eoc_0(self): From 8cca1086780d8cb605dd4378bcf29ba99fdeb774 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 12:45:35 -0500 Subject: [PATCH 07/16] More fixes, some with limited success. --- offline_tools_test.py | 6 +++++- thrift_test.py | 2 +- write_failures_test.py | 5 +++-- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/offline_tools_test.py b/offline_tools_test.py index 7c7cc8f5f2..9e3dc730c5 100644 --- a/offline_tools_test.py +++ b/offline_tools_test.py @@ -378,13 +378,17 @@ def test_sstableupgrade(self): # change before it's release. if testversion < '4.0': (out, error, rc) = node1.run_sstableupgrade(keyspace='ks', column_family='cf') + out = str(out) + error = str(error) logger.debug(out) logger.debug(error) logger.debug('Upgraded ks.cf sstable: {}'.format(node1.get_sstables(keyspace='ks', column_family='cf'))) - assert 'Found 1 sstables that need upgrading.' in out + assert 'Found 1 sstables that need upgrading.' in str(out) # Check that sstableupgrade finds no upgrade needed on current version. (out, error, rc) = node1.run_sstableupgrade(keyspace='ks', column_family='cf') + out = str(out) + error = str(error) logger.debug(out) logger.debug(error) assert 'Found 0 sstables that need upgrading.' in out diff --git a/thrift_test.py b/thrift_test.py index 23a576066e..0990d7141b 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -2318,7 +2318,7 @@ def test_range_deletion_eoc_0(self): for i in range(10): column_name = composite(str(i), str(i)) column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) - client.insert(utf8encode('key1')), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # insert a partial cell name (just the first element of the composite) column_name = composite('6', None, eoc=b'\x00') diff --git a/write_failures_test.py b/write_failures_test.py index 17ce50e21b..69a612acd6 100644 --- a/write_failures_test.py +++ b/write_failures_test.py @@ -1,6 +1,7 @@ import uuid import pytest import logging +import codecs from cassandra import ConsistencyLevel, WriteFailure, WriteTimeout @@ -222,9 +223,9 @@ def test_thrift(self): client.set_keyspace(KEYSPACE) with pytest.raises(self.expected_expt): - client.insert('key1', + client.insert(codecs.encode('key1'), thrift_types.ColumnParent('mytable'), - thrift_types.Column('value', 'Value 1', 0), + thrift_types.Column(codecs.encode('value'), codecs.encode('Value 1'), 0), thrift_types.ConsistencyLevel.ALL) client.transport.close() From 713c39c5153be876774c8f30948dea542dc48572 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 13:25:26 -0500 Subject: [PATCH 08/16] Another test fix --- putget_test.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/putget_test.py b/putget_test.py index 1933f8e739..3afcc9b56b 100644 --- a/putget_test.py +++ b/putget_test.py @@ -132,8 +132,8 @@ def test_wide_slice(self): cluster.set_configuration_options(values={'partitioner': 'org.apache.cassandra.dht.ByteOrderedPartitioner'}) cluster.populate(2) node1, node2 = cluster.nodelist() - node1.set_configuration_options(values={'initial_token': "a".encode('hex')}) - node1.set_configuration_options(values={'initial_token': "b".encode('hex')}) + node1.set_configuration_options(values={'initial_token': 'a'.encode().hex()}) + node1.set_configuration_options(values={'initial_token': 'b'.encode().hex()}) cluster.start() time.sleep(.5) session = self.patient_cql_connection(node1) From d077659eea89b11de3736dba3c1a819806a966c4 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 13:55:09 -0500 Subject: [PATCH 09/16] Should have been slashy --- rebuild_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rebuild_test.py b/rebuild_test.py index 919bd54a10..d04b2f92bf 100644 --- a/rebuild_test.py +++ b/rebuild_test.py @@ -439,7 +439,7 @@ def test_rebuild_with_specific_sources(self): node3.nodetool('rebuild -ks ks1 -ts (%s,%s] -s %s' % (tokens[2], str(pow(2, 63) - 1), node2_address)) # verify that node2 streamed to node3 - log_matches = node2.grep_log('Session with %s is complete' % node3.address_for_current_version()) + log_matches = node2.grep_log('Session with %s is complete' % node3.address_for_current_version_slashy()) assert len(log_matches) > 0 # verify that node1 did not participate From 6627a818fb4e0466dad511d6cb5249b13ed0e0cc Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 14:09:11 -0500 Subject: [PATCH 10/16] Yeah that is totally my bad. --- snitch_test.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/snitch_test.py b/snitch_test.py index 164c81e5d0..80cda7a79e 100644 --- a/snitch_test.py +++ b/snitch_test.py @@ -112,10 +112,11 @@ def test_prefer_local_reconnect_on_listen_address(self): assert "/{}".format(NODE1_BROADCAST_ADDRESS) in out assert "INTERNAL_IP:{}:{}".format('9' if running40 else '6', NODE1_LISTEN_ADDRESS) in out - assert "INTERNAL_ADDRESS_AND_PORT:7:{}".format(NODE1_40_LISTEN_ADDRESS) in out assert "/{}".format(NODE2_BROADCAST_ADDRESS) in out assert "INTERNAL_IP:{}:{}".format('9' if running40 else '6', NODE2_LISTEN_ADDRESS) in out - assert "INTERNAL_ADDRESS_AND_PORT:7:{}".format(NODE1_40_LISTEN_ADDRESS) in out + if running40: + assert "INTERNAL_ADDRESS_AND_PORT:7:{}".format(NODE1_40_LISTEN_ADDRESS) in out + assert "INTERNAL_ADDRESS_AND_PORT:7:{}".format(NODE1_40_LISTEN_ADDRESS) in out class TestDynamicEndpointSnitch(Tester): @pytest.mark.resource_intensive From 7bc6dcafb76cc303efece7841ea05db752bfcba9 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 14:24:27 -0500 Subject: [PATCH 11/16] Fix thrift issues. --- super_column_cache_test.py | 50 +- thrift_test.py | 1264 ++++++++++++++++++------------------ 2 files changed, 655 insertions(+), 659 deletions(-) diff --git a/super_column_cache_test.py b/super_column_cache_test.py index f0147a88b7..b3113d3847 100644 --- a/super_column_cache_test.py +++ b/super_column_cache_test.py @@ -61,56 +61,56 @@ def test_sc_with_row_cache(self): client.system_add_column_family(cfdef) - column = Column(name='name', value='Mina', timestamp=100) + column = Column(name='name'.encode(), value='Mina'.encode(), timestamp=100) client.batch_mutate( - {'mina': {'Users': [Mutation(ColumnOrSuperColumn(super_column=SuperColumn('attrs', [column])))]}}, + {'mina'.encode(): {'Users': [Mutation(ColumnOrSuperColumn(super_column=SuperColumn('attrs'.encode(), [column])))]}}, ThriftConsistencyLevel.ONE) column_parent = ColumnParent(column_family='Users') - predicate = SlicePredicate(slice_range=SliceRange("", "", False, 100)) - super_columns = client.get_slice('mina', column_parent, predicate, ThriftConsistencyLevel.ONE) + predicate = SlicePredicate(slice_range=SliceRange("".encode(), "".encode(), False, 100)) + super_columns = client.get_slice('mina'.encode(), column_parent, predicate, ThriftConsistencyLevel.ONE) assert 1 == len(super_columns) super_column = super_columns[0].super_column - assert 'attrs' == super_column.name + assert 'attrs'.encode() == super_column.name assert 1 == len(super_column.columns) - assert 'name' == super_column.columns[0].name - assert 'Mina' == super_column.columns[0].value + assert 'name'.encode() == super_column.columns[0].name + assert 'Mina'.encode() == super_column.columns[0].value # add a 'country' subcolumn - column = Column(name='country', value='Canada', timestamp=100) + column = Column(name='country'.encode(), value='Canada'.encode(), timestamp=100) client.batch_mutate( - {'mina': {'Users': [Mutation(ColumnOrSuperColumn(super_column=SuperColumn('attrs', [column])))]}}, + {'mina'.encode(): {'Users': [Mutation(ColumnOrSuperColumn(super_column=SuperColumn('attrs'.encode(), [column])))]}}, ThriftConsistencyLevel.ONE) - super_columns = client.get_slice('mina', column_parent, predicate, ThriftConsistencyLevel.ONE) + super_columns = client.get_slice('mina'.encode(), column_parent, predicate, ThriftConsistencyLevel.ONE) assert 1 == len(super_columns) super_column = super_columns[0].super_column - assert 'attrs' == super_column.name + assert 'attrs'.encode() == super_column.name assert 2 == len(super_column.columns) - assert 'country' == super_column.columns[0].name - assert 'Canada' == super_column.columns[0].value + assert 'country'.encode() == super_column.columns[0].name + assert 'Canada'.encode() == super_column.columns[0].value - assert 'name' == super_column.columns[1].name - assert 'Mina' == super_column.columns[1].value + assert 'name'.encode() == super_column.columns[1].name + assert 'Mina'.encode() == super_column.columns[1].value # add a 'region' subcolumn - column = Column(name='region', value='Quebec', timestamp=100) + column = Column(name='region'.encode(), value='Quebec'.encode(), timestamp=100) client.batch_mutate( - {'mina': {'Users': [Mutation(ColumnOrSuperColumn(super_column=SuperColumn('attrs', [column])))]}}, + {'mina'.encode(): {'Users': [Mutation(ColumnOrSuperColumn(super_column=SuperColumn('attrs'.encode(), [column])))]}}, ThriftConsistencyLevel.ONE) - super_columns = client.get_slice('mina', column_parent, predicate, ThriftConsistencyLevel.ONE) + super_columns = client.get_slice('mina'.encode(), column_parent, predicate, ThriftConsistencyLevel.ONE) assert 1 == len(super_columns) super_column = super_columns[0].super_column - assert 'attrs' == super_column.name + assert 'attrs'.encode() == super_column.name assert 3 == len(super_column.columns) - assert 'country' == super_column.columns[0].name - assert 'Canada' == super_column.columns[0].value + assert 'country'.encode() == super_column.columns[0].name + assert 'Canada'.encode() == super_column.columns[0].value - assert 'name' == super_column.columns[1].name - assert 'Mina' == super_column.columns[1].value + assert 'name'.encode() == super_column.columns[1].name + assert 'Mina'.encode() == super_column.columns[1].value - assert 'region' == super_column.columns[2].name - assert 'Quebec' == super_column.columns[2].value + assert 'region'.encode() == super_column.columns[2].name + assert 'Quebec'.encode() == super_column.columns[2].value diff --git a/thrift_test.py b/thrift_test.py index 0990d7141b..b9992915d3 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -4,7 +4,6 @@ import uuid import pytest import logging -import codecs from thrift.protocol import TBinaryProtocol from thrift.Thrift import TApplicationException @@ -32,9 +31,6 @@ since = pytest.mark.since logger = logging.getLogger(__name__) -utf8encoder = codecs.getencoder('utf-8') -def utf8encode(str): - return utf8encoder(str)[0] def get_thrift_client(host='127.0.0.1', port=9160): socket = TSocket.TSocket(host, port) @@ -98,8 +94,8 @@ def define_schema(self): cf_defs=[ Cassandra.CfDef('Keyspace1', 'Standard1'), Cassandra.CfDef('Keyspace1', 'Standard2'), - Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef(utf8encode('c1'), 'AsciiType'), Cassandra.ColumnDef(utf8encode('c2'), 'AsciiType')]), - Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef(utf8encode('c1'), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef(''.encode(), 'AsciiType'), Cassandra.ColumnDef(''.encode(), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef(''.encode(), 'AsciiType')]), Cassandra.CfDef('Keyspace1', 'StandardLong1', comparator_type='LongType'), Cassandra.CfDef('Keyspace1', 'StandardInteger1', comparator_type='IntegerType'), Cassandra.CfDef('Keyspace1', 'StandardComposite', comparator_type='CompositeType(AsciiType, AsciiType)'), @@ -108,10 +104,10 @@ def define_schema(self): Cassandra.CfDef('Keyspace1', 'Super3', column_type='Super', comparator_type='LongType', subcomparator_type='UTF8Type'), Cassandra.CfDef('Keyspace1', 'Counter1', default_validation_class='CounterColumnType'), Cassandra.CfDef('Keyspace1', 'SuperCounter1', column_type='Super', default_validation_class='CounterColumnType'), - Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef(utf8encode('birthdate'), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), + Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef(''.encode(), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), Cassandra.CfDef('Keyspace1', 'Indexed2', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'LongType', Cassandra.IndexType.KEYS)]), Cassandra.CfDef('Keyspace1', 'Indexed3', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'UTF8Type', Cassandra.IndexType.KEYS)]), - Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef(utf8encode('a'), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef(utf8encode('z'), 'UTF8Type')]), + Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef(''.encode(), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef(''.encode(), 'UTF8Type')]), Cassandra.CfDef('Keyspace1', 'Expiring', default_time_to_live=2) ]) @@ -163,11 +159,11 @@ def _i16(n): return struct.pack('>h', n) # big endian = network order -_SIMPLE_COLUMNS = [Column(utf8encode('c1'), utf8encode('value1'), 0), - Column(utf8encode('c2'), utf8encode('value2'), 0)] -_SUPER_COLUMNS = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), - SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 0), - Column(_i64(6), utf8encode('value6'), 0)])] +_SIMPLE_COLUMNS = [Column(''.encode(), ''.encode(), 0), + Column(''.encode(), ''.encode(), 0)] +_SUPER_COLUMNS = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), + SuperColumn(name=''.encode(), columns=[Column(_i64(5), ''.encode(), 0), + Column(_i64(6), ''.encode(), 0)])] def _assert_column(column_family, key, column, value, ts=0): @@ -202,7 +198,7 @@ def _assert_no_columnpath(key, column_path): def _insert_simple(): - return _insert_multi([utf8encode('key1')]) + return _insert_multi([''.encode()]) def _insert_multi(keys): @@ -210,75 +206,75 @@ def _insert_multi(keys): for key in keys: if isinstance(key, str): key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c2'), utf8encode('value2'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) def _insert_batch(): cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS], 'Standard2': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS]} - client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) def _big_slice(key, column_parent): if isinstance(key, str): key = utf8encode(key) - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) return client.get_slice(key, column_parent, p, ConsistencyLevel.ONE) def _big_multislice(keys, column_parent): - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) return client.multiget_slice(keys, column_parent, p, ConsistencyLevel.ONE) def _verify_batch(): _verify_simple() L = [result.column - for result in _big_slice(utf8encode('key1'), ColumnParent('Standard2'))] + for result in _big_slice(''.encode(), ColumnParent('Standard2'))] assert L == _SIMPLE_COLUMNS, L def _verify_simple(): - assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE).column == Column(utf8encode('c1'), utf8encode('value1'), 0) + assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column == Column(''.encode(), ''.encode(), 0) L = [result.column - for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + for result in _big_slice(''.encode(), ColumnParent('Standard1'))] assert L == _SIMPLE_COLUMNS, L def _insert_super(key='key1'): if isinstance(key, str): key = utf8encode(key) - client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', utf8encode('sc2')), Column(_i64(6), utf8encode('value6'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(6), ''.encode(), 0), ConsistencyLevel.ONE) def _insert_range(): - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c2'), utf8encode('value2'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) def _verify_range(): - p = SlicePredicate(slice_range=SliceRange(utf8encode('c1'), utf8encode('c2'), False, 1000)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == utf8encode('c1') - assert result[1].column.name == utf8encode('c2') + assert result[0].column.name == ''.encode() + assert result[1].column.name == ''.encode() - p = SlicePredicate(slice_range=SliceRange(utf8encode('c3'), utf8encode('c2'), True, 1000)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1000)) + result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == utf8encode('c3') - assert result[1].column.name == utf8encode('c2') + assert result[0].column.name == ''.encode() + assert result[1].column.name == ''.encode() - p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 1000)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 2)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) + result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -287,31 +283,31 @@ def _set_keyspace(keyspace): def _insert_super_range(): - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(6), utf8encode('value6'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc3')), Column(_i64(7), utf8encode('value7'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(6), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(7), ''.encode(), 0), ConsistencyLevel.ONE) time.sleep(0.1) def _verify_super_range(): - p = SlicePredicate(slice_range=SliceRange(utf8encode('sc2'), utf8encode('sc3'), False, 2)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) + result = client.get_slice(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == utf8encode('sc2') - assert result[1].super_column.name == utf8encode('sc3') + assert result[0].super_column.name == ''.encode() + assert result[1].super_column.name == ''.encode() - p = SlicePredicate(slice_range=SliceRange(utf8encode('sc3'), utf8encode('sc2'), True, 2)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 2)) + result = client.get_slice(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == utf8encode('sc3') - assert result[1].super_column.name == utf8encode('sc2') + assert result[0].super_column.name == ''.encode() + assert result[1].super_column.name == ''.encode() def _verify_super(supercf='Super1', key='key1'): if isinstance(key, str): key = utf8encode(key) - assert client.get(key, ColumnPath(supercf, utf8encode('sc1'), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), utf8encode('value4'), 0) + assert client.get(key, ColumnPath(supercf, ''.encode(), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), ''.encode(), 0) slice = [result.super_column for result in _big_slice(key, ColumnParent('Super1'))] assert slice == _SUPER_COLUMNS, slice @@ -339,23 +335,23 @@ def _insert_six_columns(key='abc'): if isinstance(key, str): key = utf8encode(key) CL = ConsistencyLevel.ONE - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('a'), utf8encode('1'), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('b'), utf8encode('2'), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c'), utf8encode('3'), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('d'), utf8encode('4'), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('e'), utf8encode('5'), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(utf8encode('f'), utf8encode('6'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) def _big_multi_slice(key='abc'): if isinstance(key, str): key = utf8encode(key) c1 = ColumnSlice() - c1.start = utf8encode('a') - c1.finish = utf8encode('c') + c1.start = ''.encode() + c1.finish = ''.encode() c2 = ColumnSlice() - c2.start = utf8encode('e') - c2.finish = utf8encode('f') + c2.start = ''.encode() + c2.finish = ''.encode() m = MultiSliceRequest() m.key = key m.column_parent = ColumnParent('Standard1') @@ -366,7 +362,7 @@ def _big_multi_slice(key='abc'): return client.get_multi_slice(m) -_MULTI_SLICE_COLUMNS = [Column(utf8encode('a'), utf8encode('1'), 0), Column(utf8encode('b'), utf8encode('2'), 0), Column(utf8encode('c'), utf8encode('3'), 0), Column(utf8encode('e'), utf8encode('5'), 0), Column(utf8encode('f'), utf8encode('6'), 0)] +_MULTI_SLICE_COLUMNS = [Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)] @since('2.0', max_version='4') @@ -385,15 +381,15 @@ def test_insert(self): def test_empty_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Standard2', 'Super1') - assert _big_slice(utf8encode('key1'), ColumnParent('Standard2')) == [] - assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] + assert _big_slice(''.encode(), ColumnParent('Standard2')) == [] + assert _big_slice(''.encode(), ColumnParent('Super1')) == [] def test_cas(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Standard3', 'Standard4') def cas(expected, updates, column_family): - return client.cas(utf8encode('key1'), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) + return client.cas(''.encode(), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) def test_cas_operations(first_columns, second_columns, column_family): # partition should be empty, so cas expecting any existing values should fail @@ -404,7 +400,7 @@ def test_cas_operations(first_columns, second_columns, column_family): # cas of empty columns -> first_columns should succeed # and the reading back from the table should match first_columns assert cas([], first_columns, column_family).success - result = [cosc.column for cosc in _big_slice(utf8encode('key1'), ColumnParent(column_family))] + result = [cosc.column for cosc in _big_slice(''.encode(), ColumnParent(column_family))] # CAS will use its own timestamp, so we can't just compare result == _SIMPLE_COLUMNS assert dict((c.name, c.value) for c in result) == dict((ex.name, ex.value) for ex in first_columns) @@ -416,7 +412,7 @@ def test_cas_operations(first_columns, second_columns, column_family): assert dict((c.name, c.value) for c in cas_result.current_values) == {first_columns[0].name: first_columns[0].value}, cas_result # CL.SERIAL for reads - assert client.get(utf8encode('key1'), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value + assert client.get(''.encode(), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value # cas first_columns -> second_columns should succeed assert cas(first_columns, second_columns, column_family).success @@ -425,8 +421,8 @@ def test_cas_operations(first_columns, second_columns, column_family): cas_result = cas(first_columns, second_columns, column_family) assert not cas_result.success - updated_columns = [Column(utf8encode('c1'), utf8encode('value101'), 1), - Column(utf8encode('c2'), utf8encode('value102'), 1)] + updated_columns = [Column(''.encode(), ''.encode(), 1), + Column(''.encode(), ''.encode(), 1)] logger.debug("Testing CAS operations on dynamic cf") test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard1') @@ -439,9 +435,9 @@ def test_missing_super(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1'), _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(1)), ConsistencyLevel.ONE)) _insert_super() - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1'), _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(1)), ConsistencyLevel.ONE)) def test_count(self): _set_keyspace('Keyspace1') @@ -449,19 +445,19 @@ def test_count(self): _insert_simple() _insert_super() - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) - assert client.get_count(utf8encode('key1'), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 - assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 - assert client.get_count(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE) == 2 - assert client.get_count(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + assert client.get_count(''.encode(), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 + assert client.get_count(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 + assert client.get_count(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE) == 2 + assert client.get_count(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 # Let's make that a little more interesting - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c4'), utf8encode('value4'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c5'), utf8encode('value5'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(utf8encode('c2'), utf8encode('c4'), False, 1000)) - assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + assert client.get_count(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 def test_count_paging(self): _set_keyspace('Keyspace1') @@ -474,14 +470,14 @@ def test_count_paging(self): # Paging for small columns starts at 1024 columns columns_to_insert = [Column(utf8encode('c%d' % (i,)), utf8encode('value%d' % (i,)), 0) for i in range(3, 1026)] cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in columns_to_insert]} - client.batch_mutate({utf8encode('key1') : cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({''.encode() : cfmap}, ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 2000)) - assert client.get_count(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE) == 1025 + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2000)) + assert client.get_count(''.encode(), column_parent, p, ConsistencyLevel.ONE) == 1025 # Ensure that the count limit isn't clobbered - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 10)) - assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 10)) + assert client.get_count(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 # test get_count() to work correctly with 'count' settings around page size (CASSANDRA-4833) def test_count_around_page_size(self): @@ -489,14 +485,14 @@ def test_count_around_page_size(self): self.truncate_all('Standard1') def slice_predicate(count): - return SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, count)) + return SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, count)) - key = utf8encode('key1') + key = ''.encode() parent = ColumnParent('Standard1') cl = ConsistencyLevel.ONE for i in range(0, 3050): - client.insert(key, parent, Column(utf8encode(str(i)), utf8encode(''), 0), cl) + client.insert(key, parent, Column(utf8encode(str(i)), ''.encode(), 0), cl) # same as page size assert client.get_count(key, parent, slice_predicate(1024), cl) == 1024 @@ -525,22 +521,22 @@ def test_super_get(self): self.truncate_all('Super1') _insert_super() - result = client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2')), ConsistencyLevel.ONE).super_column + result = client.get(''.encode(), ColumnPath('Super1', ''.encode()), ConsistencyLevel.ONE).super_column assert result == _SUPER_COLUMNS[1], result def test_super_subcolumn_limit(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') _insert_super() - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) - column_parent = ColumnParent('Super1', utf8encode('sc2')) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) + column_parent = ColumnParent('Super1', ''.encode()) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(5), utf8encode('value5'), 0)], slice - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), True, 1)) + for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(5), ''.encode(), 0)], slice + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1)) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(6), utf8encode('value6'), 0)], slice + for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(6), ''.encode(), 0)], slice def test_long_order(self): _set_keyspace('Keyspace1') @@ -554,9 +550,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(0, 104294967296, 429496729): name = _i64(i) - client.insert(utf8encode('key1'), ColumnParent('StandardLong1'), Column(name, utf8encode('v'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('StandardLong1'), Column(name, ''.encode(), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice(utf8encode('key1'), ColumnParent('StandardLong1'))] + slice = [result.column.name for result in _big_slice(''.encode(), ColumnParent('StandardLong1'))] assert slice == L, slice def test_integer_order(self): @@ -571,9 +567,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(104294967296, 0, 429496729): name = _i64(i) - client.insert(utf8encode('key1'), ColumnParent('StandardInteger1'), Column(name, utf8encode('v'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('StandardInteger1'), Column(name, ''.encode(), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice(utf8encode('key1'), ColumnParent('StandardInteger1'))] + slice = [result.column.name for result in _big_slice(''.encode(), ColumnParent('StandardInteger1'))] L.sort() assert slice == L, slice @@ -587,79 +583,79 @@ def test_time_uuid(self): # 100 isn't enough to fail reliably if the comparator is borked for i in range(500): L.append(uuid.uuid1()) - client.insert(utf8encode('key1'), ColumnParent('Super4', utf8encode('sc1')), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) - slice = _big_slice(utf8encode('key1'), ColumnParent('Super4', utf8encode('sc1'))) + client.insert(''.encode(), ColumnParent('Super4', ''.encode()), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) + slice = _big_slice(''.encode(), ColumnParent('Super4', ''.encode())) assert len(slice) == 500, len(slice) for i in range(500): u = slice[i].column assert u.value == utf8encode('value%s' % i) assert u.name == L[i].bytes - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), True, 1)) - column_parent = ColumnParent('Super4', utf8encode('sc1')) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1)) + column_parent = ColumnParent('Super4', ''.encode()) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[-1].bytes, utf8encode('value499'), 499)], slice + for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[-1].bytes, ''.encode(), 499)], slice - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), L[2].bytes, False, 1000)) - column_parent = ColumnParent('Super4', utf8encode('sc1')) + p = SlicePredicate(slice_range=SliceRange(''.encode(), L[2].bytes, False, 1000)) + column_parent = ColumnParent('Super4', ''.encode()) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[0].bytes, utf8encode('value0'), 0), - Column(L[1].bytes, utf8encode('value1'), 1), - Column(L[2].bytes, utf8encode('value2'), 2)], slice + for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[0].bytes, ''.encode(), 0), + Column(L[1].bytes, ''.encode(), 1), + Column(L[2].bytes, ''.encode(), 2)], slice - p = SlicePredicate(slice_range=SliceRange(L[2].bytes, utf8encode(''), True, 1000)) - column_parent = ColumnParent('Super4', utf8encode('sc1')) + p = SlicePredicate(slice_range=SliceRange(L[2].bytes, ''.encode(), True, 1000)) + column_parent = ColumnParent('Super4', ''.encode()) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, utf8encode('value2'), 2), - Column(L[1].bytes, utf8encode('value1'), 1), - Column(L[0].bytes, utf8encode('value0'), 0)], slice + for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, ''.encode(), 2), + Column(L[1].bytes, ''.encode(), 1), + Column(L[0].bytes, ''.encode(), 0)], slice - p = SlicePredicate(slice_range=SliceRange(L[2].bytes, utf8encode(''), False, 1)) - column_parent = ColumnParent('Super4', utf8encode('sc1')) + p = SlicePredicate(slice_range=SliceRange(L[2].bytes, ''.encode(), False, 1)) + column_parent = ColumnParent('Super4', ''.encode()) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, utf8encode('value2'), 2)], slice + for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, ''.encode(), 2)], slice def test_long_remove(self): _set_keyspace('Keyspace1') self.truncate_all('StandardLong1') column_parent = ColumnParent('StandardLong1') - sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) for i in range(10): parent = ColumnParent('StandardLong1') - client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value1'), 10 * i), ConsistencyLevel.ONE) - client.remove(utf8encode('key1'), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE) + client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i), ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value2'), 10 * i + 2), ConsistencyLevel.ONE) + client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), utf8encode('value2'), 10 * i + 2)], (slice, i) + for result in client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), ''.encode(), 10 * i + 2)], (slice, i) def test_integer_remove(self): _set_keyspace('Keyspace1') self.truncate_all('StandardInteger1') column_parent = ColumnParent('StandardInteger1') - sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) for i in range(10): parent = ColumnParent('StandardInteger1') - client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value1'), 10 * i), ConsistencyLevel.ONE) - client.remove(utf8encode('key1'), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE) + client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i), ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value2'), 10 * i + 2), ConsistencyLevel.ONE) + client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), utf8encode('value2'), 10 * i + 2)], (slice, i) + for result in client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), ''.encode(), 10 * i + 2)], (slice, i) def test_batch_insert(self): _set_keyspace('Keyspace1') @@ -681,7 +677,7 @@ def test_batch_mutate_standard_columns(self): for column_family in column_families: for key in keys: - _assert_column(column_family, key, utf8encode('c1'), utf8encode('value1')) + _assert_column(column_family, key, ''.encode(), ''.encode()) def test_batch_mutate_remove_standard_columns(self): _set_keyspace('Keyspace1') @@ -813,51 +809,51 @@ def test_batch_mutate_remove_slice_standard(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - columns = [Column(utf8encode('c1'), utf8encode('value1'), 0), - Column(utf8encode('c2'), utf8encode('value2'), 0), - Column(utf8encode('c3'), utf8encode('value3'), 0), - Column(utf8encode('c4'), utf8encode('value4'), 0), - Column(utf8encode('c5'), utf8encode('value5'), 0)] + columns = [Column(''.encode(), ''.encode(), 0), + Column(''.encode(), ''.encode(), 0), + Column(''.encode(), ''.encode(), 0), + Column(''.encode(), ''.encode(), 0), + Column(''.encode(), ''.encode(), 0)] for column in columns: - client.insert(utf8encode('key'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=utf8encode('c2'), finish=utf8encode('c4')))) - client.batch_mutate({utf8encode('key'): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode()))) + client.batch_mutate({''.encode(): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c1'))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c2'))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c3'))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c4'))) - _assert_columnpath_exists(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c5'))) + _assert_columnpath_exists(''.encode(), ColumnPath('Standard1', column=''.encode())) + _assert_no_columnpath(''.encode(), ColumnPath('Standard1', column=''.encode())) + _assert_no_columnpath(''.encode(), ColumnPath('Standard1', column=''.encode())) + _assert_no_columnpath(''.encode(), ColumnPath('Standard1', column=''.encode())) + _assert_columnpath_exists(''.encode(), ColumnPath('Standard1', column=''.encode())) # known failure: see CASSANDRA-10046 def test_batch_mutate_remove_slice_of_entire_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(1), utf8encode('value1'), 0)]), - SuperColumn(name=utf8encode('sc2'), - columns=[Column(_i64(2), utf8encode('value2') , 0), Column(_i64(3), utf8encode('value3') , 0)]), - SuperColumn(name=utf8encode('sc3'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), - SuperColumn(name=utf8encode('sc4'), - columns=[Column(_i64(5), utf8encode('value5') , 0), Column(_i64(6), utf8encode('value6') , 0)]), - SuperColumn(name=utf8encode('sc5'), columns=[Column(_i64(7), utf8encode('value7'), 0)])] + columns = [SuperColumn(name=''.encode(), columns=[Column(_i64(1), ''.encode(), 0)]), + SuperColumn(name=''.encode(), + columns=[Column(_i64(2), ''.encode() , 0), Column(_i64(3), ''.encode() , 0)]), + SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), + SuperColumn(name=''.encode(), + columns=[Column(_i64(5), ''.encode() , 0), Column(_i64(6), ''.encode() , 0)]), + SuperColumn(name=''.encode(), columns=[Column(_i64(7), ''.encode(), 0)])] for column in columns: for subcolumn in column.columns: - client.insert(utf8encode('key'), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=utf8encode('sc2') , finish=utf8encode('sc4') ))) - client.batch_mutate({utf8encode('key'): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=''.encode() , finish=''.encode() ))) + client.batch_mutate({''.encode(): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(1))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc2'), column=_i64(2))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc2'), column=_i64(3))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc3'), column=_i64(4))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc4'), column=_i64(5))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc4'), column=_i64(6))) - _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc5'), column=_i64(7))) + _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(1))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(2))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(3))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(4))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(5))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(6))) + _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(7))) @since('1.0', '2.2') @pytest.mark.skip(reason="Runs but fails and looks like it actually should fail since 8099?") @@ -865,49 +861,49 @@ def test_batch_mutate_remove_slice_part_of_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [Column(_i64(1), utf8encode('value1'), 0), - Column(_i64(2), utf8encode('value2'), 0), - Column(_i64(3), utf8encode('value3'), 0), - Column(_i64(4), utf8encode('value4'), 0), - Column(_i64(5), utf8encode('value5'), 0)] + columns = [Column(_i64(1), ''.encode(), 0), + Column(_i64(2), ''.encode(), 0), + Column(_i64(3), ''.encode(), 0), + Column(_i64(4), ''.encode(), 0), + Column(_i64(5), ''.encode(), 0)] for column in columns: - client.insert(utf8encode('key'), ColumnParent('Super1', utf8encode('sc1')), column, ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), column, ConsistencyLevel.ONE) r = SliceRange(start=_i64(2), finish=_i64(4)) - d = Deletion(1, super_column=utf8encode('sc1') , predicate=SlicePredicate(slice_range=r)) - client.batch_mutate({utf8encode('key'): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, super_column=''.encode() , predicate=SlicePredicate(slice_range=r)) + client.batch_mutate({''.encode(): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(1))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(2))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(3))) - _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(4))) - _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(5))) + _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(1))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(2))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(3))) + _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(4))) + _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(5))) def test_batch_mutate_insertions_and_deletions(self): _set_keyspace('Keyspace1') self.truncate_all('Super1', 'Super2') - first_insert = SuperColumn(utf8encode("sc1"), - columns=[Column(_i64(20), utf8encode('value20'), 3), - Column(_i64(21), utf8encode('value21'), 3)]) - second_insert = SuperColumn(utf8encode("sc1"), - columns=[Column(_i64(20), utf8encode('value20'), 3), - Column(_i64(21), utf8encode('value21'), 3)]) - first_deletion = {'super_column': utf8encode("sc1"), + first_insert = SuperColumn('sc1'.encode(), + columns=[Column(_i64(20), ''.encode(), 3), + Column(_i64(21), ''.encode(), 3)]) + second_insert = SuperColumn('sc1'.encode(), + columns=[Column(_i64(20), ''.encode(), 3), + Column(_i64(21), ''.encode(), 3)]) + first_deletion = {'super_column': 'sc1'.encode(), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - second_deletion = {'super_column': utf8encode("sc2"), + second_deletion = {'super_column': 'sc2'.encode(), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - keys = [utf8encode('key_30'), utf8encode('key_31')] + keys = [''.encode(), ''.encode()] for key in keys: - sc = SuperColumn(utf8encode('sc1'), [Column(_i64(22), utf8encode('value22'), 0), - Column(_i64(23), utf8encode('value23'), 0)]) + sc = SuperColumn(''.encode(), [Column(_i64(22), ''.encode(), 0), + Column(_i64(23), ''.encode(), 0)]) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=sc))]} client.batch_mutate({key: cfmap}, ConsistencyLevel.ONE) - sc2 = SuperColumn(utf8encode('sc2'), [Column(_i64(22), utf8encode('value22'), 0), - Column(_i64(23), utf8encode('value23'), 0)]) + sc2 = SuperColumn(''.encode(), [Column(_i64(22), ''.encode(), 0), + Column(_i64(23), ''.encode(), 0)]) cfmap2 = {'Super2': [Mutation(ColumnOrSuperColumn(super_column=sc2))]} client.batch_mutate({key: cfmap2}, ConsistencyLevel.ONE) @@ -924,18 +920,18 @@ def test_batch_mutate_insertions_and_deletions(self): for key in keys: for c in [_i64(22), _i64(23)]: - _assert_no_columnpath(key, ColumnPath('Super1', super_column=utf8encode('sc1'), column=c)) - _assert_no_columnpath(key, ColumnPath('Super2', super_column=utf8encode('sc2'), column=c)) + _assert_no_columnpath(key, ColumnPath('Super1', super_column=''.encode(), column=c)) + _assert_no_columnpath(key, ColumnPath('Super2', super_column=''.encode(), column=c)) for c in [_i64(20), _i64(21)]: - _assert_columnpath_exists(key, ColumnPath('Super1', super_column=utf8encode('sc1'), column=c)) - _assert_columnpath_exists(key, ColumnPath('Super2', super_column=utf8encode('sc1'), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super1', super_column=''.encode(), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super2', super_column=''.encode(), column=c)) def test_bad_system_calls(self): def duplicate_index_names(): _set_keyspace('Keyspace1') - cd1 = ColumnDef(utf8encode('foo'), 'BytesType', IndexType.KEYS, 'i') - cd2 = ColumnDef(utf8encode('bar'), 'BytesType', IndexType.KEYS, 'i') + cd1 = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'i') + cd2 = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'i') cf = CfDef('Keyspace1', 'BadCF', column_metadata=[cd1, cd2]) client.system_add_column_family(cf) _expect_exception(duplicate_index_names, InvalidRequestException) @@ -944,33 +940,33 @@ def test_bad_batch_calls(self): # mutate_does_not_accept_cosc_and_deletion_in_same_mutation def too_full(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column(utf8encode("foo"), utf8encode('bar'), 0)) - dele = Deletion(2, predicate=SlicePredicate(column_names=[utf8encode('baz')])) - client.batch_mutate({utf8encode('key_34'): {'Standard1': [Mutation(col, dele)]}}, + col = ColumnOrSuperColumn(column=Column('foo'.encode(), ''.encode(), 0)) + dele = Deletion(2, predicate=SlicePredicate(column_names=[''.encode()])) + client.batch_mutate({''.encode(): {'Standard1': [Mutation(col, dele)]}}, ConsistencyLevel.ONE) _expect_exception(too_full, InvalidRequestException) # test_batch_mutate_does_not_accept_cosc_on_undefined_cf: def bad_cf(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column(utf8encode("foo"), utf8encode('bar'), 0)) - client.batch_mutate({utf8encode('key_36'): {'Undefined': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column('foo'.encode(), ''.encode(), 0)) + client.batch_mutate({''.encode(): {'Undefined': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf, InvalidRequestException) # test_batch_mutate_does_not_accept_deletion_on_undefined_cf def bad_cf_2(): _set_keyspace('Keyspace1') - d = Deletion(2, predicate=SlicePredicate(column_names=[utf8encode('baz')])) - client.batch_mutate({utf8encode('key_37'): {'Undefined': [Mutation(deletion=d)]}}, + d = Deletion(2, predicate=SlicePredicate(column_names=[''.encode()])) + client.batch_mutate({''.encode(): {'Undefined': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf_2, InvalidRequestException) # a column value that does not match the declared validator def send_string_instead_of_long(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column(utf8encode('birthdate'), utf8encode('bar'), 0)) - client.batch_mutate({utf8encode('key_38'): {'Indexed1': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column(''.encode(), ''.encode(), 0)) + client.batch_mutate({''.encode(): {'Indexed1': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(send_string_instead_of_long, InvalidRequestException) @@ -978,16 +974,16 @@ def test_column_name_lengths(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode(''), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 1), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 127), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 128), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 129), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 255), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 256), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 257), utf8encode('value'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), utf8encode('value'), 0), ConsistencyLevel.ONE) - _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 1), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 127), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 128), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 129), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 255), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 256), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 257), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), ''.encode(), 0), ConsistencyLevel.ONE) + _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) def test_bad_calls(self): _set_keyspace('Keyspace1') @@ -995,71 +991,71 @@ def test_bad_calls(self): # missing arguments _expect_exception(lambda: client.insert(None, None, None, None), TApplicationException) # supercolumn in a non-super CF - _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1', utf8encode('x')), Column(utf8encode('y'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1', ''.encode()), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) # no supercolumn in a super CF - _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Super1'), Column(utf8encode('y'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Super1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) # column but no supercolumn in remove - _expect_exception(lambda: client.remove(utf8encode('key1'), ColumnPath('Super1', column=utf8encode('x')), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove(''.encode(), ColumnPath('Super1', column=''.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) # super column in non-super CF - _expect_exception(lambda: client.remove(utf8encode('key1'), ColumnPath('Standard1', utf8encode('y'), utf8encode('x')), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove(''.encode(), ColumnPath('Standard1', ''.encode(), ''.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) # key too long - _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) # empty key - _expect_exception(lambda: client.get(utf8encode(''), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - _expect_exception(lambda: client.batch_mutate({utf8encode(''): cfmap}, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE), InvalidRequestException) # empty column name - _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('')), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify column name - _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) # supercolumn in a non-super CF - _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', utf8encode('x'), utf8encode('y')), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', ''.encode(), ''.encode()), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify supercolumn name - _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(''.encode(), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) # invalid CF - _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=[utf8encode(''), utf8encode('')]), utf8encode(''), utf8encode(''), 5, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE), InvalidRequestException) # 'x' is not a valid Long - _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), Column(utf8encode('x'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long - p = SlicePredicate(slice_range=SliceRange(utf8encode('x'), utf8encode(''), False, 1)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long, supercolumn version - p = SlicePredicate(slice_range=SliceRange(utf8encode('x'), utf8encode(''), False, 1)) - column_parent = ColumnParent('Super1', utf8encode('sc1')) - _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) + column_parent = ColumnParent('Super1', ''.encode()) + _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, supercolumn version p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) - column_parent = ColumnParent('Super1', utf8encode('sc1')) - _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), + column_parent = ColumnParent('Super1', ''.encode()) + _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, key version - _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('')]), utf8encode('z'), utf8encode('a'), 1, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE), InvalidRequestException) # ttl must be greater or equals to zero - column = Column(utf8encode('cttl1'), utf8encode('value1'), 0, -1) - _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), + column = Column(''.encode(), ''.encode(), 0, -1) + _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), InvalidRequestException) # don't allow super_column in Deletion for standard Columntest_expiration_with_default_ttl_and_zero_ttl - deletion = Deletion(1, utf8encode('supercolumn'), None) + deletion = Deletion(1, ''.encode(), None) mutation = Mutation(deletion=deletion) - mutations = {utf8encode('key'): {'Standard1': [mutation]}} + mutations = {''.encode(): {'Standard1': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # 'x' is not a valid long - deletion = Deletion(1, utf8encode('x'), None) + deletion = Deletion(1, ''.encode(), None) mutation = Mutation(deletion=deletion) - mutations = {utf8encode('key'): {'Super3': [mutation]}} + mutations = {''.encode(): {'Super3': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # counters don't support ANY - _expect_exception(lambda: client.add(utf8encode('key1'), ColumnParent('Counter1', utf8encode('x')), CounterColumn(utf8encode('y'), 1), ConsistencyLevel.ANY), InvalidRequestException) + _expect_exception(lambda: client.add(''.encode(), ColumnParent('Counter1', ''.encode()), CounterColumn(''.encode(), 1), ConsistencyLevel.ANY), InvalidRequestException) def test_batch_insert_super(self): _set_keyspace('Keyspace1') @@ -1069,7 +1065,7 @@ def test_batch_insert_super(self): for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) _verify_super('Super1') _verify_super('Super2') @@ -1078,30 +1074,30 @@ def test_cf_remove_column(self): self.truncate_all('Standard1') _insert_simple() - client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE)) - assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c2')), ConsistencyLevel.ONE).column \ - == Column(utf8encode('c2'), utf8encode('value2'), 0) - assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) \ - == [ColumnOrSuperColumn(column=Column(utf8encode('c2'), utf8encode('value2'), 0))] + client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) + assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column \ + == Column(''.encode(), ''.encode(), 0) + assert _big_slice(''.encode(), ColumnParent('Standard1')) \ + == [ColumnOrSuperColumn(column=Column(''.encode(), ''.encode(), 0))] # New insert, make sure it shows up post-remove: - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] - assert columns == [Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns + for result in _big_slice(''.encode(), ColumnParent('Standard1'))] + assert columns == [Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)], columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] - assert columns == [Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns + for result in _big_slice(''.encode(), ColumnParent('Standard1'))] + assert columns == [Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)], columns # Next, w/ a newer timestamp; it should come back: - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 2), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 2), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] - assert columns == [Column(utf8encode('c1'), utf8encode('value1'), 2), Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns + for result in _big_slice(''.encode(), ColumnParent('Standard1'))] + assert columns == [Column(''.encode(), ''.encode(), 2), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)], columns def test_cf_remove(self): _set_keyspace('Keyspace1') @@ -1111,36 +1107,36 @@ def test_cf_remove(self): _insert_super() # Remove the key1:Standard1 cf; verify super is unaffected - client.remove(utf8encode('key1'), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) - assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] + client.remove(''.encode(), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) + assert _big_slice(''.encode(), ColumnParent('Standard1')) == [] _verify_super() # Test resurrection. First, re-insert a value w/ older timestamp, # and make sure it stays removed: - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) - assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + assert _big_slice(''.encode(), ColumnParent('Standard1')) == [] # Next, w/ a newer timestamp; it should come back: - client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 4), ConsistencyLevel.ONE) - result = _big_slice(utf8encode('key1'), ColumnParent('Standard1')) - assert result == [ColumnOrSuperColumn(column=Column(utf8encode('c1'), utf8encode('value1'), 4))], result + client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 4), ConsistencyLevel.ONE) + result = _big_slice(''.encode(), ColumnParent('Standard1')) + assert result == [ColumnOrSuperColumn(column=Column(''.encode(), ''.encode(), 4))], result # check removing the entire super cf, too. - client.remove(utf8encode('key1'), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) - assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] - assert _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1'))) == [] + client.remove(''.encode(), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) + assert _big_slice(''.encode(), ColumnParent('Super1')) == [] + assert _big_slice(''.encode(), ColumnParent('Super1', ''.encode())) == [] def test_super_cf_remove_and_range_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - client.insert(utf8encode('key3'), ColumnParent('Super1', utf8encode('sc1')), Column(_i64(1), utf8encode('v1'), 0), ConsistencyLevel.ONE) - client.remove(utf8encode('key3'), ColumnPath('Super1', utf8encode('sc1')), 5, ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(1), ''.encode(), 0), ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('Super1', ''.encode()), 5, ConsistencyLevel.ONE) rows = {} - for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE): + for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE): scs = [cosc.super_column for cosc in row.columns] rows[row.key] = scs - assert rows == {utf8encode('key3'): []}, rows + assert rows == {''.encode(): []}, rows def test_super_cf_remove_column(self): _set_keyspace('Keyspace1') @@ -1150,42 +1146,42 @@ def test_super_cf_remove_column(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), ConsistencyLevel.ONE)) - super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] - assert super_columns == [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), - SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(6), utf8encode('value6'), 0)])] + client.remove(''.encode(), ColumnPath('Super1', ''.encode(), _i64(5)), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(5)), ConsistencyLevel.ONE)) + super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] + assert super_columns == [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), + SuperColumn(name=''.encode(), columns=[Column(_i64(6), ''.encode(), 0)])] _verify_simple() # New insert, make sure it shows up post-remove: - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(7), utf8encode('value7'), 0), ConsistencyLevel.ONE) - super_columns_expected = [SuperColumn(name=utf8encode('sc1'), - columns=[Column(_i64(4), utf8encode('value4'), 0)]), - SuperColumn(name=utf8encode('sc2'), - columns=[Column(_i64(6), utf8encode('value6'), 0), Column(_i64(7), utf8encode('value7'), 0)])] + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(7), ''.encode(), 0), ConsistencyLevel.ONE) + super_columns_expected = [SuperColumn(name=''.encode(), + columns=[Column(_i64(4), ''.encode(), 0)]), + SuperColumn(name=''.encode(), + columns=[Column(_i64(6), ''.encode(), 0), Column(_i64(7), ''.encode(), 0)])] - super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 0), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 6), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), - SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 6), - Column(_i64(6), utf8encode('value6'), 0), - Column(_i64(7), utf8encode('value7'), 0)])] + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 6), ConsistencyLevel.ONE) + super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), + SuperColumn(name=''.encode(), columns=[Column(_i64(5), ''.encode(), 6), + Column(_i64(6), ''.encode(), 0), + Column(_i64(7), ''.encode(), 0)])] assert super_columns == super_columns_expected, super_columns # shouldn't be able to specify a column w/o a super column for remove - cp = ColumnPath(column_family='Super1', column=utf8encode('sc2')) - e = _expect_exception(lambda: client.remove(utf8encode('key1'), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) + cp = ColumnPath(column_family='Super1', column=''.encode()) + e = _expect_exception(lambda: client.remove(''.encode(), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("column cannot be specified without") >= 0 def test_super_cf_remove_supercolumn(self): @@ -1196,66 +1192,66 @@ def test_super_cf_remove_supercolumn(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2')), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), ConsistencyLevel.ONE)) - super_columns = _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2'))) + client.remove(''.encode(), ColumnPath('Super1', ''.encode()), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(5)), ConsistencyLevel.ONE)) + super_columns = _big_slice(''.encode(), ColumnParent('Super1', ''.encode())) assert super_columns == [], super_columns - super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)])] + super_columns_expected = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)])] super_columns = [result.super_column - for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + for result in _big_slice(''.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns _verify_simple() # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 1), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 1), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + for result in _big_slice(''.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 6), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 6), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), - SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 6)])] + for result in _big_slice(''.encode(), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), + SuperColumn(name=''.encode(), columns=[Column(_i64(5), ''.encode(), 6)])] assert super_columns == super_columns_expected, super_columns # check slicing at the subcolumn level too - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) columns = [result.column - for result in client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE)] - assert columns == [Column(_i64(5), utf8encode('value5'), 6)], columns + for result in client.get_slice(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE)] + assert columns == [Column(_i64(5), ''.encode(), 6)], columns def test_super_cf_resurrect_subcolumn(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - key = utf8encode('vijay') - client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) + key = ''.encode() + client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 0), ConsistencyLevel.ONE) - client.remove(key, ColumnPath('Super1', utf8encode('sc1')), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super1', ''.encode()), 1, ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 2), ConsistencyLevel.ONE) - result = client.get(key, ColumnPath('Super1', utf8encode('sc1')), ConsistencyLevel.ONE) + result = client.get(key, ColumnPath('Super1', ''.encode()), ConsistencyLevel.ONE) assert result.super_column.columns is not None, result.super_column def test_empty_range(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Super1') - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] _insert_simple() - assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] @since('2.1') def test_super_cql_read_compatibility(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _insert_super(utf8encode("key1")) - _insert_super(utf8encode("key2")) + _insert_super('key1'.encode()) + _insert_super('key2'.encode()) node1 = self.cluster.nodelist()[0] session = self.patient_cql_connection(node1) @@ -1263,32 +1259,32 @@ def test_super_cql_read_compatibility(self): session.execute('USE "Keyspace1"') assert_all(session, "SELECT * FROM \"Super1\"", - [[utf8encode("key1"), utf8encode("sc1"), 4, utf8encode("value4")], - [utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], - [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")], - [utf8encode("key2"), utf8encode("sc1"), 4, utf8encode("value4")], - [utf8encode("key2"), utf8encode("sc2"), 5, utf8encode("value5")], - [utf8encode("key2"), utf8encode("sc2"), 6, utf8encode("value6")]]) + [['key1'.encode(), 'sc1'.encode(), 4, 'value4'.encode()], + ['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], + ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()], + ['key2'.encode(), 'sc1'.encode(), 4, 'value4'.encode()], + ['key2'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], + ['key2'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1')", - [[utf8encode("key1"), utf8encode("sc1"), 4, utf8encode("value4")], - [utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], - [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) + [['key1'.encode(), 'sc1'.encode(), 4, 'value4'.encode()], + ['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], + ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2')", - [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], - [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) + [['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], + ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2') AND column2 = 5", - [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")]]) + [['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], - [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) + [['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], + ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) assert_all(session, "SELECT column2, value FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [[5, utf8encode("value5")], - [6, utf8encode("value6")]]) + [[5, 'value5'.encode()], + [6, 'value6'.encode()]]) @since('2.1') def test_super_cql_write_compatibility(self): @@ -1308,36 +1304,36 @@ def test_super_cql_write_compatibility(self): session.execute(query, ("key2", "sc2", 5, "value5")) session.execute(query, ("key2", "sc2", 6, "value6")) - p = SlicePredicate(slice_range=SliceRange(utf8encode('sc1'), utf8encode('sc2'), False, 2)) - result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) + result = client.get_slice(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert_length_equal(result, 2) - assert result[0].super_column.name == utf8encode('sc1') - assert result[0].super_column.columns[0], Column(_i64(4), utf8encode('value4') == 1234) - assert result[1].super_column.name == utf8encode('sc2') - assert result[1].super_column.columns, [Column(_i64(5), utf8encode('value5'), 1234), Column(_i64(6), utf8encode('value6') == 1234)] + assert result[0].super_column.name == ''.encode() + assert result[0].super_column.columns[0], Column(_i64(4), ''.encode() == 1234) + assert result[1].super_column.name == ''.encode() + assert result[1].super_column.columns, [Column(_i64(5), ''.encode(), 1234), Column(_i64(6), ''.encode() == 1234)] def test_range_with_remove(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode('key1'), utf8encode(''), 1000, ConsistencyLevel.ONE)[0].key == utf8encode('key1') + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == ''.encode() - client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), 1, ConsistencyLevel.ONE) - client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c2')), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c2')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key=utf8encode('key1'))], actual + client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key=''.encode())], actual def test_range_with_remove_cf(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode('key1'), utf8encode(''), 1000, ConsistencyLevel.ONE)[0].key == utf8encode('key1') + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == ''.encode() - client.remove(utf8encode('key1'), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key=utf8encode('key1'))], actual + client.remove(''.encode(), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key=''.encode())], actual def test_range_collation(self): _set_keyspace('Keyspace1') @@ -1345,9 +1341,9 @@ def test_range_collation(self): for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(key, utf8encode('v'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(key, ''.encode(), 0), ConsistencyLevel.ONE) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) L = ['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '2', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '3', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '4', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '5', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '6', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '7', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '8', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '9', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', 'a', 'b'] assert len(slices) == len(L) for key, ks in zip(L, slices): @@ -1360,7 +1356,7 @@ def test_range_partial(self): for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(key, utf8encode('v'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(key, ''.encode(), 0), ConsistencyLevel.ONE) def check_slices_against_keys(keyList, sliceList): assert len(keyList) == len(sliceList), "%d vs %d" % (len(keyList), len(sliceList)) @@ -1368,16 +1364,16 @@ def check_slices_against_keys(keyList, sliceList): key = utf8encode(key) assert key == ks.key - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('a'), utf8encode(''), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['a', 'b'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode(''), utf8encode('15'), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('50'), utf8encode('51'), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['50', '51'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('1'), utf8encode(''), 10, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 10, ConsistencyLevel.ONE) check_slices_against_keys(['1', '10', '11', '12', '13', '14', '15', '16', '17', '18'], slices) def test_get_slice_range(self): @@ -1402,15 +1398,15 @@ def test_get_range_slices_tokens(self): key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: cnameutf = utf8encode(cname) - client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', ''.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', utf8encode('sc1')) - predicate = SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]) + cp = ColumnParent('Super3', ''.encode()) + predicate = SlicePredicate(column_names=[''.encode(), ''.encode()]) range = KeyRange(start_token='55', end_token='55', count=100) result = client.get_range_slices(cp, predicate, range, ConsistencyLevel.ONE) assert len(result) == 5 - assert result[0].columns[0].column.name == utf8encode('col1') - assert result[0].columns[1].column.name == utf8encode('col3') + assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[1].column.name == ''.encode() def test_get_range_slice_super(self): _set_keyspace('Keyspace2') @@ -1420,18 +1416,18 @@ def test_get_range_slice_super(self): key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: cnameutf = utf8encode(cname) - client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', ''.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', utf8encode('sc1')) - result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) + cp = ColumnParent('Super3', ''.encode()) + result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert result[0].columns[0].column.name == utf8encode('col1') - assert result[0].columns[1].column.name == utf8encode('col3') + assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[1].column.name == ''.encode() cp = ColumnParent('Super3') - result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('sc1')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert list(set(row.columns[0].super_column.name for row in result))[0] == utf8encode('sc1') + assert list(set(row.columns[0].super_column.name for row in result))[0] == ''.encode() def test_get_range_slice(self): _set_keyspace('Keyspace1') @@ -1445,52 +1441,52 @@ def test_get_range_slice(self): cp = ColumnParent('Standard1') # test empty slice - result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key6'), utf8encode(''), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 0 # test empty columns - result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('a')]), utf8encode('key2'), utf8encode(''), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 1 assert len(result[0].columns) == 0 # test column_names predicate - result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 3, result - assert result[0].columns[0].column.name == utf8encode('col1') - assert result[0].columns[1].column.name == utf8encode('col3') + assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[1].column.name == ''.encode() # row limiting via count. - result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 1 # test column slice predicate - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=5)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=False, count=5)), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].key == utf8encode('key1') - assert result[1].key == utf8encode('key2') + assert result[0].key == ''.encode() + assert result[1].key == ''.encode() assert len(result[0].columns) == 3 - assert result[0].columns[0].column.name == utf8encode('col2') - assert result[0].columns[2].column.name == utf8encode('col4') + assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[2].column.name == ''.encode() # col limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=2)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=False, count=2)), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) assert len(result[0].columns) == 2 # and reversed - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col4'), finish=utf8encode('col2'), reversed=True, count=5)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) - assert result[0].columns[0].column.name == utf8encode('col4') - assert result[0].columns[2].column.name == utf8encode('col2') + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=True, count=5)), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[2].column.name == ''.encode() # row limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=5)), utf8encode('key1'), utf8encode('key2'), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=False, count=5)), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 1 # removed data - client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('col1')), 1, ConsistencyLevel.ONE) - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 2, result - assert result[0].columns[0].column.name == utf8encode('col2'), result[0].columns[0].column.name - assert result[1].columns[0].column.name == utf8encode('col1') + assert result[0].columns[0].column.name == ''.encode(), result[0].columns[0].column.name + assert result[1].columns[0].column.name == ''.encode() def test_wrapped_range_slices(self): _set_keyspace('Keyspace1') @@ -1510,10 +1506,10 @@ def copp_token(key): client.insert(key, ColumnParent('Standard1'), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) cp = ColumnParent('Standard1') - result = client.get_range_slices(cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) + result = client.get_range_slices(cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) assert [row.key for row in result] == keylist, [row.key for row in result] - result = client.get_range_slices(cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) + result = client.get_range_slices(cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) assert [row.key for row in result] == keylist, [row.key for row in result] def test_get_slice_by_names(self): @@ -1521,15 +1517,15 @@ def test_get_slice_by_names(self): self.truncate_all('Standard1', 'Super1') _insert_range() - p = SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c2')]) - result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(column_names=[''.encode(), ''.encode()]) + result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == utf8encode('c1') - assert result[1].column.name == utf8encode('c2') + assert result[0].column.name == ''.encode() + assert result[1].column.name == ''.encode() _insert_super() p = SlicePredicate(column_names=[_i64(4)]) - result = client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), p, ConsistencyLevel.ONE) + result = client.get_slice(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE) assert len(result) == 1 assert result[0].column.name == _i64(4) @@ -1538,23 +1534,23 @@ def test_multiget_slice_with_compact_table(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef(utf8encode('v'), 'AsciiType', None, None) + cd = ColumnDef(''.encode(), 'AsciiType', None, None) newcf = CfDef('Keyspace1', 'CompactColumnFamily', default_validation_class='AsciiType', column_metadata=[cd]) client.system_add_column_family(newcf) CL = ConsistencyLevel.ONE for i in range(0, 5): - client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column(utf8encode('v'), utf8encode('value' + str(i)), 0), CL) + client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column(''.encode(), utf8encode('value' + str(i)), 0), CL) time.sleep(0.1) - p = SlicePredicate(column_names=[utf8encode('v')]) + p = SlicePredicate(column_names=[''.encode()]) rows = client.multiget_slice([utf8encode('key' + str(i)) for i in range(0, 5)], ColumnParent('CompactColumnFamily'), p, ConsistencyLevel.ONE) for i in range(0, 5): key = utf8encode('key' + str(i)) assert key in rows assert len(rows[key]) == 1 - assert rows[key][0].column.name == utf8encode('v') + assert rows[key][0].column.name == ''.encode() assert rows[key][0].column.value == utf8encode('value' + str(i)) def test_multiget_slice(self): @@ -1590,7 +1586,7 @@ def test_multi_count(self): # Count columns in all 10 keys keys = [utf8encode('key' + str(i)) for i in range(1, num_keys + 1)] - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) counts = client.multiget_count(keys, ColumnParent('Standard1'), p, ConsistencyLevel.ONE) # Check the returned counts @@ -1603,26 +1599,26 @@ def test_batch_mutate_super_deletion(self): self.truncate_all('Super1') _insert_super('test') - d = Deletion(1, predicate=SlicePredicate(column_names=[utf8encode('sc1')])) + d = Deletion(1, predicate=SlicePredicate(column_names=[''.encode()])) cfmap = {'Super1': [Mutation(deletion=d)]} - client.batch_mutate({utf8encode('test'): cfmap}, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1')), ConsistencyLevel.ONE)) + client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode()), ConsistencyLevel.ONE)) def test_super_reinsert(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') for x in range(3): - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(x), utf8encode('value'), 1), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(x), ''.encode(), 1), ConsistencyLevel.ONE) - client.remove(utf8encode('key1'), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) for x in range(3): - client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(x + 3), utf8encode('value'), 3), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(x + 3), ''.encode(), 3), ConsistencyLevel.ONE) for n in range(1, 4): - p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, n)) - slice = client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, n)) + slice = client.get_slice(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE) assert len(slice) == n, "expected %s results; found %s" % (n, slice) def test_describe_keyspace(self): @@ -1726,9 +1722,9 @@ def test_system_cf_recreate(self): _set_keyspace(keyspace) # insert - client.insert(utf8encode('key0'), ColumnParent(cf_name), Column(utf8encode('colA'), utf8encode('colA-value'), 0), ConsistencyLevel.ONE) - col1 = client.get_slice(utf8encode('key0'), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)), ConsistencyLevel.ONE)[0].column - assert col1.name == utf8encode('colA') and col1.value == utf8encode('colA-value') + client.insert(''.encode(), ColumnParent(cf_name), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + col1 = client.get_slice(''.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE)[0].column + assert col1.name == ''.encode() and col1.value == ''.encode() # drop client.system_drop_column_family(cf_name) @@ -1737,7 +1733,7 @@ def test_system_cf_recreate(self): client.system_add_column_family(newcf) # query - cosc_list = client.get_slice(utf8encode('key0'), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)), ConsistencyLevel.ONE) + cosc_list = client.get_slice(''.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE) # this was failing prior to CASSANDRA-1477. assert len(cosc_list) == 0, 'cosc length test failed' @@ -1806,17 +1802,17 @@ def test_column_validators(self): # columndef validation for regular CF ks = 'Keyspace1' _set_keyspace(ks) - cd = ColumnDef(utf8encode('col'), 'LongType', None, None) + cd = ColumnDef(''.encode(), 'LongType', None, None) cf = CfDef('Keyspace1', 'ValidatorColumnFamily', column_metadata=[cd]) client.system_add_column_family(cf) ks_def = client.describe_keyspace(ks) assert 'ValidatorColumnFamily' in [x.name for x in ks_def.cf_defs] cp = ColumnParent('ValidatorColumnFamily') - col0 = Column(utf8encode('col'), _i64(42), 0) - col1 = Column(utf8encode('col'), utf8encode("ceci n'est pas 64bit"), 0) - client.insert(utf8encode('key0'), cp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert(utf8encode('key1'), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) + col0 = Column(''.encode(), _i64(42), 0) + col1 = Column(''.encode(), "ceci n'est pas 64bit".encode(), 0) + client.insert(''.encode(), cp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert(''.encode(), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef validation for super CF @@ -1825,9 +1821,9 @@ def test_column_validators(self): ks_def = client.describe_keyspace(ks) assert 'ValidatorSuperColumnFamily' in [x.name for x in ks_def.cf_defs] - scp = ColumnParent('ValidatorSuperColumnFamily', utf8encode('sc1')) - client.insert(utf8encode('key0'), scp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert(utf8encode('key1'), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) + scp = ColumnParent('ValidatorSuperColumnFamily', ''.encode()) + client.insert(''.encode(), scp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert(''.encode(), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef and cfdef default validation @@ -1838,23 +1834,23 @@ def test_column_validators(self): dcp = ColumnParent('DefaultValidatorColumnFamily') # inserting a longtype into column 'col' is valid at the columndef level - client.insert(utf8encode('key0'), dcp, col0, ConsistencyLevel.ONE) + client.insert(''.encode(), dcp, col0, ConsistencyLevel.ONE) # inserting a UTF8type into column 'col' fails at the columndef level - e = _expect_exception(lambda: client.insert(utf8encode('key1'), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) + e = _expect_exception(lambda: client.insert(''.encode(), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a longtype into column 'fcol' should fail at the cfdef level - col2 = Column(utf8encode('fcol'), _i64(4224), 0) - e = _expect_exception(lambda: client.insert(utf8encode('key1'), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) + col2 = Column(''.encode(), _i64(4224), 0) + e = _expect_exception(lambda: client.insert(''.encode(), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a UTF8type into column 'fcol' is valid at the cfdef level - col3 = Column(utf8encode('fcol'), utf8encode("Stringin' it up in the Stringtel Stringifornia"), 0) - client.insert(utf8encode('key0'), dcp, col3, ConsistencyLevel.ONE) + col3 = Column(''.encode(), "Stringin' it up in the Stringtel Stringifornia".encode(), 0) + client.insert(''.encode(), dcp, col3, ConsistencyLevel.ONE) def test_system_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef(utf8encode('ValidationColumn'), 'BytesType', None, None) + cd = ColumnDef(''.encode(), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewColumnFamily', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -1907,36 +1903,36 @@ def test_dynamic_indexes_creation_deletion(self): ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'BlankCF'][0] - modified_cd = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, None) + modified_cd = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, None) modified_cf = CfDef('Keyspace1', 'BlankCF', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) # Add a second indexed CF ... - birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, None) - age_coldef = ColumnDef(utf8encode('age'), 'BytesType', IndexType.KEYS, 'age_index') + birthdate_coldef = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, None) + age_coldef = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'age_index') cfdef = CfDef('Keyspace1', 'BlankCF2', column_metadata=[birthdate_coldef, age_coldef]) client.system_add_column_family(cfdef) # ... and update it to have a third index ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - name_coldef = ColumnDef(utf8encode('name'), 'BytesType', IndexType.KEYS, 'name_index') + name_coldef = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'name_index') cfdef.column_metadata.append(name_coldef) client.system_update_column_family(cfdef) # Now drop the indexes ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) - age_coldef = ColumnDef(utf8encode('age'), 'BytesType', None, None) - name_coldef = ColumnDef(utf8encode('name'), 'BytesType', None, None) + birthdate_coldef = ColumnDef(''.encode(), 'BytesType', None, None) + age_coldef = ColumnDef(''.encode(), 'BytesType', None, None) + name_coldef = ColumnDef(''.encode(), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef, age_coldef, name_coldef] client.system_update_column_family(cfdef) ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF'][0] - birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) + birthdate_coldef = ColumnDef(''.encode(), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef] client.system_update_column_family(cfdef) @@ -1945,29 +1941,29 @@ def test_dynamic_indexes_creation_deletion(self): def test_dynamic_indexes_with_system_update_cf(self): _set_keyspace('Keyspace1') - cd = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) + cd = ColumnDef(''.encode(), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'ToBeIndexed', default_validation_class='LongType', column_metadata=[cd]) client.system_add_column_family(newcf) - client.insert(utf8encode('key1'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(1), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key2'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key2'), ColumnParent('ToBeIndexed'), Column(utf8encode('b'), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key3'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(3), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key3'), ColumnParent('ToBeIndexed'), Column(utf8encode('b'), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) # First without index cp = ColumnParent('ToBeIndexed') - sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == utf8encode('key1') + assert result[0].key == ''.encode() assert len(result[0].columns) == 1, result[0].columns # add an index on 'birthdate' ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'ToBeIndexed'][0] - modified_cd = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, 'bd_index') + modified_cd = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'bd_index') modified_cf = CfDef('Keyspace1', 'ToBeIndexed', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) @@ -1984,14 +1980,14 @@ def test_dynamic_indexes_with_system_update_cf(self): # repeat query on one index expression result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == utf8encode('key1') + assert result[0].key == ''.encode() assert len(result[0].columns) == 1, result[0].columns def test_system_super_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef(utf8encode('ValidationColumn'), 'BytesType', None, None) + cd = ColumnDef(''.encode(), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewSuperColumnFamily', 'Super', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -2008,32 +2004,32 @@ def test_insert_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(utf8encode('cttl1'), utf8encode('value1'), 0, 5) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl1')), ConsistencyLevel.ONE).column == column + column = Column(''.encode(), ''.encode(), 0, 5) + client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column == column def test_simple_expiration(self): """ Test that column ttled do expires """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(utf8encode('cttl3'), utf8encode('value1'), 0, 2) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - c = client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column + column = Column(''.encode(), ''.encode(), 0, 2) + client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + c = client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl3')), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) def test_expiration_with_default_ttl(self): """ Test that column with default ttl do expires """ _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column(utf8encode('cttl3'), utf8encode('value1'), 0) - client.insert(utf8encode('key1'), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column + column = Column(''.encode(), ''.encode(), 0) + client.insert(''.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + client.get(''.encode(), ColumnPath('Expiring', column=''.encode()), ConsistencyLevel.ONE).column time.sleep(3) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Expiring', column=''.encode()), ConsistencyLevel.ONE)) @since('3.6') def test_expiration_with_default_ttl_and_zero_ttl(self): @@ -2044,45 +2040,45 @@ def test_expiration_with_default_ttl_and_zero_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column(utf8encode('cttl3'), utf8encode('value1'), 0, 0) - client.insert(utf8encode('key1'), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - c = client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column - assert Column(utf8encode('cttl3'), utf8encode('value1'), 0) == c + column = Column(''.encode(), ''.encode(), 0, 0) + client.insert(''.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + c = client.get(''.encode(), ColumnPath('Expiring', column=''.encode()), ConsistencyLevel.ONE).column + assert Column(''.encode(), ''.encode(), 0) == c def test_simple_expiration_batch_mutate(self): """ Test that column ttled do expires using batch_mutate """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(utf8encode('cttl4'), utf8encode('value1'), 0, 2) + column = Column(''.encode(), ''.encode(), 0, 2) cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(column))]} - client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) - c = client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE).column + client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) + c = client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) def test_update_expiring(self): """ Test that updating a column with ttl override the ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column1 = Column(utf8encode('cttl4'), utf8encode('value1'), 0, 1) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) - column2 = Column(utf8encode('cttl4'), utf8encode('value1'), 1) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) + column1 = Column(''.encode(), ''.encode(), 0, 1) + client.insert(''.encode(), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) + column2 = Column(''.encode(), ''.encode(), 1) + client.insert(''.encode(), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) time.sleep(1.5) - assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE).column == column2 + assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column == column2 def test_remove_expiring(self): """ Test removing a column with ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(utf8encode('cttl5'), utf8encode('value1'), 0, 10) - client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl5')), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('ctt5')), ConsistencyLevel.ONE)) + column = Column(''.encode(), ''.encode(), 0, 10) + client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) def test_describe_ring_on_invalid_keyspace(self): def req(): @@ -2097,19 +2093,19 @@ def test_incr_decr_standard_add(self, request): d2 = -21 d3 = 35 # insert positive and negative values and check the counts - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) time.sleep(0.1) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) time.sleep(0.1) - rv2 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d3), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d3), ConsistencyLevel.ONE) time.sleep(0.1) - rv3 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) def test_incr_decr_super_add(self, request): @@ -2120,18 +2116,18 @@ def test_incr_decr_super_add(self, request): d2 = 52345 d3 = 3123 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c2'), d2), ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_super_column.columns[0].value == d1 assert rv1.counter_super_column.columns[1].value == d2 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d2), ConsistencyLevel.ONE) - rv2 = client.get(key, ColumnPath('SuperCounter1', utf8encode('sc1'), utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath('SuperCounter1', ''.encode(), ''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d3), ConsistencyLevel.ONE) - rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d3), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) def test_incr_standard_remove(self, request): @@ -2142,20 +2138,20 @@ def test_incr_standard_remove(self, request): d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=''.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=''.encode())) def test_incr_super_remove(self, request): _set_keyspace('Keyspace1') @@ -2165,20 +2161,20 @@ def test_incr_super_remove(self, request): d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) def test_incr_decr_standard_remove(self, request): _set_keyspace('Keyspace1') @@ -2188,20 +2184,20 @@ def test_incr_decr_standard_remove(self, request): d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=''.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=''.encode())) def test_incr_decr_super_remove(self, request): _set_keyspace('Keyspace1') @@ -2211,20 +2207,20 @@ def test_incr_decr_super_remove(self, request): d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) def test_incr_decr_standard_batch_add(self, request): _set_keyspace('Keyspace1') @@ -2233,13 +2229,13 @@ def test_incr_decr_standard_batch_add(self, request): d1 = 12 d2 = -21 update_map = {key: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d2))), ]}} # insert positive and negative values and check the counts client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 def test_incr_decr_standard_batch_remove(self, request): @@ -2252,34 +2248,34 @@ def test_incr_decr_standard_batch_remove(self, request): # insert positive and negative values and check the counts update_map = {key1: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 # remove the previous column and check that it is gone update_map = {key1: {'Counter1': [ - Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=[utf8encode('c1')]))), + Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=[''.encode()]))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=''.encode())) # insert again and this time delete the whole row, check that it is gone update_map = {key2: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 + d2 update_map = {key2: {'Counter1': [ Mutation(deletion=Deletion()), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=''.encode())) # known failure: see CASSANDRA-10046 def test_range_deletion(self): @@ -2289,16 +2285,16 @@ def test_range_deletion(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) - client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, ''.encode(), int(time.time() * 1000)) + client.insert(''.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x01'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} + keyed_mutations = {''.encode(): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - slice_predicate = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)) - results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + slice_predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)) + results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2317,17 +2313,17 @@ def test_range_deletion_eoc_0(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) - client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, ''.encode(), int(time.time() * 1000)) + client.insert(''.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # insert a partial cell name (just the first element of the composite) column_name = composite('6', None, eoc=b'\x00') - column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) - client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, ''.encode(), int(time.time() * 1000)) + client.insert(''.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # sanity check the query - slice_predicate = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)) - results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + slice_predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)) + results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('3', '3'), composite('4', '4'), composite('5', '5'), composite('6'), @@ -2337,11 +2333,11 @@ def test_range_deletion_eoc_0(self): # do a slice deletion with (6, ) as the end delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} + keyed_mutations = {''.encode(): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - # check the columns post-deletion, (utf8encode('6'), ) because it is an exact much but not (6, 6) - results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + # check the columns post-deletion, (''.encode(), ) because it is an exact much but not (6, 6) + results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), @@ -2350,11 +2346,11 @@ def test_range_deletion_eoc_0(self): # do another slice deletion, but make the end (6, 6) this time delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', '6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} + keyed_mutations = {''.encode(): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # check the columns post-deletion, now (6, 6) is also gone - results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2365,15 +2361,15 @@ def test_incr_decr_standard_slice(self, request): d1 = 12 d2 = -21 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate([utf8encode('c3'), utf8encode('c4')]), ConsistencyLevel.ONE) + counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate([''.encode(), ''.encode()]), ConsistencyLevel.ONE) assert counters[0].counter_column.value == d1 + d2 assert counters[1].counter_column.value == d1 @@ -2385,20 +2381,20 @@ def test_incr_decr_standard_multiget_slice(self, request): d1 = 12 d2 = -21 - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) - - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate([utf8encode('c3'), utf8encode('c4')]), ConsistencyLevel.ONE) + counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate([''.encode(), ''.encode()]), ConsistencyLevel.ONE) assert counters[key1][0].counter_column.value == d1 + d2 assert counters[key1][1].counter_column.value == d1 @@ -2409,27 +2405,27 @@ def test_counter_get_slice_range(self, request): _set_keyspace('Keyspace1') key = utf8encode(request.node.name) - client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c1'), 1), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c2'), 2), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c3'), 3), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(''.encode(), 1), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(''.encode(), 2), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(''.encode(), 3), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(utf8encode('c1'), utf8encode('c2'), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == utf8encode('c1') - assert result[1].counter_column.name == utf8encode('c2') + assert result[0].counter_column.name == ''.encode() + assert result[1].counter_column.name == ''.encode() - p = SlicePredicate(slice_range=SliceRange(utf8encode('c3'), utf8encode('c2'), True, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == utf8encode('c3') - assert result[1].counter_column.name == utf8encode('c2') + assert result[0].counter_column.name == ''.encode() + assert result[1].counter_column.name == ''.encode() - p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 2)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -2437,77 +2433,77 @@ def test_counter_get_slice_super_range(self, request): _set_keyspace('Keyspace1') key = utf8encode(request.node.name) - client.add(key, ColumnParent('SuperCounter1', utf8encode('sc1')), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', utf8encode('sc2')), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', utf8encode('sc2')), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', utf8encode('sc3')), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(utf8encode('sc2'), utf8encode('sc3'), False, 2)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == utf8encode('sc2') - assert result[1].counter_super_column.name == utf8encode('sc3') + assert result[0].counter_super_column.name == ''.encode() + assert result[1].counter_super_column.name == ''.encode() - p = SlicePredicate(slice_range=SliceRange(utf8encode('sc3'), utf8encode('sc2'), True, 2)) + p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == utf8encode('sc3') - assert result[1].counter_super_column.name == utf8encode('sc2') + assert result[0].counter_super_column.name == ''.encode() + assert result[1].counter_super_column.name == ''.encode() def test_index_scan(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert(utf8encode('key1'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(1), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key2'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key2'), ColumnParent('Indexed1'), Column(utf8encode('b'), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key3'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(3), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key3'), ColumnParent('Indexed1'), Column(utf8encode('b'), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) # simple query on one index expression cp = ColumnParent('Indexed1') - sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == utf8encode('key1') + assert result[0].key == ''.encode() assert len(result[0].columns) == 1, result[0].columns # without index - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('b'), IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 0, result # but unindexed expression added to indexed one is ok - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('b'), IndexOperator.EQ, _i64(3)), IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(3))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(3)), IndexExpression(''.encode(), IndexOperator.EQ, _i64(3))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == utf8encode('key3') + assert result[0].key == ''.encode() assert len(result[0].columns) == 2, result[0].columns def test_index_scan_uuid_names(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed3') - sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) cp = ColumnParent('Indexed3') # timeuuid name, utf8 values u = uuid.UUID('00000000-0000-1000-0000-000000000000').bytes u2 = uuid.UUID('00000000-0000-1000-0000-000000000001').bytes - client.insert(utf8encode('key1'), ColumnParent('Indexed3'), Column(u, utf8encode('a'), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Indexed3'), Column(u2, utf8encode('b'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed3'), Column(u, ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed3'), Column(u2, ''.encode(), 0), ConsistencyLevel.ONE) # name comparator + data validator of incompatible types -- see CASSANDRA-2347 - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(u, IndexOperator.EQ, utf8encode('a')), IndexExpression(u2, IndexOperator.EQ, utf8encode('b'))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(u, IndexOperator.EQ, ''.encode()), IndexExpression(u2, IndexOperator.EQ, ''.encode())], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result cp = ColumnParent('Indexed2') # timeuuid name, long values # name must be valid (TimeUUID) - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('foo'), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) # value must be valid (TimeUUID) - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, utf8encode("foo"))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, 'foo'.encode())], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) def test_index_scan_expiring(self): @@ -2515,10 +2511,10 @@ def test_index_scan_expiring(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert(utf8encode('key1'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(1), 0, 2), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(1), 0, 2), ConsistencyLevel.ONE) cp = ColumnParent('Indexed1') - sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) # query before expiration result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result @@ -2538,28 +2534,28 @@ def test_index_scan_indexed_column_outside_slice_predicate(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed4') - client.insert(utf8encode('key1'), ColumnParent('Indexed4'), Column(utf8encode('a'), _i64(1), 0), ConsistencyLevel.ONE) - client.insert(utf8encode('key1'), ColumnParent('Indexed4'), Column(utf8encode('z'), utf8encode('zzz'), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed4'), Column(''.encode(), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(''.encode(), ColumnParent('Indexed4'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) cp = ColumnParent('Indexed4') - sp = SlicePredicate(slice_range=SliceRange(utf8encode('z'), utf8encode('z'))) - key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('a'), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == utf8encode('z') + assert result[0].columns[0].column.name == ''.encode() - sp = SlicePredicate(column_names=[utf8encode('z')]) + sp = SlicePredicate(column_names=[''.encode()]) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == utf8encode('z') + assert result[0].columns[0].column.name == ''.encode() def test_column_not_found_quorum(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - key = utf8encode('doesntexist') - column_path = ColumnPath(column_family="Standard1", column=utf8encode("idontexist")) + key = ''.encode() + column_path = ColumnPath(column_family="Standard1", column='idontexist'.encode()) try: client.get(key, column_path, ConsistencyLevel.QUORUM) assert False, ('columnpath %s existed in %s when it should not' % (column_path, key)) @@ -2570,13 +2566,13 @@ def test_get_range_slice_after_deletion(self): _set_keyspace('Keyspace2') self.truncate_all('Super3') - key = utf8encode('key1') + key = ''.encode() # three supercoluns, each with "col1" subcolumn for i in range(1, 4): - client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column(utf8encode('col1'), utf8encode('val1'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) cp = ColumnParent('Super3') - predicate = SlicePredicate(slice_range=SliceRange(utf8encode('sc1'), utf8encode('sc3'), False, count=1)) + predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, count=1)) k_range = KeyRange(start_key=key, end_key=key, count=1) # validate count=1 restricts to 1 supercolumn @@ -2584,13 +2580,13 @@ def test_get_range_slice_after_deletion(self): assert len(result[0].columns) == 1 # remove sc1; add back subcolumn to override tombstone - client.remove(key, ColumnPath('Super3', utf8encode('sc1')), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super3', ''.encode()), 1, ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1 - client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(utf8encode('col1'), utf8encode('val1'), 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', ''.encode()), Column(''.encode(), ''.encode(), 2), ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].super_column.name == utf8encode('sc1') + assert result[0].columns[0].super_column.name == ''.encode() def test_multi_slice(self): _set_keyspace('Keyspace1') @@ -2609,12 +2605,12 @@ def test_truncate(self): # truncate Standard1 self.truncate_all('Standard1') - assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] + assert _big_slice(''.encode(), ColumnParent('Standard1')) == [] # truncate Super1 self.truncate_all('Super1') - assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] - assert _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1'))) == [] + assert _big_slice(''.encode(), ColumnParent('Super1')) == [] + assert _big_slice(''.encode(), ColumnParent('Super1', ''.encode())) == [] @since('3.0') def test_cql_range_tombstone_and_static(self): @@ -2632,9 +2628,9 @@ def test_cql_range_tombstone_and_static(self): _set_keyspace('Keyspace1') - mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000))))] + mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000))))] mutation_map = dict((table, mutations) for table in ['t']) - keyed_mutations = dict((key, mutation_map) for key in [utf8encode('k')]) + keyed_mutations = dict((key, mutation_map) for key in [''.encode()]) client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # And check everything is gone @@ -2651,8 +2647,8 @@ def test_compact_storage_get(self): _set_keyspace('Keyspace1') CL = ConsistencyLevel.ONE i = 1 - client.insert(_i32(i), ColumnParent('cs1'), Column(utf8encode('v'), _i32(i), 0), CL) - _assert_column('cs1', _i32(i), utf8encode('v'), _i32(i), 0) + client.insert(_i32(i), ColumnParent('cs1'), Column(''.encode(), _i32(i), 0), CL) + _assert_column('cs1', _i32(i), ''.encode(), _i32(i), 0) @pytest.mark.skipif(CASSANDRA_VERSION_FROM_BUILD == '3.9', reason="Test doesn't run on 3.9") def test_range_tombstone_eoc_0(self): From f27e64b6d2c85ad0e2b707e7142d1ee7373e476e Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 14:43:30 -0500 Subject: [PATCH 12/16] More thrift stuff. --- super_counter_test.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/super_counter_test.py b/super_counter_test.py index b9ca007b04..03962ecdf3 100644 --- a/super_counter_test.py +++ b/super_counter_test.py @@ -54,9 +54,9 @@ def test_functional(self): for subcol in range(NUM_SUBCOLS): for add in range(NUM_ADDS): column_parent = ColumnParent(column_family='cf', - super_column='subcol_%d' % subcol) - counter_column = CounterColumn('col_0', 1) - thrift_conn.add('row_0', column_parent, counter_column, + super_column=('subcol_%d' % subcol).encode()) + counter_column = CounterColumn('col_0'.encode(), 1) + thrift_conn.add('row_0'.encode(), column_parent, counter_column, ConsistencyLevel.QUORUM) time.sleep(1) cluster.flush() @@ -75,9 +75,9 @@ def test_functional(self): from_db = [] for i in range(NUM_SUBCOLS): - column_path = ColumnPath(column_family='cf', column='col_0', - super_column='subcol_%d' % i) - column_or_super_column = thrift_conn.get('row_0', column_path, + column_path = ColumnPath(column_family='cf', column='col_0'.encode(), + super_column=(('subcol_%d' % i).encode())) + column_or_super_column = thrift_conn.get('row_0'.encode(), column_path, ConsistencyLevel.QUORUM) val = column_or_super_column.counter_column.value logger.debug(str(val)), From a4abb45e59c235f06777eb2b619269b53ebe6be0 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 14:55:49 -0500 Subject: [PATCH 13/16] Fix broken assertion. --- thrift_hsha_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/thrift_hsha_test.py b/thrift_hsha_test.py index 9e7dbf1f29..d1d84f839c 100644 --- a/thrift_hsha_test.py +++ b/thrift_hsha_test.py @@ -76,7 +76,7 @@ def make_connection(): with JolokiaAgent(node1) as jmx: num_clients = jmx.read_attribute(connected_thrift_clients, "Value") - assert int(num_clients), 0 == "There are still open Thrift connections after stopping service" + assert int(num_clients) == 0, "There are still open Thrift connections after stopping service " + str(num_clients) @unittest.skipIf(not os.path.exists(ATTACK_JAR), "No attack jar found") @unittest.skipIf(not os.path.exists(JNA_PATH), "No JNA jar found") From d861efd96c8ecdaa50a0b0aa7e186e07673848b1 Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 15:03:00 -0500 Subject: [PATCH 14/16] Refactor thrift_test correctly. --- thrift_test.py | 1208 ++++++++++++++++++++++++------------------------ 1 file changed, 606 insertions(+), 602 deletions(-) diff --git a/thrift_test.py b/thrift_test.py index b9992915d3..5025d64340 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -4,6 +4,7 @@ import uuid import pytest import logging +import codecs from thrift.protocol import TBinaryProtocol from thrift.Thrift import TApplicationException @@ -31,6 +32,9 @@ since = pytest.mark.since logger = logging.getLogger(__name__) +utf8encoder = codecs.getencoder('utf-8') +def utf8encode(str): + return utf8encoder(str)[0] def get_thrift_client(host='127.0.0.1', port=9160): socket = TSocket.TSocket(host, port) @@ -94,8 +98,8 @@ def define_schema(self): cf_defs=[ Cassandra.CfDef('Keyspace1', 'Standard1'), Cassandra.CfDef('Keyspace1', 'Standard2'), - Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef(''.encode(), 'AsciiType'), Cassandra.ColumnDef(''.encode(), 'AsciiType')]), - Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef(''.encode(), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef('c1'.encode(), 'AsciiType'), Cassandra.ColumnDef('c2'.encode(), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef('c1'.encode(), 'AsciiType')]), Cassandra.CfDef('Keyspace1', 'StandardLong1', comparator_type='LongType'), Cassandra.CfDef('Keyspace1', 'StandardInteger1', comparator_type='IntegerType'), Cassandra.CfDef('Keyspace1', 'StandardComposite', comparator_type='CompositeType(AsciiType, AsciiType)'), @@ -104,10 +108,10 @@ def define_schema(self): Cassandra.CfDef('Keyspace1', 'Super3', column_type='Super', comparator_type='LongType', subcomparator_type='UTF8Type'), Cassandra.CfDef('Keyspace1', 'Counter1', default_validation_class='CounterColumnType'), Cassandra.CfDef('Keyspace1', 'SuperCounter1', column_type='Super', default_validation_class='CounterColumnType'), - Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef(''.encode(), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), + Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef('birthdate'.encode(), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), Cassandra.CfDef('Keyspace1', 'Indexed2', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'LongType', Cassandra.IndexType.KEYS)]), Cassandra.CfDef('Keyspace1', 'Indexed3', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'UTF8Type', Cassandra.IndexType.KEYS)]), - Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef(''.encode(), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef(''.encode(), 'UTF8Type')]), + Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef('a'.encode(), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef('z'.encode(), 'UTF8Type')]), Cassandra.CfDef('Keyspace1', 'Expiring', default_time_to_live=2) ]) @@ -159,11 +163,11 @@ def _i16(n): return struct.pack('>h', n) # big endian = network order -_SIMPLE_COLUMNS = [Column(''.encode(), ''.encode(), 0), - Column(''.encode(), ''.encode(), 0)] -_SUPER_COLUMNS = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), - SuperColumn(name=''.encode(), columns=[Column(_i64(5), ''.encode(), 0), - Column(_i64(6), ''.encode(), 0)])] +_SIMPLE_COLUMNS = [Column('c1'.encode(), 'value1'.encode(), 0), + Column('c2'.encode(), 'value2'.encode(), 0)] +_SUPER_COLUMNS = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), + SuperColumn(name='sc2'.encode(), columns=[Column(_i64(5), 'value5'.encode(), 0), + Column(_i64(6), 'value6'.encode(), 0)])] def _assert_column(column_family, key, column, value, ts=0): @@ -198,7 +202,7 @@ def _assert_no_columnpath(key, column_path): def _insert_simple(): - return _insert_multi([''.encode()]) + return _insert_multi(['key1'.encode()]) def _insert_multi(keys): @@ -206,14 +210,14 @@ def _insert_multi(keys): for key in keys: if isinstance(key, str): key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('c2'.encode(), 'value2'.encode(), 0), CL) def _insert_batch(): cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS], 'Standard2': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS]} - client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({'key1'.encode(): cfmap}, ConsistencyLevel.ONE) def _big_slice(key, column_parent): @@ -231,50 +235,50 @@ def _big_multislice(keys, column_parent): def _verify_batch(): _verify_simple() L = [result.column - for result in _big_slice(''.encode(), ColumnParent('Standard2'))] + for result in _big_slice('key1'.encode(), ColumnParent('Standard2'))] assert L == _SIMPLE_COLUMNS, L def _verify_simple(): - assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column == Column(''.encode(), ''.encode(), 0) + assert client.get('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE).column == Column('c1'.encode(), 'value1'.encode(), 0) L = [result.column - for result in _big_slice(''.encode(), ColumnParent('Standard1'))] + for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] assert L == _SIMPLE_COLUMNS, L def _insert_super(key='key1'): if isinstance(key, str): key = utf8encode(key) - client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(6), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', 'sc2'.encode()), Column(_i64(6), 'value6'.encode(), 0), ConsistencyLevel.ONE) def _insert_range(): - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c2'.encode(), 'value2'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c3'.encode(), 'value3'.encode(), 0), ConsistencyLevel.ONE) def _verify_range(): - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) - result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('c1'.encode(), 'c2'.encode(), False, 1000)) + result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == ''.encode() - assert result[1].column.name == ''.encode() + assert result[0].column.name == 'c1'.encode() + assert result[1].column.name == 'c2'.encode() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1000)) - result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('c3'.encode(), 'c2'.encode(), True, 1000)) + result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == ''.encode() - assert result[1].column.name == ''.encode() + assert result[0].column.name == 'c3'.encode() + assert result[1].column.name == 'c2'.encode() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) - result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 1000)) + result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) - result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 2)) + result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -283,31 +287,31 @@ def _set_keyspace(keyspace): def _insert_super_range(): - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(6), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(7), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(6), 'value6'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc3'.encode()), Column(_i64(7), 'value7'.encode(), 0), ConsistencyLevel.ONE) time.sleep(0.1) def _verify_super_range(): - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) - result = client.get_slice(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('sc2'.encode(), 'sc3'.encode(), False, 2)) + result = client.get_slice('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == ''.encode() - assert result[1].super_column.name == ''.encode() + assert result[0].super_column.name == 'sc2'.encode() + assert result[1].super_column.name == 'sc3'.encode() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 2)) - result = client.get_slice(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('sc3'.encode(), 'sc2'.encode(), True, 2)) + result = client.get_slice('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == ''.encode() - assert result[1].super_column.name == ''.encode() + assert result[0].super_column.name == 'sc3'.encode() + assert result[1].super_column.name == 'sc2'.encode() def _verify_super(supercf='Super1', key='key1'): if isinstance(key, str): key = utf8encode(key) - assert client.get(key, ColumnPath(supercf, ''.encode(), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), ''.encode(), 0) + assert client.get(key, ColumnPath(supercf, 'sc1'.encode(), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), 'value4'.encode(), 0) slice = [result.super_column for result in _big_slice(key, ColumnParent('Super1'))] assert slice == _SUPER_COLUMNS, slice @@ -335,23 +339,23 @@ def _insert_six_columns(key='abc'): if isinstance(key, str): key = utf8encode(key) CL = ConsistencyLevel.ONE - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('a'.encode(), '1'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('b'.encode(), '2'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('c'.encode(), '3'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('d'.encode(), '4'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('e'.encode(), '5'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column('f'.encode(), '6'.encode(), 0), CL) def _big_multi_slice(key='abc'): if isinstance(key, str): key = utf8encode(key) c1 = ColumnSlice() - c1.start = ''.encode() - c1.finish = ''.encode() + c1.start = 'a'.encode() + c1.finish = 'c'.encode() c2 = ColumnSlice() - c2.start = ''.encode() - c2.finish = ''.encode() + c2.start = 'e'.encode() + c2.finish = 'f'.encode() m = MultiSliceRequest() m.key = key m.column_parent = ColumnParent('Standard1') @@ -362,7 +366,7 @@ def _big_multi_slice(key='abc'): return client.get_multi_slice(m) -_MULTI_SLICE_COLUMNS = [Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)] +_MULTI_SLICE_COLUMNS = [Column('a'.encode(), '1'.encode(), 0), Column('b'.encode(), '2'.encode(), 0), Column('c'.encode(), '3'.encode(), 0), Column('e'.encode(), '5'.encode(), 0), Column('f'.encode(), '6'.encode(), 0)] @since('2.0', max_version='4') @@ -381,15 +385,15 @@ def test_insert(self): def test_empty_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Standard2', 'Super1') - assert _big_slice(''.encode(), ColumnParent('Standard2')) == [] - assert _big_slice(''.encode(), ColumnParent('Super1')) == [] + assert _big_slice('key1'.encode(), ColumnParent('Standard2')) == [] + assert _big_slice('key1'.encode(), ColumnParent('Super1')) == [] def test_cas(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Standard3', 'Standard4') def cas(expected, updates, column_family): - return client.cas(''.encode(), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) + return client.cas('key1'.encode(), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) def test_cas_operations(first_columns, second_columns, column_family): # partition should be empty, so cas expecting any existing values should fail @@ -400,7 +404,7 @@ def test_cas_operations(first_columns, second_columns, column_family): # cas of empty columns -> first_columns should succeed # and the reading back from the table should match first_columns assert cas([], first_columns, column_family).success - result = [cosc.column for cosc in _big_slice(''.encode(), ColumnParent(column_family))] + result = [cosc.column for cosc in _big_slice('key1'.encode(), ColumnParent(column_family))] # CAS will use its own timestamp, so we can't just compare result == _SIMPLE_COLUMNS assert dict((c.name, c.value) for c in result) == dict((ex.name, ex.value) for ex in first_columns) @@ -412,7 +416,7 @@ def test_cas_operations(first_columns, second_columns, column_family): assert dict((c.name, c.value) for c in cas_result.current_values) == {first_columns[0].name: first_columns[0].value}, cas_result # CL.SERIAL for reads - assert client.get(''.encode(), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value + assert client.get('key1'.encode(), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value # cas first_columns -> second_columns should succeed assert cas(first_columns, second_columns, column_family).success @@ -421,8 +425,8 @@ def test_cas_operations(first_columns, second_columns, column_family): cas_result = cas(first_columns, second_columns, column_family) assert not cas_result.success - updated_columns = [Column(''.encode(), ''.encode(), 1), - Column(''.encode(), ''.encode(), 1)] + updated_columns = [Column('c1'.encode(), 'value101'.encode(), 1), + Column('c2'.encode(), 'value102'.encode(), 1)] logger.debug("Testing CAS operations on dynamic cf") test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard1') @@ -435,9 +439,9 @@ def test_missing_super(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc1'.encode(), _i64(1)), ConsistencyLevel.ONE)) _insert_super() - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc1'.encode(), _i64(1)), ConsistencyLevel.ONE)) def test_count(self): _set_keyspace('Keyspace1') @@ -446,18 +450,18 @@ def test_count(self): _insert_simple() _insert_super() p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) - assert client.get_count(''.encode(), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 - assert client.get_count(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 - assert client.get_count(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE) == 2 - assert client.get_count(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 + assert client.get_count('key1'.encode(), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 + assert client.get_count('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 + assert client.get_count('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), p, ConsistencyLevel.ONE) == 2 + assert client.get_count('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 # Let's make that a little more interesting - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c3'.encode(), 'value3'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c4'.encode(), 'value4'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c5'.encode(), 'value5'.encode(), 0), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) - assert client.get_count(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 + p = SlicePredicate(slice_range=SliceRange('c2'.encode(), 'c4'.encode(), False, 1000)) + assert client.get_count('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 def test_count_paging(self): _set_keyspace('Keyspace1') @@ -470,14 +474,14 @@ def test_count_paging(self): # Paging for small columns starts at 1024 columns columns_to_insert = [Column(utf8encode('c%d' % (i,)), utf8encode('value%d' % (i,)), 0) for i in range(3, 1026)] cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in columns_to_insert]} - client.batch_mutate({''.encode() : cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({'key1'.encode() : cfmap}, ConsistencyLevel.ONE) p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2000)) - assert client.get_count(''.encode(), column_parent, p, ConsistencyLevel.ONE) == 1025 + assert client.get_count('key1'.encode(), column_parent, p, ConsistencyLevel.ONE) == 1025 # Ensure that the count limit isn't clobbered p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 10)) - assert client.get_count(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 + assert client.get_count('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 # test get_count() to work correctly with 'count' settings around page size (CASSANDRA-4833) def test_count_around_page_size(self): @@ -487,7 +491,7 @@ def test_count_around_page_size(self): def slice_predicate(count): return SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, count)) - key = ''.encode() + key = 'key1'.encode() parent = ColumnParent('Standard1') cl = ConsistencyLevel.ONE @@ -521,7 +525,7 @@ def test_super_get(self): self.truncate_all('Super1') _insert_super() - result = client.get(''.encode(), ColumnPath('Super1', ''.encode()), ConsistencyLevel.ONE).super_column + result = client.get('key1'.encode(), ColumnPath('Super1', 'sc2'.encode()), ConsistencyLevel.ONE).super_column assert result == _SUPER_COLUMNS[1], result def test_super_subcolumn_limit(self): @@ -529,14 +533,14 @@ def test_super_subcolumn_limit(self): self.truncate_all('Super1') _insert_super() p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) - column_parent = ColumnParent('Super1', ''.encode()) + column_parent = ColumnParent('Super1', 'sc2'.encode()) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(5), ''.encode(), 0)], slice + for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(5), 'value5'.encode(), 0)], slice p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1)) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(6), ''.encode(), 0)], slice + for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(6), 'value6'.encode(), 0)], slice def test_long_order(self): _set_keyspace('Keyspace1') @@ -550,9 +554,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(0, 104294967296, 429496729): name = _i64(i) - client.insert(''.encode(), ColumnParent('StandardLong1'), Column(name, ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('StandardLong1'), Column(name, 'v'.encode(), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice(''.encode(), ColumnParent('StandardLong1'))] + slice = [result.column.name for result in _big_slice('key1'.encode(), ColumnParent('StandardLong1'))] assert slice == L, slice def test_integer_order(self): @@ -567,9 +571,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(104294967296, 0, 429496729): name = _i64(i) - client.insert(''.encode(), ColumnParent('StandardInteger1'), Column(name, ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('StandardInteger1'), Column(name, 'v'.encode(), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice(''.encode(), ColumnParent('StandardInteger1'))] + slice = [result.column.name for result in _big_slice('key1'.encode(), ColumnParent('StandardInteger1'))] L.sort() assert slice == L, slice @@ -583,8 +587,8 @@ def test_time_uuid(self): # 100 isn't enough to fail reliably if the comparator is borked for i in range(500): L.append(uuid.uuid1()) - client.insert(''.encode(), ColumnParent('Super4', ''.encode()), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) - slice = _big_slice(''.encode(), ColumnParent('Super4', ''.encode())) + client.insert('key1'.encode(), ColumnParent('Super4', 'sc1'.encode()), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) + slice = _big_slice('key1'.encode(), ColumnParent('Super4', 'sc1'.encode())) assert len(slice) == 500, len(slice) for i in range(500): u = slice[i].column @@ -592,32 +596,32 @@ def test_time_uuid(self): assert u.name == L[i].bytes p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1)) - column_parent = ColumnParent('Super4', ''.encode()) + column_parent = ColumnParent('Super4', 'sc1'.encode()) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[-1].bytes, ''.encode(), 499)], slice + for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[-1].bytes, 'value499'.encode(), 499)], slice p = SlicePredicate(slice_range=SliceRange(''.encode(), L[2].bytes, False, 1000)) - column_parent = ColumnParent('Super4', ''.encode()) + column_parent = ColumnParent('Super4', 'sc1'.encode()) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[0].bytes, ''.encode(), 0), - Column(L[1].bytes, ''.encode(), 1), - Column(L[2].bytes, ''.encode(), 2)], slice + for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[0].bytes, 'value0'.encode(), 0), + Column(L[1].bytes, 'value1'.encode(), 1), + Column(L[2].bytes, 'value2'.encode(), 2)], slice p = SlicePredicate(slice_range=SliceRange(L[2].bytes, ''.encode(), True, 1000)) - column_parent = ColumnParent('Super4', ''.encode()) + column_parent = ColumnParent('Super4', 'sc1'.encode()) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, ''.encode(), 2), - Column(L[1].bytes, ''.encode(), 1), - Column(L[0].bytes, ''.encode(), 0)], slice + for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, 'value2'.encode(), 2), + Column(L[1].bytes, 'value1'.encode(), 1), + Column(L[0].bytes, 'value0'.encode(), 0)], slice p = SlicePredicate(slice_range=SliceRange(L[2].bytes, ''.encode(), False, 1)) - column_parent = ColumnParent('Super4', ''.encode()) + column_parent = ColumnParent('Super4', 'sc1'.encode()) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, ''.encode(), 2)], slice + for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, 'value2'.encode(), 2)], slice def test_long_remove(self): _set_keyspace('Keyspace1') @@ -628,15 +632,15 @@ def test_long_remove(self): for i in range(10): parent = ColumnParent('StandardLong1') - client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i), ConsistencyLevel.ONE) - client.remove(''.encode(), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE) + client.insert('key1'.encode(), parent, Column(_i64(i), 'value1'.encode(), 10 * i), ConsistencyLevel.ONE) + client.remove('key1'.encode(), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i + 2), ConsistencyLevel.ONE) + client.insert('key1'.encode(), parent, Column(_i64(i), 'value2'.encode(), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), ''.encode(), 10 * i + 2)], (slice, i) + for result in client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), 'value2'.encode(), 10 * i + 2)], (slice, i) def test_integer_remove(self): _set_keyspace('Keyspace1') @@ -647,15 +651,15 @@ def test_integer_remove(self): for i in range(10): parent = ColumnParent('StandardInteger1') - client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i), ConsistencyLevel.ONE) - client.remove(''.encode(), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE) + client.insert('key1'.encode(), parent, Column(_i64(i), 'value1'.encode(), 10 * i), ConsistencyLevel.ONE) + client.remove('key1'.encode(), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert(''.encode(), parent, Column(_i64(i), ''.encode(), 10 * i + 2), ConsistencyLevel.ONE) + client.insert('key1'.encode(), parent, Column(_i64(i), 'value2'.encode(), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice(''.encode(), column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), ''.encode(), 10 * i + 2)], (slice, i) + for result in client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), 'value2'.encode(), 10 * i + 2)], (slice, i) def test_batch_insert(self): _set_keyspace('Keyspace1') @@ -677,7 +681,7 @@ def test_batch_mutate_standard_columns(self): for column_family in column_families: for key in keys: - _assert_column(column_family, key, ''.encode(), ''.encode()) + _assert_column(column_family, key, 'c1'.encode(), 'value1'.encode()) def test_batch_mutate_remove_standard_columns(self): _set_keyspace('Keyspace1') @@ -809,51 +813,51 @@ def test_batch_mutate_remove_slice_standard(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - columns = [Column(''.encode(), ''.encode(), 0), - Column(''.encode(), ''.encode(), 0), - Column(''.encode(), ''.encode(), 0), - Column(''.encode(), ''.encode(), 0), - Column(''.encode(), ''.encode(), 0)] + columns = [Column('c1'.encode(), 'value1'.encode(), 0), + Column('c2'.encode(), 'value2'.encode(), 0), + Column('c3'.encode(), 'value3'.encode(), 0), + Column('c4'.encode(), 'value4'.encode(), 0), + Column('c5'.encode(), 'value5'.encode(), 0)] for column in columns: - client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.insert('key'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode()))) - client.batch_mutate({''.encode(): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start='c2'.encode(), finish='c4'.encode()))) + client.batch_mutate({'key'.encode(): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists(''.encode(), ColumnPath('Standard1', column=''.encode())) - _assert_no_columnpath(''.encode(), ColumnPath('Standard1', column=''.encode())) - _assert_no_columnpath(''.encode(), ColumnPath('Standard1', column=''.encode())) - _assert_no_columnpath(''.encode(), ColumnPath('Standard1', column=''.encode())) - _assert_columnpath_exists(''.encode(), ColumnPath('Standard1', column=''.encode())) + _assert_columnpath_exists('key'.encode(), ColumnPath('Standard1', column='c1'.encode())) + _assert_no_columnpath('key'.encode(), ColumnPath('Standard1', column='c2'.encode())) + _assert_no_columnpath('key'.encode(), ColumnPath('Standard1', column='c3'.encode())) + _assert_no_columnpath('key'.encode(), ColumnPath('Standard1', column='c4'.encode())) + _assert_columnpath_exists('key'.encode(), ColumnPath('Standard1', column='c5'.encode())) # known failure: see CASSANDRA-10046 def test_batch_mutate_remove_slice_of_entire_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [SuperColumn(name=''.encode(), columns=[Column(_i64(1), ''.encode(), 0)]), - SuperColumn(name=''.encode(), - columns=[Column(_i64(2), ''.encode() , 0), Column(_i64(3), ''.encode() , 0)]), - SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), - SuperColumn(name=''.encode(), - columns=[Column(_i64(5), ''.encode() , 0), Column(_i64(6), ''.encode() , 0)]), - SuperColumn(name=''.encode(), columns=[Column(_i64(7), ''.encode(), 0)])] + columns = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(1), 'value1'.encode(), 0)]), + SuperColumn(name='sc2'.encode(), + columns=[Column(_i64(2), 'value2'.encode() , 0), Column(_i64(3), 'value3'.encode() , 0)]), + SuperColumn(name='sc3'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), + SuperColumn(name='sc4'.encode(), + columns=[Column(_i64(5), 'value5'.encode() , 0), Column(_i64(6), 'value6'.encode() , 0)]), + SuperColumn(name='sc5'.encode(), columns=[Column(_i64(7), 'value7'.encode(), 0)])] for column in columns: for subcolumn in column.columns: - client.insert(''.encode(), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) + client.insert('key'.encode(), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=''.encode() , finish=''.encode() ))) - client.batch_mutate({''.encode(): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start='sc2'.encode() , finish='sc4'.encode() ))) + client.batch_mutate({'key'.encode(): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(1))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(2))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(3))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(4))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(5))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(6))) - _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(7))) + _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(1))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc2'.encode(), column=_i64(2))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc2'.encode(), column=_i64(3))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc3'.encode(), column=_i64(4))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc4'.encode(), column=_i64(5))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc4'.encode(), column=_i64(6))) + _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc5'.encode(), column=_i64(7))) @since('1.0', '2.2') @pytest.mark.skip(reason="Runs but fails and looks like it actually should fail since 8099?") @@ -861,49 +865,49 @@ def test_batch_mutate_remove_slice_part_of_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [Column(_i64(1), ''.encode(), 0), - Column(_i64(2), ''.encode(), 0), - Column(_i64(3), ''.encode(), 0), - Column(_i64(4), ''.encode(), 0), - Column(_i64(5), ''.encode(), 0)] + columns = [Column(_i64(1), 'value1'.encode(), 0), + Column(_i64(2), 'value2'.encode(), 0), + Column(_i64(3), 'value3'.encode(), 0), + Column(_i64(4), 'value4'.encode(), 0), + Column(_i64(5), 'value5'.encode(), 0)] for column in columns: - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), column, ConsistencyLevel.ONE) + client.insert('key'.encode(), ColumnParent('Super1', 'sc1'.encode()), column, ConsistencyLevel.ONE) r = SliceRange(start=_i64(2), finish=_i64(4)) - d = Deletion(1, super_column=''.encode() , predicate=SlicePredicate(slice_range=r)) - client.batch_mutate({''.encode(): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, super_column='sc1'.encode() , predicate=SlicePredicate(slice_range=r)) + client.batch_mutate({'key'.encode(): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(1))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(2))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(3))) - _assert_no_columnpath(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(4))) - _assert_columnpath_exists(''.encode(), ColumnPath('Super1', super_column=''.encode(), column=_i64(5))) + _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(1))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(2))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(3))) + _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(4))) + _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(5))) def test_batch_mutate_insertions_and_deletions(self): _set_keyspace('Keyspace1') self.truncate_all('Super1', 'Super2') - first_insert = SuperColumn('sc1'.encode(), - columns=[Column(_i64(20), ''.encode(), 3), - Column(_i64(21), ''.encode(), 3)]) - second_insert = SuperColumn('sc1'.encode(), - columns=[Column(_i64(20), ''.encode(), 3), - Column(_i64(21), ''.encode(), 3)]) - first_deletion = {'super_column': 'sc1'.encode(), + first_insert = SuperColumn(''.encode(), + columns=[Column(_i64(20), 'value20'.encode(), 3), + Column(_i64(21), 'value21'.encode(), 3)]) + second_insert = SuperColumn(''.encode(), + columns=[Column(_i64(20), 'value20'.encode(), 3), + Column(_i64(21), 'value21'.encode(), 3)]) + first_deletion = {'super_column': ''.encode(), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - second_deletion = {'super_column': 'sc2'.encode(), + second_deletion = {'super_column': ''.encode(), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - keys = [''.encode(), ''.encode()] + keys = ['key_30'.encode(), 'key_31'.encode()] for key in keys: - sc = SuperColumn(''.encode(), [Column(_i64(22), ''.encode(), 0), - Column(_i64(23), ''.encode(), 0)]) + sc = SuperColumn('sc1'.encode(), [Column(_i64(22), 'value22'.encode(), 0), + Column(_i64(23), 'value23'.encode(), 0)]) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=sc))]} client.batch_mutate({key: cfmap}, ConsistencyLevel.ONE) - sc2 = SuperColumn(''.encode(), [Column(_i64(22), ''.encode(), 0), - Column(_i64(23), ''.encode(), 0)]) + sc2 = SuperColumn('sc2'.encode(), [Column(_i64(22), 'value22'.encode(), 0), + Column(_i64(23), 'value23'.encode(), 0)]) cfmap2 = {'Super2': [Mutation(ColumnOrSuperColumn(super_column=sc2))]} client.batch_mutate({key: cfmap2}, ConsistencyLevel.ONE) @@ -920,18 +924,18 @@ def test_batch_mutate_insertions_and_deletions(self): for key in keys: for c in [_i64(22), _i64(23)]: - _assert_no_columnpath(key, ColumnPath('Super1', super_column=''.encode(), column=c)) - _assert_no_columnpath(key, ColumnPath('Super2', super_column=''.encode(), column=c)) + _assert_no_columnpath(key, ColumnPath('Super1', super_column='sc1'.encode(), column=c)) + _assert_no_columnpath(key, ColumnPath('Super2', super_column='sc2'.encode(), column=c)) for c in [_i64(20), _i64(21)]: - _assert_columnpath_exists(key, ColumnPath('Super1', super_column=''.encode(), column=c)) - _assert_columnpath_exists(key, ColumnPath('Super2', super_column=''.encode(), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super1', super_column='sc1'.encode(), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super2', super_column='sc1'.encode(), column=c)) def test_bad_system_calls(self): def duplicate_index_names(): _set_keyspace('Keyspace1') - cd1 = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'i') - cd2 = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'i') + cd1 = ColumnDef('foo'.encode(), 'BytesType', IndexType.KEYS, 'i') + cd2 = ColumnDef('bar'.encode(), 'BytesType', IndexType.KEYS, 'i') cf = CfDef('Keyspace1', 'BadCF', column_metadata=[cd1, cd2]) client.system_add_column_family(cf) _expect_exception(duplicate_index_names, InvalidRequestException) @@ -940,33 +944,33 @@ def test_bad_batch_calls(self): # mutate_does_not_accept_cosc_and_deletion_in_same_mutation def too_full(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column('foo'.encode(), ''.encode(), 0)) - dele = Deletion(2, predicate=SlicePredicate(column_names=[''.encode()])) - client.batch_mutate({''.encode(): {'Standard1': [Mutation(col, dele)]}}, + col = ColumnOrSuperColumn(column=Column(''.encode(), 'bar'.encode(), 0)) + dele = Deletion(2, predicate=SlicePredicate(column_names=['baz'.encode()])) + client.batch_mutate({'key_34'.encode(): {'Standard1': [Mutation(col, dele)]}}, ConsistencyLevel.ONE) _expect_exception(too_full, InvalidRequestException) # test_batch_mutate_does_not_accept_cosc_on_undefined_cf: def bad_cf(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column('foo'.encode(), ''.encode(), 0)) - client.batch_mutate({''.encode(): {'Undefined': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column(''.encode(), 'bar'.encode(), 0)) + client.batch_mutate({'key_36'.encode(): {'Undefined': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf, InvalidRequestException) # test_batch_mutate_does_not_accept_deletion_on_undefined_cf def bad_cf_2(): _set_keyspace('Keyspace1') - d = Deletion(2, predicate=SlicePredicate(column_names=[''.encode()])) - client.batch_mutate({''.encode(): {'Undefined': [Mutation(deletion=d)]}}, + d = Deletion(2, predicate=SlicePredicate(column_names=['baz'.encode()])) + client.batch_mutate({'key_37'.encode(): {'Undefined': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf_2, InvalidRequestException) # a column value that does not match the declared validator def send_string_instead_of_long(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column(''.encode(), ''.encode(), 0)) - client.batch_mutate({''.encode(): {'Indexed1': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column('birthdate'.encode(), 'bar'.encode(), 0)) + client.batch_mutate({'key_38'.encode(): {'Indexed1': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(send_string_instead_of_long, InvalidRequestException) @@ -974,16 +978,16 @@ def test_column_name_lengths(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 1), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 127), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 128), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 129), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 255), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 256), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 257), ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), ''.encode(), 0), ConsistencyLevel.ONE) - _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1'), Column(''.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 1), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 127), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 128), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 129), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 255), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 256), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 257), 'value'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), 'value'.encode(), 0), ConsistencyLevel.ONE) + _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) def test_bad_calls(self): _set_keyspace('Keyspace1') @@ -991,71 +995,71 @@ def test_bad_calls(self): # missing arguments _expect_exception(lambda: client.insert(None, None, None, None), TApplicationException) # supercolumn in a non-super CF - _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1', ''.encode()), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1', 'x'.encode()), Column('y'.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) # no supercolumn in a super CF - _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Super1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Super1'), Column('y'.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) # column but no supercolumn in remove - _expect_exception(lambda: client.remove(''.encode(), ColumnPath('Super1', column=''.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove('key1'.encode(), ColumnPath('Super1', column='x'.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) # super column in non-super CF - _expect_exception(lambda: client.remove(''.encode(), ColumnPath('Standard1', ''.encode(), ''.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove('key1'.encode(), ColumnPath('Standard1', 'y'.encode(), 'x'.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) # key too long - _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE), InvalidRequestException) # empty key - _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE), InvalidRequestException) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} _expect_exception(lambda: client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE), InvalidRequestException) # empty column name - _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify column name - _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) # supercolumn in a non-super CF - _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', ''.encode(), ''.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Standard1', 'x'.encode(), 'y'.encode()), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify supercolumn name - _expect_exception(lambda: client.get(''.encode(), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) # invalid CF _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE), InvalidRequestException) # 'x' is not a valid Long - _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Super1', 'sc1'.encode()), Column('x'.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) + p = SlicePredicate(slice_range=SliceRange('x'.encode(), ''.encode(), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long, supercolumn version - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) - column_parent = ColumnParent('Super1', ''.encode()) - _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), + p = SlicePredicate(slice_range=SliceRange('x'.encode(), ''.encode(), False, 1)) + column_parent = ColumnParent('Super1', 'sc1'.encode()) + _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, supercolumn version p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) - column_parent = ColumnParent('Super1', ''.encode()) - _expect_exception(lambda: client.get_slice(''.encode(), column_parent, p, ConsistencyLevel.ONE), + column_parent = ColumnParent('Super1', 'sc1'.encode()) + _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, key version - _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode()]), 'z'.encode(), 'a'.encode(), 1, ConsistencyLevel.ONE), InvalidRequestException) # ttl must be greater or equals to zero - column = Column(''.encode(), ''.encode(), 0, -1) - _expect_exception(lambda: client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), + column = Column('cttl1'.encode(), 'value1'.encode(), 0, -1) + _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), InvalidRequestException) # don't allow super_column in Deletion for standard Columntest_expiration_with_default_ttl_and_zero_ttl - deletion = Deletion(1, ''.encode(), None) + deletion = Deletion(1, 'supercolumn'.encode(), None) mutation = Mutation(deletion=deletion) - mutations = {''.encode(): {'Standard1': [mutation]}} + mutations = {'key'.encode(): {'Standard1': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # 'x' is not a valid long - deletion = Deletion(1, ''.encode(), None) + deletion = Deletion(1, 'x'.encode(), None) mutation = Mutation(deletion=deletion) - mutations = {''.encode(): {'Super3': [mutation]}} + mutations = {'key'.encode(): {'Super3': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # counters don't support ANY - _expect_exception(lambda: client.add(''.encode(), ColumnParent('Counter1', ''.encode()), CounterColumn(''.encode(), 1), ConsistencyLevel.ANY), InvalidRequestException) + _expect_exception(lambda: client.add('key1'.encode(), ColumnParent('Counter1', 'x'.encode()), CounterColumn('y'.encode(), 1), ConsistencyLevel.ANY), InvalidRequestException) def test_batch_insert_super(self): _set_keyspace('Keyspace1') @@ -1065,7 +1069,7 @@ def test_batch_insert_super(self): for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({'key1'.encode(): cfmap}, ConsistencyLevel.ONE) _verify_super('Super1') _verify_super('Super2') @@ -1074,30 +1078,30 @@ def test_cf_remove_column(self): self.truncate_all('Standard1') _insert_simple() - client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) - assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column \ - == Column(''.encode(), ''.encode(), 0) - assert _big_slice(''.encode(), ColumnParent('Standard1')) \ - == [ColumnOrSuperColumn(column=Column(''.encode(), ''.encode(), 0))] + client.remove('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE)) + assert client.get('key1'.encode(), ColumnPath('Standard1', column='c2'.encode()), ConsistencyLevel.ONE).column \ + == Column('c2'.encode(), 'value2'.encode(), 0) + assert _big_slice('key1'.encode(), ColumnParent('Standard1')) \ + == [ColumnOrSuperColumn(column=Column('c2'.encode(), 'value2'.encode(), 0))] # New insert, make sure it shows up post-remove: - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c3'.encode(), 'value3'.encode(), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice(''.encode(), ColumnParent('Standard1'))] - assert columns == [Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)], columns + for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] + assert columns == [Column('c2'.encode(), 'value2'.encode(), 0), Column('c3'.encode(), 'value3'.encode(), 0)], columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice(''.encode(), ColumnParent('Standard1'))] - assert columns == [Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)], columns + for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] + assert columns == [Column('c2'.encode(), 'value2'.encode(), 0), Column('c3'.encode(), 'value3'.encode(), 0)], columns # Next, w/ a newer timestamp; it should come back: - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 2), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 2), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice(''.encode(), ColumnParent('Standard1'))] - assert columns == [Column(''.encode(), ''.encode(), 2), Column(''.encode(), ''.encode(), 0), Column(''.encode(), ''.encode(), 0)], columns + for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] + assert columns == [Column('c1'.encode(), 'value1'.encode(), 2), Column('c2'.encode(), 'value2'.encode(), 0), Column('c3'.encode(), 'value3'.encode(), 0)], columns def test_cf_remove(self): _set_keyspace('Keyspace1') @@ -1107,36 +1111,36 @@ def test_cf_remove(self): _insert_super() # Remove the key1:Standard1 cf; verify super is unaffected - client.remove(''.encode(), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) - assert _big_slice(''.encode(), ColumnParent('Standard1')) == [] + client.remove('key1'.encode(), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) + assert _big_slice('key1'.encode(), ColumnParent('Standard1')) == [] _verify_super() # Test resurrection. First, re-insert a value w/ older timestamp, # and make sure it stays removed: - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - assert _big_slice(''.encode(), ColumnParent('Standard1')) == [] + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), ConsistencyLevel.ONE) + assert _big_slice('key1'.encode(), ColumnParent('Standard1')) == [] # Next, w/ a newer timestamp; it should come back: - client.insert(''.encode(), ColumnParent('Standard1'), Column(''.encode(), ''.encode(), 4), ConsistencyLevel.ONE) - result = _big_slice(''.encode(), ColumnParent('Standard1')) - assert result == [ColumnOrSuperColumn(column=Column(''.encode(), ''.encode(), 4))], result + client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 4), ConsistencyLevel.ONE) + result = _big_slice('key1'.encode(), ColumnParent('Standard1')) + assert result == [ColumnOrSuperColumn(column=Column('c1'.encode(), 'value1'.encode(), 4))], result # check removing the entire super cf, too. - client.remove(''.encode(), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) - assert _big_slice(''.encode(), ColumnParent('Super1')) == [] - assert _big_slice(''.encode(), ColumnParent('Super1', ''.encode())) == [] + client.remove('key1'.encode(), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) + assert _big_slice('key1'.encode(), ColumnParent('Super1')) == [] + assert _big_slice('key1'.encode(), ColumnParent('Super1', 'sc1'.encode())) == [] def test_super_cf_remove_and_range_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(1), ''.encode(), 0), ConsistencyLevel.ONE) - client.remove(''.encode(), ColumnPath('Super1', ''.encode()), 5, ConsistencyLevel.ONE) + client.insert('key3'.encode(), ColumnParent('Super1', 'sc1'.encode()), Column(_i64(1), 'v1'.encode(), 0), ConsistencyLevel.ONE) + client.remove('key3'.encode(), ColumnPath('Super1', 'sc1'.encode()), 5, ConsistencyLevel.ONE) rows = {} for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE): scs = [cosc.super_column for cosc in row.columns] rows[row.key] = scs - assert rows == {''.encode(): []}, rows + assert rows == {'key3'.encode(): []}, rows def test_super_cf_remove_column(self): _set_keyspace('Keyspace1') @@ -1146,42 +1150,42 @@ def test_super_cf_remove_column(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove(''.encode(), ColumnPath('Super1', ''.encode(), _i64(5)), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(5)), ConsistencyLevel.ONE)) - super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] - assert super_columns == [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), - SuperColumn(name=''.encode(), columns=[Column(_i64(6), ''.encode(), 0)])] + client.remove('key1'.encode(), ColumnPath('Super1', 'sc2'.encode(), _i64(5)), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc2'.encode(), _i64(5)), ConsistencyLevel.ONE)) + super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + assert super_columns == [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), + SuperColumn(name='sc2'.encode(), columns=[Column(_i64(6), 'value6'.encode(), 0)])] _verify_simple() # New insert, make sure it shows up post-remove: - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(7), ''.encode(), 0), ConsistencyLevel.ONE) - super_columns_expected = [SuperColumn(name=''.encode(), - columns=[Column(_i64(4), ''.encode(), 0)]), - SuperColumn(name=''.encode(), - columns=[Column(_i64(6), ''.encode(), 0), Column(_i64(7), ''.encode(), 0)])] + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(7), 'value7'.encode(), 0), ConsistencyLevel.ONE) + super_columns_expected = [SuperColumn(name='sc1'.encode(), + columns=[Column(_i64(4), 'value4'.encode(), 0)]), + SuperColumn(name='sc2'.encode(), + columns=[Column(_i64(6), 'value6'.encode(), 0), Column(_i64(7), 'value7'.encode(), 0)])] - super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 0), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 6), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice(''.encode(), ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), - SuperColumn(name=''.encode(), columns=[Column(_i64(5), ''.encode(), 6), - Column(_i64(6), ''.encode(), 0), - Column(_i64(7), ''.encode(), 0)])] + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 6), ConsistencyLevel.ONE) + super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), + SuperColumn(name='sc2'.encode(), columns=[Column(_i64(5), 'value5'.encode(), 6), + Column(_i64(6), 'value6'.encode(), 0), + Column(_i64(7), 'value7'.encode(), 0)])] assert super_columns == super_columns_expected, super_columns # shouldn't be able to specify a column w/o a super column for remove - cp = ColumnPath(column_family='Super1', column=''.encode()) - e = _expect_exception(lambda: client.remove(''.encode(), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) + cp = ColumnPath(column_family='Super1', column='sc2'.encode()) + e = _expect_exception(lambda: client.remove('key1'.encode(), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("column cannot be specified without") >= 0 def test_super_cf_remove_supercolumn(self): @@ -1192,66 +1196,66 @@ def test_super_cf_remove_supercolumn(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove(''.encode(), ColumnPath('Super1', ''.encode()), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode(), _i64(5)), ConsistencyLevel.ONE)) - super_columns = _big_slice(''.encode(), ColumnParent('Super1', ''.encode())) + client.remove('key1'.encode(), ColumnPath('Super1', 'sc2'.encode()), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc2'.encode(), _i64(5)), ConsistencyLevel.ONE)) + super_columns = _big_slice('key1'.encode(), ColumnParent('Super1', 'sc2'.encode())) assert super_columns == [], super_columns - super_columns_expected = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)])] + super_columns_expected = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)])] super_columns = [result.super_column - for result in _big_slice(''.encode(), ColumnParent('Super1'))] + for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns _verify_simple() # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 1), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 1), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice(''.encode(), ColumnParent('Super1'))] + for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(5), ''.encode(), 6), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 6), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice(''.encode(), ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name=''.encode(), columns=[Column(_i64(4), ''.encode(), 0)]), - SuperColumn(name=''.encode(), columns=[Column(_i64(5), ''.encode(), 6)])] + for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), + SuperColumn(name='sc2'.encode(), columns=[Column(_i64(5), 'value5'.encode(), 6)])] assert super_columns == super_columns_expected, super_columns # check slicing at the subcolumn level too p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) columns = [result.column - for result in client.get_slice(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE)] - assert columns == [Column(_i64(5), ''.encode(), 6)], columns + for result in client.get_slice('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), p, ConsistencyLevel.ONE)] + assert columns == [Column(_i64(5), 'value5'.encode(), 6)], columns def test_super_cf_resurrect_subcolumn(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - key = ''.encode() - client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 0), ConsistencyLevel.ONE) + key = 'vijay'.encode() + client.insert(key, ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 0), ConsistencyLevel.ONE) - client.remove(key, ColumnPath('Super1', ''.encode()), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super1', 'sc1'.encode()), 1, ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', ''.encode()), Column(_i64(4), ''.encode(), 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 2), ConsistencyLevel.ONE) - result = client.get(key, ColumnPath('Super1', ''.encode()), ConsistencyLevel.ONE) + result = client.get(key, ColumnPath('Super1', 'sc1'.encode()), ConsistencyLevel.ONE) assert result.super_column.columns is not None, result.super_column def test_empty_range(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Super1') - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] _insert_simple() - assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] @since('2.1') def test_super_cql_read_compatibility(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _insert_super('key1'.encode()) - _insert_super('key2'.encode()) + _insert_super(''.encode()) + _insert_super(''.encode()) node1 = self.cluster.nodelist()[0] session = self.patient_cql_connection(node1) @@ -1259,32 +1263,32 @@ def test_super_cql_read_compatibility(self): session.execute('USE "Keyspace1"') assert_all(session, "SELECT * FROM \"Super1\"", - [['key1'.encode(), 'sc1'.encode(), 4, 'value4'.encode()], - ['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], - ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()], - ['key2'.encode(), 'sc1'.encode(), 4, 'value4'.encode()], - ['key2'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], - ['key2'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) + [[''.encode(), ''.encode(), 4, ''.encode()], + [''.encode(), ''.encode(), 5, ''.encode()], + [''.encode(), ''.encode(), 6, ''.encode()], + [''.encode(), ''.encode(), 4, ''.encode()], + [''.encode(), ''.encode(), 5, ''.encode()], + [''.encode(), ''.encode(), 6, ''.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1')", - [['key1'.encode(), 'sc1'.encode(), 4, 'value4'.encode()], - ['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], - ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) + [[''.encode(), ''.encode(), 4, ''.encode()], + [''.encode(), ''.encode(), 5, ''.encode()], + [''.encode(), ''.encode(), 6, ''.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2')", - [['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], - ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) + [[''.encode(), ''.encode(), 5, ''.encode()], + [''.encode(), ''.encode(), 6, ''.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2') AND column2 = 5", - [['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()]]) + [[''.encode(), ''.encode(), 5, ''.encode()]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [['key1'.encode(), 'sc2'.encode(), 5, 'value5'.encode()], - ['key1'.encode(), 'sc2'.encode(), 6, 'value6'.encode()]]) + [[''.encode(), ''.encode(), 5, ''.encode()], + [''.encode(), ''.encode(), 6, ''.encode()]]) assert_all(session, "SELECT column2, value FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [[5, 'value5'.encode()], - [6, 'value6'.encode()]]) + [[5, ''.encode()], + [6, ''.encode()]]) @since('2.1') def test_super_cql_write_compatibility(self): @@ -1304,36 +1308,36 @@ def test_super_cql_write_compatibility(self): session.execute(query, ("key2", "sc2", 5, "value5")) session.execute(query, ("key2", "sc2", 6, "value6")) - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) - result = client.get_slice(''.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange('sc1'.encode(), 'sc2'.encode(), False, 2)) + result = client.get_slice('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert_length_equal(result, 2) - assert result[0].super_column.name == ''.encode() - assert result[0].super_column.columns[0], Column(_i64(4), ''.encode() == 1234) - assert result[1].super_column.name == ''.encode() - assert result[1].super_column.columns, [Column(_i64(5), ''.encode(), 1234), Column(_i64(6), ''.encode() == 1234)] + assert result[0].super_column.name == 'sc1'.encode() + assert result[0].super_column.columns[0], Column(_i64(4), 'value4'.encode() == 1234) + assert result[1].super_column.name == 'sc2'.encode() + assert result[1].super_column.columns, [Column(_i64(5), 'value5'.encode(), 1234), Column(_i64(6), 'value6'.encode() == 1234)] def test_range_with_remove(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == ''.encode() + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), 'key1'.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == 'key1'.encode() - client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) - client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key=''.encode())], actual + client.remove('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), 1, ConsistencyLevel.ONE) + client.remove('key1'.encode(), ColumnPath('Standard1', column='c2'.encode()), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c2'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key='key1'.encode())], actual def test_range_with_remove_cf(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == ''.encode() + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), 'key1'.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == 'key1'.encode() - client.remove(''.encode(), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key=''.encode())], actual + client.remove('key1'.encode(), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key='key1'.encode())], actual def test_range_collation(self): _set_keyspace('Keyspace1') @@ -1341,9 +1345,9 @@ def test_range_collation(self): for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(key, ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(key, 'v'.encode(), 0), ConsistencyLevel.ONE) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) L = ['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '2', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '3', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '4', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '5', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '6', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '7', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '8', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '9', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', 'a', 'b'] assert len(slices) == len(L) for key, ks in zip(L, slices): @@ -1356,7 +1360,7 @@ def test_range_partial(self): for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(key, ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(key, 'v'.encode(), 0), ConsistencyLevel.ONE) def check_slices_against_keys(keyList, sliceList): assert len(keyList) == len(sliceList), "%d vs %d" % (len(keyList), len(sliceList)) @@ -1364,16 +1368,16 @@ def check_slices_against_keys(keyList, sliceList): key = utf8encode(key) assert key == ks.key - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), 'a'.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['a', 'b'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), ''.encode(), '15'.encode(), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), '50'.encode(), '51'.encode(), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['50', '51'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 10, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), '1'.encode(), ''.encode(), 10, ConsistencyLevel.ONE) check_slices_against_keys(['1', '10', '11', '12', '13', '14', '15', '16', '17', '18'], slices) def test_get_slice_range(self): @@ -1398,15 +1402,15 @@ def test_get_range_slices_tokens(self): key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: cnameutf = utf8encode(cname) - client.insert(key, ColumnParent('Super3', ''.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', 'sc1'.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', ''.encode()) - predicate = SlicePredicate(column_names=[''.encode(), ''.encode()]) + cp = ColumnParent('Super3', 'sc1'.encode()) + predicate = SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]) range = KeyRange(start_token='55', end_token='55', count=100) result = client.get_range_slices(cp, predicate, range, ConsistencyLevel.ONE) assert len(result) == 5 - assert result[0].columns[0].column.name == ''.encode() - assert result[0].columns[1].column.name == ''.encode() + assert result[0].columns[0].column.name == 'col1'.encode() + assert result[0].columns[1].column.name == 'col3'.encode() def test_get_range_slice_super(self): _set_keyspace('Keyspace2') @@ -1416,18 +1420,18 @@ def test_get_range_slice_super(self): key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: cnameutf = utf8encode(cname) - client.insert(key, ColumnParent('Super3', ''.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', 'sc1'.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', ''.encode()) - result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + cp = ColumnParent('Super3', 'sc1'.encode()) + result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key2'.encode(), 'key4'.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert result[0].columns[0].column.name == ''.encode() - assert result[0].columns[1].column.name == ''.encode() + assert result[0].columns[0].column.name == 'col1'.encode() + assert result[0].columns[1].column.name == 'col3'.encode() cp = ColumnParent('Super3') - result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=['sc1'.encode()]), 'key2'.encode(), 'key4'.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert list(set(row.columns[0].super_column.name for row in result))[0] == ''.encode() + assert list(set(row.columns[0].super_column.name for row in result))[0] == 'sc1'.encode() def test_get_range_slice(self): _set_keyspace('Keyspace1') @@ -1441,52 +1445,52 @@ def test_get_range_slice(self): cp = ColumnParent('Standard1') # test empty slice - result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key6'.encode(), ''.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 0 # test empty columns - result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=['a'.encode()]), 'key2'.encode(), ''.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 1 assert len(result[0].columns) == 0 # test column_names predicate - result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key2'.encode(), 'key4'.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 3, result - assert result[0].columns[0].column.name == ''.encode() - assert result[0].columns[1].column.name == ''.encode() + assert result[0].columns[0].column.name == 'col1'.encode() + assert result[0].columns[1].column.name == 'col3'.encode() # row limiting via count. - result = get_range_slice(client, cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key2'.encode(), 'key4'.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 1 # test column slice predicate - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=False, count=5)), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2'.encode(), finish='col4'.encode(), reversed=False, count=5)), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].key == ''.encode() - assert result[1].key == ''.encode() + assert result[0].key == 'key1'.encode() + assert result[1].key == 'key2'.encode() assert len(result[0].columns) == 3 - assert result[0].columns[0].column.name == ''.encode() - assert result[0].columns[2].column.name == ''.encode() + assert result[0].columns[0].column.name == 'col2'.encode() + assert result[0].columns[2].column.name == 'col4'.encode() # col limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=False, count=2)), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2'.encode(), finish='col4'.encode(), reversed=False, count=2)), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) assert len(result[0].columns) == 2 # and reversed - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=True, count=5)), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) - assert result[0].columns[0].column.name == ''.encode() - assert result[0].columns[2].column.name == ''.encode() + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col4'.encode(), finish='col2'.encode(), reversed=True, count=5)), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) + assert result[0].columns[0].column.name == 'col4'.encode() + assert result[0].columns[2].column.name == 'col2'.encode() # row limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=''.encode(), finish=''.encode(), reversed=False, count=5)), ''.encode(), ''.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2'.encode(), finish='col4'.encode(), reversed=False, count=5)), 'key1'.encode(), 'key2'.encode(), 1, ConsistencyLevel.ONE) assert len(result) == 1 # removed data - client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE) + client.remove('key1'.encode(), ColumnPath('Standard1', column='col1'.encode()), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) assert len(result) == 2, result - assert result[0].columns[0].column.name == ''.encode(), result[0].columns[0].column.name - assert result[1].columns[0].column.name == ''.encode() + assert result[0].columns[0].column.name == 'col2'.encode(), result[0].columns[0].column.name + assert result[1].columns[0].column.name == 'col1'.encode() def test_wrapped_range_slices(self): _set_keyspace('Keyspace1') @@ -1506,10 +1510,10 @@ def copp_token(key): client.insert(key, ColumnParent('Standard1'), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) cp = ColumnParent('Standard1') - result = client.get_range_slices(cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) + result = client.get_range_slices(cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) assert [row.key for row in result] == keylist, [row.key for row in result] - result = client.get_range_slices(cp, SlicePredicate(column_names=[''.encode(), ''.encode()]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) + result = client.get_range_slices(cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) assert [row.key for row in result] == keylist, [row.key for row in result] def test_get_slice_by_names(self): @@ -1517,15 +1521,15 @@ def test_get_slice_by_names(self): self.truncate_all('Standard1', 'Super1') _insert_range() - p = SlicePredicate(column_names=[''.encode(), ''.encode()]) - result = client.get_slice(''.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(column_names=['c1'.encode(), 'c2'.encode()]) + result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == ''.encode() - assert result[1].column.name == ''.encode() + assert result[0].column.name == 'c1'.encode() + assert result[1].column.name == 'c2'.encode() _insert_super() p = SlicePredicate(column_names=[_i64(4)]) - result = client.get_slice(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE) + result = client.get_slice('key1'.encode(), ColumnParent('Super1', 'sc1'.encode()), p, ConsistencyLevel.ONE) assert len(result) == 1 assert result[0].column.name == _i64(4) @@ -1534,23 +1538,23 @@ def test_multiget_slice_with_compact_table(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef(''.encode(), 'AsciiType', None, None) + cd = ColumnDef('v'.encode(), 'AsciiType', None, None) newcf = CfDef('Keyspace1', 'CompactColumnFamily', default_validation_class='AsciiType', column_metadata=[cd]) client.system_add_column_family(newcf) CL = ConsistencyLevel.ONE for i in range(0, 5): - client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column(''.encode(), utf8encode('value' + str(i)), 0), CL) + client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column('v'.encode(), utf8encode('value' + str(i)), 0), CL) time.sleep(0.1) - p = SlicePredicate(column_names=[''.encode()]) + p = SlicePredicate(column_names=['v'.encode()]) rows = client.multiget_slice([utf8encode('key' + str(i)) for i in range(0, 5)], ColumnParent('CompactColumnFamily'), p, ConsistencyLevel.ONE) for i in range(0, 5): key = utf8encode('key' + str(i)) assert key in rows assert len(rows[key]) == 1 - assert rows[key][0].column.name == ''.encode() + assert rows[key][0].column.name == 'v'.encode() assert rows[key][0].column.value == utf8encode('value' + str(i)) def test_multiget_slice(self): @@ -1599,26 +1603,26 @@ def test_batch_mutate_super_deletion(self): self.truncate_all('Super1') _insert_super('test') - d = Deletion(1, predicate=SlicePredicate(column_names=[''.encode()])) + d = Deletion(1, predicate=SlicePredicate(column_names=['sc1'.encode()])) cfmap = {'Super1': [Mutation(deletion=d)]} - client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Super1', ''.encode()), ConsistencyLevel.ONE)) + client.batch_mutate({'test'.encode(): cfmap}, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc1'.encode()), ConsistencyLevel.ONE)) def test_super_reinsert(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') for x in range(3): - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(x), ''.encode(), 1), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(x), 'value'.encode(), 1), ConsistencyLevel.ONE) - client.remove(''.encode(), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) + client.remove('key1'.encode(), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) for x in range(3): - client.insert(''.encode(), ColumnParent('Super1', ''.encode()), Column(_i64(x + 3), ''.encode(), 3), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(x + 3), 'value'.encode(), 3), ConsistencyLevel.ONE) for n in range(1, 4): p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, n)) - slice = client.get_slice(''.encode(), ColumnParent('Super1', ''.encode()), p, ConsistencyLevel.ONE) + slice = client.get_slice('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), p, ConsistencyLevel.ONE) assert len(slice) == n, "expected %s results; found %s" % (n, slice) def test_describe_keyspace(self): @@ -1722,9 +1726,9 @@ def test_system_cf_recreate(self): _set_keyspace(keyspace) # insert - client.insert(''.encode(), ColumnParent(cf_name), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) - col1 = client.get_slice(''.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE)[0].column - assert col1.name == ''.encode() and col1.value == ''.encode() + client.insert('key0'.encode(), ColumnParent(cf_name), Column('colA'.encode(), 'colA-value'.encode(), 0), ConsistencyLevel.ONE) + col1 = client.get_slice('key0'.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE)[0].column + assert col1.name == 'colA'.encode() and col1.value == 'colA-value'.encode() # drop client.system_drop_column_family(cf_name) @@ -1733,7 +1737,7 @@ def test_system_cf_recreate(self): client.system_add_column_family(newcf) # query - cosc_list = client.get_slice(''.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE) + cosc_list = client.get_slice('key0'.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE) # this was failing prior to CASSANDRA-1477. assert len(cosc_list) == 0, 'cosc length test failed' @@ -1802,17 +1806,17 @@ def test_column_validators(self): # columndef validation for regular CF ks = 'Keyspace1' _set_keyspace(ks) - cd = ColumnDef(''.encode(), 'LongType', None, None) + cd = ColumnDef('col'.encode(), 'LongType', None, None) cf = CfDef('Keyspace1', 'ValidatorColumnFamily', column_metadata=[cd]) client.system_add_column_family(cf) ks_def = client.describe_keyspace(ks) assert 'ValidatorColumnFamily' in [x.name for x in ks_def.cf_defs] cp = ColumnParent('ValidatorColumnFamily') - col0 = Column(''.encode(), _i64(42), 0) - col1 = Column(''.encode(), "ceci n'est pas 64bit".encode(), 0) - client.insert(''.encode(), cp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert(''.encode(), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) + col0 = Column('col'.encode(), _i64(42), 0) + col1 = Column('col'.encode(), ''.encode(), 0) + client.insert('key0'.encode(), cp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert('key1'.encode(), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef validation for super CF @@ -1821,9 +1825,9 @@ def test_column_validators(self): ks_def = client.describe_keyspace(ks) assert 'ValidatorSuperColumnFamily' in [x.name for x in ks_def.cf_defs] - scp = ColumnParent('ValidatorSuperColumnFamily', ''.encode()) - client.insert(''.encode(), scp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert(''.encode(), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) + scp = ColumnParent('ValidatorSuperColumnFamily', 'sc1'.encode()) + client.insert('key0'.encode(), scp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert('key1'.encode(), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef and cfdef default validation @@ -1834,23 +1838,23 @@ def test_column_validators(self): dcp = ColumnParent('DefaultValidatorColumnFamily') # inserting a longtype into column 'col' is valid at the columndef level - client.insert(''.encode(), dcp, col0, ConsistencyLevel.ONE) + client.insert('key0'.encode(), dcp, col0, ConsistencyLevel.ONE) # inserting a UTF8type into column 'col' fails at the columndef level - e = _expect_exception(lambda: client.insert(''.encode(), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) + e = _expect_exception(lambda: client.insert('key1'.encode(), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a longtype into column 'fcol' should fail at the cfdef level - col2 = Column(''.encode(), _i64(4224), 0) - e = _expect_exception(lambda: client.insert(''.encode(), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) + col2 = Column('fcol'.encode(), _i64(4224), 0) + e = _expect_exception(lambda: client.insert('key1'.encode(), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a UTF8type into column 'fcol' is valid at the cfdef level - col3 = Column(''.encode(), "Stringin' it up in the Stringtel Stringifornia".encode(), 0) - client.insert(''.encode(), dcp, col3, ConsistencyLevel.ONE) + col3 = Column('fcol'.encode(), ''.encode(), 0) + client.insert('key0'.encode(), dcp, col3, ConsistencyLevel.ONE) def test_system_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef(''.encode(), 'BytesType', None, None) + cd = ColumnDef('ValidationColumn'.encode(), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewColumnFamily', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -1903,36 +1907,36 @@ def test_dynamic_indexes_creation_deletion(self): ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'BlankCF'][0] - modified_cd = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, None) + modified_cd = ColumnDef('birthdate'.encode(), 'BytesType', IndexType.KEYS, None) modified_cf = CfDef('Keyspace1', 'BlankCF', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) # Add a second indexed CF ... - birthdate_coldef = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, None) - age_coldef = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'age_index') + birthdate_coldef = ColumnDef('birthdate'.encode(), 'BytesType', IndexType.KEYS, None) + age_coldef = ColumnDef('age'.encode(), 'BytesType', IndexType.KEYS, 'age_index') cfdef = CfDef('Keyspace1', 'BlankCF2', column_metadata=[birthdate_coldef, age_coldef]) client.system_add_column_family(cfdef) # ... and update it to have a third index ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - name_coldef = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'name_index') + name_coldef = ColumnDef('name'.encode(), 'BytesType', IndexType.KEYS, 'name_index') cfdef.column_metadata.append(name_coldef) client.system_update_column_family(cfdef) # Now drop the indexes ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - birthdate_coldef = ColumnDef(''.encode(), 'BytesType', None, None) - age_coldef = ColumnDef(''.encode(), 'BytesType', None, None) - name_coldef = ColumnDef(''.encode(), 'BytesType', None, None) + birthdate_coldef = ColumnDef('birthdate'.encode(), 'BytesType', None, None) + age_coldef = ColumnDef('age'.encode(), 'BytesType', None, None) + name_coldef = ColumnDef('name'.encode(), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef, age_coldef, name_coldef] client.system_update_column_family(cfdef) ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF'][0] - birthdate_coldef = ColumnDef(''.encode(), 'BytesType', None, None) + birthdate_coldef = ColumnDef('birthdate'.encode(), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef] client.system_update_column_family(cfdef) @@ -1941,29 +1945,29 @@ def test_dynamic_indexes_creation_deletion(self): def test_dynamic_indexes_with_system_update_cf(self): _set_keyspace('Keyspace1') - cd = ColumnDef(''.encode(), 'BytesType', None, None) + cd = ColumnDef('birthdate'.encode(), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'ToBeIndexed', default_validation_class='LongType', column_metadata=[cd]) client.system_add_column_family(newcf) - client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(1), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('ToBeIndexed'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('ToBeIndexed'), Column('birthdate'.encode(), _i64(1), 0), ConsistencyLevel.ONE) + client.insert('key2'.encode(), ColumnParent('ToBeIndexed'), Column('birthdate'.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert('key2'.encode(), ColumnParent('ToBeIndexed'), Column('b'.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert('key3'.encode(), ColumnParent('ToBeIndexed'), Column('birthdate'.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert('key3'.encode(), ColumnParent('ToBeIndexed'), Column('b'.encode(), _i64(3), 0), ConsistencyLevel.ONE) # First without index cp = ColumnParent('ToBeIndexed') sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == ''.encode() + assert result[0].key == 'key1'.encode() assert len(result[0].columns) == 1, result[0].columns # add an index on 'birthdate' ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'ToBeIndexed'][0] - modified_cd = ColumnDef(''.encode(), 'BytesType', IndexType.KEYS, 'bd_index') + modified_cd = ColumnDef('birthdate'.encode(), 'BytesType', IndexType.KEYS, 'bd_index') modified_cf = CfDef('Keyspace1', 'ToBeIndexed', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) @@ -1980,14 +1984,14 @@ def test_dynamic_indexes_with_system_update_cf(self): # repeat query on one index expression result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == ''.encode() + assert result[0].key == 'key1'.encode() assert len(result[0].columns) == 1, result[0].columns def test_system_super_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef(''.encode(), 'BytesType', None, None) + cd = ColumnDef('ValidationColumn'.encode(), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewSuperColumnFamily', 'Super', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -2004,32 +2008,32 @@ def test_insert_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(''.encode(), ''.encode(), 0, 5) - client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column == column + column = Column('cttl1'.encode(), 'value1'.encode(), 0, 5) + client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + assert client.get('key1'.encode(), ColumnPath('Standard1', column='cttl1'.encode()), ConsistencyLevel.ONE).column == column def test_simple_expiration(self): """ Test that column ttled do expires """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(''.encode(), ''.encode(), 0, 2) - client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - c = client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column + column = Column('cttl3'.encode(), 'value1'.encode(), 0, 2) + client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + c = client.get('key1'.encode(), ColumnPath('Standard1', column='cttl3'.encode()), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='cttl3'.encode()), ConsistencyLevel.ONE)) def test_expiration_with_default_ttl(self): """ Test that column with default ttl do expires """ _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column(''.encode(), ''.encode(), 0) - client.insert(''.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - client.get(''.encode(), ColumnPath('Expiring', column=''.encode()), ConsistencyLevel.ONE).column + column = Column('cttl3'.encode(), 'value1'.encode(), 0) + client.insert('key1'.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + client.get('key1'.encode(), ColumnPath('Expiring', column='cttl3'.encode()), ConsistencyLevel.ONE).column time.sleep(3) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Expiring', column=''.encode()), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Expiring', column='cttl3'.encode()), ConsistencyLevel.ONE)) @since('3.6') def test_expiration_with_default_ttl_and_zero_ttl(self): @@ -2040,45 +2044,45 @@ def test_expiration_with_default_ttl_and_zero_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column(''.encode(), ''.encode(), 0, 0) - client.insert(''.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - c = client.get(''.encode(), ColumnPath('Expiring', column=''.encode()), ConsistencyLevel.ONE).column - assert Column(''.encode(), ''.encode(), 0) == c + column = Column('cttl3'.encode(), 'value1'.encode(), 0, 0) + client.insert('key1'.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + c = client.get('key1'.encode(), ColumnPath('Expiring', column='cttl3'.encode()), ConsistencyLevel.ONE).column + assert Column('cttl3'.encode(), 'value1'.encode(), 0) == c def test_simple_expiration_batch_mutate(self): """ Test that column ttled do expires using batch_mutate """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(''.encode(), ''.encode(), 0, 2) + column = Column('cttl4'.encode(), 'value1'.encode(), 0, 2) cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(column))]} - client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE) - c = client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column + client.batch_mutate({'key1'.encode(): cfmap}, ConsistencyLevel.ONE) + c = client.get('key1'.encode(), ColumnPath('Standard1', column='cttl4'.encode()), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='cttl4'.encode()), ConsistencyLevel.ONE)) def test_update_expiring(self): """ Test that updating a column with ttl override the ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column1 = Column(''.encode(), ''.encode(), 0, 1) - client.insert(''.encode(), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) - column2 = Column(''.encode(), ''.encode(), 1) - client.insert(''.encode(), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) + column1 = Column('cttl4'.encode(), 'value1'.encode(), 0, 1) + client.insert('key1'.encode(), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) + column2 = Column('cttl4'.encode(), 'value1'.encode(), 1) + client.insert('key1'.encode(), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) time.sleep(1.5) - assert client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE).column == column2 + assert client.get('key1'.encode(), ColumnPath('Standard1', column='cttl4'.encode()), ConsistencyLevel.ONE).column == column2 def test_remove_expiring(self): """ Test removing a column with ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column(''.encode(), ''.encode(), 0, 10) - client.insert(''.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - client.remove(''.encode(), ColumnPath('Standard1', column=''.encode()), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get(''.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE)) + column = Column('cttl5'.encode(), 'value1'.encode(), 0, 10) + client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.remove('key1'.encode(), ColumnPath('Standard1', column='cttl5'.encode()), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='ctt5'.encode()), ConsistencyLevel.ONE)) def test_describe_ring_on_invalid_keyspace(self): def req(): @@ -2093,19 +2097,19 @@ def test_incr_decr_standard_add(self, request): d2 = -21 d3 = 35 # insert positive and negative values and check the counts - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) time.sleep(0.1) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d2), ConsistencyLevel.ONE) time.sleep(0.1) - rv2 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d3), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d3), ConsistencyLevel.ONE) time.sleep(0.1) - rv3 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) def test_incr_decr_super_add(self, request): @@ -2116,18 +2120,18 @@ def test_incr_decr_super_add(self, request): d2 = 52345 d3 = 3123 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=''.encode()), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c2'.encode(), d2), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_super_column.columns[0].value == d1 assert rv1.counter_super_column.columns[1].value == d2 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) - rv2 = client.get(key, ColumnPath('SuperCounter1', ''.encode(), ''.encode()), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d2), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath('SuperCounter1', 'sc1'.encode(), 'c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d3), ConsistencyLevel.ONE) - rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d3), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) def test_incr_standard_remove(self, request): @@ -2138,20 +2142,20 @@ def test_incr_standard_remove(self, request): d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=''.encode())) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1'.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=''.encode())) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1'.encode())) def test_incr_super_remove(self, request): _set_keyspace('Keyspace1') @@ -2161,20 +2165,20 @@ def test_incr_super_remove(self, request): d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) def test_incr_decr_standard_remove(self, request): _set_keyspace('Keyspace1') @@ -2184,20 +2188,20 @@ def test_incr_decr_standard_remove(self, request): d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=''.encode())) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1'.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=''.encode())) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1'.encode())) def test_incr_decr_super_remove(self, request): _set_keyspace('Keyspace1') @@ -2207,20 +2211,20 @@ def test_incr_decr_super_remove(self, request): d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=''.encode()), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=''.encode(), column=''.encode())) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode()), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) def test_incr_decr_standard_batch_add(self, request): _set_keyspace('Keyspace1') @@ -2229,13 +2233,13 @@ def test_incr_decr_standard_batch_add(self, request): d1 = 12 d2 = -21 update_map = {key: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d2))), ]}} # insert positive and negative values and check the counts client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 def test_incr_decr_standard_batch_remove(self, request): @@ -2248,34 +2252,34 @@ def test_incr_decr_standard_batch_remove(self, request): # insert positive and negative values and check the counts update_map = {key1: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 # remove the previous column and check that it is gone update_map = {key1: {'Counter1': [ - Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=[''.encode()]))), + Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=['c1'.encode()]))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=''.encode())) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1'.encode())) # insert again and this time delete the whole row, check that it is gone update_map = {key2: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(''.encode(), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=''.encode()), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 + d2 update_map = {key2: {'Counter1': [ Mutation(deletion=Deletion()), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=''.encode())) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1'.encode())) # known failure: see CASSANDRA-10046 def test_range_deletion(self): @@ -2285,16 +2289,16 @@ def test_range_deletion(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, ''.encode(), int(time.time() * 1000)) - client.insert(''.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, 'value'.encode(), int(time.time() * 1000)) + client.insert('key1'.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x01'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {''.encode(): {'StandardComposite': mutations}} + keyed_mutations = {'key1'.encode(): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) slice_predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)) - results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2313,17 +2317,17 @@ def test_range_deletion_eoc_0(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, ''.encode(), int(time.time() * 1000)) - client.insert(''.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, 'value'.encode(), int(time.time() * 1000)) + client.insert('key1'.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # insert a partial cell name (just the first element of the composite) column_name = composite('6', None, eoc=b'\x00') - column = Column(column_name, ''.encode(), int(time.time() * 1000)) - client.insert(''.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, 'value'.encode(), int(time.time() * 1000)) + client.insert('key1'.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # sanity check the query slice_predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)) - results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('3', '3'), composite('4', '4'), composite('5', '5'), composite('6'), @@ -2333,11 +2337,11 @@ def test_range_deletion_eoc_0(self): # do a slice deletion with (6, ) as the end delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {''.encode(): {'StandardComposite': mutations}} + keyed_mutations = {'key1'.encode(): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - # check the columns post-deletion, (''.encode(), ) because it is an exact much but not (6, 6) - results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + # check the columns post-deletion, ('6'.encode(), ) because it is an exact much but not (6, 6) + results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), @@ -2346,11 +2350,11 @@ def test_range_deletion_eoc_0(self): # do another slice deletion, but make the end (6, 6) this time delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', '6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {''.encode(): {'StandardComposite': mutations}} + keyed_mutations = {'key1'.encode(): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # check the columns post-deletion, now (6, 6) is also gone - results = client.get_slice(''.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2361,15 +2365,15 @@ def test_incr_decr_standard_slice(self, request): d1 = 12 d2 = -21 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c2'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c4'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c5'.encode(), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate([''.encode(), ''.encode()]), ConsistencyLevel.ONE) + counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate(['c3'.encode(), 'c4'.encode()]), ConsistencyLevel.ONE) assert counters[0].counter_column.value == d1 + d2 assert counters[1].counter_column.value == d1 @@ -2381,20 +2385,20 @@ def test_incr_decr_standard_multiget_slice(self, request): d1 = 12 d2 = -21 - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d2), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(''.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c2'.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d2), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c4'.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c5'.encode(), d1), ConsistencyLevel.ONE) + + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c2'.encode(), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d2), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c4'.encode(), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c5'.encode(), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate([''.encode(), ''.encode()]), ConsistencyLevel.ONE) + counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate(['c3'.encode(), 'c4'.encode()]), ConsistencyLevel.ONE) assert counters[key1][0].counter_column.value == d1 + d2 assert counters[key1][1].counter_column.value == d1 @@ -2405,27 +2409,27 @@ def test_counter_get_slice_range(self, request): _set_keyspace('Keyspace1') key = utf8encode(request.node.name) - client.add(key, ColumnParent('Counter1'), CounterColumn(''.encode(), 1), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn(''.encode(), 2), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn(''.encode(), 3), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn('c1'.encode(), 1), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn('c2'.encode(), 2), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn('c3'.encode(), 3), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange('c1'.encode(), 'c2'.encode(), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == ''.encode() - assert result[1].counter_column.name == ''.encode() + assert result[0].counter_column.name == 'c1'.encode() + assert result[1].counter_column.name == 'c2'.encode() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1000)) + p = SlicePredicate(slice_range=SliceRange('c3'.encode(), 'c2'.encode(), True, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == ''.encode() - assert result[1].counter_column.name == ''.encode() + assert result[0].counter_column.name == 'c3'.encode() + assert result[1].counter_column.name == 'c2'.encode() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) + p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 2)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -2433,52 +2437,52 @@ def test_counter_get_slice_super_range(self, request): _set_keyspace('Keyspace1') key = utf8encode(request.node.name) - client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', ''.encode()), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', 'sc1'.encode()), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', 'sc2'.encode()), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', 'sc2'.encode()), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', 'sc3'.encode()), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2)) + p = SlicePredicate(slice_range=SliceRange('sc2'.encode(), 'sc3'.encode(), False, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == ''.encode() - assert result[1].counter_super_column.name == ''.encode() + assert result[0].counter_super_column.name == 'sc2'.encode() + assert result[1].counter_super_column.name == 'sc3'.encode() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 2)) + p = SlicePredicate(slice_range=SliceRange('sc3'.encode(), 'sc2'.encode(), True, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == ''.encode() - assert result[1].counter_super_column.name == ''.encode() + assert result[0].counter_super_column.name == 'sc3'.encode() + assert result[1].counter_super_column.name == 'sc2'.encode() def test_index_scan(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(1), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(1), 0), ConsistencyLevel.ONE) + client.insert('key2'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert('key2'.encode(), ColumnParent('Indexed1'), Column('b'.encode(), _i64(2), 0), ConsistencyLevel.ONE) + client.insert('key3'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert('key3'.encode(), ColumnParent('Indexed1'), Column('b'.encode(), _i64(3), 0), ConsistencyLevel.ONE) # simple query on one index expression cp = ColumnParent('Indexed1') sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == ''.encode() + assert result[0].key == 'key1'.encode() assert len(result[0].columns) == 1, result[0].columns # without index - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('b'.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 0, result # but unindexed expression added to indexed one is ok - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(3)), IndexExpression(''.encode(), IndexOperator.EQ, _i64(3))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('b'.encode(), IndexOperator.EQ, _i64(3)), IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(3))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == ''.encode() + assert result[0].key == 'key3'.encode() assert len(result[0].columns) == 2, result[0].columns def test_index_scan_uuid_names(self): @@ -2489,21 +2493,21 @@ def test_index_scan_uuid_names(self): cp = ColumnParent('Indexed3') # timeuuid name, utf8 values u = uuid.UUID('00000000-0000-1000-0000-000000000000').bytes u2 = uuid.UUID('00000000-0000-1000-0000-000000000001').bytes - client.insert(''.encode(), ColumnParent('Indexed3'), Column(u, ''.encode(), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Indexed3'), Column(u2, ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Indexed3'), Column(u, 'a'.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Indexed3'), Column(u2, 'b'.encode(), 0), ConsistencyLevel.ONE) # name comparator + data validator of incompatible types -- see CASSANDRA-2347 - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(u, IndexOperator.EQ, ''.encode()), IndexExpression(u2, IndexOperator.EQ, ''.encode())], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(u, IndexOperator.EQ, 'a'.encode()), IndexExpression(u2, IndexOperator.EQ, 'b'.encode())], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result cp = ColumnParent('Indexed2') # timeuuid name, long values # name must be valid (TimeUUID) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('foo'.encode(), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) # value must be valid (TimeUUID) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, 'foo'.encode())], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, ''.encode())], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) def test_index_scan_expiring(self): @@ -2511,10 +2515,10 @@ def test_index_scan_expiring(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert(''.encode(), ColumnParent('Indexed1'), Column(''.encode(), _i64(1), 0, 2), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(1), 0, 2), ConsistencyLevel.ONE) cp = ColumnParent('Indexed1') sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(1))], 100) # query before expiration result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result @@ -2534,28 +2538,28 @@ def test_index_scan_indexed_column_outside_slice_predicate(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed4') - client.insert(''.encode(), ColumnParent('Indexed4'), Column(''.encode(), _i64(1), 0), ConsistencyLevel.ONE) - client.insert(''.encode(), ColumnParent('Indexed4'), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Indexed4'), Column('a'.encode(), _i64(1), 0), ConsistencyLevel.ONE) + client.insert('key1'.encode(), ColumnParent('Indexed4'), Column('z'.encode(), 'zzz'.encode(), 0), ConsistencyLevel.ONE) cp = ColumnParent('Indexed4') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(''.encode(), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange('z'.encode(), 'z'.encode())) + key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('a'.encode(), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[0].column.name == 'z'.encode() - sp = SlicePredicate(column_names=[''.encode()]) + sp = SlicePredicate(column_names=['z'.encode()]) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == ''.encode() + assert result[0].columns[0].column.name == 'z'.encode() def test_column_not_found_quorum(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - key = ''.encode() - column_path = ColumnPath(column_family="Standard1", column='idontexist'.encode()) + key = 'doesntexist'.encode() + column_path = ColumnPath(column_family="Standard1", column=''.encode()) try: client.get(key, column_path, ConsistencyLevel.QUORUM) assert False, ('columnpath %s existed in %s when it should not' % (column_path, key)) @@ -2566,13 +2570,13 @@ def test_get_range_slice_after_deletion(self): _set_keyspace('Keyspace2') self.truncate_all('Super3') - key = ''.encode() + key = 'key1'.encode() # three supercoluns, each with "col1" subcolumn for i in range(1, 4): - client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column(''.encode(), ''.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column('col1'.encode(), 'val1'.encode(), 0), ConsistencyLevel.ONE) cp = ColumnParent('Super3') - predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, count=1)) + predicate = SlicePredicate(slice_range=SliceRange('sc1'.encode(), 'sc3'.encode(), False, count=1)) k_range = KeyRange(start_key=key, end_key=key, count=1) # validate count=1 restricts to 1 supercolumn @@ -2580,13 +2584,13 @@ def test_get_range_slice_after_deletion(self): assert len(result[0].columns) == 1 # remove sc1; add back subcolumn to override tombstone - client.remove(key, ColumnPath('Super3', ''.encode()), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super3', 'sc1'.encode()), 1, ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1 - client.insert(key, ColumnParent('Super3', ''.encode()), Column(''.encode(), ''.encode(), 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', 'sc1'.encode()), Column('col1'.encode(), 'val1'.encode(), 2), ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].super_column.name == ''.encode() + assert result[0].columns[0].super_column.name == 'sc1'.encode() def test_multi_slice(self): _set_keyspace('Keyspace1') @@ -2605,12 +2609,12 @@ def test_truncate(self): # truncate Standard1 self.truncate_all('Standard1') - assert _big_slice(''.encode(), ColumnParent('Standard1')) == [] + assert _big_slice('key1'.encode(), ColumnParent('Standard1')) == [] # truncate Super1 self.truncate_all('Super1') - assert _big_slice(''.encode(), ColumnParent('Super1')) == [] - assert _big_slice(''.encode(), ColumnParent('Super1', ''.encode())) == [] + assert _big_slice('key1'.encode(), ColumnParent('Super1')) == [] + assert _big_slice('key1'.encode(), ColumnParent('Super1', 'sc1'.encode())) == [] @since('3.0') def test_cql_range_tombstone_and_static(self): @@ -2630,7 +2634,7 @@ def test_cql_range_tombstone_and_static(self): mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000))))] mutation_map = dict((table, mutations) for table in ['t']) - keyed_mutations = dict((key, mutation_map) for key in [''.encode()]) + keyed_mutations = dict((key, mutation_map) for key in ['k'.encode()]) client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # And check everything is gone @@ -2647,8 +2651,8 @@ def test_compact_storage_get(self): _set_keyspace('Keyspace1') CL = ConsistencyLevel.ONE i = 1 - client.insert(_i32(i), ColumnParent('cs1'), Column(''.encode(), _i32(i), 0), CL) - _assert_column('cs1', _i32(i), ''.encode(), _i32(i), 0) + client.insert(_i32(i), ColumnParent('cs1'), Column('v'.encode(), _i32(i), 0), CL) + _assert_column('cs1', _i32(i), 'v'.encode(), _i32(i), 0) @pytest.mark.skipif(CASSANDRA_VERSION_FROM_BUILD == '3.9', reason="Test doesn't run on 3.9") def test_range_tombstone_eoc_0(self): From 78730a6e80f25eab3d14aa28998a030e04b88a9d Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 15:51:26 -0500 Subject: [PATCH 15/16] Giving up on automated refactor. --- thrift_test.py | 1260 ++++++++++++++++++++++++------------------------ 1 file changed, 630 insertions(+), 630 deletions(-) diff --git a/thrift_test.py b/thrift_test.py index 5025d64340..0990d7141b 100644 --- a/thrift_test.py +++ b/thrift_test.py @@ -98,8 +98,8 @@ def define_schema(self): cf_defs=[ Cassandra.CfDef('Keyspace1', 'Standard1'), Cassandra.CfDef('Keyspace1', 'Standard2'), - Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef('c1'.encode(), 'AsciiType'), Cassandra.ColumnDef('c2'.encode(), 'AsciiType')]), - Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef('c1'.encode(), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard3', column_metadata=[Cassandra.ColumnDef(utf8encode('c1'), 'AsciiType'), Cassandra.ColumnDef(utf8encode('c2'), 'AsciiType')]), + Cassandra.CfDef('Keyspace1', 'Standard4', column_metadata=[Cassandra.ColumnDef(utf8encode('c1'), 'AsciiType')]), Cassandra.CfDef('Keyspace1', 'StandardLong1', comparator_type='LongType'), Cassandra.CfDef('Keyspace1', 'StandardInteger1', comparator_type='IntegerType'), Cassandra.CfDef('Keyspace1', 'StandardComposite', comparator_type='CompositeType(AsciiType, AsciiType)'), @@ -108,10 +108,10 @@ def define_schema(self): Cassandra.CfDef('Keyspace1', 'Super3', column_type='Super', comparator_type='LongType', subcomparator_type='UTF8Type'), Cassandra.CfDef('Keyspace1', 'Counter1', default_validation_class='CounterColumnType'), Cassandra.CfDef('Keyspace1', 'SuperCounter1', column_type='Super', default_validation_class='CounterColumnType'), - Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef('birthdate'.encode(), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), + Cassandra.CfDef('Keyspace1', 'Indexed1', column_metadata=[Cassandra.ColumnDef(utf8encode('birthdate'), 'LongType', Cassandra.IndexType.KEYS, 'birthdate_index')]), Cassandra.CfDef('Keyspace1', 'Indexed2', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'LongType', Cassandra.IndexType.KEYS)]), Cassandra.CfDef('Keyspace1', 'Indexed3', comparator_type='TimeUUIDType', column_metadata=[Cassandra.ColumnDef(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, 'UTF8Type', Cassandra.IndexType.KEYS)]), - Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef('a'.encode(), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef('z'.encode(), 'UTF8Type')]), + Cassandra.CfDef('Keyspace1', 'Indexed4', column_metadata=[Cassandra.ColumnDef(utf8encode('a'), 'LongType', Cassandra.IndexType.KEYS, 'a_index'), Cassandra.ColumnDef(utf8encode('z'), 'UTF8Type')]), Cassandra.CfDef('Keyspace1', 'Expiring', default_time_to_live=2) ]) @@ -163,11 +163,11 @@ def _i16(n): return struct.pack('>h', n) # big endian = network order -_SIMPLE_COLUMNS = [Column('c1'.encode(), 'value1'.encode(), 0), - Column('c2'.encode(), 'value2'.encode(), 0)] -_SUPER_COLUMNS = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), - SuperColumn(name='sc2'.encode(), columns=[Column(_i64(5), 'value5'.encode(), 0), - Column(_i64(6), 'value6'.encode(), 0)])] +_SIMPLE_COLUMNS = [Column(utf8encode('c1'), utf8encode('value1'), 0), + Column(utf8encode('c2'), utf8encode('value2'), 0)] +_SUPER_COLUMNS = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 0), + Column(_i64(6), utf8encode('value6'), 0)])] def _assert_column(column_family, key, column, value, ts=0): @@ -202,7 +202,7 @@ def _assert_no_columnpath(key, column_path): def _insert_simple(): - return _insert_multi(['key1'.encode()]) + return _insert_multi([utf8encode('key1')]) def _insert_multi(keys): @@ -210,75 +210,75 @@ def _insert_multi(keys): for key in keys: if isinstance(key, str): key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('c2'.encode(), 'value2'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c2'), utf8encode('value2'), 0), CL) def _insert_batch(): cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS], 'Standard2': [Mutation(ColumnOrSuperColumn(c)) for c in _SIMPLE_COLUMNS]} - client.batch_mutate({'key1'.encode(): cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) def _big_slice(key, column_parent): if isinstance(key, str): key = utf8encode(key) - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) return client.get_slice(key, column_parent, p, ConsistencyLevel.ONE) def _big_multislice(keys, column_parent): - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) return client.multiget_slice(keys, column_parent, p, ConsistencyLevel.ONE) def _verify_batch(): _verify_simple() L = [result.column - for result in _big_slice('key1'.encode(), ColumnParent('Standard2'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard2'))] assert L == _SIMPLE_COLUMNS, L def _verify_simple(): - assert client.get('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE).column == Column('c1'.encode(), 'value1'.encode(), 0) + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE).column == Column(utf8encode('c1'), utf8encode('value1'), 0) L = [result.column - for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] assert L == _SIMPLE_COLUMNS, L def _insert_super(key='key1'): if isinstance(key, str): key = utf8encode(key) - client.insert(key, ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 0), ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', 'sc2'.encode()), Column(_i64(6), 'value6'.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc2')), Column(_i64(6), utf8encode('value6'), 0), ConsistencyLevel.ONE) def _insert_range(): - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c2'.encode(), 'value2'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c3'.encode(), 'value3'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c2'), utf8encode('value2'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) def _verify_range(): - p = SlicePredicate(slice_range=SliceRange('c1'.encode(), 'c2'.encode(), False, 1000)) - result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c1'), utf8encode('c2'), False, 1000)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == 'c1'.encode() - assert result[1].column.name == 'c2'.encode() + assert result[0].column.name == utf8encode('c1') + assert result[1].column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('c3'.encode(), 'c2'.encode(), True, 1000)) - result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c3'), utf8encode('c2'), True, 1000)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == 'c3'.encode() - assert result[1].column.name == 'c2'.encode() + assert result[0].column.name == utf8encode('c3') + assert result[1].column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 1000)) - result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 1000)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 2)) - result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -287,31 +287,31 @@ def _set_keyspace(keyspace): def _insert_super_range(): - client.insert('key1'.encode(), ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(6), 'value6'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Super1', 'sc3'.encode()), Column(_i64(7), 'value7'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(6), utf8encode('value6'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc3')), Column(_i64(7), utf8encode('value7'), 0), ConsistencyLevel.ONE) time.sleep(0.1) def _verify_super_range(): - p = SlicePredicate(slice_range=SliceRange('sc2'.encode(), 'sc3'.encode(), False, 2)) - result = client.get_slice('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc2'), utf8encode('sc3'), False, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == 'sc2'.encode() - assert result[1].super_column.name == 'sc3'.encode() + assert result[0].super_column.name == utf8encode('sc2') + assert result[1].super_column.name == utf8encode('sc3') - p = SlicePredicate(slice_range=SliceRange('sc3'.encode(), 'sc2'.encode(), True, 2)) - result = client.get_slice('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc3'), utf8encode('sc2'), True, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].super_column.name == 'sc3'.encode() - assert result[1].super_column.name == 'sc2'.encode() + assert result[0].super_column.name == utf8encode('sc3') + assert result[1].super_column.name == utf8encode('sc2') def _verify_super(supercf='Super1', key='key1'): if isinstance(key, str): key = utf8encode(key) - assert client.get(key, ColumnPath(supercf, 'sc1'.encode(), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), 'value4'.encode(), 0) + assert client.get(key, ColumnPath(supercf, utf8encode('sc1'), _i64(4)), ConsistencyLevel.ONE).column == Column(_i64(4), utf8encode('value4'), 0) slice = [result.super_column for result in _big_slice(key, ColumnParent('Super1'))] assert slice == _SUPER_COLUMNS, slice @@ -339,23 +339,23 @@ def _insert_six_columns(key='abc'): if isinstance(key, str): key = utf8encode(key) CL = ConsistencyLevel.ONE - client.insert(key, ColumnParent('Standard1'), Column('a'.encode(), '1'.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('b'.encode(), '2'.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('c'.encode(), '3'.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('d'.encode(), '4'.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('e'.encode(), '5'.encode(), 0), CL) - client.insert(key, ColumnParent('Standard1'), Column('f'.encode(), '6'.encode(), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('a'), utf8encode('1'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('b'), utf8encode('2'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('c'), utf8encode('3'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('d'), utf8encode('4'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('e'), utf8encode('5'), 0), CL) + client.insert(key, ColumnParent('Standard1'), Column(utf8encode('f'), utf8encode('6'), 0), CL) def _big_multi_slice(key='abc'): if isinstance(key, str): key = utf8encode(key) c1 = ColumnSlice() - c1.start = 'a'.encode() - c1.finish = 'c'.encode() + c1.start = utf8encode('a') + c1.finish = utf8encode('c') c2 = ColumnSlice() - c2.start = 'e'.encode() - c2.finish = 'f'.encode() + c2.start = utf8encode('e') + c2.finish = utf8encode('f') m = MultiSliceRequest() m.key = key m.column_parent = ColumnParent('Standard1') @@ -366,7 +366,7 @@ def _big_multi_slice(key='abc'): return client.get_multi_slice(m) -_MULTI_SLICE_COLUMNS = [Column('a'.encode(), '1'.encode(), 0), Column('b'.encode(), '2'.encode(), 0), Column('c'.encode(), '3'.encode(), 0), Column('e'.encode(), '5'.encode(), 0), Column('f'.encode(), '6'.encode(), 0)] +_MULTI_SLICE_COLUMNS = [Column(utf8encode('a'), utf8encode('1'), 0), Column(utf8encode('b'), utf8encode('2'), 0), Column(utf8encode('c'), utf8encode('3'), 0), Column(utf8encode('e'), utf8encode('5'), 0), Column(utf8encode('f'), utf8encode('6'), 0)] @since('2.0', max_version='4') @@ -385,15 +385,15 @@ def test_insert(self): def test_empty_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Standard2', 'Super1') - assert _big_slice('key1'.encode(), ColumnParent('Standard2')) == [] - assert _big_slice('key1'.encode(), ColumnParent('Super1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Standard2')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] def test_cas(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Standard3', 'Standard4') def cas(expected, updates, column_family): - return client.cas('key1'.encode(), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) + return client.cas(utf8encode('key1'), column_family, expected, updates, ConsistencyLevel.SERIAL, ConsistencyLevel.QUORUM) def test_cas_operations(first_columns, second_columns, column_family): # partition should be empty, so cas expecting any existing values should fail @@ -404,7 +404,7 @@ def test_cas_operations(first_columns, second_columns, column_family): # cas of empty columns -> first_columns should succeed # and the reading back from the table should match first_columns assert cas([], first_columns, column_family).success - result = [cosc.column for cosc in _big_slice('key1'.encode(), ColumnParent(column_family))] + result = [cosc.column for cosc in _big_slice(utf8encode('key1'), ColumnParent(column_family))] # CAS will use its own timestamp, so we can't just compare result == _SIMPLE_COLUMNS assert dict((c.name, c.value) for c in result) == dict((ex.name, ex.value) for ex in first_columns) @@ -416,7 +416,7 @@ def test_cas_operations(first_columns, second_columns, column_family): assert dict((c.name, c.value) for c in cas_result.current_values) == {first_columns[0].name: first_columns[0].value}, cas_result # CL.SERIAL for reads - assert client.get('key1'.encode(), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value + assert client.get(utf8encode('key1'), ColumnPath(column_family, column=first_columns[0].name), ConsistencyLevel.SERIAL).column.value == first_columns[0].value # cas first_columns -> second_columns should succeed assert cas(first_columns, second_columns, column_family).success @@ -425,8 +425,8 @@ def test_cas_operations(first_columns, second_columns, column_family): cas_result = cas(first_columns, second_columns, column_family) assert not cas_result.success - updated_columns = [Column('c1'.encode(), 'value101'.encode(), 1), - Column('c2'.encode(), 'value102'.encode(), 1)] + updated_columns = [Column(utf8encode('c1'), utf8encode('value101'), 1), + Column(utf8encode('c2'), utf8encode('value102'), 1)] logger.debug("Testing CAS operations on dynamic cf") test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard1') @@ -439,9 +439,9 @@ def test_missing_super(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc1'.encode(), _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1'), _i64(1)), ConsistencyLevel.ONE)) _insert_super() - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc1'.encode(), _i64(1)), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1'), _i64(1)), ConsistencyLevel.ONE)) def test_count(self): _set_keyspace('Keyspace1') @@ -449,19 +449,19 @@ def test_count(self): _insert_simple() _insert_super() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) - assert client.get_count('key1'.encode(), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 - assert client.get_count('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 - assert client.get_count('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), p, ConsistencyLevel.ONE) == 2 - assert client.get_count('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) + assert client.get_count(utf8encode('key1'), ColumnParent('Standard2'), p, ConsistencyLevel.ONE) == 0 + assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 2 + assert client.get_count(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE) == 2 + assert client.get_count(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) == 2 # Let's make that a little more interesting - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c3'.encode(), 'value3'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c4'.encode(), 'value4'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c5'.encode(), 'value5'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c4'), utf8encode('value4'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c5'), utf8encode('value5'), 0), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('c2'.encode(), 'c4'.encode(), False, 1000)) - assert client.get_count('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 + p = SlicePredicate(slice_range=SliceRange(utf8encode('c2'), utf8encode('c4'), False, 1000)) + assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3 def test_count_paging(self): _set_keyspace('Keyspace1') @@ -474,14 +474,14 @@ def test_count_paging(self): # Paging for small columns starts at 1024 columns columns_to_insert = [Column(utf8encode('c%d' % (i,)), utf8encode('value%d' % (i,)), 0) for i in range(3, 1026)] cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in columns_to_insert]} - client.batch_mutate({'key1'.encode() : cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({utf8encode('key1') : cfmap}, ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 2000)) - assert client.get_count('key1'.encode(), column_parent, p, ConsistencyLevel.ONE) == 1025 + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 2000)) + assert client.get_count(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE) == 1025 # Ensure that the count limit isn't clobbered - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 10)) - assert client.get_count('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 10)) + assert client.get_count(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 10 # test get_count() to work correctly with 'count' settings around page size (CASSANDRA-4833) def test_count_around_page_size(self): @@ -489,14 +489,14 @@ def test_count_around_page_size(self): self.truncate_all('Standard1') def slice_predicate(count): - return SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, count)) + return SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, count)) - key = 'key1'.encode() + key = utf8encode('key1') parent = ColumnParent('Standard1') cl = ConsistencyLevel.ONE for i in range(0, 3050): - client.insert(key, parent, Column(utf8encode(str(i)), ''.encode(), 0), cl) + client.insert(key, parent, Column(utf8encode(str(i)), utf8encode(''), 0), cl) # same as page size assert client.get_count(key, parent, slice_predicate(1024), cl) == 1024 @@ -525,22 +525,22 @@ def test_super_get(self): self.truncate_all('Super1') _insert_super() - result = client.get('key1'.encode(), ColumnPath('Super1', 'sc2'.encode()), ConsistencyLevel.ONE).super_column + result = client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2')), ConsistencyLevel.ONE).super_column assert result == _SUPER_COLUMNS[1], result def test_super_subcolumn_limit(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') _insert_super() - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) - column_parent = ColumnParent('Super1', 'sc2'.encode()) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) + column_parent = ColumnParent('Super1', utf8encode('sc2')) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(5), 'value5'.encode(), 0)], slice - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1)) + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(5), utf8encode('value5'), 0)], slice + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), True, 1)) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(6), 'value6'.encode(), 0)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(6), utf8encode('value6'), 0)], slice def test_long_order(self): _set_keyspace('Keyspace1') @@ -554,9 +554,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(0, 104294967296, 429496729): name = _i64(i) - client.insert('key1'.encode(), ColumnParent('StandardLong1'), Column(name, 'v'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('StandardLong1'), Column(name, utf8encode('v'), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice('key1'.encode(), ColumnParent('StandardLong1'))] + slice = [result.column.name for result in _big_slice(utf8encode('key1'), ColumnParent('StandardLong1'))] assert slice == L, slice def test_integer_order(self): @@ -571,9 +571,9 @@ def long_xrange(start, stop, step): L = [] for i in long_xrange(104294967296, 0, 429496729): name = _i64(i) - client.insert('key1'.encode(), ColumnParent('StandardInteger1'), Column(name, 'v'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('StandardInteger1'), Column(name, utf8encode('v'), 0), ConsistencyLevel.ONE) L.append(name) - slice = [result.column.name for result in _big_slice('key1'.encode(), ColumnParent('StandardInteger1'))] + slice = [result.column.name for result in _big_slice(utf8encode('key1'), ColumnParent('StandardInteger1'))] L.sort() assert slice == L, slice @@ -587,79 +587,79 @@ def test_time_uuid(self): # 100 isn't enough to fail reliably if the comparator is borked for i in range(500): L.append(uuid.uuid1()) - client.insert('key1'.encode(), ColumnParent('Super4', 'sc1'.encode()), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) - slice = _big_slice('key1'.encode(), ColumnParent('Super4', 'sc1'.encode())) + client.insert(utf8encode('key1'), ColumnParent('Super4', utf8encode('sc1')), Column(L[-1].bytes, utf8encode('value%s' % i), i), ConsistencyLevel.ONE) + slice = _big_slice(utf8encode('key1'), ColumnParent('Super4', utf8encode('sc1'))) assert len(slice) == 500, len(slice) for i in range(500): u = slice[i].column assert u.value == utf8encode('value%s' % i) assert u.name == L[i].bytes - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), True, 1)) - column_parent = ColumnParent('Super4', 'sc1'.encode()) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), True, 1)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[-1].bytes, 'value499'.encode(), 499)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[-1].bytes, utf8encode('value499'), 499)], slice - p = SlicePredicate(slice_range=SliceRange(''.encode(), L[2].bytes, False, 1000)) - column_parent = ColumnParent('Super4', 'sc1'.encode()) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), L[2].bytes, False, 1000)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[0].bytes, 'value0'.encode(), 0), - Column(L[1].bytes, 'value1'.encode(), 1), - Column(L[2].bytes, 'value2'.encode(), 2)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[0].bytes, utf8encode('value0'), 0), + Column(L[1].bytes, utf8encode('value1'), 1), + Column(L[2].bytes, utf8encode('value2'), 2)], slice - p = SlicePredicate(slice_range=SliceRange(L[2].bytes, ''.encode(), True, 1000)) - column_parent = ColumnParent('Super4', 'sc1'.encode()) + p = SlicePredicate(slice_range=SliceRange(L[2].bytes, utf8encode(''), True, 1000)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, 'value2'.encode(), 2), - Column(L[1].bytes, 'value1'.encode(), 1), - Column(L[0].bytes, 'value0'.encode(), 0)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, utf8encode('value2'), 2), + Column(L[1].bytes, utf8encode('value1'), 1), + Column(L[0].bytes, utf8encode('value0'), 0)], slice - p = SlicePredicate(slice_range=SliceRange(L[2].bytes, ''.encode(), False, 1)) - column_parent = ColumnParent('Super4', 'sc1'.encode()) + p = SlicePredicate(slice_range=SliceRange(L[2].bytes, utf8encode(''), False, 1)) + column_parent = ColumnParent('Super4', utf8encode('sc1')) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE)] - assert slice == [Column(L[2].bytes, 'value2'.encode(), 2)], slice + for result in client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE)] + assert slice == [Column(L[2].bytes, utf8encode('value2'), 2)], slice def test_long_remove(self): _set_keyspace('Keyspace1') self.truncate_all('StandardLong1') column_parent = ColumnParent('StandardLong1') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) for i in range(10): parent = ColumnParent('StandardLong1') - client.insert('key1'.encode(), parent, Column(_i64(i), 'value1'.encode(), 10 * i), ConsistencyLevel.ONE) - client.remove('key1'.encode(), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value1'), 10 * i), ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('StandardLong1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert('key1'.encode(), parent, Column(_i64(i), 'value2'.encode(), 10 * i + 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value2'), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), 'value2'.encode(), 10 * i + 2)], (slice, i) + for result in client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), utf8encode('value2'), 10 * i + 2)], (slice, i) def test_integer_remove(self): _set_keyspace('Keyspace1') self.truncate_all('StandardInteger1') column_parent = ColumnParent('StandardInteger1') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1)) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1)) for i in range(10): parent = ColumnParent('StandardInteger1') - client.insert('key1'.encode(), parent, Column(_i64(i), 'value1'.encode(), 10 * i), ConsistencyLevel.ONE) - client.remove('key1'.encode(), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) - slice = client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value1'), 10 * i), ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('StandardInteger1'), 10 * i + 1, ConsistencyLevel.ONE) + slice = client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE) assert slice == [], slice # resurrect - client.insert('key1'.encode(), parent, Column(_i64(i), 'value2'.encode(), 10 * i + 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), parent, Column(_i64(i), utf8encode('value2'), 10 * i + 2), ConsistencyLevel.ONE) slice = [result.column - for result in client.get_slice('key1'.encode(), column_parent, sp, ConsistencyLevel.ONE)] - assert slice == [Column(_i64(i), 'value2'.encode(), 10 * i + 2)], (slice, i) + for result in client.get_slice(utf8encode('key1'), column_parent, sp, ConsistencyLevel.ONE)] + assert slice == [Column(_i64(i), utf8encode('value2'), 10 * i + 2)], (slice, i) def test_batch_insert(self): _set_keyspace('Keyspace1') @@ -681,7 +681,7 @@ def test_batch_mutate_standard_columns(self): for column_family in column_families: for key in keys: - _assert_column(column_family, key, 'c1'.encode(), 'value1'.encode()) + _assert_column(column_family, key, utf8encode('c1'), utf8encode('value1')) def test_batch_mutate_remove_standard_columns(self): _set_keyspace('Keyspace1') @@ -813,51 +813,51 @@ def test_batch_mutate_remove_slice_standard(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - columns = [Column('c1'.encode(), 'value1'.encode(), 0), - Column('c2'.encode(), 'value2'.encode(), 0), - Column('c3'.encode(), 'value3'.encode(), 0), - Column('c4'.encode(), 'value4'.encode(), 0), - Column('c5'.encode(), 'value5'.encode(), 0)] + columns = [Column(utf8encode('c1'), utf8encode('value1'), 0), + Column(utf8encode('c2'), utf8encode('value2'), 0), + Column(utf8encode('c3'), utf8encode('value3'), 0), + Column(utf8encode('c4'), utf8encode('value4'), 0), + Column(utf8encode('c5'), utf8encode('value5'), 0)] for column in columns: - client.insert('key'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.insert(utf8encode('key'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start='c2'.encode(), finish='c4'.encode()))) - client.batch_mutate({'key'.encode(): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=utf8encode('c2'), finish=utf8encode('c4')))) + client.batch_mutate({utf8encode('key'): {'Standard1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists('key'.encode(), ColumnPath('Standard1', column='c1'.encode())) - _assert_no_columnpath('key'.encode(), ColumnPath('Standard1', column='c2'.encode())) - _assert_no_columnpath('key'.encode(), ColumnPath('Standard1', column='c3'.encode())) - _assert_no_columnpath('key'.encode(), ColumnPath('Standard1', column='c4'.encode())) - _assert_columnpath_exists('key'.encode(), ColumnPath('Standard1', column='c5'.encode())) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c1'))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c2'))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c3'))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c4'))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Standard1', column=utf8encode('c5'))) # known failure: see CASSANDRA-10046 def test_batch_mutate_remove_slice_of_entire_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(1), 'value1'.encode(), 0)]), - SuperColumn(name='sc2'.encode(), - columns=[Column(_i64(2), 'value2'.encode() , 0), Column(_i64(3), 'value3'.encode() , 0)]), - SuperColumn(name='sc3'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), - SuperColumn(name='sc4'.encode(), - columns=[Column(_i64(5), 'value5'.encode() , 0), Column(_i64(6), 'value6'.encode() , 0)]), - SuperColumn(name='sc5'.encode(), columns=[Column(_i64(7), 'value7'.encode(), 0)])] + columns = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(1), utf8encode('value1'), 0)]), + SuperColumn(name=utf8encode('sc2'), + columns=[Column(_i64(2), utf8encode('value2') , 0), Column(_i64(3), utf8encode('value3') , 0)]), + SuperColumn(name=utf8encode('sc3'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc4'), + columns=[Column(_i64(5), utf8encode('value5') , 0), Column(_i64(6), utf8encode('value6') , 0)]), + SuperColumn(name=utf8encode('sc5'), columns=[Column(_i64(7), utf8encode('value7'), 0)])] for column in columns: for subcolumn in column.columns: - client.insert('key'.encode(), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) + client.insert(utf8encode('key'), ColumnParent('Super1', column.name), subcolumn, ConsistencyLevel.ONE) - d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start='sc2'.encode() , finish='sc4'.encode() ))) - client.batch_mutate({'key'.encode(): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(start=utf8encode('sc2') , finish=utf8encode('sc4') ))) + client.batch_mutate({utf8encode('key'): {'Super1': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(1))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc2'.encode(), column=_i64(2))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc2'.encode(), column=_i64(3))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc3'.encode(), column=_i64(4))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc4'.encode(), column=_i64(5))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc4'.encode(), column=_i64(6))) - _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc5'.encode(), column=_i64(7))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(1))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc2'), column=_i64(2))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc2'), column=_i64(3))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc3'), column=_i64(4))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc4'), column=_i64(5))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc4'), column=_i64(6))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc5'), column=_i64(7))) @since('1.0', '2.2') @pytest.mark.skip(reason="Runs but fails and looks like it actually should fail since 8099?") @@ -865,49 +865,49 @@ def test_batch_mutate_remove_slice_part_of_supercolumns(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - columns = [Column(_i64(1), 'value1'.encode(), 0), - Column(_i64(2), 'value2'.encode(), 0), - Column(_i64(3), 'value3'.encode(), 0), - Column(_i64(4), 'value4'.encode(), 0), - Column(_i64(5), 'value5'.encode(), 0)] + columns = [Column(_i64(1), utf8encode('value1'), 0), + Column(_i64(2), utf8encode('value2'), 0), + Column(_i64(3), utf8encode('value3'), 0), + Column(_i64(4), utf8encode('value4'), 0), + Column(_i64(5), utf8encode('value5'), 0)] for column in columns: - client.insert('key'.encode(), ColumnParent('Super1', 'sc1'.encode()), column, ConsistencyLevel.ONE) + client.insert(utf8encode('key'), ColumnParent('Super1', utf8encode('sc1')), column, ConsistencyLevel.ONE) r = SliceRange(start=_i64(2), finish=_i64(4)) - d = Deletion(1, super_column='sc1'.encode() , predicate=SlicePredicate(slice_range=r)) - client.batch_mutate({'key'.encode(): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) + d = Deletion(1, super_column=utf8encode('sc1') , predicate=SlicePredicate(slice_range=r)) + client.batch_mutate({utf8encode('key'): {'Super1' : [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) - _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(1))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(2))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(3))) - _assert_no_columnpath('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(4))) - _assert_columnpath_exists('key'.encode(), ColumnPath('Super1', super_column='sc1'.encode(), column=_i64(5))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(1))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(2))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(3))) + _assert_no_columnpath(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(4))) + _assert_columnpath_exists(utf8encode('key'), ColumnPath('Super1', super_column=utf8encode('sc1'), column=_i64(5))) def test_batch_mutate_insertions_and_deletions(self): _set_keyspace('Keyspace1') self.truncate_all('Super1', 'Super2') - first_insert = SuperColumn(''.encode(), - columns=[Column(_i64(20), 'value20'.encode(), 3), - Column(_i64(21), 'value21'.encode(), 3)]) - second_insert = SuperColumn(''.encode(), - columns=[Column(_i64(20), 'value20'.encode(), 3), - Column(_i64(21), 'value21'.encode(), 3)]) - first_deletion = {'super_column': ''.encode(), + first_insert = SuperColumn(utf8encode("sc1"), + columns=[Column(_i64(20), utf8encode('value20'), 3), + Column(_i64(21), utf8encode('value21'), 3)]) + second_insert = SuperColumn(utf8encode("sc1"), + columns=[Column(_i64(20), utf8encode('value20'), 3), + Column(_i64(21), utf8encode('value21'), 3)]) + first_deletion = {'super_column': utf8encode("sc1"), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - second_deletion = {'super_column': ''.encode(), + second_deletion = {'super_column': utf8encode("sc2"), 'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])} - keys = ['key_30'.encode(), 'key_31'.encode()] + keys = [utf8encode('key_30'), utf8encode('key_31')] for key in keys: - sc = SuperColumn('sc1'.encode(), [Column(_i64(22), 'value22'.encode(), 0), - Column(_i64(23), 'value23'.encode(), 0)]) + sc = SuperColumn(utf8encode('sc1'), [Column(_i64(22), utf8encode('value22'), 0), + Column(_i64(23), utf8encode('value23'), 0)]) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=sc))]} client.batch_mutate({key: cfmap}, ConsistencyLevel.ONE) - sc2 = SuperColumn('sc2'.encode(), [Column(_i64(22), 'value22'.encode(), 0), - Column(_i64(23), 'value23'.encode(), 0)]) + sc2 = SuperColumn(utf8encode('sc2'), [Column(_i64(22), utf8encode('value22'), 0), + Column(_i64(23), utf8encode('value23'), 0)]) cfmap2 = {'Super2': [Mutation(ColumnOrSuperColumn(super_column=sc2))]} client.batch_mutate({key: cfmap2}, ConsistencyLevel.ONE) @@ -924,18 +924,18 @@ def test_batch_mutate_insertions_and_deletions(self): for key in keys: for c in [_i64(22), _i64(23)]: - _assert_no_columnpath(key, ColumnPath('Super1', super_column='sc1'.encode(), column=c)) - _assert_no_columnpath(key, ColumnPath('Super2', super_column='sc2'.encode(), column=c)) + _assert_no_columnpath(key, ColumnPath('Super1', super_column=utf8encode('sc1'), column=c)) + _assert_no_columnpath(key, ColumnPath('Super2', super_column=utf8encode('sc2'), column=c)) for c in [_i64(20), _i64(21)]: - _assert_columnpath_exists(key, ColumnPath('Super1', super_column='sc1'.encode(), column=c)) - _assert_columnpath_exists(key, ColumnPath('Super2', super_column='sc1'.encode(), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super1', super_column=utf8encode('sc1'), column=c)) + _assert_columnpath_exists(key, ColumnPath('Super2', super_column=utf8encode('sc1'), column=c)) def test_bad_system_calls(self): def duplicate_index_names(): _set_keyspace('Keyspace1') - cd1 = ColumnDef('foo'.encode(), 'BytesType', IndexType.KEYS, 'i') - cd2 = ColumnDef('bar'.encode(), 'BytesType', IndexType.KEYS, 'i') + cd1 = ColumnDef(utf8encode('foo'), 'BytesType', IndexType.KEYS, 'i') + cd2 = ColumnDef(utf8encode('bar'), 'BytesType', IndexType.KEYS, 'i') cf = CfDef('Keyspace1', 'BadCF', column_metadata=[cd1, cd2]) client.system_add_column_family(cf) _expect_exception(duplicate_index_names, InvalidRequestException) @@ -944,33 +944,33 @@ def test_bad_batch_calls(self): # mutate_does_not_accept_cosc_and_deletion_in_same_mutation def too_full(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column(''.encode(), 'bar'.encode(), 0)) - dele = Deletion(2, predicate=SlicePredicate(column_names=['baz'.encode()])) - client.batch_mutate({'key_34'.encode(): {'Standard1': [Mutation(col, dele)]}}, + col = ColumnOrSuperColumn(column=Column(utf8encode("foo"), utf8encode('bar'), 0)) + dele = Deletion(2, predicate=SlicePredicate(column_names=[utf8encode('baz')])) + client.batch_mutate({utf8encode('key_34'): {'Standard1': [Mutation(col, dele)]}}, ConsistencyLevel.ONE) _expect_exception(too_full, InvalidRequestException) # test_batch_mutate_does_not_accept_cosc_on_undefined_cf: def bad_cf(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column(''.encode(), 'bar'.encode(), 0)) - client.batch_mutate({'key_36'.encode(): {'Undefined': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column(utf8encode("foo"), utf8encode('bar'), 0)) + client.batch_mutate({utf8encode('key_36'): {'Undefined': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf, InvalidRequestException) # test_batch_mutate_does_not_accept_deletion_on_undefined_cf def bad_cf_2(): _set_keyspace('Keyspace1') - d = Deletion(2, predicate=SlicePredicate(column_names=['baz'.encode()])) - client.batch_mutate({'key_37'.encode(): {'Undefined': [Mutation(deletion=d)]}}, + d = Deletion(2, predicate=SlicePredicate(column_names=[utf8encode('baz')])) + client.batch_mutate({utf8encode('key_37'): {'Undefined': [Mutation(deletion=d)]}}, ConsistencyLevel.ONE) _expect_exception(bad_cf_2, InvalidRequestException) # a column value that does not match the declared validator def send_string_instead_of_long(): _set_keyspace('Keyspace1') - col = ColumnOrSuperColumn(column=Column('birthdate'.encode(), 'bar'.encode(), 0)) - client.batch_mutate({'key_38'.encode(): {'Indexed1': [Mutation(col)]}}, + col = ColumnOrSuperColumn(column=Column(utf8encode('birthdate'), utf8encode('bar'), 0)) + client.batch_mutate({utf8encode('key_38'): {'Indexed1': [Mutation(col)]}}, ConsistencyLevel.ONE) _expect_exception(send_string_instead_of_long, InvalidRequestException) @@ -978,16 +978,16 @@ def test_column_name_lengths(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1'), Column(''.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 1), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 127), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 128), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 129), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 255), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 256), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * 257), 'value'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), 'value'.encode(), 0), ConsistencyLevel.ONE) - _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode(''), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 1), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 127), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 128), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 129), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 255), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 256), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * 257), utf8encode('value'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16 - 1)), utf8encode('value'), 0), ConsistencyLevel.ONE) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('x' * (2 ** 16)), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) def test_bad_calls(self): _set_keyspace('Keyspace1') @@ -995,71 +995,71 @@ def test_bad_calls(self): # missing arguments _expect_exception(lambda: client.insert(None, None, None, None), TApplicationException) # supercolumn in a non-super CF - _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1', 'x'.encode()), Column('y'.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1', utf8encode('x')), Column(utf8encode('y'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) # no supercolumn in a super CF - _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Super1'), Column('y'.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Super1'), Column(utf8encode('y'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) # column but no supercolumn in remove - _expect_exception(lambda: client.remove('key1'.encode(), ColumnPath('Super1', column='x'.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove(utf8encode('key1'), ColumnPath('Super1', column=utf8encode('x')), 0, ConsistencyLevel.ONE), InvalidRequestException) # super column in non-super CF - _expect_exception(lambda: client.remove('key1'.encode(), ColumnPath('Standard1', 'y'.encode(), 'x'.encode()), 0, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.remove(utf8encode('key1'), ColumnPath('Standard1', utf8encode('y'), utf8encode('x')), 0, ConsistencyLevel.ONE), InvalidRequestException) # key too long - _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('x' * 2 ** 16), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE), InvalidRequestException) # empty key - _expect_exception(lambda: client.get(''.encode(), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode(''), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE), InvalidRequestException) cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - _expect_exception(lambda: client.batch_mutate({''.encode(): cfmap}, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.batch_mutate({utf8encode(''): cfmap}, ConsistencyLevel.ONE), InvalidRequestException) # empty column name - _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column=''.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('')), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify column name - _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1'), ConsistencyLevel.ONE), InvalidRequestException) # supercolumn in a non-super CF - _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Standard1', 'x'.encode(), 'y'.encode()), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', utf8encode('x'), utf8encode('y')), ConsistencyLevel.ONE), InvalidRequestException) # get doesn't specify supercolumn name - _expect_exception(lambda: client.get('key1'.encode(), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.get(utf8encode('key1'), ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException) # invalid CF - _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=[''.encode(), ''.encode()]), ''.encode(), ''.encode(), 5, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=[utf8encode(''), utf8encode('')]), utf8encode(''), utf8encode(''), 5, ConsistencyLevel.ONE), InvalidRequestException) # 'x' is not a valid Long - _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Super1', 'sc1'.encode()), Column('x'.encode(), 'value'.encode(), 0), ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), Column(utf8encode('x'), utf8encode('value'), 0), ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long - p = SlicePredicate(slice_range=SliceRange('x'.encode(), ''.encode(), False, 1)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('x'), utf8encode(''), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) column_parent = ColumnParent('StandardLong1') - _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start is not a valid Long, supercolumn version - p = SlicePredicate(slice_range=SliceRange('x'.encode(), ''.encode(), False, 1)) - column_parent = ColumnParent('Super1', 'sc1'.encode()) - _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), + p = SlicePredicate(slice_range=SliceRange(utf8encode('x'), utf8encode(''), False, 1)) + column_parent = ColumnParent('Super1', utf8encode('sc1')) + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, supercolumn version p = SlicePredicate(slice_range=SliceRange(_i64(10), _i64(0), False, 1)) - column_parent = ColumnParent('Super1', 'sc1'.encode()) - _expect_exception(lambda: client.get_slice('key1'.encode(), column_parent, p, ConsistencyLevel.ONE), + column_parent = ColumnParent('Super1', utf8encode('sc1')) + _expect_exception(lambda: client.get_slice(utf8encode('key1'), column_parent, p, ConsistencyLevel.ONE), InvalidRequestException) # start > finish, key version - _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[''.encode()]), 'z'.encode(), 'a'.encode(), 1, ConsistencyLevel.ONE), InvalidRequestException) + _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('')]), utf8encode('z'), utf8encode('a'), 1, ConsistencyLevel.ONE), InvalidRequestException) # ttl must be greater or equals to zero - column = Column('cttl1'.encode(), 'value1'.encode(), 0, -1) - _expect_exception(lambda: client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), + column = Column(utf8encode('cttl1'), utf8encode('value1'), 0, -1) + _expect_exception(lambda: client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE), InvalidRequestException) # don't allow super_column in Deletion for standard Columntest_expiration_with_default_ttl_and_zero_ttl - deletion = Deletion(1, 'supercolumn'.encode(), None) + deletion = Deletion(1, utf8encode('supercolumn'), None) mutation = Mutation(deletion=deletion) - mutations = {'key'.encode(): {'Standard1': [mutation]}} + mutations = {utf8encode('key'): {'Standard1': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # 'x' is not a valid long - deletion = Deletion(1, 'x'.encode(), None) + deletion = Deletion(1, utf8encode('x'), None) mutation = Mutation(deletion=deletion) - mutations = {'key'.encode(): {'Super3': [mutation]}} + mutations = {utf8encode('key'): {'Super3': [mutation]}} _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM), InvalidRequestException) # counters don't support ANY - _expect_exception(lambda: client.add('key1'.encode(), ColumnParent('Counter1', 'x'.encode()), CounterColumn('y'.encode(), 1), ConsistencyLevel.ANY), InvalidRequestException) + _expect_exception(lambda: client.add(utf8encode('key1'), ColumnParent('Counter1', utf8encode('x')), CounterColumn(utf8encode('y'), 1), ConsistencyLevel.ANY), InvalidRequestException) def test_batch_insert_super(self): _set_keyspace('Keyspace1') @@ -1069,7 +1069,7 @@ def test_batch_insert_super(self): for c in _SUPER_COLUMNS], 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c)) for c in _SUPER_COLUMNS]} - client.batch_mutate({'key1'.encode(): cfmap}, ConsistencyLevel.ONE) + client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) _verify_super('Super1') _verify_super('Super2') @@ -1078,30 +1078,30 @@ def test_cf_remove_column(self): self.truncate_all('Standard1') _insert_simple() - client.remove('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), ConsistencyLevel.ONE)) - assert client.get('key1'.encode(), ColumnPath('Standard1', column='c2'.encode()), ConsistencyLevel.ONE).column \ - == Column('c2'.encode(), 'value2'.encode(), 0) - assert _big_slice('key1'.encode(), ColumnParent('Standard1')) \ - == [ColumnOrSuperColumn(column=Column('c2'.encode(), 'value2'.encode(), 0))] + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), ConsistencyLevel.ONE)) + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c2')), ConsistencyLevel.ONE).column \ + == Column(utf8encode('c2'), utf8encode('value2'), 0) + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) \ + == [ColumnOrSuperColumn(column=Column(utf8encode('c2'), utf8encode('value2'), 0))] # New insert, make sure it shows up post-remove: - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c3'.encode(), 'value3'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c3'), utf8encode('value3'), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] - assert columns == [Column('c2'.encode(), 'value2'.encode(), 0), Column('c3'.encode(), 'value3'.encode(), 0)], columns + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + assert columns == [Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] - assert columns == [Column('c2'.encode(), 'value2'.encode(), 0), Column('c3'.encode(), 'value3'.encode(), 0)], columns + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + assert columns == [Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns # Next, w/ a newer timestamp; it should come back: - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 2), ConsistencyLevel.ONE) columns = [result.column - for result in _big_slice('key1'.encode(), ColumnParent('Standard1'))] - assert columns == [Column('c1'.encode(), 'value1'.encode(), 2), Column('c2'.encode(), 'value2'.encode(), 0), Column('c3'.encode(), 'value3'.encode(), 0)], columns + for result in _big_slice(utf8encode('key1'), ColumnParent('Standard1'))] + assert columns == [Column(utf8encode('c1'), utf8encode('value1'), 2), Column(utf8encode('c2'), utf8encode('value2'), 0), Column(utf8encode('c3'), utf8encode('value3'), 0)], columns def test_cf_remove(self): _set_keyspace('Keyspace1') @@ -1111,36 +1111,36 @@ def test_cf_remove(self): _insert_super() # Remove the key1:Standard1 cf; verify super is unaffected - client.remove('key1'.encode(), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) - assert _big_slice('key1'.encode(), ColumnParent('Standard1')) == [] + client.remove(utf8encode('key1'), ColumnPath('Standard1'), 3, ConsistencyLevel.ONE) + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] _verify_super() # Test resurrection. First, re-insert a value w/ older timestamp, # and make sure it stays removed: - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 0), ConsistencyLevel.ONE) - assert _big_slice('key1'.encode(), ColumnParent('Standard1')) == [] + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 0), ConsistencyLevel.ONE) + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] # Next, w/ a newer timestamp; it should come back: - client.insert('key1'.encode(), ColumnParent('Standard1'), Column('c1'.encode(), 'value1'.encode(), 4), ConsistencyLevel.ONE) - result = _big_slice('key1'.encode(), ColumnParent('Standard1')) - assert result == [ColumnOrSuperColumn(column=Column('c1'.encode(), 'value1'.encode(), 4))], result + client.insert(utf8encode('key1'), ColumnParent('Standard1'), Column(utf8encode('c1'), utf8encode('value1'), 4), ConsistencyLevel.ONE) + result = _big_slice(utf8encode('key1'), ColumnParent('Standard1')) + assert result == [ColumnOrSuperColumn(column=Column(utf8encode('c1'), utf8encode('value1'), 4))], result # check removing the entire super cf, too. - client.remove('key1'.encode(), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) - assert _big_slice('key1'.encode(), ColumnParent('Super1')) == [] - assert _big_slice('key1'.encode(), ColumnParent('Super1', 'sc1'.encode())) == [] + client.remove(utf8encode('key1'), ColumnPath('Super1'), 3, ConsistencyLevel.ONE) + assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1'))) == [] def test_super_cf_remove_and_range_slice(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - client.insert('key3'.encode(), ColumnParent('Super1', 'sc1'.encode()), Column(_i64(1), 'v1'.encode(), 0), ConsistencyLevel.ONE) - client.remove('key3'.encode(), ColumnPath('Super1', 'sc1'.encode()), 5, ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('Super1', utf8encode('sc1')), Column(_i64(1), utf8encode('v1'), 0), ConsistencyLevel.ONE) + client.remove(utf8encode('key3'), ColumnPath('Super1', utf8encode('sc1')), 5, ConsistencyLevel.ONE) rows = {} - for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE): + for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE): scs = [cosc.super_column for cosc in row.columns] rows[row.key] = scs - assert rows == {'key3'.encode(): []}, rows + assert rows == {utf8encode('key3'): []}, rows def test_super_cf_remove_column(self): _set_keyspace('Keyspace1') @@ -1150,42 +1150,42 @@ def test_super_cf_remove_column(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove('key1'.encode(), ColumnPath('Super1', 'sc2'.encode(), _i64(5)), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc2'.encode(), _i64(5)), ConsistencyLevel.ONE)) - super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] - assert super_columns == [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), - SuperColumn(name='sc2'.encode(), columns=[Column(_i64(6), 'value6'.encode(), 0)])] + client.remove(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), ConsistencyLevel.ONE)) + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + assert super_columns == [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(6), utf8encode('value6'), 0)])] _verify_simple() # New insert, make sure it shows up post-remove: - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(7), 'value7'.encode(), 0), ConsistencyLevel.ONE) - super_columns_expected = [SuperColumn(name='sc1'.encode(), - columns=[Column(_i64(4), 'value4'.encode(), 0)]), - SuperColumn(name='sc2'.encode(), - columns=[Column(_i64(6), 'value6'.encode(), 0), Column(_i64(7), 'value7'.encode(), 0)])] + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(7), utf8encode('value7'), 0), ConsistencyLevel.ONE) + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), + columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), + columns=[Column(_i64(6), utf8encode('value6'), 0), Column(_i64(7), utf8encode('value7'), 0)])] - super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 0), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 6), ConsistencyLevel.ONE) - super_columns = [result.super_column for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), - SuperColumn(name='sc2'.encode(), columns=[Column(_i64(5), 'value5'.encode(), 6), - Column(_i64(6), 'value6'.encode(), 0), - Column(_i64(7), 'value7'.encode(), 0)])] + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 6), ConsistencyLevel.ONE) + super_columns = [result.super_column for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 6), + Column(_i64(6), utf8encode('value6'), 0), + Column(_i64(7), utf8encode('value7'), 0)])] assert super_columns == super_columns_expected, super_columns # shouldn't be able to specify a column w/o a super column for remove - cp = ColumnPath(column_family='Super1', column='sc2'.encode()) - e = _expect_exception(lambda: client.remove('key1'.encode(), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) + cp = ColumnPath(column_family='Super1', column=utf8encode('sc2')) + e = _expect_exception(lambda: client.remove(utf8encode('key1'), cp, 5, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("column cannot be specified without") >= 0 def test_super_cf_remove_supercolumn(self): @@ -1196,66 +1196,66 @@ def test_super_cf_remove_supercolumn(self): _insert_super() # Make sure remove clears out what it's supposed to, and _only_ that: - client.remove('key1'.encode(), ColumnPath('Super1', 'sc2'.encode()), 5, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc2'.encode(), _i64(5)), ConsistencyLevel.ONE)) - super_columns = _big_slice('key1'.encode(), ColumnParent('Super1', 'sc2'.encode())) + client.remove(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2')), 5, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc2'), _i64(5)), ConsistencyLevel.ONE)) + super_columns = _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2'))) assert super_columns == [], super_columns - super_columns_expected = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)])] + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)])] super_columns = [result.super_column - for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns _verify_simple() # Test resurrection. First, re-insert the value w/ older timestamp, # and make sure it stays removed: - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 1), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 1), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] + for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] assert super_columns == super_columns_expected, super_columns # Next, w/ a newer timestamp; it should come back - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(5), 'value5'.encode(), 6), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(5), utf8encode('value5'), 6), ConsistencyLevel.ONE) super_columns = [result.super_column - for result in _big_slice('key1'.encode(), ColumnParent('Super1'))] - super_columns_expected = [SuperColumn(name='sc1'.encode(), columns=[Column(_i64(4), 'value4'.encode(), 0)]), - SuperColumn(name='sc2'.encode(), columns=[Column(_i64(5), 'value5'.encode(), 6)])] + for result in _big_slice(utf8encode('key1'), ColumnParent('Super1'))] + super_columns_expected = [SuperColumn(name=utf8encode('sc1'), columns=[Column(_i64(4), utf8encode('value4'), 0)]), + SuperColumn(name=utf8encode('sc2'), columns=[Column(_i64(5), utf8encode('value5'), 6)])] assert super_columns == super_columns_expected, super_columns # check slicing at the subcolumn level too - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) columns = [result.column - for result in client.get_slice('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), p, ConsistencyLevel.ONE)] - assert columns == [Column(_i64(5), 'value5'.encode(), 6)], columns + for result in client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE)] + assert columns == [Column(_i64(5), utf8encode('value5'), 6)], columns def test_super_cf_resurrect_subcolumn(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - key = 'vijay'.encode() - client.insert(key, ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 0), ConsistencyLevel.ONE) + key = utf8encode('vijay') + client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 0), ConsistencyLevel.ONE) - client.remove(key, ColumnPath('Super1', 'sc1'.encode()), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super1', utf8encode('sc1')), 1, ConsistencyLevel.ONE) - client.insert(key, ColumnParent('Super1', 'sc1'.encode()), Column(_i64(4), 'value4'.encode(), 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super1', utf8encode('sc1')), Column(_i64(4), utf8encode('value4'), 2), ConsistencyLevel.ONE) - result = client.get(key, ColumnPath('Super1', 'sc1'.encode()), ConsistencyLevel.ONE) + result = client.get(key, ColumnPath('Super1', utf8encode('sc1')), ConsistencyLevel.ONE) assert result.super_column.columns is not None, result.super_column def test_empty_range(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1', 'Super1') - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) == [] _insert_simple() - assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) == [] + assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) == [] @since('2.1') def test_super_cql_read_compatibility(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') - _insert_super(''.encode()) - _insert_super(''.encode()) + _insert_super(utf8encode("key1")) + _insert_super(utf8encode("key2")) node1 = self.cluster.nodelist()[0] session = self.patient_cql_connection(node1) @@ -1263,32 +1263,32 @@ def test_super_cql_read_compatibility(self): session.execute('USE "Keyspace1"') assert_all(session, "SELECT * FROM \"Super1\"", - [[''.encode(), ''.encode(), 4, ''.encode()], - [''.encode(), ''.encode(), 5, ''.encode()], - [''.encode(), ''.encode(), 6, ''.encode()], - [''.encode(), ''.encode(), 4, ''.encode()], - [''.encode(), ''.encode(), 5, ''.encode()], - [''.encode(), ''.encode(), 6, ''.encode()]]) + [[utf8encode("key1"), utf8encode("sc1"), 4, utf8encode("value4")], + [utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")], + [utf8encode("key2"), utf8encode("sc1"), 4, utf8encode("value4")], + [utf8encode("key2"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key2"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1')", - [[''.encode(), ''.encode(), 4, ''.encode()], - [''.encode(), ''.encode(), 5, ''.encode()], - [''.encode(), ''.encode(), 6, ''.encode()]]) + [[utf8encode("key1"), utf8encode("sc1"), 4, utf8encode("value4")], + [utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2')", - [[''.encode(), ''.encode(), 5, ''.encode()], - [''.encode(), ''.encode(), 6, ''.encode()]]) + [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2') AND column2 = 5", - [[''.encode(), ''.encode(), 5, ''.encode()]]) + [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")]]) assert_all(session, "SELECT * FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [[''.encode(), ''.encode(), 5, ''.encode()], - [''.encode(), ''.encode(), 6, ''.encode()]]) + [[utf8encode("key1"), utf8encode("sc2"), 5, utf8encode("value5")], + [utf8encode("key1"), utf8encode("sc2"), 6, utf8encode("value6")]]) assert_all(session, "SELECT column2, value FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')", - [[5, ''.encode()], - [6, ''.encode()]]) + [[5, utf8encode("value5")], + [6, utf8encode("value6")]]) @since('2.1') def test_super_cql_write_compatibility(self): @@ -1308,36 +1308,36 @@ def test_super_cql_write_compatibility(self): session.execute(query, ("key2", "sc2", 5, "value5")) session.execute(query, ("key2", "sc2", 6, "value6")) - p = SlicePredicate(slice_range=SliceRange('sc1'.encode(), 'sc2'.encode(), False, 2)) - result = client.get_slice('key1'.encode(), ColumnParent('Super1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc1'), utf8encode('sc2'), False, 2)) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1'), p, ConsistencyLevel.ONE) assert_length_equal(result, 2) - assert result[0].super_column.name == 'sc1'.encode() - assert result[0].super_column.columns[0], Column(_i64(4), 'value4'.encode() == 1234) - assert result[1].super_column.name == 'sc2'.encode() - assert result[1].super_column.columns, [Column(_i64(5), 'value5'.encode(), 1234), Column(_i64(6), 'value6'.encode() == 1234)] + assert result[0].super_column.name == utf8encode('sc1') + assert result[0].super_column.columns[0], Column(_i64(4), utf8encode('value4') == 1234) + assert result[1].super_column.name == utf8encode('sc2') + assert result[1].super_column.columns, [Column(_i64(5), utf8encode('value5'), 1234), Column(_i64(6), utf8encode('value6') == 1234)] def test_range_with_remove(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), 'key1'.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == 'key1'.encode() + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode('key1'), utf8encode(''), 1000, ConsistencyLevel.ONE)[0].key == utf8encode('key1') - client.remove('key1'.encode(), ColumnPath('Standard1', column='c1'.encode()), 1, ConsistencyLevel.ONE) - client.remove('key1'.encode(), ColumnPath('Standard1', column='c2'.encode()), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c2'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key='key1'.encode())], actual + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c1')), 1, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('c2')), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c2')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key=utf8encode('key1'))], actual def test_range_with_remove_cf(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') _insert_simple() - assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), 'key1'.encode(), ''.encode(), 1000, ConsistencyLevel.ONE)[0].key == 'key1'.encode() + assert get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode('key1'), utf8encode(''), 1000, ConsistencyLevel.ONE)[0].key == utf8encode('key1') - client.remove('key1'.encode(), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) - actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['c1'.encode(), 'c1'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) - assert actual == [KeySlice(columns=[], key='key1'.encode())], actual + client.remove(utf8encode('key1'), ColumnPath('Standard1'), 1, ConsistencyLevel.ONE) + actual = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c1')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) + assert actual == [KeySlice(columns=[], key=utf8encode('key1'))], actual def test_range_collation(self): _set_keyspace('Keyspace1') @@ -1345,9 +1345,9 @@ def test_range_collation(self): for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(key, 'v'.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(key, utf8encode('v'), 0), ConsistencyLevel.ONE) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), ''.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode(''), utf8encode(''), 1000, ConsistencyLevel.ONE) L = ['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '2', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '3', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '4', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '5', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '6', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '7', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '8', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '9', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', 'a', 'b'] assert len(slices) == len(L) for key, ks in zip(L, slices): @@ -1360,7 +1360,7 @@ def test_range_partial(self): for key in ['-a', '-b', 'a', 'b'] + [str(i) for i in range(100)]: key = utf8encode(key) - client.insert(key, ColumnParent('Standard1'), Column(key, 'v'.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Standard1'), Column(key, utf8encode('v'), 0), ConsistencyLevel.ONE) def check_slices_against_keys(keyList, sliceList): assert len(keyList) == len(sliceList), "%d vs %d" % (len(keyList), len(sliceList)) @@ -1368,16 +1368,16 @@ def check_slices_against_keys(keyList, sliceList): key = utf8encode(key) assert key == ks.key - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), 'a'.encode(), ''.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('a'), utf8encode(''), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['a', 'b'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), ''.encode(), '15'.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode(''), utf8encode('15'), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['-a', '-b', '0', '1', '10', '11', '12', '13', '14', '15'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), '50'.encode(), '51'.encode(), 1000, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('50'), utf8encode('51'), 1000, ConsistencyLevel.ONE) check_slices_against_keys(['50', '51'], slices) - slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a'.encode(), '-a'.encode()]), '1'.encode(), ''.encode(), 10, ConsistencyLevel.ONE) + slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=[utf8encode('-a'), utf8encode('-a')]), utf8encode('1'), utf8encode(''), 10, ConsistencyLevel.ONE) check_slices_against_keys(['1', '10', '11', '12', '13', '14', '15', '16', '17', '18'], slices) def test_get_slice_range(self): @@ -1402,15 +1402,15 @@ def test_get_range_slices_tokens(self): key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: cnameutf = utf8encode(cname) - client.insert(key, ColumnParent('Super3', 'sc1'.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', 'sc1'.encode()) - predicate = SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]) + cp = ColumnParent('Super3', utf8encode('sc1')) + predicate = SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]) range = KeyRange(start_token='55', end_token='55', count=100) result = client.get_range_slices(cp, predicate, range, ConsistencyLevel.ONE) assert len(result) == 5 - assert result[0].columns[0].column.name == 'col1'.encode() - assert result[0].columns[1].column.name == 'col3'.encode() + assert result[0].columns[0].column.name == utf8encode('col1') + assert result[0].columns[1].column.name == utf8encode('col3') def test_get_range_slice_super(self): _set_keyspace('Keyspace2') @@ -1420,18 +1420,18 @@ def test_get_range_slice_super(self): key = utf8encode(key) for cname in ['col1', 'col2', 'col3', 'col4', 'col5']: cnameutf = utf8encode(cname) - client.insert(key, ColumnParent('Super3', 'sc1'.encode()), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) - cp = ColumnParent('Super3', 'sc1'.encode()) - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key2'.encode(), 'key4'.encode(), 5, ConsistencyLevel.ONE) + cp = ColumnParent('Super3', utf8encode('sc1')) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert result[0].columns[0].column.name == 'col1'.encode() - assert result[0].columns[1].column.name == 'col3'.encode() + assert result[0].columns[0].column.name == utf8encode('col1') + assert result[0].columns[1].column.name == utf8encode('col3') cp = ColumnParent('Super3') - result = get_range_slice(client, cp, SlicePredicate(column_names=['sc1'.encode()]), 'key2'.encode(), 'key4'.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('sc1')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) assert len(result) == 3 - assert list(set(row.columns[0].super_column.name for row in result))[0] == 'sc1'.encode() + assert list(set(row.columns[0].super_column.name for row in result))[0] == utf8encode('sc1') def test_get_range_slice(self): _set_keyspace('Keyspace1') @@ -1445,52 +1445,52 @@ def test_get_range_slice(self): cp = ColumnParent('Standard1') # test empty slice - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key6'.encode(), ''.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key6'), utf8encode(''), 1, ConsistencyLevel.ONE) assert len(result) == 0 # test empty columns - result = get_range_slice(client, cp, SlicePredicate(column_names=['a'.encode()]), 'key2'.encode(), ''.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('a')]), utf8encode('key2'), utf8encode(''), 1, ConsistencyLevel.ONE) assert len(result) == 1 assert len(result[0].columns) == 0 # test column_names predicate - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key2'.encode(), 'key4'.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 5, ConsistencyLevel.ONE) assert len(result) == 3, result - assert result[0].columns[0].column.name == 'col1'.encode() - assert result[0].columns[1].column.name == 'col3'.encode() + assert result[0].columns[0].column.name == utf8encode('col1') + assert result[0].columns[1].column.name == utf8encode('col3') # row limiting via count. - result = get_range_slice(client, cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), 'key2'.encode(), 'key4'.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), utf8encode('key2'), utf8encode('key4'), 1, ConsistencyLevel.ONE) assert len(result) == 1 # test column slice predicate - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2'.encode(), finish='col4'.encode(), reversed=False, count=5)), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=5)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].key == 'key1'.encode() - assert result[1].key == 'key2'.encode() + assert result[0].key == utf8encode('key1') + assert result[1].key == utf8encode('key2') assert len(result[0].columns) == 3 - assert result[0].columns[0].column.name == 'col2'.encode() - assert result[0].columns[2].column.name == 'col4'.encode() + assert result[0].columns[0].column.name == utf8encode('col2') + assert result[0].columns[2].column.name == utf8encode('col4') # col limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2'.encode(), finish='col4'.encode(), reversed=False, count=2)), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=2)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) assert len(result[0].columns) == 2 # and reversed - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col4'.encode(), finish='col2'.encode(), reversed=True, count=5)), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) - assert result[0].columns[0].column.name == 'col4'.encode() - assert result[0].columns[2].column.name == 'col2'.encode() + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col4'), finish=utf8encode('col2'), reversed=True, count=5)), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) + assert result[0].columns[0].column.name == utf8encode('col4') + assert result[0].columns[2].column.name == utf8encode('col2') # row limiting via count - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start='col2'.encode(), finish='col4'.encode(), reversed=False, count=5)), 'key1'.encode(), 'key2'.encode(), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(start=utf8encode('col2'), finish=utf8encode('col4'), reversed=False, count=5)), utf8encode('key1'), utf8encode('key2'), 1, ConsistencyLevel.ONE) assert len(result) == 1 # removed data - client.remove('key1'.encode(), ColumnPath('Standard1', column='col1'.encode()), 1, ConsistencyLevel.ONE) - result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())), 'key1'.encode(), 'key2'.encode(), 5, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('col1')), 1, ConsistencyLevel.ONE) + result = get_range_slice(client, cp, SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))), utf8encode('key1'), utf8encode('key2'), 5, ConsistencyLevel.ONE) assert len(result) == 2, result - assert result[0].columns[0].column.name == 'col2'.encode(), result[0].columns[0].column.name - assert result[1].columns[0].column.name == 'col1'.encode() + assert result[0].columns[0].column.name == utf8encode('col2'), result[0].columns[0].column.name + assert result[1].columns[0].column.name == utf8encode('col1') def test_wrapped_range_slices(self): _set_keyspace('Keyspace1') @@ -1510,10 +1510,10 @@ def copp_token(key): client.insert(key, ColumnParent('Standard1'), Column(cnameutf, utf8encode('v-' + cname), 0), ConsistencyLevel.ONE) cp = ColumnParent('Standard1') - result = client.get_range_slices(cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) + result = client.get_range_slices(cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), KeyRange(start_token=copp_token('e'), end_token=copp_token('e')), ConsistencyLevel.ONE) assert [row.key for row in result] == keylist, [row.key for row in result] - result = client.get_range_slices(cp, SlicePredicate(column_names=['col1'.encode(), 'col3'.encode()]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) + result = client.get_range_slices(cp, SlicePredicate(column_names=[utf8encode('col1'), utf8encode('col3')]), KeyRange(start_token=copp_token('c'), end_token=copp_token('c')), ConsistencyLevel.ONE) assert [row.key for row in result] == keylist, [row.key for row in result] def test_get_slice_by_names(self): @@ -1521,15 +1521,15 @@ def test_get_slice_by_names(self): self.truncate_all('Standard1', 'Super1') _insert_range() - p = SlicePredicate(column_names=['c1'.encode(), 'c2'.encode()]) - result = client.get_slice('key1'.encode(), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) + p = SlicePredicate(column_names=[utf8encode('c1'), utf8encode('c2')]) + result = client.get_slice(utf8encode('key1'), ColumnParent('Standard1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].column.name == 'c1'.encode() - assert result[1].column.name == 'c2'.encode() + assert result[0].column.name == utf8encode('c1') + assert result[1].column.name == utf8encode('c2') _insert_super() p = SlicePredicate(column_names=[_i64(4)]) - result = client.get_slice('key1'.encode(), ColumnParent('Super1', 'sc1'.encode()), p, ConsistencyLevel.ONE) + result = client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1')), p, ConsistencyLevel.ONE) assert len(result) == 1 assert result[0].column.name == _i64(4) @@ -1538,23 +1538,23 @@ def test_multiget_slice_with_compact_table(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef('v'.encode(), 'AsciiType', None, None) + cd = ColumnDef(utf8encode('v'), 'AsciiType', None, None) newcf = CfDef('Keyspace1', 'CompactColumnFamily', default_validation_class='AsciiType', column_metadata=[cd]) client.system_add_column_family(newcf) CL = ConsistencyLevel.ONE for i in range(0, 5): - client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column('v'.encode(), utf8encode('value' + str(i)), 0), CL) + client.insert(utf8encode('key' + str(i)), ColumnParent('CompactColumnFamily'), Column(utf8encode('v'), utf8encode('value' + str(i)), 0), CL) time.sleep(0.1) - p = SlicePredicate(column_names=['v'.encode()]) + p = SlicePredicate(column_names=[utf8encode('v')]) rows = client.multiget_slice([utf8encode('key' + str(i)) for i in range(0, 5)], ColumnParent('CompactColumnFamily'), p, ConsistencyLevel.ONE) for i in range(0, 5): key = utf8encode('key' + str(i)) assert key in rows assert len(rows[key]) == 1 - assert rows[key][0].column.name == 'v'.encode() + assert rows[key][0].column.name == utf8encode('v') assert rows[key][0].column.value == utf8encode('value' + str(i)) def test_multiget_slice(self): @@ -1590,7 +1590,7 @@ def test_multi_count(self): # Count columns in all 10 keys keys = [utf8encode('key' + str(i)) for i in range(1, num_keys + 1)] - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000)) counts = client.multiget_count(keys, ColumnParent('Standard1'), p, ConsistencyLevel.ONE) # Check the returned counts @@ -1603,26 +1603,26 @@ def test_batch_mutate_super_deletion(self): self.truncate_all('Super1') _insert_super('test') - d = Deletion(1, predicate=SlicePredicate(column_names=['sc1'.encode()])) + d = Deletion(1, predicate=SlicePredicate(column_names=[utf8encode('sc1')])) cfmap = {'Super1': [Mutation(deletion=d)]} - client.batch_mutate({'test'.encode(): cfmap}, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Super1', 'sc1'.encode()), ConsistencyLevel.ONE)) + client.batch_mutate({utf8encode('test'): cfmap}, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Super1', utf8encode('sc1')), ConsistencyLevel.ONE)) def test_super_reinsert(self): _set_keyspace('Keyspace1') self.truncate_all('Super1') for x in range(3): - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(x), 'value'.encode(), 1), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(x), utf8encode('value'), 1), ConsistencyLevel.ONE) - client.remove('key1'.encode(), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Super1'), 2, ConsistencyLevel.ONE) for x in range(3): - client.insert('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), Column(_i64(x + 3), 'value'.encode(), 3), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), Column(_i64(x + 3), utf8encode('value'), 3), ConsistencyLevel.ONE) for n in range(1, 4): - p = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, n)) - slice = client.get_slice('key1'.encode(), ColumnParent('Super1', 'sc2'.encode()), p, ConsistencyLevel.ONE) + p = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, n)) + slice = client.get_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc2')), p, ConsistencyLevel.ONE) assert len(slice) == n, "expected %s results; found %s" % (n, slice) def test_describe_keyspace(self): @@ -1726,9 +1726,9 @@ def test_system_cf_recreate(self): _set_keyspace(keyspace) # insert - client.insert('key0'.encode(), ColumnParent(cf_name), Column('colA'.encode(), 'colA-value'.encode(), 0), ConsistencyLevel.ONE) - col1 = client.get_slice('key0'.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE)[0].column - assert col1.name == 'colA'.encode() and col1.value == 'colA-value'.encode() + client.insert(utf8encode('key0'), ColumnParent(cf_name), Column(utf8encode('colA'), utf8encode('colA-value'), 0), ConsistencyLevel.ONE) + col1 = client.get_slice(utf8encode('key0'), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)), ConsistencyLevel.ONE)[0].column + assert col1.name == utf8encode('colA') and col1.value == utf8encode('colA-value') # drop client.system_drop_column_family(cf_name) @@ -1737,7 +1737,7 @@ def test_system_cf_recreate(self): client.system_add_column_family(newcf) # query - cosc_list = client.get_slice('key0'.encode(), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)), ConsistencyLevel.ONE) + cosc_list = client.get_slice(utf8encode('key0'), ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)), ConsistencyLevel.ONE) # this was failing prior to CASSANDRA-1477. assert len(cosc_list) == 0, 'cosc length test failed' @@ -1806,17 +1806,17 @@ def test_column_validators(self): # columndef validation for regular CF ks = 'Keyspace1' _set_keyspace(ks) - cd = ColumnDef('col'.encode(), 'LongType', None, None) + cd = ColumnDef(utf8encode('col'), 'LongType', None, None) cf = CfDef('Keyspace1', 'ValidatorColumnFamily', column_metadata=[cd]) client.system_add_column_family(cf) ks_def = client.describe_keyspace(ks) assert 'ValidatorColumnFamily' in [x.name for x in ks_def.cf_defs] cp = ColumnParent('ValidatorColumnFamily') - col0 = Column('col'.encode(), _i64(42), 0) - col1 = Column('col'.encode(), ''.encode(), 0) - client.insert('key0'.encode(), cp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert('key1'.encode(), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) + col0 = Column(utf8encode('col'), _i64(42), 0) + col1 = Column(utf8encode('col'), utf8encode("ceci n'est pas 64bit"), 0) + client.insert(utf8encode('key0'), cp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), cp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef validation for super CF @@ -1825,9 +1825,9 @@ def test_column_validators(self): ks_def = client.describe_keyspace(ks) assert 'ValidatorSuperColumnFamily' in [x.name for x in ks_def.cf_defs] - scp = ColumnParent('ValidatorSuperColumnFamily', 'sc1'.encode()) - client.insert('key0'.encode(), scp, col0, ConsistencyLevel.ONE) - e = _expect_exception(lambda: client.insert('key1'.encode(), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) + scp = ColumnParent('ValidatorSuperColumnFamily', utf8encode('sc1')) + client.insert(utf8encode('key0'), scp, col0, ConsistencyLevel.ONE) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), scp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # columndef and cfdef default validation @@ -1838,23 +1838,23 @@ def test_column_validators(self): dcp = ColumnParent('DefaultValidatorColumnFamily') # inserting a longtype into column 'col' is valid at the columndef level - client.insert('key0'.encode(), dcp, col0, ConsistencyLevel.ONE) + client.insert(utf8encode('key0'), dcp, col0, ConsistencyLevel.ONE) # inserting a UTF8type into column 'col' fails at the columndef level - e = _expect_exception(lambda: client.insert('key1'.encode(), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), dcp, col1, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a longtype into column 'fcol' should fail at the cfdef level - col2 = Column('fcol'.encode(), _i64(4224), 0) - e = _expect_exception(lambda: client.insert('key1'.encode(), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) + col2 = Column(utf8encode('fcol'), _i64(4224), 0) + e = _expect_exception(lambda: client.insert(utf8encode('key1'), dcp, col2, ConsistencyLevel.ONE), InvalidRequestException) assert e.why.find("failed validation") >= 0 # insert a UTF8type into column 'fcol' is valid at the cfdef level - col3 = Column('fcol'.encode(), ''.encode(), 0) - client.insert('key0'.encode(), dcp, col3, ConsistencyLevel.ONE) + col3 = Column(utf8encode('fcol'), utf8encode("Stringin' it up in the Stringtel Stringifornia"), 0) + client.insert(utf8encode('key0'), dcp, col3, ConsistencyLevel.ONE) def test_system_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef('ValidationColumn'.encode(), 'BytesType', None, None) + cd = ColumnDef(utf8encode('ValidationColumn'), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewColumnFamily', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -1907,36 +1907,36 @@ def test_dynamic_indexes_creation_deletion(self): ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'BlankCF'][0] - modified_cd = ColumnDef('birthdate'.encode(), 'BytesType', IndexType.KEYS, None) + modified_cd = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, None) modified_cf = CfDef('Keyspace1', 'BlankCF', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) # Add a second indexed CF ... - birthdate_coldef = ColumnDef('birthdate'.encode(), 'BytesType', IndexType.KEYS, None) - age_coldef = ColumnDef('age'.encode(), 'BytesType', IndexType.KEYS, 'age_index') + birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, None) + age_coldef = ColumnDef(utf8encode('age'), 'BytesType', IndexType.KEYS, 'age_index') cfdef = CfDef('Keyspace1', 'BlankCF2', column_metadata=[birthdate_coldef, age_coldef]) client.system_add_column_family(cfdef) # ... and update it to have a third index ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - name_coldef = ColumnDef('name'.encode(), 'BytesType', IndexType.KEYS, 'name_index') + name_coldef = ColumnDef(utf8encode('name'), 'BytesType', IndexType.KEYS, 'name_index') cfdef.column_metadata.append(name_coldef) client.system_update_column_family(cfdef) # Now drop the indexes ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF2'][0] - birthdate_coldef = ColumnDef('birthdate'.encode(), 'BytesType', None, None) - age_coldef = ColumnDef('age'.encode(), 'BytesType', None, None) - name_coldef = ColumnDef('name'.encode(), 'BytesType', None, None) + birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) + age_coldef = ColumnDef(utf8encode('age'), 'BytesType', None, None) + name_coldef = ColumnDef(utf8encode('name'), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef, age_coldef, name_coldef] client.system_update_column_family(cfdef) ks1 = client.describe_keyspace('Keyspace1') cfdef = [x for x in ks1.cf_defs if x.name == 'BlankCF'][0] - birthdate_coldef = ColumnDef('birthdate'.encode(), 'BytesType', None, None) + birthdate_coldef = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) cfdef.column_metadata = [birthdate_coldef] client.system_update_column_family(cfdef) @@ -1945,29 +1945,29 @@ def test_dynamic_indexes_creation_deletion(self): def test_dynamic_indexes_with_system_update_cf(self): _set_keyspace('Keyspace1') - cd = ColumnDef('birthdate'.encode(), 'BytesType', None, None) + cd = ColumnDef(utf8encode('birthdate'), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'ToBeIndexed', default_validation_class='LongType', column_metadata=[cd]) client.system_add_column_family(newcf) - client.insert('key1'.encode(), ColumnParent('ToBeIndexed'), Column('birthdate'.encode(), _i64(1), 0), ConsistencyLevel.ONE) - client.insert('key2'.encode(), ColumnParent('ToBeIndexed'), Column('birthdate'.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key2'.encode(), ColumnParent('ToBeIndexed'), Column('b'.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key3'.encode(), ColumnParent('ToBeIndexed'), Column('birthdate'.encode(), _i64(3), 0), ConsistencyLevel.ONE) - client.insert('key3'.encode(), ColumnParent('ToBeIndexed'), Column('b'.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('ToBeIndexed'), Column(utf8encode('b'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('ToBeIndexed'), Column(utf8encode('birthdate'), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('ToBeIndexed'), Column(utf8encode('b'), _i64(3), 0), ConsistencyLevel.ONE) # First without index cp = ColumnParent('ToBeIndexed') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key1'.encode() + assert result[0].key == utf8encode('key1') assert len(result[0].columns) == 1, result[0].columns # add an index on 'birthdate' ks1 = client.describe_keyspace('Keyspace1') cfid = [x.id for x in ks1.cf_defs if x.name == 'ToBeIndexed'][0] - modified_cd = ColumnDef('birthdate'.encode(), 'BytesType', IndexType.KEYS, 'bd_index') + modified_cd = ColumnDef(utf8encode('birthdate'), 'BytesType', IndexType.KEYS, 'bd_index') modified_cf = CfDef('Keyspace1', 'ToBeIndexed', column_metadata=[modified_cd]) modified_cf.id = cfid client.system_update_column_family(modified_cf) @@ -1984,14 +1984,14 @@ def test_dynamic_indexes_with_system_update_cf(self): # repeat query on one index expression result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key1'.encode() + assert result[0].key == utf8encode('key1') assert len(result[0].columns) == 1, result[0].columns def test_system_super_column_family_operations(self): _set_keyspace('Keyspace1') # create - cd = ColumnDef('ValidationColumn'.encode(), 'BytesType', None, None) + cd = ColumnDef(utf8encode('ValidationColumn'), 'BytesType', None, None) newcf = CfDef('Keyspace1', 'NewSuperColumnFamily', 'Super', column_metadata=[cd]) client.system_add_column_family(newcf) ks1 = client.describe_keyspace('Keyspace1') @@ -2008,32 +2008,32 @@ def test_insert_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl1'.encode(), 'value1'.encode(), 0, 5) - client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - assert client.get('key1'.encode(), ColumnPath('Standard1', column='cttl1'.encode()), ConsistencyLevel.ONE).column == column + column = Column(utf8encode('cttl1'), utf8encode('value1'), 0, 5) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl1')), ConsistencyLevel.ONE).column == column def test_simple_expiration(self): """ Test that column ttled do expires """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl3'.encode(), 'value1'.encode(), 0, 2) - client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - c = client.get('key1'.encode(), ColumnPath('Standard1', column='cttl3'.encode()), ConsistencyLevel.ONE).column + column = Column(utf8encode('cttl3'), utf8encode('value1'), 0, 2) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + c = client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='cttl3'.encode()), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl3')), ConsistencyLevel.ONE)) def test_expiration_with_default_ttl(self): """ Test that column with default ttl do expires """ _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column('cttl3'.encode(), 'value1'.encode(), 0) - client.insert('key1'.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - client.get('key1'.encode(), ColumnPath('Expiring', column='cttl3'.encode()), ConsistencyLevel.ONE).column + column = Column(utf8encode('cttl3'), utf8encode('value1'), 0) + client.insert(utf8encode('key1'), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column time.sleep(3) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Expiring', column='cttl3'.encode()), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE)) @since('3.6') def test_expiration_with_default_ttl_and_zero_ttl(self): @@ -2044,45 +2044,45 @@ def test_expiration_with_default_ttl_and_zero_ttl(self): _set_keyspace('Keyspace1') self.truncate_all('Expiring') - column = Column('cttl3'.encode(), 'value1'.encode(), 0, 0) - client.insert('key1'.encode(), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) - c = client.get('key1'.encode(), ColumnPath('Expiring', column='cttl3'.encode()), ConsistencyLevel.ONE).column - assert Column('cttl3'.encode(), 'value1'.encode(), 0) == c + column = Column(utf8encode('cttl3'), utf8encode('value1'), 0, 0) + client.insert(utf8encode('key1'), ColumnParent('Expiring'), column, ConsistencyLevel.ONE) + c = client.get(utf8encode('key1'), ColumnPath('Expiring', column=utf8encode('cttl3')), ConsistencyLevel.ONE).column + assert Column(utf8encode('cttl3'), utf8encode('value1'), 0) == c def test_simple_expiration_batch_mutate(self): """ Test that column ttled do expires using batch_mutate """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl4'.encode(), 'value1'.encode(), 0, 2) + column = Column(utf8encode('cttl4'), utf8encode('value1'), 0, 2) cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(column))]} - client.batch_mutate({'key1'.encode(): cfmap}, ConsistencyLevel.ONE) - c = client.get('key1'.encode(), ColumnPath('Standard1', column='cttl4'.encode()), ConsistencyLevel.ONE).column + client.batch_mutate({utf8encode('key1'): cfmap}, ConsistencyLevel.ONE) + c = client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE).column assert c == column time.sleep(3) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='cttl4'.encode()), ConsistencyLevel.ONE)) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE)) def test_update_expiring(self): """ Test that updating a column with ttl override the ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column1 = Column('cttl4'.encode(), 'value1'.encode(), 0, 1) - client.insert('key1'.encode(), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) - column2 = Column('cttl4'.encode(), 'value1'.encode(), 1) - client.insert('key1'.encode(), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) + column1 = Column(utf8encode('cttl4'), utf8encode('value1'), 0, 1) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column1, ConsistencyLevel.ONE) + column2 = Column(utf8encode('cttl4'), utf8encode('value1'), 1) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column2, ConsistencyLevel.ONE) time.sleep(1.5) - assert client.get('key1'.encode(), ColumnPath('Standard1', column='cttl4'.encode()), ConsistencyLevel.ONE).column == column2 + assert client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl4')), ConsistencyLevel.ONE).column == column2 def test_remove_expiring(self): """ Test removing a column with ttl """ _set_keyspace('Keyspace1') self.truncate_all('Standard1') - column = Column('cttl5'.encode(), 'value1'.encode(), 0, 10) - client.insert('key1'.encode(), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) - client.remove('key1'.encode(), ColumnPath('Standard1', column='cttl5'.encode()), 1, ConsistencyLevel.ONE) - _expect_missing(lambda: client.get('key1'.encode(), ColumnPath('Standard1', column='ctt5'.encode()), ConsistencyLevel.ONE)) + column = Column(utf8encode('cttl5'), utf8encode('value1'), 0, 10) + client.insert(utf8encode('key1'), ColumnParent('Standard1'), column, ConsistencyLevel.ONE) + client.remove(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('cttl5')), 1, ConsistencyLevel.ONE) + _expect_missing(lambda: client.get(utf8encode('key1'), ColumnPath('Standard1', column=utf8encode('ctt5')), ConsistencyLevel.ONE)) def test_describe_ring_on_invalid_keyspace(self): def req(): @@ -2097,19 +2097,19 @@ def test_incr_decr_standard_add(self, request): d2 = -21 d3 = 35 # insert positive and negative values and check the counts - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) time.sleep(0.1) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d2), ConsistencyLevel.ONE) time.sleep(0.1) - rv2 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d3), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d3), ConsistencyLevel.ONE) time.sleep(0.1) - rv3 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) def test_incr_decr_super_add(self, request): @@ -2120,18 +2120,18 @@ def test_incr_decr_super_add(self, request): d2 = 52345 d3 = 3123 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c2'.encode(), d2), ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode()), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c2'), d2), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) assert rv1.counter_super_column.columns[0].value == d1 assert rv1.counter_super_column.columns[1].value == d2 - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d2), ConsistencyLevel.ONE) - rv2 = client.get(key, ColumnPath('SuperCounter1', 'sc1'.encode(), 'c1'.encode()), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d2), ConsistencyLevel.ONE) + rv2 = client.get(key, ColumnPath('SuperCounter1', utf8encode('sc1'), utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == (d1 + d2) - client.add(key, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d3), ConsistencyLevel.ONE) - rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d3), ConsistencyLevel.ONE) + rv3 = client.get(key, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv3.counter_column.value == (d1 + d2 + d3) def test_incr_standard_remove(self, request): @@ -2142,20 +2142,20 @@ def test_incr_standard_remove(self, request): d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1'.encode())) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1'.encode())) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) def test_incr_super_remove(self, request): _set_keyspace('Keyspace1') @@ -2165,20 +2165,20 @@ def test_incr_super_remove(self, request): d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) def test_incr_decr_standard_remove(self, request): _set_keyspace('Keyspace1') @@ -2188,20 +2188,20 @@ def test_incr_decr_standard_remove(self, request): d1 = 124 # insert value and check it exists - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1'.encode())) + client.remove_counter(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 client.remove_counter(key2, ColumnPath(column_family='Counter1'), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1'.encode())) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) def test_incr_decr_super_remove(self, request): _set_keyspace('Keyspace1') @@ -2211,20 +2211,20 @@ def test_incr_decr_super_remove(self, request): d1 = 52345 # insert value and check it exists - client.add(key1, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 # remove the previous column and check that it is gone - client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) + client.remove_counter(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key1, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone - client.add(key2, ColumnParent(column_family='SuperCounter1', super_column='sc1'.encode()), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode()), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='SuperCounter1', super_column=utf8encode('sc1')), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 - client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode()), ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column='sc1'.encode(), column='c1'.encode())) + client.remove_counter(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1')), ConsistencyLevel.ONE) + _assert_no_columnpath(key2, ColumnPath(column_family='SuperCounter1', super_column=utf8encode('sc1'), column=utf8encode('c1'))) def test_incr_decr_standard_batch_add(self, request): _set_keyspace('Keyspace1') @@ -2233,13 +2233,13 @@ def test_incr_decr_standard_batch_add(self, request): d1 = 12 d2 = -21 update_map = {key: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), ]}} # insert positive and negative values and check the counts client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + rv1 = client.get(key, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 def test_incr_decr_standard_batch_remove(self, request): @@ -2252,34 +2252,34 @@ def test_incr_decr_standard_batch_remove(self, request): # insert positive and negative values and check the counts update_map = {key1: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv1 = client.get(key1, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + rv1 = client.get(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv1.counter_column.value == d1 + d2 # remove the previous column and check that it is gone update_map = {key1: {'Counter1': [ - Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=['c1'.encode()]))), + Mutation(deletion=Deletion(predicate=SlicePredicate(column_names=[utf8encode('c1')]))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column='c1'.encode())) + _assert_no_columnpath(key1, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # insert again and this time delete the whole row, check that it is gone update_map = {key2: {'Counter1': [ - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d1))), - Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn('c1'.encode(), d2))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d1))), + Mutation(column_or_supercolumn=ColumnOrSuperColumn(counter_column=CounterColumn(utf8encode('c1'), d2))), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - rv2 = client.get(key2, ColumnPath(column_family='Counter1', column='c1'.encode()), ConsistencyLevel.ONE) + rv2 = client.get(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1')), ConsistencyLevel.ONE) assert rv2.counter_column.value == d1 + d2 update_map = {key2: {'Counter1': [ Mutation(deletion=Deletion()), ]}} client.batch_mutate(update_map, ConsistencyLevel.ONE) - _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column='c1'.encode())) + _assert_no_columnpath(key2, ColumnPath(column_family='Counter1', column=utf8encode('c1'))) # known failure: see CASSANDRA-10046 def test_range_deletion(self): @@ -2289,16 +2289,16 @@ def test_range_deletion(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, 'value'.encode(), int(time.time() * 1000)) - client.insert('key1'.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x01'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {'key1'.encode(): {'StandardComposite': mutations}} + keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - slice_predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)) - results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + slice_predicate = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2317,17 +2317,17 @@ def test_range_deletion_eoc_0(self): for i in range(10): column_name = composite(str(i), str(i)) - column = Column(column_name, 'value'.encode(), int(time.time() * 1000)) - client.insert('key1'.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # insert a partial cell name (just the first element of the composite) column_name = composite('6', None, eoc=b'\x00') - column = Column(column_name, 'value'.encode(), int(time.time() * 1000)) - client.insert('key1'.encode(), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) + column = Column(column_name, utf8encode('value'), int(time.time() * 1000)) + client.insert(utf8encode('key1'), ColumnParent('StandardComposite'), column, ConsistencyLevel.ONE) # sanity check the query - slice_predicate = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 100)) - results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + slice_predicate = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 100)) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('3', '3'), composite('4', '4'), composite('5', '5'), composite('6'), @@ -2337,11 +2337,11 @@ def test_range_deletion_eoc_0(self): # do a slice deletion with (6, ) as the end delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {'key1'.encode(): {'StandardComposite': mutations}} + keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) - # check the columns post-deletion, ('6'.encode(), ) because it is an exact much but not (6, 6) - results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + # check the columns post-deletion, (utf8encode('6'), ) because it is an exact much but not (6, 6) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('6', '6'), @@ -2350,11 +2350,11 @@ def test_range_deletion_eoc_0(self): # do another slice deletion, but make the end (6, 6) this time delete_slice = SlicePredicate(slice_range=SliceRange(composite('3', eoc=b'\xff'), composite('6', '6', b'\x00'), False, 100)) mutations = [Mutation(deletion=Deletion(int(time.time() * 1000), predicate=delete_slice))] - keyed_mutations = {'key1'.encode(): {'StandardComposite': mutations}} + keyed_mutations = {utf8encode('key1'): {'StandardComposite': mutations}} client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # check the columns post-deletion, now (6, 6) is also gone - results = client.get_slice('key1'.encode(), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) + results = client.get_slice(utf8encode('key1'), ColumnParent('StandardComposite'), slice_predicate, ConsistencyLevel.ONE) columns = [result.column.name for result in results] assert columns == [composite('0', '0'), composite('1', '1'), composite('2', '2'), composite('7', '7'), composite('8', '8'), composite('9', '9')] @@ -2365,15 +2365,15 @@ def test_incr_decr_standard_slice(self, request): d1 = 12 d2 = -21 - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c1'.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c2'.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d2), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c4'.encode(), d1), ConsistencyLevel.ONE) - client.add(key, ColumnParent(column_family='Counter1'), CounterColumn('c5'.encode(), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c1'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) + client.add(key, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate(['c3'.encode(), 'c4'.encode()]), ConsistencyLevel.ONE) + counters = client.get_slice(key, ColumnParent('Counter1'), SlicePredicate([utf8encode('c3'), utf8encode('c4')]), ConsistencyLevel.ONE) assert counters[0].counter_column.value == d1 + d2 assert counters[1].counter_column.value == d1 @@ -2385,20 +2385,20 @@ def test_incr_decr_standard_multiget_slice(self, request): d1 = 12 d2 = -21 - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c2'.encode(), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d2), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c4'.encode(), d1), ConsistencyLevel.ONE) - client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn('c5'.encode(), d1), ConsistencyLevel.ONE) - - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c2'.encode(), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c3'.encode(), d2), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c4'.encode(), d1), ConsistencyLevel.ONE) - client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn('c5'.encode(), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) + client.add(key1, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) + + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c2'), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c3'), d2), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c4'), d1), ConsistencyLevel.ONE) + client.add(key2, ColumnParent(column_family='Counter1'), CounterColumn(utf8encode('c5'), d1), ConsistencyLevel.ONE) # insert positive and negative values and check the counts - counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate(['c3'.encode(), 'c4'.encode()]), ConsistencyLevel.ONE) + counters = client.multiget_slice([key1, key2], ColumnParent('Counter1'), SlicePredicate([utf8encode('c3'), utf8encode('c4')]), ConsistencyLevel.ONE) assert counters[key1][0].counter_column.value == d1 + d2 assert counters[key1][1].counter_column.value == d1 @@ -2409,27 +2409,27 @@ def test_counter_get_slice_range(self, request): _set_keyspace('Keyspace1') key = utf8encode(request.node.name) - client.add(key, ColumnParent('Counter1'), CounterColumn('c1'.encode(), 1), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn('c2'.encode(), 2), ConsistencyLevel.ONE) - client.add(key, ColumnParent('Counter1'), CounterColumn('c3'.encode(), 3), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c1'), 1), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c2'), 2), ConsistencyLevel.ONE) + client.add(key, ColumnParent('Counter1'), CounterColumn(utf8encode('c3'), 3), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('c1'.encode(), 'c2'.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c1'), utf8encode('c2'), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == 'c1'.encode() - assert result[1].counter_column.name == 'c2'.encode() + assert result[0].counter_column.name == utf8encode('c1') + assert result[1].counter_column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('c3'.encode(), 'c2'.encode(), True, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('c3'), utf8encode('c2'), True, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_column.name == 'c3'.encode() - assert result[1].counter_column.name == 'c2'.encode() + assert result[0].counter_column.name == utf8encode('c3') + assert result[1].counter_column.name == utf8encode('c2') - p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 1000)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 1000)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 3, result - p = SlicePredicate(slice_range=SliceRange('a'.encode(), 'z'.encode(), False, 2)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('a'), utf8encode('z'), False, 2)) result = client.get_slice(key, ColumnParent('Counter1'), p, ConsistencyLevel.ONE) assert len(result) == 2, result @@ -2437,77 +2437,77 @@ def test_counter_get_slice_super_range(self, request): _set_keyspace('Keyspace1') key = utf8encode(request.node.name) - client.add(key, ColumnParent('SuperCounter1', 'sc1'.encode()), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', 'sc2'.encode()), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', 'sc2'.encode()), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) - client.add(key, ColumnParent('SuperCounter1', 'sc3'.encode()), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc1')), CounterColumn(_i64(4), 4), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc2')), CounterColumn(_i64(5), 5), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc2')), CounterColumn(_i64(6), 6), ConsistencyLevel.ONE) + client.add(key, ColumnParent('SuperCounter1', utf8encode('sc3')), CounterColumn(_i64(7), 7), ConsistencyLevel.ONE) - p = SlicePredicate(slice_range=SliceRange('sc2'.encode(), 'sc3'.encode(), False, 2)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc2'), utf8encode('sc3'), False, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == 'sc2'.encode() - assert result[1].counter_super_column.name == 'sc3'.encode() + assert result[0].counter_super_column.name == utf8encode('sc2') + assert result[1].counter_super_column.name == utf8encode('sc3') - p = SlicePredicate(slice_range=SliceRange('sc3'.encode(), 'sc2'.encode(), True, 2)) + p = SlicePredicate(slice_range=SliceRange(utf8encode('sc3'), utf8encode('sc2'), True, 2)) result = client.get_slice(key, ColumnParent('SuperCounter1'), p, ConsistencyLevel.ONE) assert len(result) == 2 - assert result[0].counter_super_column.name == 'sc3'.encode() - assert result[1].counter_super_column.name == 'sc2'.encode() + assert result[0].counter_super_column.name == utf8encode('sc3') + assert result[1].counter_super_column.name == utf8encode('sc2') def test_index_scan(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert('key1'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(1), 0), ConsistencyLevel.ONE) - client.insert('key2'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key2'.encode(), ColumnParent('Indexed1'), Column('b'.encode(), _i64(2), 0), ConsistencyLevel.ONE) - client.insert('key3'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(3), 0), ConsistencyLevel.ONE) - client.insert('key3'.encode(), ColumnParent('Indexed1'), Column('b'.encode(), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key2'), ColumnParent('Indexed1'), Column(utf8encode('b'), _i64(2), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(3), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key3'), ColumnParent('Indexed1'), Column(utf8encode('b'), _i64(3), 0), ConsistencyLevel.ONE) # simple query on one index expression cp = ColumnParent('Indexed1') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key1'.encode() + assert result[0].key == utf8encode('key1') assert len(result[0].columns) == 1, result[0].columns # without index - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('b'.encode(), IndexOperator.EQ, _i64(1))], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('b'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 0, result # but unindexed expression added to indexed one is ok - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('b'.encode(), IndexOperator.EQ, _i64(3)), IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(3))], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('b'), IndexOperator.EQ, _i64(3)), IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(3))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result - assert result[0].key == 'key3'.encode() + assert result[0].key == utf8encode('key3') assert len(result[0].columns) == 2, result[0].columns def test_index_scan_uuid_names(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed3') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) cp = ColumnParent('Indexed3') # timeuuid name, utf8 values u = uuid.UUID('00000000-0000-1000-0000-000000000000').bytes u2 = uuid.UUID('00000000-0000-1000-0000-000000000001').bytes - client.insert('key1'.encode(), ColumnParent('Indexed3'), Column(u, 'a'.encode(), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Indexed3'), Column(u2, 'b'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed3'), Column(u, utf8encode('a'), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed3'), Column(u2, utf8encode('b'), 0), ConsistencyLevel.ONE) # name comparator + data validator of incompatible types -- see CASSANDRA-2347 - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(u, IndexOperator.EQ, 'a'.encode()), IndexExpression(u2, IndexOperator.EQ, 'b'.encode())], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(u, IndexOperator.EQ, utf8encode('a')), IndexExpression(u2, IndexOperator.EQ, utf8encode('b'))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result cp = ColumnParent('Indexed2') # timeuuid name, long values # name must be valid (TimeUUID) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('foo'.encode(), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('foo'), IndexOperator.EQ, uuid.UUID('00000000-0000-1000-0000-000000000000').bytes)], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) # value must be valid (TimeUUID) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, ''.encode())], 100) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(uuid.UUID('00000000-0000-1000-0000-000000000000').bytes, IndexOperator.EQ, utf8encode("foo"))], 100) _expect_exception(lambda: client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE), InvalidRequestException) def test_index_scan_expiring(self): @@ -2515,10 +2515,10 @@ def test_index_scan_expiring(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed1') - client.insert('key1'.encode(), ColumnParent('Indexed1'), Column('birthdate'.encode(), _i64(1), 0, 2), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed1'), Column(utf8encode('birthdate'), _i64(1), 0, 2), ConsistencyLevel.ONE) cp = ColumnParent('Indexed1') - sp = SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('birthdate'.encode(), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('birthdate'), IndexOperator.EQ, _i64(1))], 100) # query before expiration result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result @@ -2538,28 +2538,28 @@ def test_index_scan_indexed_column_outside_slice_predicate(self): _set_keyspace('Keyspace1') self.truncate_all('Indexed4') - client.insert('key1'.encode(), ColumnParent('Indexed4'), Column('a'.encode(), _i64(1), 0), ConsistencyLevel.ONE) - client.insert('key1'.encode(), ColumnParent('Indexed4'), Column('z'.encode(), 'zzz'.encode(), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed4'), Column(utf8encode('a'), _i64(1), 0), ConsistencyLevel.ONE) + client.insert(utf8encode('key1'), ColumnParent('Indexed4'), Column(utf8encode('z'), utf8encode('zzz'), 0), ConsistencyLevel.ONE) cp = ColumnParent('Indexed4') - sp = SlicePredicate(slice_range=SliceRange('z'.encode(), 'z'.encode())) - key_range = KeyRange(''.encode(), ''.encode(), None, None, [IndexExpression('a'.encode(), IndexOperator.EQ, _i64(1))], 100) + sp = SlicePredicate(slice_range=SliceRange(utf8encode('z'), utf8encode('z'))) + key_range = KeyRange(utf8encode(''), utf8encode(''), None, None, [IndexExpression(utf8encode('a'), IndexOperator.EQ, _i64(1))], 100) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == 'z'.encode() + assert result[0].columns[0].column.name == utf8encode('z') - sp = SlicePredicate(column_names=['z'.encode()]) + sp = SlicePredicate(column_names=[utf8encode('z')]) result = client.get_range_slices(cp, sp, key_range, ConsistencyLevel.ONE) assert len(result) == 1, result assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].column.name == 'z'.encode() + assert result[0].columns[0].column.name == utf8encode('z') def test_column_not_found_quorum(self): _set_keyspace('Keyspace1') self.truncate_all('Standard1') - key = 'doesntexist'.encode() - column_path = ColumnPath(column_family="Standard1", column=''.encode()) + key = utf8encode('doesntexist') + column_path = ColumnPath(column_family="Standard1", column=utf8encode("idontexist")) try: client.get(key, column_path, ConsistencyLevel.QUORUM) assert False, ('columnpath %s existed in %s when it should not' % (column_path, key)) @@ -2570,13 +2570,13 @@ def test_get_range_slice_after_deletion(self): _set_keyspace('Keyspace2') self.truncate_all('Super3') - key = 'key1'.encode() + key = utf8encode('key1') # three supercoluns, each with "col1" subcolumn for i in range(1, 4): - client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column('col1'.encode(), 'val1'.encode(), 0), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc%d' % i)), Column(utf8encode('col1'), utf8encode('val1'), 0), ConsistencyLevel.ONE) cp = ColumnParent('Super3') - predicate = SlicePredicate(slice_range=SliceRange('sc1'.encode(), 'sc3'.encode(), False, count=1)) + predicate = SlicePredicate(slice_range=SliceRange(utf8encode('sc1'), utf8encode('sc3'), False, count=1)) k_range = KeyRange(start_key=key, end_key=key, count=1) # validate count=1 restricts to 1 supercolumn @@ -2584,13 +2584,13 @@ def test_get_range_slice_after_deletion(self): assert len(result[0].columns) == 1 # remove sc1; add back subcolumn to override tombstone - client.remove(key, ColumnPath('Super3', 'sc1'.encode()), 1, ConsistencyLevel.ONE) + client.remove(key, ColumnPath('Super3', utf8encode('sc1')), 1, ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1 - client.insert(key, ColumnParent('Super3', 'sc1'.encode()), Column('col1'.encode(), 'val1'.encode(), 2), ConsistencyLevel.ONE) + client.insert(key, ColumnParent('Super3', utf8encode('sc1')), Column(utf8encode('col1'), utf8encode('val1'), 2), ConsistencyLevel.ONE) result = client.get_range_slices(cp, predicate, k_range, ConsistencyLevel.ONE) assert len(result[0].columns) == 1, result[0].columns - assert result[0].columns[0].super_column.name == 'sc1'.encode() + assert result[0].columns[0].super_column.name == utf8encode('sc1') def test_multi_slice(self): _set_keyspace('Keyspace1') @@ -2609,12 +2609,12 @@ def test_truncate(self): # truncate Standard1 self.truncate_all('Standard1') - assert _big_slice('key1'.encode(), ColumnParent('Standard1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Standard1')) == [] # truncate Super1 self.truncate_all('Super1') - assert _big_slice('key1'.encode(), ColumnParent('Super1')) == [] - assert _big_slice('key1'.encode(), ColumnParent('Super1', 'sc1'.encode())) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1')) == [] + assert _big_slice(utf8encode('key1'), ColumnParent('Super1', utf8encode('sc1'))) == [] @since('3.0') def test_cql_range_tombstone_and_static(self): @@ -2632,9 +2632,9 @@ def test_cql_range_tombstone_and_static(self): _set_keyspace('Keyspace1') - mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(''.encode(), ''.encode(), False, 1000))))] + mutations = [Mutation(deletion=Deletion(1, predicate=SlicePredicate(slice_range=SliceRange(utf8encode(''), utf8encode(''), False, 1000))))] mutation_map = dict((table, mutations) for table in ['t']) - keyed_mutations = dict((key, mutation_map) for key in ['k'.encode()]) + keyed_mutations = dict((key, mutation_map) for key in [utf8encode('k')]) client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE) # And check everything is gone @@ -2651,8 +2651,8 @@ def test_compact_storage_get(self): _set_keyspace('Keyspace1') CL = ConsistencyLevel.ONE i = 1 - client.insert(_i32(i), ColumnParent('cs1'), Column('v'.encode(), _i32(i), 0), CL) - _assert_column('cs1', _i32(i), 'v'.encode(), _i32(i), 0) + client.insert(_i32(i), ColumnParent('cs1'), Column(utf8encode('v'), _i32(i), 0), CL) + _assert_column('cs1', _i32(i), utf8encode('v'), _i32(i), 0) @pytest.mark.skipif(CASSANDRA_VERSION_FROM_BUILD == '3.9', reason="Test doesn't run on 3.9") def test_range_tombstone_eoc_0(self): From 2ac944b000f6764c9e4c133ebaf997f664360f7c Mon Sep 17 00:00:00 2001 From: Ariel Weisberg Date: Fri, 2 Feb 2018 16:45:13 -0500 Subject: [PATCH 16/16] Cleanup a few things --- conftest.py | 5 ----- write_failures_test.py | 5 ++--- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/conftest.py b/conftest.py index 36bd623836..04a0eecdcc 100644 --- a/conftest.py +++ b/conftest.py @@ -354,25 +354,20 @@ def fixture_dtest_setup(request, parse_dtest_config, fixture_dtest_setup_overrid #Based on https://bugs.python.org/file25808/14894.patch def loose_version_compare(a, b): - print("Comparing " + str(a) + " and " + str(b) + " lists " + str(a.version) + " and " + str(b.version)) for i, j in zip_longest(a.version, b.version, fillvalue=''): if type(i) != type(j): i = str(i) j = str(j) if i == j: - print(str(i) + " == " + str(j)) continue elif i < j: - print(str(i) + " < " + str(j)) return -1 else: # i > j - print(str(i) + " > " + str(j)) return 1 #Longer version strings with equal prefixes are equal, but if one version string is longer than it is greater aLen = len(a.version) bLen = len(b.version) - print("aLen " + str(aLen) + " bLen " + str(bLen)) if aLen == bLen: return 0 elif aLen < bLen: diff --git a/write_failures_test.py b/write_failures_test.py index 69a612acd6..67bb22a0f6 100644 --- a/write_failures_test.py +++ b/write_failures_test.py @@ -1,7 +1,6 @@ import uuid import pytest import logging -import codecs from cassandra import ConsistencyLevel, WriteFailure, WriteTimeout @@ -223,9 +222,9 @@ def test_thrift(self): client.set_keyspace(KEYSPACE) with pytest.raises(self.expected_expt): - client.insert(codecs.encode('key1'), + client.insert('key1'.encode(), thrift_types.ColumnParent('mytable'), - thrift_types.Column(codecs.encode('value'), codecs.encode('Value 1'), 0), + thrift_types.Column('value'.encode(), 'Value 1'.enocde(), 0), thrift_types.ConsistencyLevel.ALL) client.transport.close()