Reloate cqlengine tests to integration tests, update imports

Not integrated with existing integration ccm operation.
There is a handful of failing cqlengine tests in the commit, that worked
before the move.

cassandra/cqlengine/tests/__init__.py

@@ -1,30 +0,0 @@
-import os
-
-
-from cqlengine import connection
-from cqlengine.management import create_keyspace
-
-
-def setup_package():
-    try:
-        CASSANDRA_VERSION = int(os.environ["CASSANDRA_VERSION"])
-    except:
-        print("CASSANDRA_VERSION must be set as an environment variable. "
-              "One of (12, 20, 21)")
-        raise
-
-    if os.environ.get('CASSANDRA_TEST_HOST'):
-        CASSANDRA_TEST_HOST = os.environ['CASSANDRA_TEST_HOST']
-    else:
-        CASSANDRA_TEST_HOST = 'localhost'
-
-    if CASSANDRA_VERSION < 20:
-        protocol_version = 1
-    else:
-        protocol_version = 2
-
-    connection.setup([CASSANDRA_TEST_HOST],
-                      protocol_version=protocol_version,
-                      default_keyspace='cqlengine_test')
-
-    create_keyspace("cqlengine_test", replication_factor=1, strategy_class="SimpleStrategy")

tests/integration/cqlengine/__init__.py

@@ -0,0 +1,13 @@
+from cassandra.cqlengine import connection
+from cassandra.cqlengine.management import create_keyspace
+
+from tests.integration import PROTOCOL_VERSION
+
+
+def setup_package():
+    keyspace = 'cqlengine_test'
+    connection.setup(['localhost'],
+                      protocol_version=PROTOCOL_VERSION,
+                      default_keyspace=keyspace)
+
+    create_keyspace(keyspace, replication_factor=1, strategy_class="SimpleStrategy")

tests/integration/cqlengine/base.py

@@ -1,19 +1,11 @@
-from unittest import TestCase
-import os
 import sys
-import six
-from cqlengine.connection import get_session
+from unittest import TestCase
 
-
-CASSANDRA_VERSION = int(os.environ['CASSANDRA_VERSION'])
-PROTOCOL_VERSION = 1 if CASSANDRA_VERSION < 20 else 2
+from cassandra.cqlengine.connection import get_session
 
 
 class BaseCassEngTestCase(TestCase):
 
-    # @classmethod
-    # def setUpClass(cls):
-    #     super(BaseCassEngTestCase, cls).setUpClass()
     session = None
 
     def setUp(self):

tests/integration/cqlengine/columns/test_container_columns.py

@@ -3,10 +3,10 @@ import json
 from uuid import uuid4
 import six
 
-from cqlengine import Model, ValidationError
-from cqlengine import columns
-from cqlengine.management import sync_table, drop_table
-from cqlengine.tests.base import BaseCassEngTestCase
+from cassandra.cqlengine.models import Model, ValidationError
+import cassandra.cqlengine.columns as columns
+from cassandra.cqlengine.management import sync_table, drop_table
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 
 class TestSetModel(Model):

tests/integration/cqlengine/columns/test_counter_column.py

@@ -1,10 +1,9 @@
 from uuid import uuid4
 
-from cqlengine import Model
-from cqlengine import columns
-from cqlengine.management import sync_table, drop_table
-from cqlengine.models import ModelDefinitionException
-from cqlengine.tests.base import BaseCassEngTestCase
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model, ModelDefinitionException
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 
 class TestCounterModel(Model):

tests/integration/cqlengine/columns/test_static_column.py

@@ -1,11 +1,12 @@
-from uuid import uuid4
 from unittest import skipUnless
-from cqlengine import Model
-from cqlengine import columns
-from cqlengine.management import sync_table, drop_table
-from cqlengine.models import ModelDefinitionException
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.tests.base import CASSANDRA_VERSION, PROTOCOL_VERSION
+from uuid import uuid4
+
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from tests.integration import PROTOCOL_VERSION
 
 
 class TestStaticModel(Model):
@@ -15,21 +16,20 @@ class TestStaticModel(Model):
     text = columns.Text()
 
 
+@skipUnless(PROTOCOL_VERSION >= 2, "only runs against the cql3 protocol v2.0")
 class TestStaticColumn(BaseCassEngTestCase):
 
     @classmethod
     def setUpClass(cls):
         super(TestStaticColumn, cls).setUpClass()
         drop_table(TestStaticModel)
-        if CASSANDRA_VERSION >= 20:
-            sync_table(TestStaticModel)
+        sync_table(TestStaticModel)
 
     @classmethod
     def tearDownClass(cls):
         super(TestStaticColumn, cls).tearDownClass()
         drop_table(TestStaticModel)
 
-    @skipUnless(PROTOCOL_VERSION >= 2, "only runs against the cql3 protocol v2.0")
     def test_mixed_updates(self):
         """ Tests that updates on both static and non-static columns work as intended """
         instance = TestStaticModel.create()
