def __init__(self, builder, consumer=None):
self._client = builder.client
self._base_url = str(builder.base_url)
self._converters = list(builder.converters)
self._auth = builder.auth
self._consumer = consumer
if builder.hooks:
self._session_chain = hooks_.TransactionHookChain(*builder.hooks)
else:
self._session_chain = None
def test_delegate_handle_exception(self, transaction_hook_mock):
class CustomException(Exception):
pass
err = CustomException()
chain = hooks.TransactionHookChain(transaction_hook_mock)
with pytest.raises(CustomException):
chain.handle_exception(None, CustomException, err, None)
transaction_hook_mock.handle_exception.assert_called_with(
None, CustomException, err, None)
def prepare_request(self, request_builder, execution_builder):
self._auth(request_builder)
request_hooks = self._get_request_hooks(request_builder)
if request_hooks:
chain = hooks_.TransactionHookChain(*request_hooks)
chain.audit_request(self._consumer, request_builder)
self.apply_hooks(execution_builder, chain)
if self._session_chain:
self.apply_hooks(execution_builder, self._session_chain)
execution_builder.with_client(self._client)
execution_builder.with_io(self._client.io())
execution_builder.with_template(request_builder.request_template)
def test_delegate_handle_response_multiple(self, mocker):
# Include one hook that can't handle responses
mock_response_handler = mocker.Mock()
mock_request_auditor = mocker.Mock()
chain = hooks.TransactionHookChain(
hooks.RequestAuditor(mock_request_auditor),
hooks.ResponseHandler(mock_response_handler),
hooks.ResponseHandler(mock_response_handler),
)
chain.handle_response("consumer", {})
assert mock_response_handler.call_count == 2
assert mock_request_auditor.call_count == 0
def apply_hooks(self, chain, request_builder, sender):
hook = hooks_.TransactionHookChain(*chain)
hook.audit_request(self._consumer, request_builder)
if hook.handle_response is not None:
sender.add_callback(self._wrap_hook(hook.handle_response))
sender.add_exception_handler(self._wrap_hook(hook.handle_exception))
def test_delegate_handle_response(self, transaction_hook_mock):
chain = hooks.TransactionHookChain(transaction_hook_mock)
chain.handle_response("consumer", {})
transaction_hook_mock.handle_response.assert_called_with(
"consumer", {})
def test_delegate_audit_request(self, transaction_hook_mock):
chain = hooks.TransactionHookChain(transaction_hook_mock)
chain.audit_request("consumer", "request")
transaction_hook_mock.audit_request.assert_called_with(
"consumer", "request")
def test_delegate_handle_exception(self, transaction_hook_mock):
chain = hooks.TransactionHookChain(transaction_hook_mock)
chain.handle_exception(None, None, None)
transaction_hook_mock.handle_exception.assert_called_with(
None, None, None)
def test_delegate_handle_response_multiple(self, transaction_hook_mock):
chain = hooks.TransactionHookChain(transaction_hook_mock,
transaction_hook_mock)
chain.handle_response({})
transaction_hook_mock.call_count == 2
def test_delegate_audit_request(self, transaction_hook_mock):
chain = hooks.TransactionHookChain(transaction_hook_mock)
chain.audit_request("method", "url", {})
transaction_hook_mock.audit_request.assert_called_with(
"method", "url", {})
def apply_hooks(chain, request_builder, sender):
hook = hooks_.TransactionHookChain(*chain)
hook.audit_request(request_builder)
if hook.handle_response is not None:
sender.add_callback(hook.handle_response)
sender.add_exception_handler(hook.handle_exception)
