kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! One-partition name-based Fetch request construction scenarios.

use kafka_wire_core::{ApiVersion, KafkaEncode};

use super::{
    FETCH_NAME_ROUTE_MAX_VERSION, FETCH_NAME_ROUTE_MIN_VERSION, FetchRequestFailure,
    FetchRequestSettings, FetchSessionRequest, fetch_request, fetch_request_with_session,
};

fn settings(isolation_level: i8) -> FetchRequestSettings {
    FetchRequestSettings::new(500, 1, 50 * 1024 * 1024, 1024 * 1024, isolation_level)
}

#[test]
fn request_represents_initial_and_incremental_session_epochs_without_losing_old_brokers() {
    let initial =
        fetch_request_with_session("events", 7, 42, settings(0), FetchSessionRequest::INITIAL)
            .unwrap_or_else(|error| panic!("initial session Fetch: {error:?}"));
    assert_eq!((initial.session_id, initial.session_epoch), (0, 0));
    assert!(initial.encoded_len(ApiVersion::new(6)).is_ok());
    assert!(initial.encoded_len(ApiVersion::new(7)).is_ok());

    let metadata = FetchSessionRequest::incremental(91, 3)
        .unwrap_or_else(|| panic!("positive incremental session"));
    let incremental = fetch_request_with_session("events", 7, 43, settings(0), metadata)
        .unwrap_or_else(|error| panic!("incremental session Fetch: {error:?}"));
    assert_eq!((incremental.session_id, incremental.session_epoch), (91, 3));
    assert!(incremental.encoded_len(ApiVersion::new(7)).is_ok());
    assert_eq!(metadata.next_incremental_epoch(), Some(4));
}

#[test]
fn request_uses_generated_v12_name_and_exact_consumer_sentinels() {
    let request = fetch_request("events", 7, 42, settings(1))
        .unwrap_or_else(|error| panic!("valid Fetch request: {error:?}"));

    assert_eq!(
        (FETCH_NAME_ROUTE_MIN_VERSION, FETCH_NAME_ROUTE_MAX_VERSION),
        (4, 12)
    );
    assert_eq!(request.replica_id, -1);
    assert_eq!(request.max_wait_ms, 500);
    assert_eq!(request.min_bytes, 1);
    assert_eq!(request.max_bytes, 50 * 1024 * 1024);
    assert_eq!(request.isolation_level, 1);
    assert_eq!(request.session_id, 0);
    assert_eq!(request.session_epoch, -1);
    assert!(request.cluster_id.is_none());
    assert!(request.forgotten_topics_data.is_empty());
    assert!(request.rack_id.as_str().is_empty());
    assert_eq!(request.topics.len(), 1);
    assert_eq!(request.topics[0].topic.as_str(), "events");
    assert_eq!(request.topics[0].partitions.len(), 1);
    let partition = &request.topics[0].partitions[0];
    assert_eq!(partition.partition, 7);
    assert_eq!(partition.current_leader_epoch, -1);
    assert_eq!(partition.fetch_offset, 42);
    assert_eq!(partition.last_fetched_epoch, -1);
    assert_eq!(partition.log_start_offset, -1);
    assert_eq!(partition.partition_max_bytes, 1024 * 1024);
    assert!(
        request
            .encoded_len(ApiVersion::new(FETCH_NAME_ROUTE_MAX_VERSION))
            .is_ok()
    );
    assert!(
        request
            .encoded_len(ApiVersion::new(FETCH_NAME_ROUTE_MIN_VERSION))
            .is_ok()
    );
}

