kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Lossless recovery scenarios for rejected prepared commit snapshots.

use std::sync::Arc;

use kafka_client_core::{
    Deadline, GroupOffsetCommitBatch, GroupOffsetCommitEffect, GroupOffsetCommitTerminal,
    OperationId, TopicId,
};

use crate::clock::OperationDeadline;

use super::{
    model_test::{entry, generation, group_id, inputs, member_id, prepare, session, topic},
    preparation::{GroupOffsetCommitPreparationError, GroupOffsetCommitPreparationErrorKind},
    session::ClassicGroupCommitSession,
};

#[test]
fn deadline_generation_and_unknown_topic_failures_return_every_owner() {
    let (effect, _deadline, session, topics) = inputs(
        vec![entry(1, 0, 10, None)],
        4,
        Arc::from("readers"),
        Arc::from("member-a"),
        vec![topic(1, Arc::from("orders"))],
    );
    let supplied = OperationDeadline::from_core_for_test(Deadline::from_tick(101));
    let error = result_error(
        prepare(effect, supplied, session, topics),
        "deadline mismatch",
    );
    assert_eq!(
        error.kind(),
        GroupOffsetCommitPreparationErrorKind::DeadlineMismatch {
            effect: Deadline::from_tick(100),
            operation: Deadline::from_tick(101),
        }
    );
    let (effect, returned, _session, topics, entry_reservation, result_reservation) =
        error.into_parts();
    assert!(matches!(effect, GroupOffsetCommitEffect::Submit { .. }));
    assert_eq!(returned, supplied);
    assert_eq!(topics.len(), 1);
    assert_eq!(entry_reservation.entry_count(), 1);
    assert_eq!(result_reservation.entry_count(), 1);

    let (effect, deadline, _session, topics) = inputs(
        vec![entry(1, 0, 10, None)],
        4,
        Arc::from("readers"),
        Arc::from("member-a"),
        vec![topic(1, Arc::from("orders"))],
    );
    let session = ClassicGroupCommitSession::new(
        group_id(),
        Arc::from("readers"),
        member_id(),
        Arc::from("member-a"),
        generation(5),
        4,
    );
    assert_recovered(
        result_error(
            prepare(effect, deadline, session, topics),
            "generation mismatch",
        ),
        GroupOffsetCommitPreparationErrorKind::GenerationMismatch,
    );

    let (effect, deadline, session, _) = inputs(
        vec![entry(1, 0, 10, None)],
        4,
        Arc::from("readers"),
        Arc::from("member-a"),
        vec![],
    );
    assert_recovered(
        result_error(prepare(effect, deadline, session, vec![]), "unknown topic"),
        GroupOffsetCommitPreparationErrorKind::UnknownTopic(TopicId::from_raw(1)),
    );
}

#[test]
fn unexpected_complete_effect_is_recovered_intact() {
    let effect = GroupOffsetCommitEffect::Complete {
        operation_id: OperationId::from_raw(9),
        terminal: GroupOffsetCommitTerminal::Committed(GroupOffsetCommitBatch::new(0, vec![])),
    };
    let deadline = OperationDeadline::from_core_for_test(Deadline::from_tick(100));
    let session = session(4, Arc::from("readers"), Arc::from("member-a"));
    let error = result_error(
        prepare(effect, deadline, session, vec![]),
        "complete is not a submit",
    );
    assert_eq!(
        error.kind(),
        GroupOffsetCommitPreparationErrorKind::UnexpectedEffect
    );
    let (effect, returned_deadline, _, topics, entry_reservation, result_reservation) =
        error.into_parts();
    assert!(matches!(effect, GroupOffsetCommitEffect::Complete { .. }));
    assert_eq!(returned_deadline, deadline);
    assert!(topics.is_empty());
    assert_eq!(entry_reservation.entry_count(), 0);
    assert_eq!(result_reservation.entry_count(), 0);
}

fn assert_recovered(
    error: GroupOffsetCommitPreparationError,
    expected: GroupOffsetCommitPreparationErrorKind,
) {
    assert_eq!(error.kind(), expected);
    let (effect, _deadline, _session, topics, entry_reservation, result_reservation) =
        error.into_parts();
    let GroupOffsetCommitEffect::Submit {
        operation_id,
        checkpoint,
        ..
    } = effect
    else {
        panic!("submit effect must be recovered");
    };
    assert_eq!(operation_id, OperationId::from_raw(9));
    assert!(!checkpoint.entries().is_empty());
    assert_eq!(entry_reservation.entry_count(), checkpoint.entries().len());
    assert_eq!(result_reservation.entry_count(), checkpoint.entries().len());
    drop(topics);
}

fn result_error<T, E>(result: Result<T, E>, context: &str) -> E {
    match result {
        Ok(_) => panic!("{context}"),
        Err(error) => error,
    }
}