kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Delivery-certainty translation scenarios at the client-driver boundary.

use kafka_client_core::{DeliveryStatus, ProducerAttemptFailureKind};
use kafka_driver::{
    ApiKey, ApiVersion, CallFailure, ConnectionCloseReason, Delivery, NegotiationFailure,
    RequestError, TransportFailure,
};

use super::delivery::{request_failure_delivery, request_failure_kind};

#[test]
fn local_driver_failures_remain_definitely_not_sent() {
    assert_eq!(
        request_failure_delivery(&RequestError::RouteUnavailable),
        DeliveryStatus::NotSent
    );
}

#[test]
fn negotiated_version_failures_are_definitely_unsent_and_compatible() {
    let api_key = ApiKey::new(3);
    for error in [
        RequestError::ApiUnavailable { api_key },
        RequestError::VersionLimitUnavailable {
            api_key,
            maximum: ApiVersion::new(3),
            negotiated_minimum: ApiVersion::new(4),
        },
        RequestError::VersionFloorUnavailable {
            api_key,
            minimum: ApiVersion::new(4),
            negotiated_maximum: ApiVersion::new(3),
        },
    ] {
        assert_eq!(request_failure_delivery(&error), DeliveryStatus::NotSent);
        assert_eq!(
            request_failure_kind(&error),
            ProducerAttemptFailureKind::Compatibility
        );
    }
}

#[test]
fn invalid_caller_version_bounds_remain_an_internal_permanent_failure() {
    let error = RequestError::VersionBoundsInvalid {
        api_key: ApiKey::new(0),
        minimum: ApiVersion::new(13),
        maximum: ApiVersion::new(12),
    };

    assert_eq!(request_failure_delivery(&error), DeliveryStatus::NotSent);
    assert_eq!(
        request_failure_kind(&error),
        ProducerAttemptFailureKind::Permanent
    );
}

#[test]
fn driver_owned_possibly_sent_evidence_is_preserved() {
    let error = RequestError::Rejected {
        failure: CallFailure::ConnectionClosed {
            reason: kafka_driver::ConnectionCloseReason::Requested,
        },
        delivery: Delivery::PossiblySent,
    };

    assert_eq!(
        request_failure_delivery(&error),
        DeliveryStatus::PossiblySent
    );
}

#[test]
fn bounded_local_and_route_failures_keep_distinct_structure() {
    assert_eq!(
        request_failure_kind(&RequestError::ResponseCapacityReached { limit: 3 }),
        ProducerAttemptFailureKind::LocalCapacity
    );
    assert_eq!(
        request_failure_kind(&RequestError::RouteUnavailable),
        ProducerAttemptFailureKind::RouteUnavailable
    );
    assert_eq!(
        request_failure_kind(&RequestError::CoordinatorCapacityReached { limit: 2 }),
        ProducerAttemptFailureKind::Permanent
    );
}

#[test]
fn only_recoverable_connection_shapes_are_transient() {
    for failure in [
        CallFailure::NotReady,
        CallFailure::Draining,
        CallFailure::Closed,
        CallFailure::ConnectionClosed {
            reason: ConnectionCloseReason::OpenFailed(TransportFailure::Refused),
        },
        CallFailure::ConnectionClosed {
            reason: ConnectionCloseReason::NegotiationFailed(NegotiationFailure::Timeout),
        },
    ] {
        let error = RequestError::Rejected {
            failure,
            delivery: Delivery::NotSent,
        };
        assert_eq!(
            request_failure_kind(&error),
            ProducerAttemptFailureKind::ConnectionUnavailable
        );
    }
}

#[test]
fn possibly_sent_transport_loss_is_transient_but_keeps_delivery_uncertain() {
    let error = RequestError::Rejected {
        failure: CallFailure::ConnectionClosed {
            reason: ConnectionCloseReason::TransportLost(TransportFailure::Reset),
        },
        delivery: Delivery::PossiblySent,
    };

    assert_eq!(
        request_failure_kind(&error),
        ProducerAttemptFailureKind::ConnectionUnavailable
    );
    assert_eq!(
        request_failure_delivery(&error),
        DeliveryStatus::PossiblySent
    );
}