#[test]
fn both_kafka_isolation_levels_are_represented_exactly() {
    for isolation_level in [0, 1] {
        let configured = settings(isolation_level);
        let request = fetch_request("events", 0, 0, configured)
            .unwrap_or_else(|error| panic!("valid isolation level: {error:?}"));
        assert_eq!(request.isolation_level, isolation_level);
        assert_eq!(
            configured.isolation(),
            Some(if isolation_level == 0 {
                super::FetchIsolation::ReadUncommitted
            } else {
                super::FetchIsolation::ReadCommitted
            })
        );
    }
    assert_eq!(settings(2).isolation(), None);
    assert_eq!(
        fetch_request("events", 0, 0, settings(2)),
        Err(FetchRequestFailure::InvalidIsolationLevel { actual: 2 })
    );
}

#[test]
fn max_wait_cap_changes_only_the_broker_long_poll() {
    let configured = settings(1);
    let capped = fetch_request("events", 7, 42, configured.cap_max_wait_ms(37))
        .unwrap_or_else(|error| panic!("deadline-capped Fetch request: {error:?}"));
    assert_eq!(capped.max_wait_ms, 37);
    assert_eq!(capped.min_bytes, 1);
    assert_eq!(capped.max_bytes, 50 * 1024 * 1024);
    assert_eq!(capped.isolation_level, 1);

    let unchanged = fetch_request("events", 7, 42, configured.cap_max_wait_ms(1_000))
        .unwrap_or_else(|error| panic!("uncapped Fetch request: {error:?}"));
    assert_eq!(unchanged.max_wait_ms, 500);
}

#[test]
fn topic_partition_and_offset_are_validated_before_generated_storage() {
    assert_eq!(
        fetch_request("", 0, 0, settings(0)),
        Err(FetchRequestFailure::EmptyTopic)
    );
    let long_topic = "t".repeat(250);
    assert_eq!(
        fetch_request(&long_topic, 0, 0, settings(0)),
        Err(FetchRequestFailure::TopicTooLong {
            actual: 250,
            limit: 249,
        })
    );
    assert_eq!(
        fetch_request("events", i32::MAX as u32 + 1, 0, settings(0)),
        Err(FetchRequestFailure::PartitionOutOfRange {
            actual: i32::MAX as u32 + 1,
        })
    );
    assert_eq!(
        fetch_request("events", 0, -1, settings(0)),
        Err(FetchRequestFailure::NegativeFetchOffset { actual: -1 })
    );
}

#[test]
fn request_and_partition_byte_bounds_reject_zero_overflow_and_inversion() {
    let maximum = i32::MAX as u32;
    assert!(
        fetch_request(
            "events",
            0,
            0,
            FetchRequestSettings::new(maximum, maximum, maximum, maximum, 0),
        )
        .is_ok()
    );

    for (settings, expected) in [
        (
            FetchRequestSettings::new(maximum + 1, 0, 1, 1, 0),
            FetchRequestFailure::MaxWaitOutOfRange {
                actual: maximum + 1,
            },
        ),
        (
            FetchRequestSettings::new(0, maximum + 1, maximum + 1, 1, 0),
            FetchRequestFailure::MinBytesOutOfRange {
                actual: maximum + 1,
            },
        ),
        (
            FetchRequestSettings::new(0, 0, 0, 1, 0),
            FetchRequestFailure::MaxBytesOutOfRange { actual: 0 },
        ),
        (
            FetchRequestSettings::new(0, 0, maximum + 1, 1, 0),
            FetchRequestFailure::MaxBytesOutOfRange {
                actual: maximum + 1,
            },
        ),
        (
            FetchRequestSettings::new(0, 0, 1, 0, 0),
            FetchRequestFailure::PartitionMaxBytesOutOfRange { actual: 0 },
        ),
        (
            FetchRequestSettings::new(0, 0, 1, maximum + 1, 0),
            FetchRequestFailure::PartitionMaxBytesOutOfRange {
                actual: maximum + 1,
            },
        ),
        (
            FetchRequestSettings::new(0, 2, 1, 1, 0),
            FetchRequestFailure::MinBytesExceedMaxBytes {
                min_bytes: 2,
                max_bytes: 1,
            },
        ),
    ] {
        assert_eq!(fetch_request("events", 0, 0, settings), Err(expected));
    }
}