openstack/deb-python-cassandra-driver
Code Issues Proposed changes

Reloate cqlengine tests to integration tests, update imports

Browse Source 
Not integrated with existing integration ccm operation.
There is a handful of failing cqlengine tests in the commit, that worked
before the move.
This commit is contained in:
Adam Holmberg
2015-02-04 11:56:19 -06:00
parent 0ded875003
commit 4698509727
51 changed files with 268 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
cassandra/cqlengine/tests/__init__.py
View File

@@ -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")

13
tests/integration/cqlengine/__init__.py Normal file
View File

@@ -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")

12
cassandra/cqlengine/tests/base.py → tests/integration/cqlengine/base.py
View File

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

0
cassandra/cqlengine/tests/columns/__init__.py → tests/integration/cqlengine/columns/__init__.py
View File

8
cassandra/cqlengine/tests/columns/test_container_columns.py → tests/integration/cqlengine/columns/test_container_columns.py
View File

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

9
cassandra/cqlengine/tests/columns/test_counter_column.py → tests/integration/cqlengine/columns/test_counter_column.py
View File

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

20
cassandra/cqlengine/tests/columns/test_static_column.py → tests/integration/cqlengine/columns/test_static_column.py
View File

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

42
cassandra/cqlengine/tests/columns/test_validation.py → tests/integration/cqlengine/columns/test_validation.py
View File

@@ -1,34 +1,26 @@
#tests the behavior of the column classes from datetime import datetime, timedelta, date, tzinfo
from datetime import datetime, timedelta
from datetime import date
from datetime import tzinfo
from decimal import Decimal as D from decimal import Decimal as D
from unittest import TestCase from unittest import TestCase
from uuid import uuid4, uuid1 from uuid import uuid4, uuid1
from cassandra import InvalidRequest from cassandra import InvalidRequest
import six from cassandra.cqlengine.management import sync_table, drop_table
from cqlengine import ValidationError from cassandra.cqlengine.models import Model, ValidationError
from cqlengine.connection import execute 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 tests.integration.cqlengine.base import BaseCassEngTestCase
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
class TestDatetime(BaseCassEngTestCase): class TestDatetime(BaseCassEngTestCase):

12
cassandra/cqlengine/tests/columns/test_value_io.py → tests/integration/cqlengine/columns/test_value_io.py
View File

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

0
cassandra/cqlengine/tests/connections/__init__.py → tests/integration/cqlengine/connections/__init__.py
View File

0
cassandra/cqlengine/tests/management/__init__.py → tests/integration/cqlengine/management/__init__.py
View File

20
cassandra/cqlengine/tests/management/test_compaction_settings.py → tests/integration/cqlengine/management/test_compaction_settings.py
View File

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

39
cassandra/cqlengine/tests/management/test_management.py → tests/integration/cqlengine/management/test_management.py
View File