@@ -45,7 +45,6 @@ class TestStaticColumn(BaseCassEngTestCase):
 
         assert actual.static == "it's still shared"
 
-    @skipUnless(PROTOCOL_VERSION >= 2, "only runs against the cql3 protocol v2.0")
     def test_static_only_updates(self):
         """ Tests that updates on static only column work as intended """
         instance = TestStaticModel.create()
@@ -59,7 +58,6 @@ class TestStaticColumn(BaseCassEngTestCase):
         actual = TestStaticModel.get(partition=u.partition)
         assert actual.static == "it's still shared"
 
-    @skipUnless(PROTOCOL_VERSION >= 2, "only runs against the cql3 protocol v2.0")
     def test_static_with_null_cluster_key(self):
         """ Tests that save/update/delete works for static column works when clustering key is null"""
         instance = TestStaticModel.create(cluster=None, static = "it's shared")

tests/integration/cqlengine/columns/test_validation.py

@@ -1,34 +1,26 @@
-#tests the behavior of the column classes
-from datetime import datetime, timedelta
-from datetime import date
-from datetime import tzinfo
+from datetime import datetime, timedelta, date, tzinfo
 from decimal import Decimal as D
 from unittest import TestCase
 from uuid import uuid4, uuid1
+
 from cassandra import InvalidRequest
-import six
-from cqlengine import ValidationError
-from cqlengine.connection import execute
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model, ValidationError
+from cassandra.cqlengine.connection import execute
 
-from cqlengine.tests.base import BaseCassEngTestCase
+from cassandra.cqlengine.columns import TimeUUID
+from cassandra.cqlengine.columns import Text
+from cassandra.cqlengine.columns import Integer
+from cassandra.cqlengine.columns import BigInt
+from cassandra.cqlengine.columns import VarInt
+from cassandra.cqlengine.columns import DateTime
+from cassandra.cqlengine.columns import Date
+from cassandra.cqlengine.columns import UUID
+from cassandra.cqlengine.columns import Boolean
+from cassandra.cqlengine.columns import Decimal
+from cassandra.cqlengine.columns import Inet
 
-from cqlengine.columns import Column, TimeUUID
-from cqlengine.columns import Bytes
-from cqlengine.columns import Ascii
-from cqlengine.columns import Text
-from cqlengine.columns import Integer
-from cqlengine.columns import BigInt
-from cqlengine.columns import VarInt
-from cqlengine.columns import DateTime
-from cqlengine.columns import Date
-from cqlengine.columns import UUID
-from cqlengine.columns import Boolean
-from cqlengine.columns import Float
-from cqlengine.columns import Decimal
-from cqlengine.columns import Inet
-
-from cqlengine.management import sync_table, drop_table
-from cqlengine.models import Model
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 
 class TestDatetime(BaseCassEngTestCase):

tests/integration/cqlengine/columns/test_value_io.py

@@ -3,13 +3,13 @@ from decimal import Decimal
 from uuid import uuid1, uuid4, UUID
 import six
 
-from cqlengine.tests.base import BaseCassEngTestCase
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
-from cqlengine.management import sync_table
-from cqlengine.management import drop_table
-from cqlengine.models import Model
-from cqlengine.columns import ValueQuoter
-from cqlengine import columns
+from cassandra.cqlengine.management import sync_table
+from cassandra.cqlengine.management import drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.columns import ValueQuoter
+from cassandra.cqlengine import columns
 import unittest
 
 

tests/integration/cqlengine/management/test_compaction_settings.py

@@ -1,11 +1,13 @@
 import copy
 import json
-from time import sleep
-from mock import patch, MagicMock
-from cqlengine import Model, columns, SizeTieredCompactionStrategy, LeveledCompactionStrategy
-from cqlengine.exceptions import CQLEngineException
-from cqlengine.management import get_compaction_options, drop_table, sync_table, get_table_settings
-from cqlengine.tests.base import BaseCassEngTestCase
+from mock import patch
+
+from cassandra.cqlengine import columns, SizeTieredCompactionStrategy, LeveledCompactionStrategy
+from cassandra.cqlengine.exceptions import CQLEngineException
+from cassandra.cqlengine.management import get_compaction_options, drop_table, sync_table, get_table_settings
+from cassandra.cqlengine.models import Model
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 
 class CompactionModel(Model):
@@ -81,7 +83,7 @@ class LeveledcompactionTestTable(Model):
     user_id = columns.UUID(primary_key=True)
     name = columns.Text()
 
-from cqlengine.management import schema_columnfamilies
+from cassandra.cqlengine.management import schema_columnfamilies
 
 class AlterTableTest(BaseCassEngTestCase):
 
@@ -93,7 +95,7 @@ class AlterTableTest(BaseCassEngTestCase):
         assert mock.called == 1
 
     def test_compaction_not_altered_without_changes_leveled(self):
