kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Generated Kafka transaction-control schema composition scenarios.

use bytes::{Bytes, BytesMut};
use kafka_wire::{ControlRecordTypeSchema, EndTxnMarker};
use kafka_wire_core::{ApiVersion, Encoder, KafkaEncode};

use super::{
    FetchBatch, FetchHeader, FetchProducerIdentity, FetchRecord, FetchTimestampType,
    control_record::{FetchControlRecordFailure, FetchControlRecordKind, decode_control_record},
};

#[test]
fn generated_schemas_decode_abort_and_commit_markers_exactly() {
    for (control_type, expected) in [
        (0, FetchControlRecordKind::Abort),
        (1, FetchControlRecordKind::Commit),
        (7, FetchControlRecordKind::Other(7)),
    ] {
        let batch = marker_batch(control_type, 0);
        assert_eq!(decode_control_record(&batch), Ok(expected));
    }
}

#[test]
fn schema_versions_and_trailing_bytes_are_strict() {
    let mut unsupported = marker_batch(0, 0);
    unsupported.records[0].key = Some(Bytes::from_static(&[0, 1, 0, 0]));
    assert!(matches!(
        decode_control_record(&unsupported),
        Err(FetchControlRecordFailure::Key(
            kafka_wire_core::DecodeError::UnsupportedVersion { .. }
        ))
    ));

    let mut trailing = marker_batch(0, 0);
    let mut value = marker_value(0);
    value.extend_from_slice(&[0]);
    trailing.records[0].value = Some(value.freeze());
    assert_eq!(
        decode_control_record(&trailing),
        Err(FetchControlRecordFailure::Value(
            kafka_wire_core::DecodeError::TrailingBytes { remaining: 1 }
        ))
    );
}

#[test]
fn marker_shape_requires_one_nonnull_key_and_value() {
    let mut missing_key = marker_batch(0, 0);
    missing_key.records[0].key = None;
    assert_eq!(
        decode_control_record(&missing_key),
        Err(FetchControlRecordFailure::MissingKey)
    );

    let mut missing_value = marker_batch(0, 0);
    missing_value.records[0].value = None;
    assert_eq!(
        decode_control_record(&missing_value),
        Err(FetchControlRecordFailure::MissingValue)
    );

    let mut two = marker_batch(0, 0);
    two.records.push(record(0, 0));
    assert_eq!(
        decode_control_record(&two),
        Err(FetchControlRecordFailure::RecordCount { actual: 2 })
    );
}

fn marker_batch(control_type: i16, version: i16) -> FetchBatch {
    FetchBatch {
        base_offset: 4,
        last_offset: 4,
        next_offset: 5,
        partition_leader_epoch: None,
        timestamp_type: FetchTimestampType::Create,
        max_timestamp: Some(1),
        producer: Some(FetchProducerIdentity {
            producer_id: 8,
            producer_epoch: 1,
            base_sequence: -1,
        }),
        is_transactional: true,
        is_control: true,
        delete_horizon_ms: None,
        records: vec![record(control_type, version)],
    }
}

fn record(control_type: i16, version: i16) -> FetchRecord {
    FetchRecord {
        attributes: 0,
        offset: 4,
        timestamp: Some(1),
        key: Some(marker_key(control_type, version).freeze()),
        value: Some(marker_value(version).freeze()),
        headers: Vec::<FetchHeader>::new(),
    }
}

fn marker_key(control_type: i16, version: i16) -> BytesMut {
    let mut bytes = BytesMut::new();
    let mut encoder = Encoder::new(&mut bytes);
    encoder
        .write_i16(version)
        .unwrap_or_else(|error| panic!("control key version: {error}"));
    let mut key = ControlRecordTypeSchema::default();
    key.type_ = control_type;
    key.encode(&mut encoder, ApiVersion::new(version))
        .unwrap_or_else(|error| panic!("generated control key: {error}"));
    bytes
}

fn marker_value(version: i16) -> BytesMut {
    let mut bytes = BytesMut::new();
    let mut encoder = Encoder::new(&mut bytes);
    encoder
        .write_i16(version)
        .unwrap_or_else(|error| panic!("marker value version: {error}"));
    let mut marker = EndTxnMarker::default();
    marker.coordinator_epoch = 3;
    marker
        .encode(&mut encoder, ApiVersion::new(version))
        .unwrap_or_else(|error| panic!("generated marker value: {error}"));
    bytes
}