kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Evidence for the concrete Produce protocol-to-core join.

use core::num::NonZeroI16;

use kafka_client_core::{
    BatchExecutionGeneration, BatchExecutionId, BatchId, DeliveryStatus, Moment,
    ProducerAttemptFailureKind, ProducerBatchSuccess, ProducerBrokerFailure,
    ProducerBrokerFailureKind, ProducerInput,
};
use kafka_wire::{
    ProduceResponse,
    produce_response::{BatchIndexAndErrorMessage, PartitionProduceResponse, TopicProduceResponse},
};

use super::{
    produce_outcome::{explicit_produce_response_input, produce_transport_failure_input},
    produce_response::{ProduceResponseFailure, ProduceResponseProtocolFailure},
};

const BATCH_ID: BatchId = BatchId::from_raw(41);
const EXECUTION: BatchExecutionId =
    BatchExecutionId::new(BATCH_ID, BatchExecutionGeneration::initial());
const NOW: Moment = Moment::from_tick(73);
const TOPIC: &str = "art-events";
const PARTITION: i32 = 7;

#[test]
fn successful_response_becomes_the_correlated_core_success() {
    let mut response = response();
    let partition = sole_partition_mut(&mut response);
    partition.base_offset = 42;
    partition.log_append_time_ms = 1_234;
    partition.current_leader.leader_epoch = 9;

    assert_eq!(
        explicit_produce_response_input(EXECUTION, NOW, TOPIC, PARTITION, &response),
        Ok(ProducerInput::BrokerSucceeded {
            execution: EXECUTION,
            success: ProducerBatchSuccess::new(42, Some(1_234), Some(9)),
        })
    );
}

#[test]
fn broker_error_becomes_the_correlated_core_failure() {
    let mut response = response();
    sole_partition_mut(&mut response).error_code = 6;

    assert_eq!(
        explicit_produce_response_input(EXECUTION, NOW, TOPIC, PARTITION, &response),
        Ok(ProducerInput::BrokerFailed {
            execution: EXECUTION,
            now: NOW,
            failure: ProducerBrokerFailure::new(ProducerBrokerFailureKind::Routing, nonzero(6)),
            delivery: DeliveryStatus::PossiblySent,
            route_refreshed: false,
        })
    );
}

#[test]
fn structural_mismatch_remains_an_exact_protocol_failure() {
    let mut response = response();
    sole_partition_mut(&mut response).index = 99;

    assert_eq!(
        explicit_produce_response_input(EXECUTION, NOW, TOPIC, PARTITION, &response),
        Err(ProduceResponseFailure::Protocol {
            failure: ProduceResponseProtocolFailure::PartitionIndexMismatch { actual: 99 },
            delivery: DeliveryStatus::PossiblySent,
        })
    );
}

#[test]
fn false_success_remains_an_exact_protocol_failure() {
    let mut response = response();
    let mut record_error = BatchIndexAndErrorMessage::default();
    record_error.batch_index = 0;
    record_error.batch_index_error_message = Some("record rejected".into());
    sole_partition_mut(&mut response)
        .record_errors
        .push(record_error);

    assert_eq!(
        explicit_produce_response_input(EXECUTION, NOW, TOPIC, PARTITION, &response),
        Err(ProduceResponseFailure::Protocol {
            failure: ProduceResponseProtocolFailure::RecordErrorsOnSuccess { actual: 1 },
            delivery: DeliveryStatus::PossiblySent,
        })
    );
}

#[test]
fn transport_failure_preserves_adapter_normalized_delivery_certainty() {
    for delivery in [DeliveryStatus::NotSent, DeliveryStatus::PossiblySent] {
        assert_eq!(
            produce_transport_failure_input(
                EXECUTION,
                NOW,
                ProducerAttemptFailureKind::ConnectionUnavailable,
                delivery,
            ),
            ProducerInput::TransportFailed {
                execution: EXECUTION,
                now: NOW,
                failure: ProducerAttemptFailureKind::ConnectionUnavailable,
                delivery,
                route_refreshed: false,
            }
        );
    }
}

fn nonzero(value: i16) -> NonZeroI16 {
    match NonZeroI16::new(value) {
        Some(value) => value,
        None => panic!("test broker error must be nonzero"),
    }
}

fn response() -> ProduceResponse {
    let mut response = ProduceResponse::default();
    let mut topic = TopicProduceResponse::default();
    topic.name = TOPIC.into();
    topic.partition_responses.push(partition_response());
    response.responses.push(topic);
    response
}

fn partition_response() -> PartitionProduceResponse {
    let mut partition = PartitionProduceResponse::default();
    partition.index = PARTITION;
    partition
}

fn sole_partition_mut(response: &mut ProduceResponse) -> &mut PartitionProduceResponse {
    &mut response.responses[0].partition_responses[0]
}