-        from cqlengine.management import update_compaction
+        from cassandra.cqlengine.management import update_compaction
 
         class LeveledCompactionChangesDetectionTest(Model):
 
@@ -110,7 +112,7 @@ class AlterTableTest(BaseCassEngTestCase):
         assert not update_compaction(LeveledCompactionChangesDetectionTest)
 
     def test_compaction_not_altered_without_changes_sizetiered(self):
-        from cqlengine.management import update_compaction
+        from cassandra.cqlengine.management import update_compaction
 
         class SizeTieredCompactionChangesDetectionTest(Model):
 

tests/integration/cqlengine/management/test_management.py

@@ -1,16 +1,17 @@
 import mock
-from cqlengine import ALL, CACHING_ALL, CACHING_NONE
-from cqlengine.connection import get_session
-from cqlengine.exceptions import CQLEngineException
-from cqlengine.management import  get_fields, sync_table, drop_table
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.tests.base import CASSANDRA_VERSION, PROTOCOL_VERSION
-from cqlengine import management
-from cqlengine.tests.query.test_queryset import TestModel
-from cqlengine.models import Model
-from cqlengine import columns, SizeTieredCompactionStrategy, LeveledCompactionStrategy
 from unittest import skipUnless
 
+from cassandra.cqlengine import CACHING_ALL, CACHING_NONE
+from cassandra.cqlengine.connection import get_session
+from cassandra.cqlengine.exceptions import CQLEngineException
+from cassandra.cqlengine import management
+from cassandra.cqlengine.management import  get_fields, sync_table, drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns, SizeTieredCompactionStrategy, LeveledCompactionStrategy
+
+from tests.integration import CASSANDRA_VERSION, PROTOCOL_VERSION
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from tests.integration.cqlengine.query.test_queryset import TestModel
 
 class CreateKeyspaceTest(BaseCassEngTestCase):
     def test_create_succeeeds(self):
@@ -132,7 +133,7 @@ class ModelWithTableProperties(Model):
     key = columns.UUID(primary_key=True)
 
 # kind of a hack, but we only test this property on C >= 2.0
-if CASSANDRA_VERSION >= 20:
+if CASSANDRA_VERSION >= '2.0.0':
     ModelWithTableProperties.__memtable_flush_period_in_ms__ = 43681
     ModelWithTableProperties.__index_interval__ = 98706
     ModelWithTableProperties.__default_time_to_live__ = 4756
@@ -155,15 +156,15 @@ class TablePropertiesTests(BaseCassEngTestCase):
                      #  TODO: due to a bug in the native driver i'm not seeing the local read repair chance show up
                      # 'local_read_repair_chance': 0.50811,
                     }
-        if CASSANDRA_VERSION <= 20:
+        if CASSANDRA_VERSION >= '2.0.0':
             expected['caching'] = CACHING_ALL
             expected['replicate_on_write'] = False
 
-        if CASSANDRA_VERSION == 20:
+        if CASSANDRA_VERSION >= '2.0.0':
             expected['populate_io_cache_on_flush'] = True
             expected['index_interval'] = 98706
 
-        if CASSANDRA_VERSION >= 20:
+        if CASSANDRA_VERSION >= '2.0.0':
             expected['default_time_to_live'] = 4756
             expected['memtable_flush_period_in_ms'] = 43681
 
@@ -180,7 +181,7 @@ class TablePropertiesTests(BaseCassEngTestCase):
         ModelWithTableProperties.__replicate_on_write__ = True
         ModelWithTableProperties.__dclocal_read_repair_chance__ = 0.12732
 
-        if CASSANDRA_VERSION >= 20:
+        if CASSANDRA_VERSION >= '2.0.0':
             ModelWithTableProperties.__default_time_to_live__ = 65178
             ModelWithTableProperties.__memtable_flush_period_in_ms__ = 60210
             ModelWithTableProperties.__index_interval__ = 94207
@@ -195,15 +196,15 @@ class TablePropertiesTests(BaseCassEngTestCase):
                      'read_repair_chance': 0.2989,
                      #'local_read_repair_chance': 0.12732,
                     }
-        if CASSANDRA_VERSION >= 20:
+        if CASSANDRA_VERSION >= '2.0.0':
              expected['memtable_flush_period_in_ms'] = 60210
              expected['default_time_to_live'] = 65178
 
-        if CASSANDRA_VERSION == 20:
+        if CASSANDRA_VERSION >= '2.0.0':
              expected['index_interval'] = 94207
 
         # these featuers removed in cassandra 2.1
-        if CASSANDRA_VERSION <= 20:
+        if CASSANDRA_VERSION >= '2.0.0':
             expected['caching'] = CACHING_NONE
             expected['replicate_on_write'] = True
             expected['populate_io_cache_on_flush'] = False
