def test_statement_params_override_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(),
*[object() for _ in range(3)])
cluster = Cluster(
execution_profiles={'non-default': non_default_profile})
session = Session(cluster,
hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
rf = session.execute_async("query", execution_profile='non-default')
ss = SimpleStatement("query",
retry_policy=DowngradingConsistencyRetryPolicy(),
consistency_level=ConsistencyLevel.ALL,
serial_consistency_level=ConsistencyLevel.SERIAL)
my_timeout = 1.1234
self.assertNotEqual(ss.retry_policy.__class__,
rf._load_balancer.__class__)
self.assertNotEqual(ss.consistency_level, rf.message.consistency_level)
self.assertNotEqual(ss._serial_consistency_level,
rf.message.serial_consistency_level)
self.assertNotEqual(my_timeout, rf.timeout)
rf = session.execute_async(ss,
timeout=my_timeout,
execution_profile='non-default')
expected_profile = ExecutionProfile(
non_default_profile.load_balancing_policy, ss.retry_policy,
ss.consistency_level, ss._serial_consistency_level, my_timeout,
non_default_profile.row_factory)
self._verify_response_future_profile(rf, expected_profile)
def test_default_serial_consistency_level(self, *_):
"""
Make sure default_serial_consistency_level passes through to a query message.
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)
sentinel = 1001
for cl in (None, ConsistencyLevel.LOCAL_SERIAL,
ConsistencyLevel.SERIAL, sentinel):
default_profile.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_profile_name_value(self):
internalized_profile = ExecutionProfile(RoundRobinPolicy(),
*[object() for _ in range(3)])
cluster = Cluster(execution_profiles={'by-name': internalized_profile})
session = Session(cluster,
hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
rf = session.execute_async("query", execution_profile='by-name')
self._verify_response_future_profile(rf, internalized_profile)
by_value = ExecutionProfile(RoundRobinPolicy(),
*[object() for _ in range(3)])
rf = session.execute_async("query", execution_profile=by_value)
self._verify_response_future_profile(rf, by_value)
def test_default_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(),
*[object() for _ in range(3)])
cluster = Cluster(
execution_profiles={'non-default': non_default_profile})
session = Session(cluster,
hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
default_profile = cluster.profile_manager.profiles[
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)