From a78e4ee54ffb592c92c938b4d82297ca5e2288bb Mon Sep 17 00:00:00 2001 From: Jon Haddad Date: Thu, 15 Aug 2013 18:54:56 -0700 Subject: [PATCH] moved compaction settings to it's own test module --- cqlengine/management.py | 23 ++-- .../management/test_compaction_settings.py | 104 +++++++++++++++++ cqlengine/tests/management/test_management.py | 106 +----------------- 3 files changed, 125 insertions(+), 108 deletions(-) create mode 100644 cqlengine/tests/management/test_compaction_settings.py diff --git a/cqlengine/management.py b/cqlengine/management.py index ddcbdaa2..0267a719 100644 --- a/cqlengine/management.py +++ b/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): diff --git a/cqlengine/tests/management/test_compaction_settings.py b/cqlengine/tests/management/test_compaction_settings.py new file mode 100644 index 00000000..6242be65 --- /dev/null +++ b/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() diff --git a/cqlengine/tests/management/test_management.py b/cqlengine/tests/management/test_management.py index 6f1a8337..88405b1e 100644 --- a/cqlengine/tests/management/test_management.py +++ b/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) -