@@ -267,7 +268,7 @@ def test_static_columns():
 
     from mock import patch
 
-    from cqlengine.connection import get_session
+    from cassandra.cqlengine.connection import get_session
     session = get_session()
 
     with patch.object(session, "execute", wraps=session.execute) as m:

tests/integration/cqlengine/model/test_class_construction.py

@@ -1,12 +1,12 @@
 from uuid import uuid4
 import warnings
-from cqlengine.query import QueryException, ModelQuerySet, DMLQuery
-from cqlengine.tests.base import BaseCassEngTestCase
 
-from cqlengine.exceptions import ModelException, CQLEngineException
-from cqlengine.models import Model, ModelDefinitionException, ColumnQueryEvaluator, UndefinedKeyspaceWarning
-from cqlengine import columns
-import cqlengine
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.exceptions import ModelException, CQLEngineException
+from cassandra.cqlengine.models import Model, ModelDefinitionException, ColumnQueryEvaluator
+from cassandra.cqlengine.query import ModelQuerySet, DMLQuery
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 class TestModelClassFunction(BaseCassEngTestCase):
     """
@@ -152,12 +152,12 @@ class TestModelClassFunction(BaseCassEngTestCase):
         """
         Test compound partition key definition
         """
-        class ModelWithPartitionKeys(cqlengine.Model):
+        class ModelWithPartitionKeys(Model):
 
             id = columns.UUID(primary_key=True, default=lambda:uuid4())
-            c1 = cqlengine.Text(primary_key=True)
-            p1 = cqlengine.Text(partition_key=True)
-            p2 = cqlengine.Text(partition_key=True)
+            c1 = columns.Text(primary_key=True)
+            p1 = columns.Text(partition_key=True)
+            p2 = columns.Text(partition_key=True)
 
         cols = ModelWithPartitionKeys._columns
 
@@ -231,12 +231,12 @@ class TestModelClassFunction(BaseCassEngTestCase):
 
 class TestManualTableNaming(BaseCassEngTestCase):
 
-    class RenamedTest(cqlengine.Model):
+    class RenamedTest(Model):
         __keyspace__ = 'whatever'
         __table_name__ = 'manual_name'
 
-        id = cqlengine.UUID(primary_key=True)
-        data = cqlengine.Text()
+        id = columns.UUID(primary_key=True)
+        data = columns.Text()
 
     def test_proper_table_naming(self):
         assert self.RenamedTest.column_family_name(include_keyspace=False) == 'manual_name'
@@ -286,7 +286,7 @@ class TestAbstractModelClasses(BaseCassEngTestCase):
 
     def test_attempting_to_create_abstract_table_fails(self):
         """ Attempting to create a table from an abstract model should fail """
-        from cqlengine.management import sync_table
+        from cassandra.cqlengine.management import sync_table
         with self.assertRaises(CQLEngineException):
             sync_table(AbstractModelWithFullCols)
 
@@ -303,7 +303,7 @@ class TestAbstractModelClasses(BaseCassEngTestCase):
 
     def test_concrete_class_table_creation_cycle(self):
         """ Tests that models with inherited abstract classes can be created, and have io performed """
-        from cqlengine.management import sync_table, drop_table
+        from cassandra.cqlengine.management import sync_table, drop_table
         sync_table(ConcreteModelWithCol)
 
         w1 = ConcreteModelWithCol.create(pkey=5, data=6)

tests/integration/cqlengine/model/test_equality_operations.py

@@ -1,11 +1,11 @@
 from unittest import skip
 from uuid import uuid4
-from cqlengine.tests.base import BaseCassEngTestCase
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
-from cqlengine.management import sync_table
-from cqlengine.management import drop_table
-from cqlengine.models import Model
-from cqlengine import columns
+from cassandra.cqlengine.management import sync_table
+from cassandra.cqlengine.management import drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
 
 class TestModel(Model):
 

tests/integration/cqlengine/model/test_model.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
 
-from cqlengine.models import Model, ModelDefinitionException
-from cqlengine import columns
+from cassandra.cqlengine.models import Model, ModelDefinitionException
+from cassandra.cqlengine import columns
 
 
 class TestModel(TestCase):

tests/integration/cqlengine/model/test_model_io.py

@@ -2,13 +2,13 @@ from uuid import uuid4
 import random
 from datetime import date
 from operator import itemgetter
-from cqlengine.exceptions import CQLEngineException
-from cqlengine.tests.base import BaseCassEngTestCase
+from cassandra.cqlengine.exceptions import CQLEngineException
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
-from cqlengine.management import sync_table
-from cqlengine.management import drop_table
-from cqlengine.models import Model
-from cqlengine import columns
+from cassandra.cqlengine.management import sync_table
+from cassandra.cqlengine.management import drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
 
 class TestModel(Model):
 

tests/integration/cqlengine/model/test_polymorphism.py

@@ -1,11 +1,11 @@
 import uuid
 import mock
 
-from cqlengine import columns
-from cqlengine import models
-from cqlengine.connection import get_session
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine import management
+from cassandra.cqlengine import columns
+from cassandra.cqlengine import models
+from cassandra.cqlengine.connection import get_session
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from cassandra.cqlengine import management
 
 
 class TestPolymorphicClassConstruction(BaseCassEngTestCase):

tests/integration/cqlengine/model/test_updates.py

@@ -1,12 +1,12 @@
 from uuid import uuid4
 
 from mock import patch
-from cqlengine.exceptions import ValidationError
+from cassandra.cqlengine.exceptions import ValidationError
 
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.models import Model
-from cqlengine import columns
-from cqlengine.management import sync_table, drop_table
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import sync_table, drop_table
 
 
 class TestUpdateModel(Model):

tests/integration/cqlengine/model/test_value_lists.py

@@ -1,10 +1,10 @@
 import random
-from cqlengine.tests.base import BaseCassEngTestCase
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
-from cqlengine.management import sync_table
-from cqlengine.management import drop_table
-from cqlengine.models import Model
-from cqlengine import columns
+from cassandra.cqlengine.management import sync_table
+from cassandra.cqlengine.management import drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
 
 
 class TestModel(Model):

tests/integration/cqlengine/operators/test_base_operator.py

@@ -1,9 +1,9 @@
 from unittest import TestCase
-from cqlengine.operators import BaseQueryOperator, QueryOperatorException
+from cassandra.cqlengine.operators import BaseQueryOperator, QueryOperatorException
 
 
 class BaseOperatorTest(TestCase):
 
     def test_get_operator_cannot_be_called_from_base_class(self):
         with self.assertRaises(QueryOperatorException):
-            BaseQueryOperator.get_operator('*')
+            BaseQueryOperator.get_operator('*')

tests/integration/cqlengine/operators/test_where_operators.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from cqlengine.operators import *
+from cassandra.cqlengine.operators import *
 
 import six
 

tests/integration/cqlengine/query/test_batch_query.py

@@ -1,15 +1,13 @@
-from datetime import datetime
-from unittest import skip
-from uuid import uuid4
-import random
-from cqlengine import Model, columns
-from cqlengine.connection import NOT_SET
-from cqlengine.management import drop_table, sync_table
-from cqlengine.query import BatchQuery, DMLQuery
-from cqlengine.tests.base import BaseCassEngTestCase
-from cassandra.cluster import Session
 import mock
 
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.connection import NOT_SET
+from cassandra.cqlengine.management import drop_table, sync_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.query import BatchQuery, DMLQuery
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from cassandra.cluster import Session
+
 
 class TestMultiKeyModel(Model):
 

tests/integration/cqlengine/query/test_datetime_queries.py

@@ -1,14 +1,14 @@
 from datetime import datetime, timedelta
 from uuid import uuid4
 
-from cqlengine.tests.base import BaseCassEngTestCase
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
-from cqlengine.exceptions import ModelException
-from cqlengine.management import sync_table
-from cqlengine.management import drop_table
-from cqlengine.models import Model
-from cqlengine import columns
-from cqlengine import query
+from cassandra.cqlengine.exceptions import ModelException
+from cassandra.cqlengine.management import sync_table
+from cassandra.cqlengine.management import drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
+from cassandra.cqlengine import query
 
 class DateTimeQueryTestModel(Model):
 

tests/integration/cqlengine/query/test_named.py

@@ -1,9 +1,10 @@
-from cqlengine import operators
-from cqlengine.named import NamedKeyspace
-from cqlengine.operators import EqualsOperator, GreaterThanOrEqualOperator
-from cqlengine.query import ResultObject
-from cqlengine.tests.query.test_queryset import BaseQuerySetUsage
-from cqlengine.tests.base import BaseCassEngTestCase
+from cassandra.cqlengine import operators
+from cassandra.cqlengine.named import NamedKeyspace
+from cassandra.cqlengine.operators import EqualsOperator, GreaterThanOrEqualOperator
+from cassandra.cqlengine.query import ResultObject
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from tests.integration.cqlengine.query.test_queryset import BaseQuerySetUsage
 
 
 class TestQuerySetOperation(BaseCassEngTestCase):
@@ -101,7 +102,7 @@ class TestQuerySetCountSelectionAndIteration(BaseQuerySetUsage):
     def setUpClass(cls):
         super(TestQuerySetCountSelectionAndIteration, cls).setUpClass()
 
-        from cqlengine.tests.query.test_queryset import TestModel
+        from cassandra.cqlengine.tests.query.test_queryset import TestModel
 
         ks,tn = TestModel.column_family_name().split('.')
         cls.keyspace = NamedKeyspace(ks)

tests/integration/cqlengine/query/test_queryoperators.py

@@ -1,13 +1,14 @@
 from datetime import datetime
-from cqlengine.columns import DateTime
 
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine import columns, Model
-from cqlengine import functions
-from cqlengine import query
-from cqlengine.statements import WhereClause
-from cqlengine.operators import EqualsOperator
-from cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine import columns
+from cassandra.cqlengine import functions
+from cassandra.cqlengine import query
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.operators import EqualsOperator
+from cassandra.cqlengine.statements import WhereClause
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 class TestQuerySetOperation(BaseCassEngTestCase):
 
@@ -22,7 +23,7 @@ class TestQuerySetOperation(BaseCassEngTestCase):
         self.assertEqual(str(where), '"time" = MaxTimeUUID(%(5)s)')
         ctx = {}
         where.update_context(ctx)
-        self.assertEqual(ctx, {'5': DateTime().to_database(now)})
+        self.assertEqual(ctx, {'5': columns.DateTime().to_database(now)})
 
     def test_mintimeuuid_function(self):
         """
