kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Sync terminal interpretation at the exact original absolute deadline.

use kafka_client_core::{ClassicBrokerStage, ClassicGroupFatalReason, ClassicGroupPhase, Moment};

use crate::driver::classic_group::install_sync_broker_rejection_terminal;

use super::{
    classic_group_join::ClassicGroupExecutionState,
    classic_group_sync_settlement::ClassicGroupSyncSettlementTurn,
    classic_group_sync_settlement_test::{install_assignment_terminal, sync_key},
    classic_group_sync_submission_test::{make_sync_driver_owned, prepared_registry},
    registry_test_support::stop_registry,
};

#[test]
fn late_success_terminalizes_once_without_install_or_replay() {
    let (mut registry, group_id, identity) = prepared_registry();
    make_sync_driver_owned(&mut registry, group_id, identity);
    install_assignment_terminal(&mut registry, identity, "orders", &[0]);
    let deadline = Moment::from_tick(identity.deadline().core().tick());

    assert_eq!(
        registry.settle_one_classic_sync(deadline),
        Ok(ClassicGroupSyncSettlementTurn::Progress)
    );
    let entry = registry
        .entry(group_id)
        .unwrap_or_else(|| panic!("registered entry expected"));
    assert_eq!(entry.classic.machine().phase(), ClassicGroupPhase::Lost);
    assert!(entry.classic.pending().is_none());
    assert!(entry.catalog.live_assignment().is_none());
    assert!(entry.fault.is_none());
    assert!(matches!(
        entry.execution.borrow_execution_state(),
        ClassicGroupExecutionState::SyncConfirmationPending(_)
    ));

    assert_eq!(
        registry.settle_one_classic_sync(deadline),
        Ok(ClassicGroupSyncSettlementTurn::Progress)
    );
    assert!(matches!(
        registry
            .entry(group_id)
            .unwrap_or_else(|| panic!("registered entry expected"))
            .execution
            .borrow_execution_state(),
        ClassicGroupExecutionState::Idle
    ));
    stop_registry(&mut registry);
}

#[test]
fn load_in_progress_arms_the_exact_retained_coordinator_rejoin() {
    let (mut registry, group_id, identity) = prepared_registry();
    make_sync_driver_owned(&mut registry, group_id, identity);
    install_sync_rejection(&mut registry, identity, 14);

    assert_eq!(
        registry.settle_one_classic_sync(Moment::from_tick(3)),
        Ok(ClassicGroupSyncSettlementTurn::Progress)
    );
    let entry = registry
        .entry(group_id)
        .unwrap_or_else(|| panic!("registered entry expected"));
    assert_eq!(
        entry.classic.machine().phase(),
        ClassicGroupPhase::WaitingToRejoin
    );
    assert_eq!(
        entry.rejoin.schedule(),
        entry.classic.machine().pending_rejoin()
    );
    assert!(entry.rejoin.schedule().is_some());
    assert!(entry.fault.is_none());

    assert_eq!(
        registry.settle_one_classic_sync(Moment::from_tick(4)),
        Ok(ClassicGroupSyncSettlementTurn::Progress)
    );
    stop_registry(&mut registry);
}

#[test]
fn unknown_sync_code_becomes_the_exact_core_fatal() {
    let (mut registry, group_id, identity) = prepared_registry();
    make_sync_driver_owned(&mut registry, group_id, identity);
    install_sync_rejection(&mut registry, identity, 1_235);

    assert_eq!(
        registry.settle_one_classic_sync(Moment::from_tick(3)),
        Ok(ClassicGroupSyncSettlementTurn::Progress)
    );
    let entry = registry
        .entry(group_id)
        .unwrap_or_else(|| panic!("registered entry expected"));
    let fatal = entry
        .classic
        .machine()
        .fatal()
        .unwrap_or_else(|| panic!("fatal broker fact expected"));
    let ClassicGroupFatalReason::Broker { stage, error } = fatal.reason() else {
        panic!("broker fatal expected");
    };
    assert_eq!(stage, ClassicBrokerStage::Sync);
    assert_eq!(error.code(), 1_235);
    assert_eq!(entry.classic.machine().phase(), ClassicGroupPhase::Fatal);
    assert!(entry.rejoin.is_dormant());

    assert_eq!(
        registry.settle_one_classic_sync(Moment::from_tick(4)),
        Ok(ClassicGroupSyncSettlementTurn::Progress)
    );
    stop_registry(&mut registry);
}

fn install_sync_rejection(
    registry: &mut super::registry::GroupConsumerRegistry,
    identity: super::classic_group_sync::ClassicGroupSyncIdentity,
    error_code: i16,
) {
    install_sync_broker_rejection_terminal(
        registry
            .sync_calls
            .as_mut()
            .unwrap_or_else(|| panic!("Sync calls expected")),
        sync_key(identity),
        error_code,
    );
}