def test_that_when_a_network_error_occurs_on_retrieving_multiple_messages_it_logs_them(
):
    mock_uploader = MagicMock()
    logger = logging.getLogger("awsmesh.forwarder")

    good_message = mock_mesh_message()
    forwarder = build_forwarder(
        list_message_ids=[
            "bad_message_id", good_message.id, "another_bad_message_id"
        ],
        retrieve_message=[
            mesh_client_network_error(), good_message,
            mesh_client_network_error()
        ],
        uploader=mock_uploader,
    )

    try:
        with patch.object(logger, "info") as mock_info:
            forwarder.forward_messages()
    except Exception:
        pass

    mock_uploader.upload.assert_called_once_with(good_message, mock.ANY)
    mock_info.assert_called_once_with(
        "Raising single retryable exception, actually caught 2 message exception(s)"
    )
def test_raises_retryable_exception_when_inbox_receive_message_raises_mesh_network_exception(
):
    forwarder = build_forwarder(list_message_ids=["some_id"],
                                retrieve_message=[mesh_client_network_error()])

    with pytest.raises(RetryableException):
        forwarder.forward_messages()
def test_raises_retryable_exception_when_inbox_list_message_ids_raises_mesh_network_exception(
):
    forwarder = build_forwarder(
        list_message_ids_error=mesh_client_network_error())

    with pytest.raises(RetryableException):
        forwarder.forward_messages()
def test_raises_retryable_exception_when_mesh_message_ack_raises_mesh_network_exception(
):
    mock_message = mock_mesh_message(
        acknowledge_error=mesh_client_network_error())
    forwarder = build_forwarder(list_message_ids=[mock_message.id],
                                retrieve_message=[mock_message])

    with pytest.raises(RetryableException):
        forwarder.forward_messages()
def test_records_mesh_error_when_counting_messages():
    probe = MagicMock()

    network_error = mesh_client_network_error("Network error")
    forwarder = build_forwarder(count_error=network_error, probe=probe)

    with pytest.raises(RetryableException):
        forwarder.is_mailbox_empty()

    probe.assert_has_calls([
        call.new_count_messages_event(),
        call.new_count_messages_event().record_mesh_client_network_error(
            network_error),
        call.new_count_messages_event().finish(),
    ])
def test_records_mesh_error_when_polling_messages():
    probe = MagicMock()
    poll_inbox_event = MagicMock()
    probe.new_poll_inbox_event.return_value = poll_inbox_event

    client_error = mesh_client_network_error()
    forwarder = build_forwarder(probe=probe,
                                list_message_ids_error=client_error)
    with pytest.raises(RetryableException):
        forwarder.forward_messages()

    poll_inbox_event.assert_has_calls(
        [call.record_mesh_client_network_error(client_error),
         call.finish()],
        any_order=False,
    )
def test_that_when_a_network_error_occurs_on_retrieving_a_message_it_continues_to_download_other_messages(
):
    mock_uploader = MagicMock()

    good_message = mock_mesh_message()
    forwarder = build_forwarder(
        list_message_ids=["bad_message_id", good_message.id],
        retrieve_message=[mesh_client_network_error(), good_message],
        uploader=mock_uploader,
    )

    try:
        forwarder.forward_messages()
    except Exception:
        pass

    mock_uploader.upload.assert_called_once_with(good_message, mock.ANY)
def test_records_error_when_mesh_message_ack_raises_mesh_network_exception():
    probe = MagicMock()
    forward_message_event = MagicMock()
    probe.new_forward_message_event.return_value = forward_message_event
    network_error = mesh_client_network_error("Network error")
    mock_message = mock_mesh_message(acknowledge_error=network_error, )

    forwarder = build_forwarder(list_message_ids=[mock_message.id],
                                retrieve_message=[mock_message],
                                probe=probe)

    with pytest.raises(RetryableException):
        forwarder.forward_messages()

    forward_message_event.assert_has_calls(
        [
            call.record_message_metadata(mock_message),
            call.record_mesh_client_network_error(network_error),
            call.finish(),
        ],
        any_order=False,
    )
def test_raises_retryable_exception_when_inbox_count_messages_raises_mesh_network_exception(
):
    forwarder = build_forwarder(count_error=mesh_client_network_error())

    with pytest.raises(RetryableException):
        forwarder.is_mailbox_empty()