@@ -1,16 +1,17 @@
import mock 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 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): class CreateKeyspaceTest(BaseCassEngTestCase):
def test_create_succeeeds(self): def test_create_succeeeds(self):
@@ -132,7 +133,7 @@ class ModelWithTableProperties(Model):
key = columns.UUID(primary_key=True) key = columns.UUID(primary_key=True)
# kind of a hack, but we only test this property on C >= 2.0 # 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.__memtable_flush_period_in_ms__ = 43681
ModelWithTableProperties.__index_interval__ = 98706 ModelWithTableProperties.__index_interval__ = 98706
ModelWithTableProperties.__default_time_to_live__ = 4756 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 # 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, # 'local_read_repair_chance': 0.50811,
} }
if CASSANDRA_VERSION <= 20: if CASSANDRA_VERSION >= '2.0.0':
expected['caching'] = CACHING_ALL expected['caching'] = CACHING_ALL
expected['replicate_on_write'] = False expected['replicate_on_write'] = False
if CASSANDRA_VERSION == 20: if CASSANDRA_VERSION >= '2.0.0':
expected['populate_io_cache_on_flush'] = True expected['populate_io_cache_on_flush'] = True
expected['index_interval'] = 98706 expected['index_interval'] = 98706
if CASSANDRA_VERSION >= 20: if CASSANDRA_VERSION >= '2.0.0':
expected['default_time_to_live'] = 4756 expected['default_time_to_live'] = 4756
expected['memtable_flush_period_in_ms'] = 43681 expected['memtable_flush_period_in_ms'] = 43681
@@ -180,7 +181,7 @@ class TablePropertiesTests(BaseCassEngTestCase):
ModelWithTableProperties.__replicate_on_write__ = True ModelWithTableProperties.__replicate_on_write__ = True
ModelWithTableProperties.__dclocal_read_repair_chance__ = 0.12732 ModelWithTableProperties.__dclocal_read_repair_chance__ = 0.12732
if CASSANDRA_VERSION >= 20: if CASSANDRA_VERSION >= '2.0.0':
ModelWithTableProperties.__default_time_to_live__ = 65178 ModelWithTableProperties.__default_time_to_live__ = 65178
ModelWithTableProperties.__memtable_flush_period_in_ms__ = 60210 ModelWithTableProperties.__memtable_flush_period_in_ms__ = 60210
ModelWithTableProperties.__index_interval__ = 94207 ModelWithTableProperties.__index_interval__ = 94207
@@ -195,15 +196,15 @@ class TablePropertiesTests(BaseCassEngTestCase):
'read_repair_chance': 0.2989, 'read_repair_chance': 0.2989,
#'local_read_repair_chance': 0.12732, #'local_read_repair_chance': 0.12732,
} }
if CASSANDRA_VERSION >= 20: if CASSANDRA_VERSION >= '2.0.0':
expected['memtable_flush_period_in_ms'] = 60210 expected['memtable_flush_period_in_ms'] = 60210
expected['default_time_to_live'] = 65178 expected['default_time_to_live'] = 65178
if CASSANDRA_VERSION == 20: if CASSANDRA_VERSION >= '2.0.0':
expected['index_interval'] = 94207 expected['index_interval'] = 94207
# these featuers removed in cassandra 2.1 # these featuers removed in cassandra 2.1
if CASSANDRA_VERSION <= 20: if CASSANDRA_VERSION >= '2.0.0':
expected['caching'] = CACHING_NONE expected['caching'] = CACHING_NONE
expected['replicate_on_write'] = True expected['replicate_on_write'] = True
expected['populate_io_cache_on_flush'] = False expected['populate_io_cache_on_flush'] = False
@@ -267,7 +268,7 @@ def test_static_columns():
from mock import patch from mock import patch
from cqlengine.connection import get_session from cassandra.cqlengine.connection import get_session
session = get_session() session = get_session()
with patch.object(session, "execute", wraps=session.execute) as m: with patch.object(session, "execute", wraps=session.execute) as m:

0
cassandra/cqlengine/tests/model/__init__.py → tests/integration/cqlengine/model/__init__.py
View File

30
cassandra/cqlengine/tests/model/test_class_construction.py → tests/integration/cqlengine/model/test_class_construction.py
View File

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

10
cassandra/cqlengine/tests/model/test_equality_operations.py → tests/integration/cqlengine/model/test_equality_operations.py
View File

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

4
cassandra/cqlengine/tests/model/test_model.py → tests/integration/cqlengine/model/test_model.py
View File

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

12
cassandra/cqlengine/tests/model/test_model_io.py → tests/integration/cqlengine/model/test_model_io.py
View File

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

10
cassandra/cqlengine/tests/model/test_polymorphism.py → tests/integration/cqlengine/model/test_polymorphism.py
View File

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

10
cassandra/cqlengine/tests/model/test_updates.py → tests/integration/cqlengine/model/test_updates.py
View File

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

0
cassandra/cqlengine/tests/model/test_validation.py → tests/integration/cqlengine/model/test_validation.py
View File

10
cassandra/cqlengine/tests/model/test_value_lists.py → tests/integration/cqlengine/model/test_value_lists.py
View File

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

