def test_add_callbacks(self):
session = self.make_session()
query = SimpleStatement("INSERT INFO foo (a, b) VALUES (1, 2)")
query.retry_policy = Mock()
query.retry_policy.on_unavailable.return_value = (RetryPolicy.RETHROW, None)
message = QueryMessage(query=query, consistency_level=ConsistencyLevel.ONE)
# test errback
rf = ResponseFuture(session, message, query, 1)
rf.send_request()
rf.add_callbacks(
callback=self.assertEqual, callback_args=([{'col': 'val'}],),
errback=self.assertIsInstance, errback_args=(Exception,))
result = Mock(spec=UnavailableErrorMessage, info={})
rf._set_result(result)
self.assertRaises(Exception, rf.result)
# test callback
rf = ResponseFuture(session, message, query, 1)
rf.send_request()
callback = Mock()
expected_result = [{'col': 'val'}]
arg = "positional"
kwargs = {'one': 1, 'two': 2}
rf.add_callbacks(
callback=callback, callback_args=(arg,), callback_kwargs=kwargs,
errback=self.assertIsInstance, errback_args=(Exception,))
rf._set_result(self.make_mock_response(expected_result))
self.assertEqual(rf.result(), expected_result)
callback.assert_called_once_with(expected_result, arg, **kwargs)
def test_add_callbacks(self):
session = self.make_session()
query = SimpleStatement("INSERT INFO foo (a, b) VALUES (1, 2)")
query.retry_policy = Mock()
query.retry_policy.on_unavailable.return_value = (RetryPolicy.RETHROW, None)
message = QueryMessage(query=query, consistency_level=ConsistencyLevel.ONE)
# test errback
rf = ResponseFuture(session, message, query)
rf.send_request()
rf.add_callbacks(
callback=self.assertEquals, callback_args=([{'col': 'val'}],),
errback=self.assertIsInstance, errback_args=(Exception,))
result = Mock(spec=UnavailableErrorMessage, info={})
rf._set_result(result)
self.assertRaises(Exception, rf.result)
# test callback
rf = ResponseFuture(session, message, query)
rf.send_request()
rf.add_callbacks(
callback=self.assertEquals, callback_args=([{'col': 'val'}],),
errback=self.assertIsInstance, errback_args=(Exception,))
response = Mock(spec=ResultMessage, kind=ResultMessage.KIND_ROWS, results=[{'col': 'val'}])
rf._set_result(response)
self.assertEqual(rf.result(), [{'col': 'val'}])
def test_retry_policy_says_ignore(self):
session = self.make_session()
query = SimpleStatement("INSERT INFO foo (a, b) VALUES (1, 2)")
query.retry_policy = Mock()
query.retry_policy.on_unavailable.return_value = (RetryPolicy.IGNORE, None)
message = QueryMessage(query=query, consistency_level=ConsistencyLevel.ONE)
rf = ResponseFuture(session, message, query)
rf.send_request()
result = Mock(spec=UnavailableErrorMessage, info={})
rf._set_result(result)
self.assertEqual(None, rf.result())
def test_add_callbacks(self):
session = self.make_session()
query = SimpleStatement("INSERT INFO foo (a, b) VALUES (1, 2)")
query.retry_policy = Mock()
query.retry_policy.on_unavailable.return_value = (RetryPolicy.RETHROW,
None)
message = QueryMessage(query=query,
consistency_level=ConsistencyLevel.ONE)
# test errback
rf = ResponseFuture(session, message, query, 1)
rf.send_request()
rf.add_callbacks(callback=self.assertEqual,
callback_args=([{
'col': 'val'
}], ),
errback=self.assertIsInstance,
errback_args=(Exception, ))
result = Mock(spec=UnavailableErrorMessage, info={})
rf._set_result(None, None, None, result)
self.assertRaises(Exception, rf.result)
# test callback
rf = ResponseFuture(session, message, query, 1)
rf.send_request()
callback = Mock()
expected_result = [{'col': 'val'}]
arg = "positional"
kwargs = {'one': 1, 'two': 2}
rf.add_callbacks(callback=callback,
callback_args=(arg, ),
callback_kwargs=kwargs,
errback=self.assertIsInstance,
errback_args=(Exception, ))
rf._set_result(None, None, None,
self.make_mock_response(expected_result))
self.assertEqual(rf.result(), expected_result)
callback.assert_called_once_with(expected_result, arg, **kwargs)
def wait_for_callbacks_result(self):
exc = None
try:
result = ResponseFuture.result(self)
except Exception as e:
exc = e
# wait for either _on_execute_complete or _on_execute_failed to run
wait_result = self._callback_event.wait(timeout=0.01)
if not wait_result:
logger.warning(
"Cassandra metrics callback took too long. Some metrics may be lost."
)
if exc:
raise exc # pylint: disable=E0702
return result
def test_add_callbacks(self):
session = self.make_session()
query = SimpleStatement("INSERT INFO foo (a, b) VALUES (1, 2)")
query.retry_policy = Mock()
query.retry_policy.on_unavailable.return_value = (RetryPolicy.RETHROW,
None)
message = QueryMessage(query=query,
consistency_level=ConsistencyLevel.ONE)
# test errback
rf = ResponseFuture(session, message, query)
rf.send_request()
rf.add_callbacks(callback=self.assertEquals,
callback_args=([{
'col': 'val'
}], ),
errback=self.assertIsInstance,
errback_args=(Exception, ))
result = Mock(spec=UnavailableErrorMessage, info={})
rf._set_result(result)
self.assertRaises(Exception, rf.result)
# test callback
rf = ResponseFuture(session, message, query)
rf.send_request()
rf.add_callbacks(callback=self.assertEquals,
callback_args=([{
'col': 'val'
}], ),
errback=self.assertIsInstance,
errback_args=(Exception, ))
response = Mock(spec=ResultMessage,
kind=ResultMessage.KIND_ROWS,
results=[{
'col': 'val'
}])
rf._set_result(response)
self.assertEqual(rf.result(), [{'col': 'val'}])
def get_async_result(self, future: ResponseFuture) -> ResultSet:
"""
Get the result of asynchronous CQL statement.
*Args:*\n
_future_ - object, returned as a result of keyword [#Execute Async Cql | Execute Async Cql]
*Returns:*\n
Result of asynchronous CQL statement.
*Example:*\n
| ${obj}= | Execute Async Cql | SELECT * FROM system.schema_keyspaces; |
| Sleep | 5 |
| ${result}= | Get Async Result | ${obj} |
| Log | ${result[1].keyspace_name} |
=>\n
system
"""
try:
result = future.result()
except Exception as e:
raise Exception('Operation failed: {0}'.format(e))
return result