@@ -35,7 +36,7 @@ class TestQuerySetOperation(BaseCassEngTestCase):
         self.assertEqual(str(where), '"time" = MinTimeUUID(%(5)s)')
         ctx = {}
         where.update_context(ctx)
-        self.assertEqual(ctx, {'5': DateTime().to_database(now)})
+        self.assertEqual(ctx, {'5': columns.DateTime().to_database(now)})
 
 
 class TokenTestModel(Model):

tests/integration/cqlengine/query/test_queryset.py

@@ -6,22 +6,22 @@ from uuid import uuid1, uuid4
 import uuid
 
 from cassandra.cluster import Session
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.connection import NOT_SET
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from cassandra.cqlengine.connection import NOT_SET
 import mock
-from cqlengine import functions
-from cqlengine.management import sync_table, drop_table
-from cqlengine.models import Model
-from cqlengine import columns
-from cqlengine import query
+from cassandra.cqlengine import functions
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
+from cassandra.cqlengine import query
 from datetime import timedelta
 from datetime import tzinfo
 
-from cqlengine import statements
-from cqlengine import operators
+from cassandra.cqlengine import statements
+from cassandra.cqlengine import operators
 
-from cqlengine.connection import get_session
-from cqlengine.tests.base import PROTOCOL_VERSION
+from cassandra.cqlengine.connection import get_session
+from tests.integration import PROTOCOL_VERSION
 
 
 class TzOffset(tzinfo):