0
cassandra/cqlengine/tests/operators/__init__.py → tests/integration/cqlengine/operators/__init__.py
View File

0
cassandra/cqlengine/tests/operators/test_assignment_operators.py → tests/integration/cqlengine/operators/test_assignment_operators.py
View File

2
cassandra/cqlengine/tests/operators/test_base_operator.py → tests/integration/cqlengine/operators/test_base_operator.py
View File

@@ -1,5 +1,5 @@
from unittest import TestCase from unittest import TestCase
from cqlengine.operators import BaseQueryOperator, QueryOperatorException from cassandra.cqlengine.operators import BaseQueryOperator, QueryOperatorException
class BaseOperatorTest(TestCase): class BaseOperatorTest(TestCase):

2
cassandra/cqlengine/tests/operators/test_where_operators.py → tests/integration/cqlengine/operators/test_where_operators.py
View File

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

0
cassandra/cqlengine/tests/query/__init__.py → tests/integration/cqlengine/query/__init__.py
View File

18
cassandra/cqlengine/tests/query/test_batch_query.py → tests/integration/cqlengine/query/test_batch_query.py
View File

@@ -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 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): class TestMultiKeyModel(Model):

14
cassandra/cqlengine/tests/query/test_datetime_queries.py → tests/integration/cqlengine/query/test_datetime_queries.py
View File

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

15
cassandra/cqlengine/tests/query/test_named.py → tests/integration/cqlengine/query/test_named.py
View File

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

21
cassandra/cqlengine/tests/query/test_queryoperators.py → tests/integration/cqlengine/query/test_queryoperators.py
View File

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

22
cassandra/cqlengine/tests/query/test_queryset.py → tests/integration/cqlengine/query/test_queryset.py
View File

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

12
cassandra/cqlengine/tests/query/test_updates.py → tests/integration/cqlengine/query/test_updates.py
View File

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

0
cassandra/cqlengine/tests/statements/__init__.py → tests/integration/cqlengine/statements/__init__.py
View File

2
cassandra/cqlengine/tests/statements/test_assignment_clauses.py → tests/integration/cqlengine/statements/test_assignment_clauses.py
View File

@@ -1,5 +1,5 @@
from unittest import TestCase 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): class AssignmentClauseTests(TestCase):

2
cassandra/cqlengine/tests/statements/test_assignment_statement.py → tests/integration/cqlengine/statements/test_assignment_statement.py
View File

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

2
cassandra/cqlengine/tests/statements/test_base_clause.py → tests/integration/cqlengine/statements/test_base_clause.py
View File

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

2
cassandra/cqlengine/tests/statements/test_base_statement.py → tests/integration/cqlengine/statements/test_base_statement.py
View File

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

4
cassandra/cqlengine/tests/statements/test_delete_statement.py → tests/integration/cqlengine/statements/test_delete_statement.py
View File

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

2
cassandra/cqlengine/tests/statements/test_insert_statement.py → tests/integration/cqlengine/statements/test_insert_statement.py
View File

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

0
cassandra/cqlengine/tests/statements/test_quoter.py → tests/integration/cqlengine/statements/test_quoter.py
View File

4
cassandra/cqlengine/tests/statements/test_select_statement.py → tests/integration/cqlengine/statements/test_select_statement.py
View File

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

6
cassandra/cqlengine/tests/statements/test_update_statement.py → tests/integration/cqlengine/statements/test_update_statement.py
View File

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

4
cassandra/cqlengine/tests/statements/test_where_clause.py → tests/integration/cqlengine/statements/test_where_clause.py
View File

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

14
cassandra/cqlengine/tests/test_batch_query.py → tests/integration/cqlengine/test_batch_query.py
View File

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

39
cassandra/cqlengine/tests/test_consistency.py → tests/integration/cqlengine/test_consistency.py
View File

