def test_exec_profile_clone(self):
cluster = Cluster(execution_profiles={EXEC_PROFILE_DEFAULT: ExecutionProfile(), 'one': ExecutionProfile()})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
profile_attrs = {'request_timeout': 1,
'consistency_level': ConsistencyLevel.ANY,
'serial_consistency_level': ConsistencyLevel.SERIAL,
'row_factory': tuple_factory,
'retry_policy': RetryPolicy(),
'load_balancing_policy': default_lbp_factory()}
reference_attributes = ('retry_policy', 'load_balancing_policy')
# default and one named
for profile in (EXEC_PROFILE_DEFAULT, 'one'):
active = session.get_execution_profile(profile)
clone = session.execution_profile_clone_update(profile)
self.assertIsNot(clone, active)
all_updated = session.execution_profile_clone_update(clone, **profile_attrs)
self.assertIsNot(all_updated, clone)
for attr, value in profile_attrs.items():
self.assertEqual(getattr(clone, attr), getattr(active, attr))
if attr in reference_attributes:
self.assertIs(getattr(clone, attr), getattr(active, attr))
self.assertNotEqual(getattr(all_updated, attr), getattr(active, attr))
# cannot clone nonexistent profile
self.assertRaises(ValueError, session.execution_profile_clone_update, 'DOES NOT EXIST', **profile_attrs)
def test_default_serial_consistency_level_ep(self, *_):
"""
Make sure default_serial_consistency_level passes through to a query message using execution profiles.
Also make sure Statement.serial_consistency_level overrides the default.
PR #510
"""
c = Cluster(protocol_version=4)
s = Session(c, [Host("127.0.0.1", SimpleConvictionPolicy)])
# default is None
default_profile = c.profile_manager.default
self.assertIsNone(default_profile.serial_consistency_level)
for cl in (None, ConsistencyLevel.LOCAL_SERIAL,
ConsistencyLevel.SERIAL):
s.get_execution_profile(
EXEC_PROFILE_DEFAULT).serial_consistency_level = cl
# default is passed through
f = s.execute_async(query='')
self.assertEqual(f.message.serial_consistency_level, cl)
# any non-None statement setting takes precedence
for cl_override in (ConsistencyLevel.LOCAL_SERIAL,
ConsistencyLevel.SERIAL):
f = s.execute_async(
SimpleStatement(query_string='',
serial_consistency_level=cl_override))
self.assertEqual(default_profile.serial_consistency_level, cl)
self.assertEqual(f.message.serial_consistency_level,
cl_override)
def test_default_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
cluster = Cluster(execution_profiles={'non-default': non_default_profile})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
default_profile = session.get_execution_profile(EXEC_PROFILE_DEFAULT)
rf = session.execute_async("query")
self._verify_response_future_profile(rf, default_profile)
rf = session.execute_async("query", execution_profile='non-default')
self._verify_response_future_profile(rf, non_default_profile)
for name, ep in six.iteritems(cluster.profile_manager.profiles):
self.assertEqual(ep, session.get_execution_profile(name))
# invalid ep
with self.assertRaises(ValueError):
session.get_execution_profile('non-existent')
