cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aweisb...@apache.org
Subject [08/36] cassandra-dtest git commit: Migrate dtests to use pytest and python3
Date Mon, 29 Jan 2018 21:10:11 GMT
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/thrift_test.py
----------------------------------------------------------------------
diff --git a/thrift_test.py b/thrift_test.py
new file mode 100644
index 0000000..23e3f7b
--- /dev/null
+++ b/thrift_test.py
@@ -0,0 +1,2649 @@
+import re
+import struct
+import time
+import uuid
+import pytest
+import logging
+
+from thrift.protocol import TBinaryProtocol
+from thrift.Thrift import TApplicationException
+from thrift.transport import TSocket, TTransport
+
+from tools.assertions import assert_length_equal
+from tools.misc import ImmutableMapping
+
+from dtest_setup_overrides import DTestSetupOverrides
+from dtest import CASSANDRA_VERSION_FROM_BUILD, Tester
+
+from thrift_bindings.thrift010 import Cassandra
+from thrift_bindings.thrift010.Cassandra import (CfDef, Column, ColumnDef,
+                                           ColumnOrSuperColumn, ColumnParent,
+                                           ColumnPath, ColumnSlice,
+                                           ConsistencyLevel, CounterColumn,
+                                           Deletion, IndexExpression,
+                                           IndexOperator, IndexType,
+                                           InvalidRequestException, KeyRange,
+                                           KeySlice, KsDef, MultiSliceRequest,
+                                           Mutation, NotFoundException,
+                                           SlicePredicate, SliceRange,
+                                           SuperColumn)
+from tools.assertions import (assert_all, assert_none, assert_one)
+
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
+
+
+def get_thrift_client(host='127.0.0.1', port=9160):
+    socket = TSocket.TSocket(host, port)
+    transport = TTransport.TFramedTransport(socket)
+    protocol = TBinaryProtocol.TBinaryProtocol(transport)
+    client = Cassandra.Client(protocol)
+    client.transport = transport
+    return client
+
+
+client = None
+
+pid_fname = "system_test.pid"
+
+
+def pid():
+    return int(open(pid_fname).read())
+
+
+@since('2.0', max_version='4')
+class TestThrift(Tester):
+
+    @pytest.fixture(scope='function', autouse=True)
+    def fixture_dtest_setup_overrides(self):
+        dtest_setup_overrides = DTestSetupOverrides()
+        """
+        @jira_ticket CASSANDRA-7653
+        """
+        dtest_setup_overrides.cluster_options = ImmutableMapping(
+            {'partitioner': 'org.apache.cassandra.dht.ByteOrderedPartitioner',
+             'start_rpc': 'true'})
+        return dtest_setup_overrides
+
+    @pytest.fixture(scope='function', autouse=True)
+    def fixture_set_cluster_settings(self, fixture_dtest_setup):
+        fixture_dtest_setup.cluster.populate(1)
+        node1, = fixture_dtest_setup.cluster.nodelist()
+
+        # If vnodes are not used, we must set our own initial_token
+        # Because ccm will not set a hex token for ByteOrderedPartitioner
+        # 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')})
+
+        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
+        time.sleep(0.1)
+        # this is ugly, but the whole test module is written against a global client
+        global client
+        client = get_thrift_client()
+        client.transport.open()
+        self.define_schema()
+
+        yield client
+
+        client.transport.close()
+
+    def define_schema(self):
+        keyspace1 = Cassandra.KsDef('Keyspace1', 'org.apache.cassandra.locator.SimpleStrategy', {'replication_factor': '1'},
+                                    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', 'StandardLong1', comparator_type='LongType'),
+            Cassandra.CfDef('Keyspace1', 'StandardInteger1', comparator_type='IntegerType'),
+            Cassandra.CfDef('Keyspace1', 'StandardComposite', comparator_type='CompositeType(AsciiType, AsciiType)'),
+            Cassandra.CfDef('Keyspace1', 'Super1', column_type='Super', subcomparator_type='LongType'),
+            Cassandra.CfDef('Keyspace1', 'Super2', column_type='Super', subcomparator_type='LongType'),
+            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', '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', 'Expiring', default_time_to_live=2)
+        ])
+
+        keyspace2 = Cassandra.KsDef('Keyspace2', 'org.apache.cassandra.locator.SimpleStrategy', {'replication_factor': '1'},
+                                    cf_defs=[
+                                        Cassandra.CfDef('Keyspace2', 'Standard1'),
+                                        Cassandra.CfDef('Keyspace2', 'Standard3'),
+                                        Cassandra.CfDef('Keyspace2', 'Super3', column_type='Super', subcomparator_type='BytesType'),
+                                        Cassandra.CfDef('Keyspace2', 'Super4', column_type='Super', subcomparator_type='TimeUUIDType'), ])
+
+        for ks in [keyspace1, keyspace2]:
+            cls.client.system_add_keyspace(ks)
+
+
+def i64(n):
+    return _i64(n)
+
+
+def i32(n):
+    return _i32(n)
+
+
+def i16(n):
+    return _i16(n)
+
+
+def composite(item1, item2=None, eoc='\x00'):
+    packed = _i16(len(item1)) + item1 + eoc
+    if item2 is not None:
+        packed += _i16(len(item2)) + item2
+        packed += eoc
+    return packed
+
+
+def _i64(n):
+    return struct.pack('>q', n)  # big endian = network order
+
+
+def _i32(n):
+    return struct.pack('>i', n)  # big endian = network order
+
+
+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)])]
+
+
+def _assert_column(column_family, key, column, value, ts=0):
+    try:
+        assert client.get(key, ColumnPath(column_family, column=column), ConsistencyLevel.ONE).column == Column(column, value, ts)
+    except NotFoundException:
+        raise Exception('expected %s:%s:%s:%s, but was not present' % (column_family, key, column, value))
+
+
+def _assert_columnpath_exists(key, column_path):
+    try:
+        assert client.get(key, column_path, ConsistencyLevel.ONE)
+    except NotFoundException:
+        raise Exception('expected %s with %s but was not present.' % (key, column_path))
+
+
+def _assert_no_columnpath(key, column_path):
+    try:
+        client.get(key, column_path, ConsistencyLevel.ONE)
+        assert False, ('columnpath %s existed in %s when it should not' % (column_path, key))
+    except NotFoundException:
+        assert True, 'column did not exist'
+
+
+def _insert_simple():
+    return _insert_multi(['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)
+
+
+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)
+
+
+def _big_slice(key, column_parent):
+    p = SlicePredicate(slice_range=SliceRange('', '', 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))
+    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'))]
+    assert L == _SIMPLE_COLUMNS, L
+
+
+def _verify_simple():
+    assert client.get('key1', ColumnPath('Standard1', column='c1'), ConsistencyLevel.ONE).column == Column('c1', 'value1', 0)
+    L = [result.column
+         for result in _big_slice('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)
+
+
+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)
+
+
+def _verify_range():
+    p = SlicePredicate(slice_range=SliceRange('c1', 'c2', False, 1000))
+    result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE)
+    assert len(result) == 2
+    assert result[0].column.name == 'c1'
+    assert result[1].column.name == 'c2'
+
+    p = SlicePredicate(slice_range=SliceRange('c3', 'c2', True, 1000))
+    result = client.get_slice('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE)
+    assert len(result) == 2
+    assert result[0].column.name == 'c3'
+    assert result[1].column.name == 'c2'
+
+    p = SlicePredicate(slice_range=SliceRange('a', 'z', False, 1000))
+    result = client.get_slice('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)
+    assert len(result) == 2, result
+
+
+def _set_keyspace(keyspace):
+    client.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)
+    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)
+    assert len(result) == 2
+    assert result[0].super_column.name == 'sc2'
+    assert result[1].super_column.name == 'sc3'
+
+    p = SlicePredicate(slice_range=SliceRange('sc3', 'sc2', True, 2))
+    result = client.get_slice('key1', ColumnParent('Super1'), p, ConsistencyLevel.ONE)
+    assert len(result) == 2
+    assert result[0].super_column.name == 'sc3'
+    assert result[1].super_column.name == '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)
+    slice = [result.super_column
+             for result in _big_slice(key, ColumnParent('Super1'))]
+    assert slice == _SUPER_COLUMNS, slice
+
+
+def _expect_exception(fn, type_):
+    try:
+        r = fn()
+    except type_ as t:
+        return t
+    else:
+        raise Exception('expected %s; got %s' % (type_.__name__, r))
+
+
+def _expect_missing(fn):
+    _expect_exception(fn, NotFoundException)
+
+
+def get_range_slice(client, parent, predicate, start, end, count, cl, row_filter=None):
+    kr = KeyRange(start, end, count=count, row_filter=row_filter)
+    return client.get_range_slices(parent, predicate, kr, cl)
+
+
+def _insert_six_columns(key='abc'):
+    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)
+
+
+def _big_multi_slice(key='abc'):
+    c1 = ColumnSlice()
+    c1.start = 'a'
+    c1.finish = 'c'
+    c2 = ColumnSlice()
+    c2.start = 'e'
+    c2.finish = 'f'
+    m = MultiSliceRequest()
+    m.key = key
+    m.column_parent = ColumnParent('Standard1')
+    m.column_slices = [c1, c2]
+    m.reversed = False
+    m.count = 10
+    m.consistency_level = ConsistencyLevel.ONE
+    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)]
+
+
+@since('2.0', max_version='4')
+class TestMutations(TestThrift):
+
+    def truncate_all(self, *table_names):
+        for table in table_names:
+            client.truncate(table)
+
+    def test_insert(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+        _insert_simple()
+        _verify_simple()
+
+    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')) == []
+
+    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)
+
+        def test_cas_operations(first_columns, second_columns, column_family):
+            # partition should be empty, so cas expecting any existing values should fail
+            cas_result = cas(first_columns, first_columns, column_family)
+            assert not cas_result.success
+            assert len(cas_result.current_values) == 0, cas_result
+
+            # 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))]
+            # 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)
+
+            # now that the partition has been updated, repeating the
+            # operation which expects it to be empty should not succeed
+            cas_result = cas([], first_columns, column_family)
+            assert not cas_result.success
+            # When we CAS for non-existence, current_values is the first live column of the row
+            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
+
+            # cas first_columns -> second_columns should succeed
+            assert cas(first_columns, second_columns, column_family).success
+
+            # as before, an operation with an incorrect expectation should fail
+            cas_result = cas(first_columns, second_columns, column_family)
+            assert not cas_result.success
+
+        updated_columns = [Column('c1', 'value101', 1),
+                           Column('c2', 'value102', 1)]
+
+        logger.debug("Testing CAS operations on dynamic cf")
+        test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard1')
+        logger.debug("Testing CAS operations on static cf")
+        test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard3')
+        logger.debug("Testing CAS on mixed static/dynamic cf")
+        test_cas_operations(_SIMPLE_COLUMNS, updated_columns, 'Standard4')
+
+    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))
+        _insert_super()
+        _expect_missing(lambda: client.get('key1', ColumnPath('Super1', 'sc1', _i64(1)), ConsistencyLevel.ONE))
+
+    def test_count(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Standard2', 'Super1')
+
+        _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
+
+        # 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)
+
+        p = SlicePredicate(slice_range=SliceRange('c2', 'c4', False, 1000))
+        assert client.get_count('key1', ColumnParent('Standard1'), p, ConsistencyLevel.ONE) == 3
+
+    def test_count_paging(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+
+        _insert_simple()
+
+        # 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)]
+        cfmap = {'Standard1': [Mutation(ColumnOrSuperColumn(c)) for c in columns_to_insert]}
+        client.batch_mutate({'key1': cfmap}, ConsistencyLevel.ONE)
+
+        p = SlicePredicate(slice_range=SliceRange('', '', False, 2000))
+        assert client.get_count('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
+
+    # test get_count() to work correctly with 'count' settings around page size (CASSANDRA-4833)
+    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))
+
+        key = 'key1'
+        parent = ColumnParent('Standard1')
+        cl = ConsistencyLevel.ONE
+
+        for i in range(0, 3050):
+            client.insert(key, parent, Column(str(i), '', 0), cl)
+
+        # same as page size
+        assert client.get_count(key, parent, slice_predicate(1024), cl) == 1024
+
+        # 1 above page size
+        assert client.get_count(key, parent, slice_predicate(1025), cl) == 1025
+
+        # above number or columns
+        assert client.get_count(key, parent, slice_predicate(4000), cl) == 3050
+
+        # same as number of columns
+        assert client.get_count(key, parent, slice_predicate(3050), cl) == 3050
+
+        # 1 above number of columns
+        assert client.get_count(key, parent, slice_predicate(3051), cl) == 3050
+
+    def test_super_insert(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1')
+
+        _insert_super()
+        _verify_super()
+
+    def test_super_get(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1')
+
+        _insert_super()
+        result = client.get('key1', ColumnPath('Super1', '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')
+        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))
+        slice = [result.column
+                 for result in client.get_slice('key1', column_parent, p, ConsistencyLevel.ONE)]
+        assert slice == [Column(_i64(6), 'value6', 0)], slice
+
+    def test_long_order(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('StandardLong1')
+
+        def long_xrange(start, stop, step):
+            i = start
+            while i < stop:
+                yield i
+                i += step
+        L = []
+        for i in long_xrange(0, 104294967296, 429496729):
+            name = _i64(i)
+            client.insert('key1', ColumnParent('StandardLong1'), Column(name, 'v', 0), ConsistencyLevel.ONE)
+            L.append(name)
+        slice = [result.column.name for result in _big_slice('key1', ColumnParent('StandardLong1'))]
+        assert slice == L, slice
+
+    def test_integer_order(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('StandardInteger1')
+
+        def long_xrange(start, stop, step):
+            i = start
+            while i >= stop:
+                yield i
+                i -= step
+        L = []
+        for i in long_xrange(104294967296, 0, 429496729):
+            name = _i64(i)
+            client.insert('key1', ColumnParent('StandardInteger1'), Column(name, 'v', 0), ConsistencyLevel.ONE)
+            L.append(name)
+        slice = [result.column.name for result in _big_slice('key1', ColumnParent('StandardInteger1'))]
+        L.sort()
+        assert slice == L, slice
+
+    def test_time_uuid(self):
+        _set_keyspace('Keyspace2')
+        self.truncate_all('Super4')
+
+        import uuid
+        L = []
+
+        # 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'))
+        assert len(slice) == 500, len(slice)
+        for i in range(500):
+            u = slice[i].column
+            assert u.value == 'value%s' % i
+            assert u.name == L[i].bytes
+
+        p = SlicePredicate(slice_range=SliceRange('', '', True, 1))
+        column_parent = ColumnParent('Super4', '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
+
+        p = SlicePredicate(slice_range=SliceRange('', L[2].bytes, False, 1000))
+        column_parent = ColumnParent('Super4', '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
+
+        p = SlicePredicate(slice_range=SliceRange(L[2].bytes, '', True, 1000))
+        column_parent = ColumnParent('Super4', '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
+
+        p = SlicePredicate(slice_range=SliceRange(L[2].bytes, '', False, 1))
+        column_parent = ColumnParent('Super4', '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
+
+    def test_long_remove(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('StandardLong1')
+
+        column_parent = ColumnParent('StandardLong1')
+        sp = SlicePredicate(slice_range=SliceRange('', '', 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)
+            assert slice == [], slice
+            # resurrect
+            client.insert('key1', parent, Column(_i64(i), '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)
+
+    def test_integer_remove(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('StandardInteger1')
+
+        column_parent = ColumnParent('StandardInteger1')
+        sp = SlicePredicate(slice_range=SliceRange('', '', 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)
+            assert slice == [], slice
+            # resurrect
+            client.insert('key1', parent, Column(_i64(i), '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)
+
+    def test_batch_insert(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Standard2')
+        _insert_batch()
+        _verify_batch()
+
+    def test_batch_mutate_standard_columns(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Standard2')
+
+        column_families = ['Standard1', 'Standard2']
+        keys = ['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)
+
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+
+        for column_family in column_families:
+            for key in keys:
+                _assert_column(column_family, key, 'c1', '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)]
+        _insert_multi(keys)
+
+        mutations = [Mutation(deletion=Deletion(20, predicate=SlicePredicate(column_names=[c.name]))) 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)
+
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+
+        for column_family in column_families:
+            for c in _SIMPLE_COLUMNS:
+                for key in keys:
+                    _assert_no_columnpath(key, ColumnPath(column_family, column=c.name))
+
+    def test_batch_mutate_remove_standard_row(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Standard2')
+
+        column_families = ['Standard1', 'Standard2']
+        keys = ['key_%d' % i for i in range(11, 21)]
+        _insert_multi(keys)
+
+        mutations = [Mutation(deletion=Deletion(20))]
+        mutation_map = dict((column_family, mutations) for column_family in column_families)
+
+        keyed_mutations = dict((key, mutation_map) for key in keys)
+
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+
+        for column_family in column_families:
+            for c in _SIMPLE_COLUMNS:
+                for key in keys:
+                    _assert_no_columnpath(key, ColumnPath(column_family, column=c.name))
+
+    def test_batch_mutate_remove_super_columns_with_standard_under(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1', 'Super2')
+
+        column_families = ['Super1', 'Super2']
+        keys = ['key_%d' % i for i in range(11, 21)]
+        _insert_super()
+
+        mutations = []
+        for sc in _SUPER_COLUMNS:
+            names = []
+            for c in sc.columns:
+                names.append(c.name)
+            mutations.append(Mutation(deletion=Deletion(20, super_column=c.name, predicate=SlicePredicate(column_names=names))))
+
+        mutation_map = dict((column_family, mutations) for column_family in column_families)
+
+        keyed_mutations = dict((key, mutation_map) for key in keys)
+
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+        for column_family in column_families:
+            for sc in _SUPER_COLUMNS:
+                for c in sc.columns:
+                    for key in keys:
+                        _assert_no_columnpath(key, ColumnPath(column_family, super_column=sc.name, column=c.name))
+
+    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)]
+
+        for key in keys:
+            _insert_super(key)
+
+        mutations = []
+
+        for sc in _SUPER_COLUMNS:
+            mutations.append(Mutation(deletion=Deletion(20,
+                                                        super_column=sc.name)))
+
+        mutation_map = {'Super1': mutations}
+
+        keyed_mutations = dict((key, mutation_map) for key in keys)
+
+        # Sanity check
+        for sc in _SUPER_COLUMNS:
+            for key in keys:
+                _assert_columnpath_exists(key, ColumnPath('Super1', super_column=sc.name))
+
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+
+        for sc in _SUPER_COLUMNS:
+            for c in sc.columns:
+                for key in keys:
+                    _assert_no_columnpath(key, ColumnPath('Super1', super_column=sc.name))
+
+    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)]
+
+        for key in keys:
+            _insert_super(key)
+
+        mutations = []
+
+        mutations.append(Mutation(deletion=Deletion(20)))
+
+        mutation_map = {'Super1': mutations}
+
+        keyed_mutations = dict((key, mutation_map) for key in keys)
+
+        # Sanity check
+        for sc in _SUPER_COLUMNS:
+            for key in keys:
+                _assert_columnpath_exists(key, ColumnPath('Super1', super_column=sc.name))
+
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+
+        for sc in _SUPER_COLUMNS:
+            for key in keys:
+                _assert_no_columnpath(key, ColumnPath('Super1', super_column=sc.name))
+
+    # known failure: see CASSANDRA-10046
+    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)]
+
+        for column in columns:
+            client.insert('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)
+
+        _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'))
+
+    # 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)])]
+
+        for column in columns:
+            for subcolumn in column.columns:
+                client.insert('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)
+
+        _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)))
+
+    @since('1.0', '2.2')
+    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)]
+
+        for column in columns:
+            client.insert('key', ColumnParent('Super1', '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)
+
+        _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)))
+
+    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",
+                          'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])}
+        second_deletion = {'super_column': "sc2",
+                           'predicate': SlicePredicate(column_names=[_i64(22), _i64(23)])}
+
+        keys = ['key_30', 'key_31']
+        for key in keys:
+            sc = SuperColumn('sc1', [Column(_i64(22), 'value22', 0),
+                                     Column(_i64(23), '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)])
+            cfmap2 = {'Super2': [Mutation(ColumnOrSuperColumn(super_column=sc2))]}
+            client.batch_mutate({key: cfmap2}, ConsistencyLevel.ONE)
+
+        cfmap3 = {
+            'Super1': [Mutation(ColumnOrSuperColumn(super_column=first_insert)),
+                       Mutation(deletion=Deletion(3, **first_deletion))],
+
+            'Super2': [Mutation(deletion=Deletion(2, **second_deletion)),
+                       Mutation(ColumnOrSuperColumn(super_column=second_insert))]
+        }
+
+        keyed_mutations = dict((key, cfmap3) for key in keys)
+        client.batch_mutate(keyed_mutations, ConsistencyLevel.ONE)
+
+        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))
+
+            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))
+
+    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')
+            cf = CfDef('Keyspace1', 'BadCF', column_metadata=[cd1, cd2])
+            client.system_add_column_family(cf)
+        _expect_exception(duplicate_index_names, InvalidRequestException)
+
+    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)]}},
+                                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)]}},
+                                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)]}},
+                                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)]}},
+                                ConsistencyLevel.ONE)
+        _expect_exception(send_string_instead_of_long, InvalidRequestException)
+
+    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)
+
+    def test_bad_calls(self):
+        _set_keyspace('Keyspace1')
+
+        # 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)
+        # no supercolumn in a super CF
+        _expect_exception(lambda: client.insert('key1', ColumnParent('Super1'), Column('y', '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)
+        # super column in non-super CF
+        _expect_exception(lambda: client.remove('key1', ColumnPath('Standard1', 'y', 'x'), 0, ConsistencyLevel.ONE), InvalidRequestException)
+        # key too long
+        _expect_exception(lambda: client.get('x' * 2 ** 16, ColumnPath('Standard1', column='c1'), ConsistencyLevel.ONE), InvalidRequestException)
+        # empty key
+        _expect_exception(lambda: client.get('', ColumnPath('Standard1', column='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)
+        # empty column name
+        _expect_exception(lambda: client.get('key1', ColumnPath('Standard1', column=''), ConsistencyLevel.ONE), InvalidRequestException)
+        # get doesn't specify column name
+        _expect_exception(lambda: client.get('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)
+        # get doesn't specify supercolumn name
+        _expect_exception(lambda: client.get('key1', ColumnPath('Super1'), ConsistencyLevel.ONE), InvalidRequestException)
+        # invalid CF
+        _expect_exception(lambda: get_range_slice(client, ColumnParent('S'), SlicePredicate(column_names=['', '']), '', '', 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)
+        # start is not a valid Long
+        p = SlicePredicate(slice_range=SliceRange('x', '', False, 1))
+        column_parent = ColumnParent('StandardLong1')
+        _expect_exception(lambda: client.get_slice('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),
+                          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),
+                          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),
+                          InvalidRequestException)
+        # start > finish, key version
+        _expect_exception(lambda: get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['']), 'z', '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),
+                          InvalidRequestException)
+        # don't allow super_column in Deletion for standard Columntest_expiration_with_default_ttl_and_zero_ttl
+        deletion = Deletion(1, 'supercolumn', None)
+        mutation = Mutation(deletion=deletion)
+        mutations = {'key': {'Standard1': [mutation]}}
+        _expect_exception(lambda: client.batch_mutate(mutations, ConsistencyLevel.QUORUM),
+                          InvalidRequestException)
+        # 'x' is not a valid long
+        deletion = Deletion(1, 'x', None)
+        mutation = Mutation(deletion=deletion)
+        mutations = {'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)
+
+    def test_batch_insert_super(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1', 'Super2')
+
+        cfmap = {'Super1': [Mutation(ColumnOrSuperColumn(super_column=c))
+                            for c in _SUPER_COLUMNS],
+                 'Super2': [Mutation(ColumnOrSuperColumn(super_column=c))
+                            for c in _SUPER_COLUMNS]}
+        client.batch_mutate({'key1': cfmap}, ConsistencyLevel.ONE)
+        _verify_super('Super1')
+        _verify_super('Super2')
+
+    def test_cf_remove_column(self):
+        _set_keyspace('Keyspace1')
+        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))]
+
+        # New insert, make sure it shows up post-remove:
+        client.insert('key1', ColumnParent('Standard1'), Column('c3', '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
+
+        # 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)
+        columns = [result.column
+                   for result in _big_slice('key1', ColumnParent('Standard1'))]
+        assert columns == [Column('c2', 'value2', 0), Column('c3', 'value3', 0)], columns
+        # Next, w/ a newer timestamp; it should come back:
+        client.insert('key1', ColumnParent('Standard1'), Column('c1', '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
+
+    def test_cf_remove(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Super1')
+
+        _insert_simple()
+        _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')) == []
+        _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')) == []
+        # 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
+
+        # 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')) == []
+
+    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)
+
+        rows = {}
+        for row in get_range_slice(client, ColumnParent('Super1'), SlicePredicate(slice_range=SliceRange('', '', False, 1000)), '', '', 1000, ConsistencyLevel.ONE):
+            scs = [cosc.super_column for cosc in row.columns]
+            rows[row.key] = scs
+        assert rows == {'key3': []}, rows
+
+    def test_super_cf_remove_column(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Super1')
+
+        _insert_simple()
+        _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)])]
+        _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)])]
+
+        super_columns = [result.super_column for result in _big_slice('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)
+
+        super_columns = [result.super_column for result in _big_slice('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)])]
+        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)
+        assert e.why.find("column cannot be specified without") >= 0
+
+    def test_super_cf_remove_supercolumn(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1', 'Super1')
+
+        _insert_simple()
+        _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'))
+        assert super_columns == [], super_columns
+        super_columns_expected = [SuperColumn(name='sc1', columns=[Column(_i64(4), 'value4', 0)])]
+        super_columns = [result.super_column
+                         for result in _big_slice('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)
+        super_columns = [result.super_column
+                         for result in _big_slice('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)])]
+        assert super_columns == super_columns_expected, super_columns
+
+        # check slicing at the subcolumn level too
+        p = SlicePredicate(slice_range=SliceRange('', '', 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
+
+    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)
+
+        client.remove(key, ColumnPath('Super1', 'sc1'), 1, ConsistencyLevel.ONE)
+
+        client.insert(key, ColumnParent('Super1', 'sc1'), Column(_i64(4), 'value4', 2), ConsistencyLevel.ONE)
+
+        result = client.get(key, ColumnPath('Super1', '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) == []
+        _insert_simple()
+        assert get_range_slice(client, ColumnParent('Super1'), SlicePredicate(column_names=['c1', 'c1']), '', '', 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")
+
+        node1 = self.cluster.nodelist()[0]
+        session = self.patient_cql_connection(node1)
+
+        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"]])
+
+        assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1')",
+                   [["key1", "sc1", 4, "value4"],
+                    ["key1", "sc2", 5, "value5"],
+                    ["key1", "sc2", 6, "value6"]])
+
+        assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2')",
+                   [["key1", "sc2", 5, "value5"],
+                    ["key1", "sc2", 6, "value6"]])
+
+        assert_all(session, "SELECT * FROM \"Super1\" WHERE key=textAsBlob('key1') AND column1=textAsBlob('sc2') AND column2 = 5",
+                   [["key1", "sc2", 5, "value5"]])
+
+        assert_all(session, "SELECT * FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')",
+                   [["key1", "sc2", 5, "value5"],
+                    ["key1", "sc2", 6, "value6"]])
+
+        assert_all(session, "SELECT column2, value FROM \"Super1\" WHERE key = textAsBlob('key1') AND column1 = textAsBlob('sc2')",
+                   [[5, "value5"],
+                    [6, "value6"]])
+
+    @since('2.1')
+    def test_super_cql_write_compatibility(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1')
+
+        node1 = self.cluster.nodelist()[0]
+        session = self.patient_cql_connection(node1)
+
+        session.execute('USE "Keyspace1"')
+
+        query = "INSERT INTO \"Super1\" (key, column1, column2, value) VALUES (textAsBlob(%s), textAsBlob(%s), %s, textAsBlob(%s)) USING TIMESTAMP 1234"
+        session.execute(query, ("key1", "sc1", 4, "value4"))
+        session.execute(query, ("key1", "sc2", 5, "value5"))
+        session.execute(query, ("key1", "sc2", 6, "value6"))
+        session.execute(query, ("key2", "sc1", 4, "value4"))
+        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)
+        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)]
+
+    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'
+
+        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
+
+    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'
+
+        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
+
+    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)
+
+        slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), '', '', 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):
+            assert key == ks.key
+
+    def test_range_partial(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)
+
+        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):
+                assert key == ks.key
+
+        slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), 'a', '', 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)
+        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)
+        check_slices_against_keys(['50', '51'], slices)
+
+        slices = get_range_slice(client, ColumnParent('Standard1'), SlicePredicate(column_names=['-a', '-a']), '1', '', 10, ConsistencyLevel.ONE)
+        check_slices_against_keys(['1', '10', '11', '12', '13', '14', '15', '16', '17', '18'], slices)
+
+    def test_get_slice_range(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+
+        _insert_range()
+        _verify_range()
+
+    def test_get_slice_super_range(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1')
+
+        _insert_super_range()
+        _verify_super_range()
+
+    def test_get_range_slices_tokens(self):
+        _set_keyspace('Keyspace2')
+        self.truncate_all('Super3')
+
+        for key in ['key1', 'key2', 'key3', 'key4', 'key5']:
+            for cname in ['col1', 'col2', 'col3', 'col4', 'col5']:
+                client.insert(key, ColumnParent('Super3', 'sc1'), Column(cname, 'v-' + cname, 0), ConsistencyLevel.ONE)
+
+        cp = ColumnParent('Super3', 'sc1')
+        predicate = SlicePredicate(column_names=['col1', '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'
+
+    def test_get_range_slice_super(self):
+        _set_keyspace('Keyspace2')
+        self.truncate_all('Super3')
+
+        for key in ['key1', 'key2', 'key3', 'key4', 'key5']:
+            for cname in ['col1', 'col2', 'col3', 'col4', 'col5']:
+                client.insert(key, ColumnParent('Super3', 'sc1'), Column(cname, '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)
+        assert len(result) == 3
+        assert result[0].columns[0].column.name == 'col1'
+        assert result[0].columns[1].column.name == 'col3'
+
+        cp = ColumnParent('Super3')
+        result = get_range_slice(client, cp, SlicePredicate(column_names=['sc1']), 'key2', 'key4', 5, ConsistencyLevel.ONE)
+        assert len(result) == 3
+        assert list(set(row.columns[0].super_column.name for row in result))[0] == 'sc1'
+
+    def test_get_range_slice(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+
+        for key in ['key1', 'key2', 'key3', 'key4', 'key5']:
+            for cname in ['col1', 'col2', 'col3', 'col4', 'col5']:
+                client.insert(key, ColumnParent('Standard1'), Column(cname, '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)
+        assert len(result) == 0
+
+        # test empty columns
+        result = get_range_slice(client, cp, SlicePredicate(column_names=['a']), 'key2', '', 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)
+        assert len(result) == 3, result
+        assert result[0].columns[0].column.name == 'col1'
+        assert result[0].columns[1].column.name == 'col3'
+
+        # row limiting via count.
+        result = get_range_slice(client, cp, SlicePredicate(column_names=['col1', 'col3']), 'key2', '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)
+        assert len(result) == 2
+        assert result[0].key == 'key1'
+        assert result[1].key == 'key2'
+        assert len(result[0].columns) == 3
+        assert result[0].columns[0].column.name == 'col2'
+        assert result[0].columns[2].column.name == '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)
+        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'
+
+        # 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)
+        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)
+        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'
+
+    def test_wrapped_range_slices(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+
+        def copp_token(key):
+            # I cheated and generated this from Java
+            return {'a': '00530000000100000001',
+                    'b': '00540000000100000001',
+                    'c': '00550000000100000001',
+                    'd': '00560000000100000001',
+                    'e': '00580000000100000001'}[key]
+
+        for key in ['a', 'b', 'c', 'd', 'e']:
+            for cname in ['col1', 'col2', 'col3', 'col4', 'col5']:
+                client.insert(key, ColumnParent('Standard1'), Column(cname, '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=['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]
+
+    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)
+        assert len(result) == 2
+        assert result[0].column.name == 'c1'
+        assert result[1].column.name == 'c2'
+
+        _insert_super()
+        p = SlicePredicate(column_names=[_i64(4)])
+        result = client.get_slice('key1', ColumnParent('Super1', 'sc1'), p, ConsistencyLevel.ONE)
+        assert len(result) == 1
+        assert result[0].column.name == _i64(4)
+
+    def test_multiget_slice_with_compact_table(self):
+        """Insert multiple keys in a compact table and retrieve them using the multiget_slice interface"""
+        _set_keyspace('Keyspace1')
+
+        # create
+        cd = ColumnDef('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)
+        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)
+
+        for i in range(0, 5):
+            key = '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)
+
+    def test_multiget_slice(self):
+        """Insert multiple keys and retrieve them using the multiget_slice interface"""
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+
+        # Generate a list of 10 keys and insert them
+        num_keys = 10
+        keys = ['key' + str(i) for i in range(1, num_keys + 1)]
+        _insert_multi(keys)
+
+        # Retrieve all 10 key slices
+        rows = _big_multislice(keys, ColumnParent('Standard1'))
+
+        columns = [ColumnOrSuperColumn(c) for c in _SIMPLE_COLUMNS]
+        # Validate if the returned rows have the keys requested and if the ColumnOrSuperColumn is what was inserted
+        for key in keys:
+            assert key in rows
+            assert columns == rows[key]
+
+    def test_multi_count(self):
+        """Insert multiple keys and count them using the multiget interface"""
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Standard1')
+
+        # 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)
+            for j in range(1, i + 1):
+                client.insert(key, ColumnParent('Standard1'), Column('c' + str(j), '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))
+        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)
+            assert counts[key] == i
+
+    def test_batch_mutate_super_deletion(self):
+        _set_keyspace('Keyspace1')
+        self.truncate_all('Super1')
+
+        _insert_super('test')
+        d = Deletion(1, predicate=SlicePredicate(column_names=['sc1']))
+        cfmap = {'Super1': [Mutation(deletion=d)]}
+        client.batch_mutate({'test': cfmap}, ConsistencyLevel.ONE)
+        _expect_missing(lambda: client.get('key1', ColumnPath('Super1', '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.remove('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)
+
+        for n in range(1, 4):
+            p = SlicePredicate(slice_range=SliceRange('', '', False, n))
+            slice = client.get_slice('key1', ColumnParent('Super1', 'sc2'), p, ConsistencyLevel.ONE)
+            assert len(slice) == n, "expected %s results; found %s" % (n, slice)
+
+    def test_describe_keyspace(self):
+        try:
+            client.system_drop_keyspace("ValidKsForUpdate")
+        except InvalidRequestException:
+            pass  # The keyspace doesn't exit, because this test was run in isolation.
+
+        kspaces = client.describe_keyspaces()
+        if self.cluster.version() >= '3.0':
+            assert len(kspaces) == 7, [x.name for x in kspaces]  # ['Keyspace2', 'Keyspace1', 'system', 'system_traces', 'system_auth', 'system_distributed', 'system_schema']
+        elif self.cluster.version() >= '2.2':
+            assert len(kspaces) == 6, [x.name for x in kspaces]  # ['Keyspace2', 'Keyspace1', 'system', 'system_traces', 'system_auth', 'system_distributed']
+        else:
+            assert len(kspaces) == 4, [x.name for x in kspaces]  # ['Keyspace2', 'Keyspace1', 'system', 'system_traces']
+
+        sysks = client.describe_keyspace("system")
+        assert sysks in kspaces
+
+        ks1 = client.describe_keyspace("Keyspace1")
+        assert ks1.strategy_options['replication_factor'] == '1', ks1.strategy_options
+        for cf in ks1.cf_defs:
+            if cf.name == "Standard1":
+                cf0 = cf
+                break
+        assert cf0.comparator_type == "org.apache.cassandra.db.marshal.BytesType"
+
+    def test_describe(self):
+        assert client.describe_cluster_name() == 'test'
+
+    def test_describe_ring(self):
+        assert list(client.describe_ring('Keyspace1'))[0].endpoints == ['127.0.0.1']
+
+    def test_describe_token_map(self):
+        # test/conf/cassandra.yaml specifies org.apache.cassandra.dht.ByteOrderedPartitioner
+        # which uses BytesToken, so this just tests that the string representation of the token
+        # matches a regex pattern for BytesToken.toString().
+        ring = list(client.describe_token_map().items())
+        if not self.dtest_config.use_vnodes:
+            assert len(ring) == 1
+        else:
+            assert len(ring) == int(self.dtest_config.num_tokens)
+        token, node = ring[0]
+        if self.dtest_config.use_vnodes:
+            assert re.match("[0-9A-Fa-f]{32}", token)
+        assert node == '127.0.0.1'
+
+    def test_describe_partitioner(self):
+        # Make sure this just reads back the values from the config.
+        assert client.describe_partitioner() == "org.apache.cassandra.dht.ByteOrderedPartitioner"
+
+    def test_describe_snitch(self):
+        assert client.describe_snitch() == "org.apache.cassandra.locator.SimpleSnitch"
+
+    def test_invalid_ks_names(self):
+        def invalid_keyspace():
+            client.system_add_keyspace(KsDef('in-valid', 'org.apache.cassandra.locator.SimpleStrategy', {'replication_factor': '1'}, cf_defs=[]))
+        _expect_exception(invalid_keyspace, InvalidRequestException)
+
+    def test_invalid_strategy_class(self):
+        def add_invalid_keyspace():
+            client.system_add_keyspace(KsDef('ValidKs', 'InvalidStrategyClass', {}, cf_defs=[]))
+        exc = _expect_exception(add_invalid_keyspace, InvalidRequestException)
+        s = str(exc)
+        assert s.find("InvalidStrategyClass") > -1, s
+        assert s.find("Unable to find replication strategy") > -1, s
+
+        def update_invalid_keyspace():
+            client.system_add_keyspace(KsDef('ValidKsForUpdate', 'org.apache.cassandra.locator.SimpleStrategy', {'replication_factor': '1'}, cf_defs=[]))
+            client.system_update_keyspace(KsDef('ValidKsForUpdate', 'InvalidStrategyClass', {}, cf_defs=[]))
+
+        exc = _expect_exception(update_invalid_keyspace, InvalidRequestException)
+        s = str(exc)
+        assert s.find("InvalidStrategyClass") > -1, s
+        assert s.find("Unable to find replication strategy") > -1, s
+
+    def test_invalid_cf_names(self):
+        def invalid_cf():
+            _set_keyspace('Keyspace1')
+            newcf = CfDef('Keyspace1', 'in-valid')
+            client.system_add_column_family(newcf)
+        _expect_exception(invalid_cf, InvalidRequestException)
+
+        def invalid_cf_inside_new_ks():
+            cf = CfDef('ValidKsName_invalid_cf', 'in-valid')
+            _set_keyspace('system')
+            client.system_add_keyspace(KsDef('ValidKsName_invalid_cf', 'org.apache.cassandra.locator.SimpleStrategy', {'replication_factor': '1'}, cf_defs=[cf]))
+        _expect_exception(invalid_cf_inside_new_ks, InvalidRequestException)
+
+    def test_system_cf_recreate(self):
+        "ensures that keyspaces and column familes can be dropped and recreated in short order"
+        for x in range(2):
+
+            keyspace = 'test_cf_recreate'
+            cf_name = 'recreate_cf'
+
+            # create
+            newcf = CfDef(keyspace, cf_name)
+            newks = KsDef(keyspace, 'org.apache.cassandra.locator.SimpleStrategy', {'replication_factor': '1'}, cf_defs=[newcf])
+            client.system_add_keyspace(newks)
+            _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'
+
+            # drop
+            client.system_drop_column_family(cf_name)
+
+            # recreate
+            client.system_add_column_family(newcf)
+
+            # query
+            cosc_list = client.get_slice('key0', ColumnParent(cf_name), SlicePredicate(slice_range=SliceRange('', '', False, 100)), ConsistencyLevel.ONE)
+            # this was failing prior to CASSANDRA-1477.
+            assert len(cosc_list) == 0, 'cosc length test failed'
+
+            client.system_drop_keyspace(keyspace)
+
+    def test_system_keyspace_operations(self):
+        # create.  note large RF, this is OK
+        keyspace = KsDef('CreateKeyspace',
+                         'org.apache.cassandra.locator.SimpleStrategy',
+                         {'replication_factor': '10'},
+                         cf_defs=[CfDef('CreateKeyspace', 'CreateKsCf')])
+        client.system_add_keyspace(keyspace)
+        newks = client.describe_keyspace('CreateKeyspace')
+        assert 'CreateKsCf' in [x.name for x in newks.cf_defs]
+
+        _set_keyspace('CreateKeyspace')
+
+        # modify valid
+        modified_keyspace = KsDef('CreateKeyspace',
+                                  'org.apache.cassandra.locator.OldNetworkTopologyStrategy',
+                                  {'replication_factor': '1'},
+                                  cf_defs=[])
+        client.system_update_keyspace(modified_keyspace)
+        modks = client.describe_keyspace('CreateKeyspace')
+        assert modks.strategy_class == modified_keyspace.strategy_class
+        assert modks.strategy_options == modified_keyspace.strategy_options
+
+        # check strategy options are validated on modify
+        def modify_invalid_ks():
+            client.system_update_keyspace(KsDef('CreateKeyspace',
+                                                'org.apache.cassandra.locator.SimpleStrategy',
+                                                {},
+                                                cf_defs=[]))
+        _expect_exception(modify_invalid_ks, InvalidRequestException)
+
+        # drop
+        client.system_drop_keyspace('CreateKeyspace')
+
+        def get_second_ks():
+            client.describe_keyspace('CreateKeyspace')
+        _expect_exception(get_second_ks, NotFoundException)
+
+        # check strategy options are validated on creation
+        def create_invalid_ks():
+            client.system_add_keyspace(KsDef('InvalidKeyspace',
+                                             'org.apache.cassandra.locator.SimpleStrategy',
+                                             {},
+                                             cf_defs=[]))
+        _expect_exception(create_invalid_ks, InvalidRequestException)
+
+    def test_create_then_drop_ks(self):
+        keyspace = KsDef('AddThenDrop',
+                         strategy_class='org.apache.cassandra.locator.SimpleStrategy',
+                         strategy_options={'replication_factor': '1'},
+                         cf_defs=[])
+
+        def test_existence():
+            client.describe_keyspace(keyspace.name)
+        _expect_exception(test_existence, NotFoundException)
+        client.set_keyspace('system')
+        client.system_add_keyspace(keyspace)
+        test_existence()
+        client.system_drop_keyspace(keyspace.name)
+
+    def test_column_validators(self):
+        # columndef validation for regular CF
+        ks = 'Keyspace1'
+        _set_keyspace(ks)
+        cd = ColumnDef('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)
+        assert e.why.find("failed validation") >= 0
+
+        # columndef validation for super CF
+        scf = CfDef('Keyspace1', 'ValidatorSuperColumnFamily', column_type='Super', column_metadata=[cd])
+        client.system_add_column_family(scf)
+        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)
+        assert e.why.find("failed validation") >= 0
+
+        # columndef and cfdef default validation
+        cf = CfDef('Keyspace1', 'DefaultValidatorColumnFamily', column_metadata=[cd], default_validation_class='UTF8Type')
+        client.system_add_column_family(cf)
+        ks_def = client.describe_keyspace(ks)
+        assert 'DefaultValidatorColumnFamily' in [x.name for x in ks_def.cf_defs]
+
+        dcp = ColumnParent('DefaultValidatorColumnFamily')
+        # inserting a longtype into column 'col' is valid at the columndef level
+        client.insert('key0', dcp, col0, ConsistencyLevel.ONE)
+        # inserting a UTF8type into column

<TRUNCATED>

---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org


Mime
View raw message