@@ -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 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): class TestConsistencyModel(Model):
@@ -28,15 +31,15 @@ class BaseConsistencyTest(BaseCassEngTestCase):
class TestConsistency(BaseConsistencyTest): class TestConsistency(BaseConsistencyTest):
def test_create_uses_consistency(self): def test_create_uses_consistency(self):
qs = TestConsistencyModel.consistency(ALL) qs = TestConsistencyModel.consistency(CL.ALL)
with mock.patch.object(self.session, 'execute') as m: with mock.patch.object(self.session, 'execute') as m:
qs.create(text="i am not fault tolerant this way") qs.create(text="i am not fault tolerant this way")
args = m.call_args 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): 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)) self.assertTrue(isinstance(qs, TestConsistencyModel.__queryset__), type(qs))
def test_update_uses_consistency(self): def test_update_uses_consistency(self):
@@ -44,10 +47,10 @@ class TestConsistency(BaseConsistencyTest):
t.text = "ham sandwich" t.text = "ham sandwich"
with mock.patch.object(self.session, 'execute') as m: with mock.patch.object(self.session, 'execute') as m:
t.consistency(ALL).save() t.consistency(CL.ALL).save()
args = m.call_args 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): def test_batch_consistency(self):
@@ -58,14 +61,14 @@ class TestConsistency(BaseConsistencyTest):
args = m.call_args 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 mock.patch.object(self.session, 'execute') as m:
with BatchQuery() as b: with BatchQuery() as b:
TestConsistencyModel.batch(b).create(text="monkey") TestConsistencyModel.batch(b).create(text="monkey")
args = m.call_args 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): def test_blind_update(self):
t = TestConsistencyModel.create(text="bacon and eggs") t = TestConsistencyModel.create(text="bacon and eggs")
@@ -73,10 +76,10 @@ class TestConsistency(BaseConsistencyTest):
uid = t.id uid = t.id
with mock.patch.object(self.session, 'execute') as m: 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 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): def test_delete(self):
@@ -86,10 +89,10 @@ class TestConsistency(BaseConsistencyTest):
uid = t.id uid = t.id
with mock.patch.object(self.session, 'execute') as m: 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: 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 args = m.call_args
self.assertEqual(ALL, args[0][0].consistency_level) self.assertEqual(CL.ALL, args[0][0].consistency_level)

18
cassandra/cqlengine/tests/test_ifnotexists.py → tests/integration/cqlengine/test_ifnotexists.py
View File

@@ -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 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): class TestIfNotExistsModel(Model):

19
cassandra/cqlengine/tests/test_load.py → tests/integration/cqlengine/test_load.py
View File

@@ -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 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): class LoadTest(Model):
k = columns.Integer(primary_key=True)
k = Integer(primary_key=True) v = columns.Integer()
v = Integer()
@skipUnless("LOADTEST" in os.environ, "LOADTEST not on") @skipUnless("LOADTEST" in os.environ, "LOADTEST not on")

15
cassandra/cqlengine/tests/test_timestamp.py → tests/integration/cqlengine/test_timestamp.py
View File

@@ -1,14 +1,13 @@
"""
Tests surrounding the blah.timestamp( timedelta(seconds=30) ) format.
"""
from datetime import timedelta, datetime from datetime import timedelta, datetime
from uuid import uuid4
import mock import mock
import sure import sure
from cqlengine import Model, columns, BatchQuery from uuid import uuid4
from cqlengine.management import sync_table
from cqlengine.tests.base import BaseCassEngTestCase 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): class TestTimestampModel(Model):

25
cassandra/cqlengine/tests/test_transaction.py → tests/integration/cqlengine/test_transaction.py
View File

@@ -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 import mock
from cqlengine import ALL, BatchQuery
from cqlengine.statements import TransactionClause
import six 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): class TestTransactionModel(Model):
id = columns.UUID(primary_key=True, default=lambda:uuid4()) id = columns.UUID(primary_key=True, default=lambda:uuid4())
@@ -20,7 +19,7 @@ class TestTransactionModel(Model):
text = columns.Text(required=False) 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): class TestTransaction(BaseCassEngTestCase):
@classmethod @classmethod

10
cassandra/cqlengine/tests/test_ttl.py → tests/integration/cqlengine/test_ttl.py
View File

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