From 46985097277fd491c30f833bc4024b7deb9dac01 Mon Sep 17 00:00:00 2001 From: Adam Holmberg Date: Wed, 4 Feb 2015 11:56:19 -0600 Subject: [PATCH] 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 | 30 ------------- tests/integration/cqlengine/__init__.py | 13 ++++++ .../integration/cqlengine}/base.py | 12 +----- .../cqlengine}/columns/__init__.py | 0 .../columns/test_container_columns.py | 8 ++-- .../cqlengine}/columns/test_counter_column.py | 9 ++-- .../cqlengine}/columns/test_static_column.py | 22 +++++----- .../cqlengine}/columns/test_validation.py | 42 ++++++++----------- .../cqlengine}/columns/test_value_io.py | 12 +++--- .../cqlengine}/connections/__init__.py | 0 .../cqlengine}/management/__init__.py | 0 .../management/test_compaction_settings.py | 20 +++++---- .../cqlengine}/management/test_management.py | 39 ++++++++--------- .../integration/cqlengine}/model/__init__.py | 0 .../model/test_class_construction.py | 30 ++++++------- .../model/test_equality_operations.py | 10 ++--- .../cqlengine}/model/test_model.py | 4 +- .../cqlengine}/model/test_model_io.py | 12 +++--- .../cqlengine}/model/test_polymorphism.py | 10 ++--- .../cqlengine}/model/test_updates.py | 10 ++--- .../cqlengine}/model/test_validation.py | 0 .../cqlengine}/model/test_value_lists.py | 10 ++--- .../cqlengine}/operators/__init__.py | 0 .../operators/test_assignment_operators.py | 0 .../operators/test_base_operator.py | 4 +- .../operators/test_where_operators.py | 2 +- .../integration/cqlengine}/query/__init__.py | 0 .../cqlengine}/query/test_batch_query.py | 18 ++++---- .../cqlengine}/query/test_datetime_queries.py | 14 +++---- .../cqlengine}/query/test_named.py | 15 +++---- .../cqlengine}/query/test_queryoperators.py | 21 +++++----- .../cqlengine}/query/test_queryset.py | 22 +++++----- .../cqlengine}/query/test_updates.py | 12 +++--- .../cqlengine}/statements/__init__.py | 0 .../statements/test_assignment_clauses.py | 2 +- .../statements/test_assignment_statement.py | 4 +- .../cqlengine}/statements/test_base_clause.py | 2 +- .../statements/test_base_statement.py | 2 +- .../statements/test_delete_statement.py | 4 +- .../statements/test_insert_statement.py | 2 +- .../cqlengine}/statements/test_quoter.py | 0 .../statements/test_select_statement.py | 4 +- .../statements/test_update_statement.py | 6 +-- .../statements/test_where_clause.py | 4 +- .../cqlengine}/test_batch_query.py | 14 +++---- .../cqlengine}/test_consistency.py | 39 +++++++++-------- .../cqlengine}/test_ifnotexists.py | 18 ++++---- .../integration/cqlengine}/test_load.py | 19 ++++----- .../integration/cqlengine}/test_timestamp.py | 15 ++++--- .../cqlengine}/test_transaction.py | 25 ++++++----- .../integration/cqlengine}/test_ttl.py | 10 ++--- 51 files changed, 268 insertions(+), 303 deletions(-) delete mode 100644 cassandra/cqlengine/tests/__init__.py create mode 100644 tests/integration/cqlengine/__init__.py rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/base.py (70%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/columns/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/columns/test_container_columns.py (98%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/columns/test_counter_column.py (92%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/columns/test_static_column.py (77%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/columns/test_validation.py (92%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/columns/test_value_io.py (93%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/connections/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/management/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/management/test_compaction_settings.py (92%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/management/test_management.py (89%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_class_construction.py (93%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_equality_operations.py (84%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_model.py (93%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_model_io.py (96%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_polymorphism.py (96%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_updates.py (91%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_validation.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/model/test_value_lists.py (86%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/operators/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/operators/test_assignment_operators.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/operators/test_base_operator.py (58%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/operators/test_where_operators.py (96%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/test_batch_query.py (94%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/test_datetime_queries.py (81%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/test_named.py (95%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/test_queryoperators.py (86%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/test_queryset.py (98%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/query/test_updates.py (96%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/__init__.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_assignment_clauses.py (98%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_assignment_statement.py (69%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_base_clause.py (84%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_base_statement.py (80%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_delete_statement.py (94%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_insert_statement.py (93%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_quoter.py (100%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_select_statement.py (96%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_update_statement.py (95%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/statements/test_where_clause.py (86%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_batch_query.py (95%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_consistency.py (67%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_ifnotexists.py (94%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_load.py (70%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_timestamp.py (95%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_transaction.py (85%) rename {cassandra/cqlengine/tests => tests/integration/cqlengine}/test_ttl.py (94%) diff --git a/cassandra/cqlengine/tests/__init__.py b/cassandra/cqlengine/tests/__init__.py deleted file mode 100644 index e03842d3..00000000 --- a/cassandra/cqlengine/tests/__init__.py +++ /dev/null @@ -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") diff --git a/tests/integration/cqlengine/__init__.py b/tests/integration/cqlengine/__init__.py new file mode 100644 index 00000000..8fa5480e --- /dev/null +++ b/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") diff --git a/cassandra/cqlengine/tests/base.py b/tests/integration/cqlengine/base.py similarity index 70% rename from cassandra/cqlengine/tests/base.py rename to tests/integration/cqlengine/base.py index 5bd66b64..ea3f0b59 100644 --- a/cassandra/cqlengine/tests/base.py +++ b/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): diff --git a/cassandra/cqlengine/tests/columns/__init__.py b/tests/integration/cqlengine/columns/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/columns/__init__.py rename to tests/integration/cqlengine/columns/__init__.py diff --git a/cassandra/cqlengine/tests/columns/test_container_columns.py b/tests/integration/cqlengine/columns/test_container_columns.py similarity index 98% rename from cassandra/cqlengine/tests/columns/test_container_columns.py rename to tests/integration/cqlengine/columns/test_container_columns.py index f8c0db59..4de46c15 100644 --- a/cassandra/cqlengine/tests/columns/test_container_columns.py +++ b/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): diff --git a/cassandra/cqlengine/tests/columns/test_counter_column.py b/tests/integration/cqlengine/columns/test_counter_column.py similarity index 92% rename from cassandra/cqlengine/tests/columns/test_counter_column.py rename to tests/integration/cqlengine/columns/test_counter_column.py index 964cacb8..074f7e52 100644 --- a/cassandra/cqlengine/tests/columns/test_counter_column.py +++ b/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): diff --git a/cassandra/cqlengine/tests/columns/test_static_column.py b/tests/integration/cqlengine/columns/test_static_column.py similarity index 77% rename from cassandra/cqlengine/tests/columns/test_static_column.py rename to tests/integration/cqlengine/columns/test_static_column.py index d7e6dc9b..d3f537f2 100644 --- a/cassandra/cqlengine/tests/columns/test_static_column.py +++ b/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") diff --git a/cassandra/cqlengine/tests/columns/test_validation.py b/tests/integration/cqlengine/columns/test_validation.py similarity index 92% rename from cassandra/cqlengine/tests/columns/test_validation.py rename to tests/integration/cqlengine/columns/test_validation.py index a4a939e8..d1dd90cc 100644 --- a/cassandra/cqlengine/tests/columns/test_validation.py +++ b/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): diff --git a/cassandra/cqlengine/tests/columns/test_value_io.py b/tests/integration/cqlengine/columns/test_value_io.py similarity index 93% rename from cassandra/cqlengine/tests/columns/test_value_io.py rename to tests/integration/cqlengine/columns/test_value_io.py index d3b589f0..16e34bf2 100644 --- a/cassandra/cqlengine/tests/columns/test_value_io.py +++ b/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 diff --git a/cassandra/cqlengine/tests/connections/__init__.py b/tests/integration/cqlengine/connections/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/connections/__init__.py rename to tests/integration/cqlengine/connections/__init__.py diff --git a/cassandra/cqlengine/tests/management/__init__.py b/tests/integration/cqlengine/management/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/management/__init__.py rename to tests/integration/cqlengine/management/__init__.py diff --git a/cassandra/cqlengine/tests/management/test_compaction_settings.py b/tests/integration/cqlengine/management/test_compaction_settings.py similarity index 92% rename from cassandra/cqlengine/tests/management/test_compaction_settings.py rename to tests/integration/cqlengine/management/test_compaction_settings.py index 9607334e..5358a4aa 100644 --- a/cassandra/cqlengine/tests/management/test_compaction_settings.py +++ b/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): diff --git a/cassandra/cqlengine/tests/management/test_management.py b/tests/integration/cqlengine/management/test_management.py similarity index 89% rename from cassandra/cqlengine/tests/management/test_management.py rename to tests/integration/cqlengine/management/test_management.py index 5dae9ff1..3359547a 100644 --- a/cassandra/cqlengine/tests/management/test_management.py +++ b/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: diff --git a/cassandra/cqlengine/tests/model/__init__.py b/tests/integration/cqlengine/model/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/model/__init__.py rename to tests/integration/cqlengine/model/__init__.py diff --git a/cassandra/cqlengine/tests/model/test_class_construction.py b/tests/integration/cqlengine/model/test_class_construction.py similarity index 93% rename from cassandra/cqlengine/tests/model/test_class_construction.py rename to tests/integration/cqlengine/model/test_class_construction.py index 7616d79c..977240b1 100644 --- a/cassandra/cqlengine/tests/model/test_class_construction.py +++ b/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) diff --git a/cassandra/cqlengine/tests/model/test_equality_operations.py b/tests/integration/cqlengine/model/test_equality_operations.py similarity index 84% rename from cassandra/cqlengine/tests/model/test_equality_operations.py rename to tests/integration/cqlengine/model/test_equality_operations.py index 84855ad8..b5e89ce1 100644 --- a/cassandra/cqlengine/tests/model/test_equality_operations.py +++ b/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): diff --git a/cassandra/cqlengine/tests/model/test_model.py b/tests/integration/cqlengine/model/test_model.py similarity index 93% rename from cassandra/cqlengine/tests/model/test_model.py rename to tests/integration/cqlengine/model/test_model.py index 592ff4b8..4b11ebb3 100644 --- a/cassandra/cqlengine/tests/model/test_model.py +++ b/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): diff --git a/cassandra/cqlengine/tests/model/test_model_io.py b/tests/integration/cqlengine/model/test_model_io.py similarity index 96% rename from cassandra/cqlengine/tests/model/test_model_io.py rename to tests/integration/cqlengine/model/test_model_io.py index e15c5c43..51cac3c5 100644 --- a/cassandra/cqlengine/tests/model/test_model_io.py +++ b/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): diff --git a/cassandra/cqlengine/tests/model/test_polymorphism.py b/tests/integration/cqlengine/model/test_polymorphism.py similarity index 96% rename from cassandra/cqlengine/tests/model/test_polymorphism.py rename to tests/integration/cqlengine/model/test_polymorphism.py index 42626909..c569d48d 100644 --- a/cassandra/cqlengine/tests/model/test_polymorphism.py +++ b/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): diff --git a/cassandra/cqlengine/tests/model/test_updates.py b/tests/integration/cqlengine/model/test_updates.py similarity index 91% rename from cassandra/cqlengine/tests/model/test_updates.py rename to tests/integration/cqlengine/model/test_updates.py index 77f64f72..eecad304 100644 --- a/cassandra/cqlengine/tests/model/test_updates.py +++ b/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): diff --git a/cassandra/cqlengine/tests/model/test_validation.py b/tests/integration/cqlengine/model/test_validation.py similarity index 100% rename from cassandra/cqlengine/tests/model/test_validation.py rename to tests/integration/cqlengine/model/test_validation.py diff --git a/cassandra/cqlengine/tests/model/test_value_lists.py b/tests/integration/cqlengine/model/test_value_lists.py similarity index 86% rename from cassandra/cqlengine/tests/model/test_value_lists.py rename to tests/integration/cqlengine/model/test_value_lists.py index 1b17d784..893b7d96 100644 --- a/cassandra/cqlengine/tests/model/test_value_lists.py +++ b/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): diff --git a/cassandra/cqlengine/tests/operators/__init__.py b/tests/integration/cqlengine/operators/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/operators/__init__.py rename to tests/integration/cqlengine/operators/__init__.py diff --git a/cassandra/cqlengine/tests/operators/test_assignment_operators.py b/tests/integration/cqlengine/operators/test_assignment_operators.py similarity index 100% rename from cassandra/cqlengine/tests/operators/test_assignment_operators.py rename to tests/integration/cqlengine/operators/test_assignment_operators.py diff --git a/cassandra/cqlengine/tests/operators/test_base_operator.py b/tests/integration/cqlengine/operators/test_base_operator.py similarity index 58% rename from cassandra/cqlengine/tests/operators/test_base_operator.py rename to tests/integration/cqlengine/operators/test_base_operator.py index af13fdb1..cb929350 100644 --- a/cassandra/cqlengine/tests/operators/test_base_operator.py +++ b/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('*') \ No newline at end of file + BaseQueryOperator.get_operator('*') diff --git a/cassandra/cqlengine/tests/operators/test_where_operators.py b/tests/integration/cqlengine/operators/test_where_operators.py similarity index 96% rename from cassandra/cqlengine/tests/operators/test_where_operators.py rename to tests/integration/cqlengine/operators/test_where_operators.py index a73454c6..5a241eff 100644 --- a/cassandra/cqlengine/tests/operators/test_where_operators.py +++ b/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 diff --git a/cassandra/cqlengine/tests/query/__init__.py b/tests/integration/cqlengine/query/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/query/__init__.py rename to tests/integration/cqlengine/query/__init__.py diff --git a/cassandra/cqlengine/tests/query/test_batch_query.py b/tests/integration/cqlengine/query/test_batch_query.py similarity index 94% rename from cassandra/cqlengine/tests/query/test_batch_query.py rename to tests/integration/cqlengine/query/test_batch_query.py index 3875375f..93b37fb0 100644 --- a/cassandra/cqlengine/tests/query/test_batch_query.py +++ b/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): diff --git a/cassandra/cqlengine/tests/query/test_datetime_queries.py b/tests/integration/cqlengine/query/test_datetime_queries.py similarity index 81% rename from cassandra/cqlengine/tests/query/test_datetime_queries.py rename to tests/integration/cqlengine/query/test_datetime_queries.py index 704e55e3..8e0ccbdf 100644 --- a/cassandra/cqlengine/tests/query/test_datetime_queries.py +++ b/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): diff --git a/cassandra/cqlengine/tests/query/test_named.py b/tests/integration/cqlengine/query/test_named.py similarity index 95% rename from cassandra/cqlengine/tests/query/test_named.py rename to tests/integration/cqlengine/query/test_named.py index 7e0ccc3d..a5f31c55 100644 --- a/cassandra/cqlengine/tests/query/test_named.py +++ b/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) diff --git a/cassandra/cqlengine/tests/query/test_queryoperators.py b/tests/integration/cqlengine/query/test_queryoperators.py similarity index 86% rename from cassandra/cqlengine/tests/query/test_queryoperators.py rename to tests/integration/cqlengine/query/test_queryoperators.py index 3facdd68..7e252209 100644 --- a/cassandra/cqlengine/tests/query/test_queryoperators.py +++ b/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): diff --git a/cassandra/cqlengine/tests/query/test_queryset.py b/tests/integration/cqlengine/query/test_queryset.py similarity index 98% rename from cassandra/cqlengine/tests/query/test_queryset.py rename to tests/integration/cqlengine/query/test_queryset.py index 441d6e21..240b414a 100644 --- a/cassandra/cqlengine/tests/query/test_queryset.py +++ b/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): diff --git a/cassandra/cqlengine/tests/query/test_updates.py b/tests/integration/cqlengine/query/test_updates.py similarity index 96% rename from cassandra/cqlengine/tests/query/test_updates.py rename to tests/integration/cqlengine/query/test_updates.py index 97fb7e32..714d6419 100644 --- a/cassandra/cqlengine/tests/query/test_updates.py +++ b/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): diff --git a/cassandra/cqlengine/tests/statements/__init__.py b/tests/integration/cqlengine/statements/__init__.py similarity index 100% rename from cassandra/cqlengine/tests/statements/__init__.py rename to tests/integration/cqlengine/statements/__init__.py diff --git a/cassandra/cqlengine/tests/statements/test_assignment_clauses.py b/tests/integration/cqlengine/statements/test_assignment_clauses.py similarity index 98% rename from cassandra/cqlengine/tests/statements/test_assignment_clauses.py rename to tests/integration/cqlengine/statements/test_assignment_clauses.py index 982688a0..aea3b813 100644 --- a/cassandra/cqlengine/tests/statements/test_assignment_clauses.py +++ b/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): diff --git a/cassandra/cqlengine/tests/statements/test_assignment_statement.py b/tests/integration/cqlengine/statements/test_assignment_statement.py similarity index 69% rename from cassandra/cqlengine/tests/statements/test_assignment_statement.py rename to tests/integration/cqlengine/statements/test_assignment_statement.py index 695c7ceb..c33e2177 100644 --- a/cassandra/cqlengine/tests/statements/test_assignment_statement.py +++ b/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') \ No newline at end of file + stmt.add_assignment_clause('x=5') diff --git a/cassandra/cqlengine/tests/statements/test_base_clause.py b/tests/integration/cqlengine/statements/test_base_clause.py similarity index 84% rename from cassandra/cqlengine/tests/statements/test_base_clause.py rename to tests/integration/cqlengine/statements/test_base_clause.py index c5bbeb40..969757a0 100644 --- a/cassandra/cqlengine/tests/statements/test_base_clause.py +++ b/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): diff --git a/cassandra/cqlengine/tests/statements/test_base_statement.py b/tests/integration/cqlengine/statements/test_base_statement.py similarity index 80% rename from cassandra/cqlengine/tests/statements/test_base_statement.py rename to tests/integration/cqlengine/statements/test_base_statement.py index 4acc1b92..f0b1793a 100644 --- a/cassandra/cqlengine/tests/statements/test_base_statement.py +++ b/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): diff --git a/cassandra/cqlengine/tests/statements/test_delete_statement.py b/tests/integration/cqlengine/statements/test_delete_statement.py similarity index 94% rename from cassandra/cqlengine/tests/statements/test_delete_statement.py rename to tests/integration/cqlengine/statements/test_delete_statement.py index e658784f..79b8a78f 100644 --- a/cassandra/cqlengine/tests/statements/test_delete_statement.py +++ b/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): diff --git a/cassandra/cqlengine/tests/statements/test_insert_statement.py b/tests/integration/cqlengine/statements/test_insert_statement.py similarity index 93% rename from cassandra/cqlengine/tests/statements/test_insert_statement.py rename to tests/integration/cqlengine/statements/test_insert_statement.py index 7a165cbf..a29bc9ba 100644 --- a/cassandra/cqlengine/tests/statements/test_insert_statement.py +++ b/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 diff --git a/cassandra/cqlengine/tests/statements/test_quoter.py b/tests/integration/cqlengine/statements/test_quoter.py similarity index 100% rename from cassandra/cqlengine/tests/statements/test_quoter.py rename to tests/integration/cqlengine/statements/test_quoter.py diff --git a/cassandra/cqlengine/tests/statements/test_select_statement.py b/tests/integration/cqlengine/statements/test_select_statement.py similarity index 96% rename from cassandra/cqlengine/tests/statements/test_select_statement.py rename to tests/integration/cqlengine/statements/test_select_statement.py index 62d6ce69..2f816519 100644 --- a/cassandra/cqlengine/tests/statements/test_select_statement.py +++ b/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): diff --git a/cassandra/cqlengine/tests/statements/test_update_statement.py b/tests/integration/cqlengine/statements/test_update_statement.py similarity index 95% rename from cassandra/cqlengine/tests/statements/test_update_statement.py rename to tests/integration/cqlengine/statements/test_update_statement.py index ab5aeec0..72b705d7 100644 --- a/cassandra/cqlengine/tests/statements/test_update_statement.py +++ b/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 diff --git a/cassandra/cqlengine/tests/statements/test_where_clause.py b/tests/integration/cqlengine/statements/test_where_clause.py similarity index 86% rename from cassandra/cqlengine/tests/statements/test_where_clause.py rename to tests/integration/cqlengine/statements/test_where_clause.py index cd3bcd6b..8ad71083 100644 --- a/cassandra/cqlengine/tests/statements/test_where_clause.py +++ b/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): diff --git a/cassandra/cqlengine/tests/test_batch_query.py b/tests/integration/cqlengine/test_batch_query.py similarity index 95% rename from cassandra/cqlengine/tests/test_batch_query.py rename to tests/integration/cqlengine/test_batch_query.py index 780dee53..cd53b7f8 100644 --- a/cassandra/cqlengine/tests/test_batch_query.py +++ b/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): diff --git a/cassandra/cqlengine/tests/test_consistency.py b/tests/integration/cqlengine/test_consistency.py similarity index 67% rename from cassandra/cqlengine/tests/test_consistency.py rename to tests/integration/cqlengine/test_consistency.py index 7438fccf..478e3c65 100644 --- a/cassandra/cqlengine/tests/test_consistency.py +++ b/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) diff --git a/cassandra/cqlengine/tests/test_ifnotexists.py b/tests/integration/cqlengine/test_ifnotexists.py similarity index 94% rename from cassandra/cqlengine/tests/test_ifnotexists.py rename to tests/integration/cqlengine/test_ifnotexists.py index dc175f87..c6402561 100644 --- a/cassandra/cqlengine/tests/test_ifnotexists.py +++ b/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): diff --git a/cassandra/cqlengine/tests/test_load.py b/tests/integration/cqlengine/test_load.py similarity index 70% rename from cassandra/cqlengine/tests/test_load.py rename to tests/integration/cqlengine/test_load.py index 3e784ac8..15c93d7a 100644 --- a/cassandra/cqlengine/tests/test_load.py +++ b/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") diff --git a/cassandra/cqlengine/tests/test_timestamp.py b/tests/integration/cqlengine/test_timestamp.py similarity index 95% rename from cassandra/cqlengine/tests/test_timestamp.py rename to tests/integration/cqlengine/test_timestamp.py index b1a6a286..eb7e6145 100644 --- a/cassandra/cqlengine/tests/test_timestamp.py +++ b/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): diff --git a/cassandra/cqlengine/tests/test_transaction.py b/tests/integration/cqlengine/test_transaction.py similarity index 85% rename from cassandra/cqlengine/tests/test_transaction.py rename to tests/integration/cqlengine/test_transaction.py index eacb3660..3b4fe686 100644 --- a/cassandra/cqlengine/tests/test_transaction.py +++ b/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 diff --git a/cassandra/cqlengine/tests/test_ttl.py b/tests/integration/cqlengine/test_ttl.py similarity index 94% rename from cassandra/cqlengine/tests/test_ttl.py rename to tests/integration/cqlengine/test_ttl.py index fc3cf57f..96c7d48e 100644 --- a/cassandra/cqlengine/tests/test_ttl.py +++ b/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):