kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Exact scalar Join retention and directional cycle-fault evidence.

use kafka_client_core::{
    ClassicGroupEffect, ClassicProtocol, Deadline, GroupId, MemberId, MembershipCycle,
};

use super::{
    classic_group_entry_fault::ClassicGroupEntryFault,
    classic_group_rejoin_fault::{ClassicRejoinPostCore, ClassicRejoinPostCoreFailure},
    classic_group_rejoin_test_support::entry_mut,
    registry_test_support::{register, started_registry},
};

#[test]
fn post_core_fault_retains_the_exact_scalar_join_owner() {
    let mut registry = started_registry();
    let group_id = register(&mut registry, "workers");
    let cycle = MembershipCycle::try_from_raw(3).unwrap_or_else(|| panic!("nonzero skipped cycle"));
    let member_id = MemberId::try_from_raw(5).unwrap_or_else(|| panic!("nonzero member identity"));
    let core_deadline = Deadline::from_tick(47);
    let timing = registry
        .entry(group_id)
        .unwrap_or_else(|| panic!("registered entry expected"))
        .classic
        .machine()
        .timing();
    entry_mut(&mut registry, group_id).fault = Some(ClassicGroupEntryFault::RejoinPostCore(
        ClassicRejoinPostCore::join_for_test(
            group_id,
            cycle,
            Some(member_id),
            timing,
            core_deadline,
            ClassicRejoinPostCoreFailure::CycleSequence,
        ),
    ));

    let entry = registry
        .entry(group_id)
        .unwrap_or_else(|| panic!("registered entry expected"));
    let Some(ClassicGroupEntryFault::RejoinPostCore(fault)) = &entry.fault else {
        panic!("post-core rejoin fault expected");
    };
    let join = fault
        .join()
        .unwrap_or_else(|| panic!("exact scalar Join expected"));
    assert_eq!(join.cycle(), cycle);
    assert_eq!(join.member_id(), Some(member_id));
    assert_eq!(join.deadline(), core_deadline);
    assert_eq!(fault.failure(), ClassicRejoinPostCoreFailure::CycleSequence);
    assert_eq!(registry.membership_unsettled(), 1);
}

#[test]
fn impossible_two_effect_shape_is_retained_without_dropping_either_slot() {
    let group_id = GroupId::try_from_raw(41).unwrap_or_else(|| panic!("nonzero group identity"));
    let timing = super::classic_group_test_support::timing();
    let first_cycle = MembershipCycle::initial();
    let second_cycle = first_cycle
        .checked_next()
        .unwrap_or_else(|| panic!("next cycle expected"));
    let first = join_effect(group_id, first_cycle, timing, Deadline::from_tick(10));
    let second = join_effect(group_id, second_cycle, timing, Deadline::from_tick(20));
    let fault = ClassicRejoinPostCore::new(
        None,
        [Some(first), Some(second)],
        ClassicRejoinPostCoreFailure::EffectShape,
    );

    assert_eq!(fault.retained_owner_count(), 2);
    assert!(matches!(
        &fault.other()[0],
        Some(ClassicGroupEffect::Join { cycle, .. }) if *cycle == first_cycle
    ));
    assert!(matches!(
        &fault.other()[1],
        Some(ClassicGroupEffect::Join { cycle, .. }) if *cycle == second_cycle
    ));
}

fn join_effect(
    group_id: GroupId,
    cycle: MembershipCycle,
    timing: kafka_client_core::ClassicGroupTiming,
    deadline: Deadline,
) -> ClassicGroupEffect {
    ClassicGroupEffect::Join {
        group_id,
        cycle,
        protocol: ClassicProtocol::Range,
        member_id: None,
        timing,
        deadline,
    }
}