kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Generated classic-group `OffsetCommit` request semantics.

use std::sync::Arc;

use kafka_client_core::ConsumerGroupMemberEpoch;
use kafka_wire::OffsetCommitRequest;
use kafka_wire_core::{ApiVersion, BytesMut, DecodeLimits, Decoder, KafkaDecode, KafkaEncode};

use super::{
    ClassicGroupCommitSession,
    model_test::{entry, generation, group_id, inputs, member_id, prepare, prepared, topic},
    request::group_offset_commit_request,
};

#[test]
fn request_uses_exact_spellings_next_offsets_epochs_and_empty_metadata() {
    let prepared = prepared(
        vec![
            entry(1, 0, 10, Some(7)),
            entry(1, 2, 30, None),
            entry(2, 1, 20, Some(8)),
        ],
        4,
        vec![topic(1, Arc::from("orders")), topic(2, Arc::from("audit"))],
    );
    let request = group_offset_commit_request(&prepared);

    assert_eq!(request.group_id.as_str(), "readers");
    assert_eq!(request.member_id.as_str(), "member-a");
    assert_eq!(request.generation_id_or_member_epoch, 4);
    assert_eq!(request.retention_time_ms, -1);
    assert!(request.group_instance_id.is_none());
    assert_eq!(request.topics.len(), 2);
    assert_eq!(request.topics[0].name.as_str(), "orders");
    assert_eq!(request.topics[1].name.as_str(), "audit");
    assert_eq!(
        request.topics[0]
            .partitions
            .iter()
            .map(|partition| (
                partition.partition_index,
                partition.committed_offset,
                partition.committed_leader_epoch,
                partition
                    .committed_metadata
                    .as_ref()
                    .map(kafka_wire_core::StrBytes::as_str),
            ))
            .collect::<Vec<_>>(),
        vec![(0, 10, 7, Some("")), (2, 30, -1, Some(""))]
    );
    assert_round_trip(&request, 6);
    assert_round_trip(&request, 9);
}

#[test]
fn absent_leader_epoch_does_not_require_v6() {
    let prepared = prepared(
        vec![entry(1, 0, 10, None)],
        4,
        vec![topic(1, Arc::from("orders"))],
    );
    assert!(!prepared.requires_leader_epoch());
    let request = group_offset_commit_request(&prepared);
    assert_eq!(request.topics[0].partitions[0].committed_leader_epoch, -1);
    assert_round_trip(&request, 2);
}

#[test]
fn consumer_epoch_projects_to_the_shared_wire_field_and_requires_v9() {
    let topics = vec![topic(1, Arc::from("orders"))];
    let (effect, deadline, _classic_session, topics) = inputs(
        vec![entry(1, 0, 10, None)],
        4,
        Arc::from("readers"),
        Arc::from("member-a"),
        topics,
    );
    let member_epoch = ConsumerGroupMemberEpoch::try_from_raw(3)
        .unwrap_or_else(|| panic!("positive member epoch"));
    let session = ClassicGroupCommitSession::new_consumer(
        group_id(),
        Arc::from("readers"),
        member_id(),
        Arc::from("member-a"),
        generation(4),
        member_epoch,
    );
    let prepared = prepare(effect, deadline, session, topics)
        .unwrap_or_else(|error| panic!("consumer prepared commit: {:?}", error.kind()));

    assert!(prepared.requires_consumer_group_version());
    let request = group_offset_commit_request(&prepared);
    assert_eq!(request.generation_id_or_member_epoch, member_epoch.get());
    assert!(request.group_instance_id.is_none());
    assert_round_trip(&request, 9);
}

fn assert_round_trip(request: &OffsetCommitRequest, version: i16) {
    let version = ApiVersion::new(version);
    let mut encoded = BytesMut::new();
    request
        .encode_into(&mut encoded, version)
        .unwrap_or_else(|error| panic!("generated v{version} request encodes: {error}"));
    let mut decoder = Decoder::new(encoded.freeze(), DecodeLimits::default())
        .unwrap_or_else(|error| panic!("generated request frame is bounded: {error}"));
    let decoded = OffsetCommitRequest::decode(&mut decoder, version)
        .unwrap_or_else(|error| panic!("generated v{version} request decodes: {error}"));
    decoder
        .finish()
        .unwrap_or_else(|error| panic!("generated request consumes its frame: {error}"));
    assert_eq!(decoded.group_id.as_str(), "readers");
    assert_eq!(decoded.member_id.as_str(), "member-a");
}