tests/integration/cqlengine/query/test_updates.py

@@ -1,11 +1,11 @@
 from uuid import uuid4
-from cqlengine.exceptions import ValidationError
-from cqlengine.query import QueryException
+from cassandra.cqlengine.exceptions import ValidationError
+from cassandra.cqlengine.query import QueryException
 
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.models import Model
-from cqlengine.management import sync_table, drop_table
-from cqlengine import columns
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine import columns
 
 
 class TestQueryUpdateModel(Model):

tests/integration/cqlengine/statements/test_assignment_clauses.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from cqlengine.statements import AssignmentClause, SetUpdateClause, ListUpdateClause, MapUpdateClause, MapDeleteClause, FieldDeleteClause, CounterUpdateClause
+from cassandra.cqlengine.statements import AssignmentClause, SetUpdateClause, ListUpdateClause, MapUpdateClause, MapDeleteClause, FieldDeleteClause, CounterUpdateClause
 
 
 class AssignmentClauseTests(TestCase):

tests/integration/cqlengine/statements/test_assignment_statement.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from cqlengine.statements import AssignmentStatement, StatementException
+from cassandra.cqlengine.statements import AssignmentStatement, StatementException
 
 
 class AssignmentStatementTest(TestCase):
@@ -8,4 +8,4 @@ class AssignmentStatementTest(TestCase):
         """ tests that only assignment clauses can be added to queries """
         stmt = AssignmentStatement('table', [])
         with self.assertRaises(StatementException):
-            stmt.add_assignment_clause('x=5')
+            stmt.add_assignment_clause('x=5')

tests/integration/cqlengine/statements/test_base_clause.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from cqlengine.statements import BaseClause
+from cassandra.cqlengine.statements import BaseClause
 
 
 class BaseClauseTests(TestCase):

tests/integration/cqlengine/statements/test_base_statement.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from cqlengine.statements import BaseCQLStatement, StatementException
+from cassandra.cqlengine.statements import BaseCQLStatement, StatementException
 
 
 class BaseStatementTest(TestCase):

tests/integration/cqlengine/statements/test_delete_statement.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
-from cqlengine.statements import DeleteStatement, WhereClause, MapDeleteClause
-from cqlengine.operators import *
+from cassandra.cqlengine.statements import DeleteStatement, WhereClause, MapDeleteClause
+from cassandra.cqlengine.operators import *
 import six
 
 class DeleteStatementTests(TestCase):

tests/integration/cqlengine/statements/test_insert_statement.py

