use kafka_client_core::{ClassicGroupInput, GroupOffsetCommitAdmissionErrorKind, Moment};
use super::{
offset_commit::GroupOffsetCommitAdmissionFailureKind,
registry_close::GroupRegistryCloseError,
registry_commit::GroupConsumerCommitFailureKind,
registry_event_reconciliation_test::prepared_reconciliation,
registry_host_error::GroupConsumerHostError,
registry_membership::GroupConsumerMembershipTurn,
registry_test_support::{
checkpoint, deadline, install_session, register, started_registry, stop_registry,
},
};
#[test]
fn contended_control_authority_does_not_mutate_and_retries_on_a_later_turn() {
let mut registry = started_registry();
let group_id = register(&mut registry, "workers");
let authority = registry
.entry(group_id)
.unwrap_or_else(|| panic!("registered entry"))
.close_authority();
let requested_deadline = deadline(40);
assert!(authority.request(requested_deadline));
let held = authority.hold_for_test();
assert_eq!(registry.close_one_requested_group(), Ok(false));
let entry = registry
.entry(group_id)
.unwrap_or_else(|| panic!("unmodified entry"));
assert!(entry.is_active());
assert_eq!(entry.leave.pending_deadline(), None);
drop(held);
assert_eq!(registry.close_one_requested_group(), Ok(true));
let entry = registry
.entry(group_id)
.unwrap_or_else(|| panic!("closing entry"));
assert!(!entry.is_active());
assert_eq!(entry.leave.pending_deadline(), Some(requested_deadline));
stop_registry(&mut registry);
}
#[test]
fn prepared_classic_reconciliation_blocks_physical_removal() {
let mut registry = started_registry();
let group_id = register(&mut registry, "workers");
let entry = registry
.entries
.iter_mut()
.find(|entry| entry.group_id() == group_id)
.unwrap_or_else(|| panic!("registered group"));
let _original = core::mem::replace(entry, prepared_reconciliation());
registry
.close_group(group_id)
.unwrap_or_else(|error| panic!("close prepared reconciliation: {error:?}"));
let entry = registry
.entries
.iter_mut()
.find(|entry| entry.group_id() == group_id)
.unwrap_or_else(|| panic!("closing group"));
let _transition = entry
.classic
.apply(ClassicGroupInput::Close)
.unwrap_or_else(|error| panic!("close classic core: {error}"));
entry.catalog.current = None;
assert_eq!(registry.remove_one_closed_group(), Ok(false));
let entry = registry
.entries
.iter_mut()
.find(|entry| entry.group_id() == group_id)
.unwrap_or_else(|| panic!("retained reconciliation group"));
let _reconciliation = entry
.classic_reconciliation
.take()
.unwrap_or_else(|| panic!("retained classic reconciliation"));
assert_eq!(registry.remove_one_closed_group(), Ok(true));
stop_registry(&mut registry);
}
#[test]
fn closing_one_group_does_not_close_global_commit_admission() {
let mut registry = started_registry();
let first = register(&mut registry, "first");
let second = register(&mut registry, "second");
install_session(&mut registry, first);
install_session(&mut registry, second);
let first_checkpoint = checkpoint(®istry, first);
assert_eq!(registry.close_group(first), Ok(()));
let failure = registry
.try_commit(first, deadline(100), first_checkpoint)
.err()
.unwrap_or_else(|| panic!("closing group must reject new commit"));
assert_eq!(failure.kind, GroupConsumerCommitFailureKind::GroupClosing);
assert!(registry.accepting);
assert!(
registry
.entry(second)
.is_some_and(super::registry_entry::GroupConsumerEntry::is_active)
);
let first_checkpoint = checkpoint(®istry, first);
let second_failure = registry
.try_commit(second, deadline(100), first_checkpoint)
.err()
.unwrap_or_else(|| panic!("cross-group checkpoint must be rejected"));
assert_eq!(
second_failure.kind,
GroupConsumerCommitFailureKind::OffsetCommit(GroupOffsetCommitAdmissionFailureKind::Core(
GroupOffsetCommitAdmissionErrorKind::GroupMismatch
))
);
stop_registry(&mut registry);
}
#[test]
fn whole_registry_close_fences_every_entry_and_global_host_once() {
let mut registry = started_registry();
let group_id = register(&mut registry, "workers");
install_session(&mut registry, group_id);
registry.close_admission();
assert!(!registry.accepting);
assert!(registry.entries.iter().all(|entry| !entry.is_active()));
assert_eq!(
registry.close_group(group_id),
Err(GroupRegistryCloseError::AlreadyClosing)
);
let shutdown_error = registry
.finish_shutdown()
.err()
.unwrap_or_else(|| panic!("unsettled membership must block shutdown"));
let expected = GroupConsumerHostError::membership_unsettled(2);
assert_eq!(shutdown_error, expected);
assert_eq!(
registry.turn_local_membership(Moment::from_tick(u64::MAX)),
Ok(GroupConsumerMembershipTurn::Progress)
);
let join = registry
.finish_shutdown()
.unwrap_or_else(|error| panic!("finish shutdown failed: {error}"));
join.join_off_notifier()
.unwrap_or_else(|error| panic!("notifier join failed: {error}"));
}