moved compaction settings to it's own test module

cqlengine/management.py

@@ -1,6 +1,7 @@
 import json
 import warnings
 from cqlengine import SizeTieredCompactionStrategy, LeveledCompactionStrategy
+from cqlengine.named import NamedTable
 
 from cqlengine.connection import connection_manager, execute
 from cqlengine.exceptions import CQLEngineException
@@ -12,6 +13,10 @@ Field = namedtuple('Field', ['name', 'type'])
 logger = logging.getLogger(__name__)
 
 
+# system keyspaces
+schema_columnfamilies = NamedTable('system', 'schema_columnfamilies')
+
+
 def create_keyspace(name, strategy_class='SimpleStrategy', replication_factor=3, durable_writes=True, **replication_values):
     """
     creates a keyspace
@@ -98,6 +103,10 @@ def sync_table(model, create_missing_keyspace=True):
             logger.debug(query)
             execute(query)
 
+            update_compaction(model)
+            # update compaction
+
+
 
     #get existing index names, skip ones that already exist
     with connection_manager() as con:
@@ -217,18 +226,16 @@ def get_fields(model):
     return [Field(x[0], x[1]) for x in tmp.results]
     # convert to Field named tuples
 
-def get_compaction_settings(model):
-    # returns a dictionary of compaction settings in an existing table
+
+def update_compaction(model):
     ks_name = model._get_keyspace()
     col_family = model.column_family_name(include_keyspace=False)
-    with connection_manager() as con:
-        query = "SELECT , validator FROM system.schema_columns \
-                 WHERE keyspace_name = :ks_name AND columnfamily_name = :col_family"
 
-        logger.debug("get_fields %s %s", ks_name, col_family)
+    row = schema_columnfamilies.get(keyspace_name=ks_name,
+                                    columnfamily_name=col_family)
+    # check compaction_strategy_class
+    # check compaction_strategy_options
 
-        tmp = con.execute(query, {'ks_name':ks_name, 'col_family':col_family})
-    import ipdb; ipdb.set_trace()
 
 
 def delete_table(model):

cqlengine/tests/management/test_compaction_settings.py

@@ -0,0 +1,104 @@
+import copy
+from mock import patch
+from cqlengine import Model, columns, SizeTieredCompactionStrategy, LeveledCompactionStrategy
+from cqlengine.exceptions import CQLEngineException
+from cqlengine.management import get_compaction_options, drop_table, sync_table
+from cqlengine.tests.base import BaseCassEngTestCase
+
+
+class CompactionModel(Model):
+    __compaction__ = None
+    cid = columns.UUID(primary_key=True)
+    name = columns.Text()
+
+
+class BaseCompactionTest(BaseCassEngTestCase):
+    def assert_option_fails(self, key):
+        # key is a normal_key, converted to
+        # __compaction_key__
+
+        key = "__compaction_{}__".format(key)
+
+        with patch.object(self.model, key, 10), \
+             self.assertRaises(CQLEngineException):
+            get_compaction_options(self.model)
+
+
+class SizeTieredCompactionTest(BaseCompactionTest):
+
+    def setUp(self):
+        self.model = copy.deepcopy(CompactionModel)
+        self.model.__compaction__ = SizeTieredCompactionStrategy
+
+    def test_size_tiered(self):
+        result = get_compaction_options(self.model)
+        assert result['class'] == SizeTieredCompactionStrategy
+
+    def test_min_threshold(self):
+        self.model.__compaction_min_threshold__ = 2
+        result = get_compaction_options(self.model)
+        assert result['min_threshold'] == 2
+
+
+class LeveledCompactionTest(BaseCompactionTest):
+    def setUp(self):
+        self.model = copy.deepcopy(CompactionLeveledStrategyModel)
+
+    def test_simple_leveled(self):
+        result = get_compaction_options(self.model)
+        assert result['class'] == LeveledCompactionStrategy
+
+    def test_bucket_high_fails(self):
+        self.assert_option_fails('bucket_high')
+
+    def test_bucket_low_fails(self):
+        self.assert_option_fails('bucket_low')
+
+    def test_max_threshold_fails(self):
+        self.assert_option_fails('max_threshold')
+
+    def test_min_threshold_fails(self):
+        self.assert_option_fails('min_threshold')
+
+    def test_min_sstable_size_fails(self):
+        self.assert_option_fails('min_sstable_size')
+
+    def test_sstable_size_in_mb(self):
+        with patch.object(self.model, '__compaction_sstable_size_in_mb__', 32):
+            result = get_compaction_options(self.model)
+
+        assert result['sstable_size_in_mb'] == 32
+
+    def test_create_table(self):
+        class LeveledcompactionTestTable(Model):
+            __compaction__ = LeveledCompactionStrategy
+            __compaction_sstable_size_in_mb__ = 64
+            user_id = columns.UUID(primary_key=True)
+            name = columns.Text()
+
+        drop_table(LeveledcompactionTestTable)
+        sync_table(LeveledcompactionTestTable)
+
+        LeveledcompactionTestTable.__compaction__ = SizeTieredCompactionStrategy
+        LeveledcompactionTestTable.__compaction_sstable_size_in_mb__ = None
+
+        sync_table(LeveledcompactionTestTable)
+
+
+class EmptyCompactionTest(BaseCassEngTestCase):
+    def test_empty_compaction(self):
+        self.model = copy.deepcopy(CompactionModel)
+        result = get_compaction_options(self.model)
+        self.assertIsNone(result)
+
+
+class CompactionLeveledStrategyModel(Model):
+    __compaction__ = LeveledCompactionStrategy
+    cid = columns.UUID(primary_key=True)
+    name = columns.Text()
+
+
+class CompactionSizeTieredModel(Model):
+    __compaction__ = SizeTieredCompactionStrategy
+    cid = columns.UUID(primary_key=True)
+    name = columns.Text()

cqlengine/tests/management/test_management.py

@@ -1,11 +1,10 @@
-from cqlengine.exceptions import CQLEngineException
-from cqlengine.management import create_table, delete_table, get_fields, get_compaction_options, get_create_table, sync_table, drop_table
-from cqlengine.tests.base import BaseCassEngTestCase
-
-from cqlengine.connection import ConnectionPool, Host
-
 from mock import MagicMock, patch
-from cqlengine import management, SizeTieredCompactionStrategy, LeveledCompactionStrategy
+
+from cqlengine.exceptions import CQLEngineException
+from cqlengine.management import create_table, delete_table, get_fields
+from cqlengine.tests.base import BaseCassEngTestCase
+from cqlengine.connection import ConnectionPool, Host
+from cqlengine import management
 from cqlengine.tests.query.test_queryset import TestModel
 from cqlengine.models import Model
 from cqlengine import columns
@@ -141,97 +140,4 @@ class AddColumnTest(BaseCassEngTestCase):
         fields = get_fields(FirstModel)
         self.assertEqual(len(fields), 4)
 
-class CompactionModel(Model):
-    __compaction__ = None
-    cid = columns.UUID(primary_key=True)
-    name = columns.Text()
-
-class CompactionSizeTieredModel(Model):
-    __compaction__ = SizeTieredCompactionStrategy
-    cid = columns.UUID(primary_key=True)
-    name = columns.Text()
-
-class CompactionLeveledStrategyModel(Model):
-    __compaction__ = LeveledCompactionStrategy
-    cid = columns.UUID(primary_key=True)
-    name = columns.Text()
-
-import copy
-
-class EmptyCompactionTest(BaseCassEngTestCase):
-    def test_empty_compaction(self):
-        self.model = copy.deepcopy(CompactionModel)
-        result = get_compaction_options(self.model)
-        self.assertIsNone(result)
-
-class BaseCompactionTest(BaseCassEngTestCase):
-    def assert_option_fails(self, key):
-        # key is a normal_key, converted to
-        # __compaction_key__
-
-        key = "__compaction_{}__".format(key)
-
-        with patch.object(self.model, key, 10), \
-             self.assertRaises(CQLEngineException):
-            get_compaction_options(self.model)
-
-class SizeTieredCompactionTest(BaseCompactionTest):
-
-    def setUp(self):
-        self.model = copy.deepcopy(CompactionModel)
-        self.model.__compaction__ = SizeTieredCompactionStrategy
-
-    def test_size_tiered(self):
-        result = get_compaction_options(self.model)
-        assert result['class'] == SizeTieredCompactionStrategy
-
-    def test_min_threshold(self):
-        self.model.__compaction_min_threshold__ = 2
-        result = get_compaction_options(self.model)
-        assert result['min_threshold'] == 2
-
-class LeveledCompactionTest(BaseCompactionTest):
-    def setUp(self):
-        self.model = copy.deepcopy(CompactionLeveledStrategyModel)
-
-    def test_simple_leveled(self):
-        result = get_compaction_options(self.model)
-        assert result['class'] == LeveledCompactionStrategy
-
-    def test_bucket_high_fails(self):
-        self.assert_option_fails('bucket_high')
-
-    def test_bucket_low_fails(self):
-        self.assert_option_fails('bucket_low')
-
-    def test_max_threshold_fails(self):
-        self.assert_option_fails('max_threshold')
-
-    def test_min_threshold_fails(self):
-        self.assert_option_fails('min_threshold')
-
-    def test_min_sstable_size_fails(self):
-        self.assert_option_fails('min_sstable_size')
-
-    def test_sstable_size_in_mb(self):
-        with patch.object(self.model, '__compaction_sstable_size_in_mb__', 32):
-            result = get_compaction_options(self.model)
-
-        assert result['sstable_size_in_mb'] == 32
-
-    def test_create_table(self):
-        class LeveledcompactionTestTable(Model):
-            __compaction__ = LeveledCompactionStrategy
-            __compaction_sstable_size_in_mb__ = 64
-            user_id = columns.UUID(primary_key=True)
-            name = columns.Text()
-
-        drop_table(LeveledcompactionTestTable)
-        sync_table(LeveledcompactionTestTable)
-
-        LeveledcompactionTestTable.__compaction__ = SizeTieredCompactionStrategy
-        LeveledcompactionTestTable.__compaction_sstable_size_in_mb__ = None
-
-        sync_table(LeveledcompactionTestTable)
-