use kafka_client_core::{ClassicBrokerStage, ClassicGroupFatalReason, ClassicGroupPhase, Moment};
use crate::driver::classic_group::install_heartbeat_broker_rejection_terminal;
use super::{
classic_group_heartbeat::{ClassicHeartbeatExecutionState, ClassicHeartbeatSuccessor},
classic_group_heartbeat_interpret::interpret_heartbeat,
classic_group_heartbeat_settlement_test::{
heartbeat_calls, make_driver_owned, prepared_heartbeat,
},
registry_test_support::stop_registry,
};
#[test]
fn generation_rejection_revokes_and_arms_the_exact_retained_rejoin() {
let (mut registry, group_id, key) = prepared_heartbeat();
make_driver_owned(&mut registry, group_id, key);
install_heartbeat_broker_rejection_terminal(heartbeat_calls(&mut registry), key, 25);
let successor = interpret_rejection(&mut registry, group_id, key);
assert!(matches!(successor, ClassicHeartbeatSuccessor::Dormant));
let entry = registry
.entry(group_id)
.unwrap_or_else(|| panic!("entry expected"));
assert_eq!(
entry.classic.machine().phase(),
ClassicGroupPhase::WaitingToRejoin
);
assert_eq!(
entry.rejoin.schedule(),
entry.classic.machine().pending_rejoin()
);
assert!(entry.catalog.live_assignment().is_some());
assert!(!entry.revocation.is_dormant());
confirm_terminal(&mut registry, group_id);
stop_registry(&mut registry);
}
#[test]
fn unknown_heartbeat_code_revokes_and_becomes_the_exact_core_fatal() {
let (mut registry, group_id, key) = prepared_heartbeat();
make_driver_owned(&mut registry, group_id, key);
install_heartbeat_broker_rejection_terminal(heartbeat_calls(&mut registry), key, 1_236);
let successor = interpret_rejection(&mut registry, group_id, key);
assert!(matches!(successor, ClassicHeartbeatSuccessor::Dormant));
let entry = registry
.entry(group_id)
.unwrap_or_else(|| panic!("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::Heartbeat);
assert_eq!(error.code(), 1_236);
assert_eq!(entry.classic.machine().phase(), ClassicGroupPhase::Fatal);
assert!(entry.catalog.live_assignment().is_none());
assert!(entry.rejoin.is_dormant());
confirm_terminal(&mut registry, group_id);
stop_registry(&mut registry);
}
fn interpret_rejection(
registry: &mut super::registry::GroupConsumerRegistry,
group_id: kafka_client_core::GroupId,
key: crate::driver::classic_group::ClassicHeartbeatCallKey,
) -> ClassicHeartbeatSuccessor {
let (entries, calls) = (&mut registry.entries, &mut registry.heartbeat_calls);
let entry = entries
.iter_mut()
.find(|entry| entry.group_id() == group_id)
.unwrap_or_else(|| panic!("entry expected"));
let calls = calls
.as_mut()
.unwrap_or_else(|| panic!("Heartbeat calls expected"));
let accepted = entry
.heartbeat
.accepted()
.unwrap_or_else(|| panic!("accepted Heartbeat expected"));
let terminal = calls
.begin_classic_heartbeat_settlement(accepted)
.unwrap_or_else(|error| panic!("Heartbeat settlement failed: {error:?}"));
let now = Moment::from_tick(key.deadline().core().tick() - 1);
let successor = interpret_heartbeat(entry, now, &terminal, false).unwrap_or_else(|error| match error {
super::classic_group_heartbeat_interpret::ClassicHeartbeatInterpretationFailure::PostCoreRejection(
fault,
) => panic!("broker rejection interpretation failed: {:?}", fault.failure()),
_ => panic!("broker rejection interpretation failed"),
});
drop(terminal);
successor
}
fn confirm_terminal(
registry: &mut super::registry::GroupConsumerRegistry,
group_id: kafka_client_core::GroupId,
) {
let (entries, calls) = (&mut registry.entries, &mut registry.heartbeat_calls);
let entry = entries
.iter_mut()
.find(|entry| entry.group_id() == group_id)
.unwrap_or_else(|| panic!("entry expected"));
let calls = calls
.as_mut()
.unwrap_or_else(|| panic!("Heartbeat calls expected"));
let state = entry
.heartbeat
.replace(ClassicHeartbeatExecutionState::Dormant);
let ClassicHeartbeatExecutionState::DriverOwned(owner) = state else {
panic!("driver-owned Heartbeat expected");
};
calls
.confirm_classic_heartbeat_settlement(owner.into_accepted())
.unwrap_or_else(|_failure| panic!("exact confirmation must succeed"));
}