@@ -1,5 +1,5 @@
 from unittest import TestCase
-from cqlengine.statements import InsertStatement, StatementException, AssignmentClause
+from cassandra.cqlengine.statements import InsertStatement, StatementException, AssignmentClause
 
 import six
 

tests/integration/cqlengine/statements/test_select_statement.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
-from cqlengine.statements import SelectStatement, WhereClause
-from cqlengine.operators import *
+from cassandra.cqlengine.statements import SelectStatement, WhereClause
+from cassandra.cqlengine.operators import *
 import six
 
 class SelectStatementTests(TestCase):

tests/integration/cqlengine/statements/test_update_statement.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
-from cqlengine.columns import Set, List
-from cqlengine.operators import *
-from cqlengine.statements import (UpdateStatement, WhereClause,
+from cassandra.cqlengine.columns import Set, List
+from cassandra.cqlengine.operators import *
+from cassandra.cqlengine.statements import (UpdateStatement, WhereClause,
                                   AssignmentClause, SetUpdateClause,
                                   ListUpdateClause)
 import six

tests/integration/cqlengine/statements/test_where_clause.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
 import six
-from cqlengine.operators import EqualsOperator
-from cqlengine.statements import StatementException, WhereClause
+from cassandra.cqlengine.operators import EqualsOperator
+from cassandra.cqlengine.statements import StatementException, WhereClause
 
 
 class TestWhereClause(TestCase):

tests/integration/cqlengine/test_batch_query.py

@@ -1,14 +1,10 @@
-from unittest import skip
-from uuid import uuid4
-import random
-
-import mock
 import sure
 
-from cqlengine import Model, columns
-from cqlengine.management import drop_table, sync_table
-from cqlengine.query import BatchQuery
-from cqlengine.tests.base import BaseCassEngTestCase
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import drop_table, sync_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.query import BatchQuery
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 class TestMultiKeyModel(Model):
 

tests/integration/cqlengine/test_consistency.py

@@ -1,10 +1,13 @@
-from cqlengine.management import sync_table, drop_table
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.models import Model
-from uuid import uuid4
-from cqlengine import columns
 import mock
-from cqlengine import ALL, BatchQuery
+from uuid import uuid4
+
+from cassandra import ConsistencyLevel as CL
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.query import BatchQuery
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 class TestConsistencyModel(Model):
 
@@ -28,15 +31,15 @@ class BaseConsistencyTest(BaseCassEngTestCase):
 class TestConsistency(BaseConsistencyTest):
     def test_create_uses_consistency(self):
 
-        qs = TestConsistencyModel.consistency(ALL)
+        qs = TestConsistencyModel.consistency(CL.ALL)
         with mock.patch.object(self.session, 'execute') as m:
             qs.create(text="i am not fault tolerant this way")
 
         args = m.call_args
-        self.assertEqual(ALL, args[0][0].consistency_level)
+        self.assertEqual(CL.ALL, args[0][0].consistency_level)
 
     def test_queryset_is_returned_on_create(self):
-        qs = TestConsistencyModel.consistency(ALL)
+        qs = TestConsistencyModel.consistency(CL.ALL)
         self.assertTrue(isinstance(qs, TestConsistencyModel.__queryset__), type(qs))
 
     def test_update_uses_consistency(self):
@@ -44,10 +47,10 @@ class TestConsistency(BaseConsistencyTest):
         t.text = "ham sandwich"
 
         with mock.patch.object(self.session, 'execute') as m:
-            t.consistency(ALL).save()
+            t.consistency(CL.ALL).save()
 
         args = m.call_args
-        self.assertEqual(ALL, args[0][0].consistency_level)
+        self.assertEqual(CL.ALL, args[0][0].consistency_level)
 
 
     def test_batch_consistency(self):
@@ -58,14 +61,14 @@ class TestConsistency(BaseConsistencyTest):
 
         args = m.call_args
 
-        self.assertEqual(ALL, args[0][0].consistency_level)
+        self.assertEqual(CL.ALL, args[0][0].consistency_level)
 
         with mock.patch.object(self.session, 'execute') as m:
             with BatchQuery() as b:
                 TestConsistencyModel.batch(b).create(text="monkey")
 
         args = m.call_args
-        self.assertNotEqual(ALL, args[0][0].consistency_level)
+        self.assertNotEqual(CL.ALL, args[0][0].consistency_level)
 
     def test_blind_update(self):
         t = TestConsistencyModel.create(text="bacon and eggs")
@@ -73,10 +76,10 @@ class TestConsistency(BaseConsistencyTest):
         uid = t.id
 
         with mock.patch.object(self.session, 'execute') as m:
-            TestConsistencyModel.objects(id=uid).consistency(ALL).update(text="grilled cheese")
+            TestConsistencyModel.objects(id=uid).consistency(CL.ALL).update(text="grilled cheese")
 
         args = m.call_args
-        self.assertEqual(ALL, args[0][0].consistency_level)
+        self.assertEqual(CL.ALL, args[0][0].consistency_level)
 
 
     def test_delete(self):
@@ -86,10 +89,10 @@ class TestConsistency(BaseConsistencyTest):
         uid = t.id
 
         with mock.patch.object(self.session, 'execute') as m:
-            t.consistency(ALL).delete()
+            t.consistency(CL.ALL).delete()
 
         with mock.patch.object(self.session, 'execute') as m:
-            TestConsistencyModel.objects(id=uid).consistency(ALL).delete()
+            TestConsistencyModel.objects(id=uid).consistency(CL.ALL).delete()
 
         args = m.call_args
-        self.assertEqual(ALL, args[0][0].consistency_level)
+        self.assertEqual(CL.ALL, args[0][0].consistency_level)

tests/integration/cqlengine/test_ifnotexists.py

@@ -1,13 +1,15 @@
-from unittest import skipUnless
-from cqlengine.management import sync_table, drop_table, create_keyspace, delete_keyspace
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.tests.base import PROTOCOL_VERSION
-from cqlengine.models import Model
-from cqlengine.exceptions import LWTException, IfNotExistsWithCounterColumn
-from cqlengine import columns, BatchQuery
-from uuid import uuid4
 import mock
+from unittest import skipUnless
+from uuid import uuid4
 
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.exceptions import LWTException, IfNotExistsWithCounterColumn
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.query import BatchQuery
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from tests.integration import PROTOCOL_VERSION
 
 class TestIfNotExistsModel(Model):
 

tests/integration/cqlengine/test_load.py

@@ -1,16 +1,15 @@
-import os
-from unittest import TestCase, skipUnless
-
-from cqlengine import Model, Integer
-from cqlengine.management import sync_table
-from cqlengine.tests import base
-import resource
 import gc
+import os
+import resource
+from unittest import skipUnless
+
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.management import sync_table
 
 class LoadTest(Model):
-
-    k = Integer(primary_key=True)
-    v = Integer()
+    k = columns.Integer(primary_key=True)
+    v = columns.Integer()
 
 
 @skipUnless("LOADTEST" in os.environ, "LOADTEST not on")

tests/integration/cqlengine/test_timestamp.py

@@ -1,14 +1,13 @@
-"""
-Tests surrounding the blah.timestamp( timedelta(seconds=30) ) format.
-"""
 from datetime import timedelta, datetime
-
-from uuid import uuid4
 import mock
 import sure
-from cqlengine import Model, columns, BatchQuery
-from cqlengine.management import sync_table
-from cqlengine.tests.base import BaseCassEngTestCase
+from uuid import uuid4
+
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import sync_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.query import BatchQuery
+from tests.integration.cqlengine.base import BaseCassEngTestCase
 
 
 class TestTimestampModel(Model):

tests/integration/cqlengine/test_transaction.py

@@ -1,18 +1,17 @@
-__author__ = 'Tim Martin'
-from unittest import skipUnless
-
-from cqlengine.management import sync_table, drop_table
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.tests.base import CASSANDRA_VERSION
-from cqlengine.models import Model
-from cqlengine.exceptions import LWTException
-from uuid import uuid4
-from cqlengine import columns, BatchQuery
 import mock
-from cqlengine import ALL, BatchQuery
-from cqlengine.statements import TransactionClause
 import six
+from unittest import skipUnless
+from uuid import uuid4
 
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.management import sync_table, drop_table
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.exceptions import LWTException
+from cassandra.cqlengine.query import BatchQuery
+from cassandra.cqlengine.statements import TransactionClause
+
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from tests.integration import CASSANDRA_VERSION
 
 class TestTransactionModel(Model):
     id = columns.UUID(primary_key=True, default=lambda:uuid4())
@@ -20,7 +19,7 @@ class TestTransactionModel(Model):
     text = columns.Text(required=False)
 
 
-@skipUnless(CASSANDRA_VERSION >= 20, "transactions only supported on cassandra 2.0 or higher")
+@skipUnless(CASSANDRA_VERSION >= '2.0.0', "transactions only supported on cassandra 2.0 or higher")
 class TestTransaction(BaseCassEngTestCase):
 
     @classmethod

tests/integration/cqlengine/test_ttl.py

@@ -1,10 +1,10 @@
-from cqlengine.management import sync_table, drop_table
-from cqlengine.tests.base import BaseCassEngTestCase
-from cqlengine.models import Model
+from cassandra.cqlengine.management import sync_table, drop_table
+from tests.integration.cqlengine.base import BaseCassEngTestCase
+from cassandra.cqlengine.models import Model
 from uuid import uuid4
-from cqlengine import columns
+from cassandra.cqlengine import columns
 import mock
-from cqlengine.connection import get_session
+from cassandra.cqlengine.connection import get_session
 
 
 class TestTTLModel(Model):