use std::sync::Arc;
use kafka_client_core::{
ClassicGeneration, ClassicGroupEffect, ClassicGroupInput, GroupAssignmentPartition, GroupId,
LiveGroupAssignment, Moment, PartitionIndex, TopicId,
};
use super::{
classic_group_owner::ClassicGroupOwner, classic_group_test_support,
session_catalog::GroupSessionCatalog,
};
fn owners() -> (GroupSessionCatalog, ClassicGroupOwner) {
let group_id = GroupId::try_from_raw(9).unwrap_or_else(|| panic!("nonzero group identity"));
let catalog =
GroupSessionCatalog::try_new(group_id, Arc::from("workers"), &[Arc::from("orders")])
.unwrap_or_else(|error| panic!("catalog creation failed: {error:?}"));
(
catalog,
ClassicGroupOwner::new(
group_id,
super::classic_group_test_support::timing(),
super::classic_group_test_support::heartbeat_policy(),
super::classic_group_test_support::rejoin_policy(),
),
)
}
#[test]
fn install_moves_the_exact_core_assignment_and_advances_staged_identities() {
let (mut catalog, mut owner) = owners();
let cycle = classic_group_test_support::begin(&mut owner);
let member_cursor = catalog.next_member_id;
let candidate = catalog
.prepare_follower_cycle(cycle, Arc::from("member-a"))
.unwrap_or_else(|error| panic!("candidate failed: {error:?}"));
let member_id = candidate.local_member_id();
owner
.stage_candidate(candidate)
.unwrap_or_else(|error| panic!("candidate stage failed: {error:?}"));
owner
.apply(ClassicGroupInput::JoinFollower {
cycle,
now: Moment::from_tick(2),
member_id,
generation: ClassicGeneration::try_from_raw(7)
.unwrap_or_else(|| panic!("classic generation")),
})
.unwrap_or_else(|error| panic!("Join failed: {error}"));
assert!(catalog.live_assignment().is_none());
assert_eq!(catalog.next_member_id, member_cursor);
let install = owner
.apply(ClassicGroupInput::SyncSucceeded {
cycle,
now: Moment::from_tick(3),
partitions: vec![GroupAssignmentPartition::new(
TopicId::from_raw(1),
PartitionIndex::from_raw(2),
)],
})
.unwrap_or_else(|error| panic!("Sync failed: {error}"))
.into_effects()
.next()
.unwrap_or_else(|| panic!("Install expected"));
let ClassicGroupEffect::Install {
assignment,
classic_generation,
heartbeat: _heartbeat,
} = install
else {
panic!("Install expected");
};
let assignment_storage = assignment.partitions().as_ptr();
owner
.prepare_install(&mut catalog, assignment, classic_generation)
.unwrap_or_else(|failure| panic!("install preparation failed: {:?}", failure.kind))
.commit();
let current = catalog
.live_assignment()
.unwrap_or_else(|| panic!("installed assignment expected"));
assert_eq!(current.member_id(), member_id);
assert_eq!(current.partitions().as_ptr(), assignment_storage);
assert_eq!(current.partitions()[0].partition().get(), 2);
assert_eq!(
catalog.current_member().map(std::convert::AsRef::as_ref),
Some("member-a")
);
assert_eq!(catalog.classic_generation(), Some(7));
assert_eq!(
catalog.next_member_id.map(kafka_client_core::MemberId::get),
Some(2)
);
}
#[test]
fn revoke_clears_only_after_core_assignment_loss() {
let (mut catalog, mut owner) = owners();
classic_group_test_support::install_follower(
&mut catalog,
&mut owner,
"member-a",
7,
Vec::new(),
);
let cycle = owner
.machine()
.active_cycle()
.unwrap_or_else(|| panic!("stable cycle expected"));
let revoke = owner
.apply(ClassicGroupInput::AssignmentLost { cycle })
.unwrap_or_else(|error| panic!("assignment loss failed: {error}"))
.into_effects()
.next()
.unwrap_or_else(|| panic!("Revoke expected"));
let ClassicGroupEffect::Revoke {
assignment,
classic_generation,
} = revoke
else {
panic!("Revoke expected");
};
assert!(catalog.live_assignment().is_some());
owner
.prepare_revoke(&mut catalog, assignment, classic_generation)
.unwrap_or_else(|failure| panic!("revoke preparation failed: {:?}", failure.kind))
.commit();
assert!(catalog.live_assignment().is_none());
assert!(catalog.current_member().is_none());
}
#[test]
fn reconciliation_advances_broker_generation_without_replacing_assignment() {
let (mut catalog, mut owner) = owners();
classic_group_test_support::install_follower(
&mut catalog,
&mut owner,
"member-a",
7,
vec![GroupAssignmentPartition::new(
TopicId::from_raw(1),
PartitionIndex::from_raw(2),
)],
);
let current = catalog
.live_assignment()
.unwrap_or_else(|| panic!("installed assignment"));
let previous = LiveGroupAssignment::try_new(
current.group_id(),
current.member_id(),
current.assignment_generation(),
current.partitions().to_vec(),
)
.unwrap_or_else(|error| panic!("previous assignment copy: {error}"));
let old_storage = current.partitions().as_ptr();
let cycle = owner
.machine()
.active_cycle()
.and_then(kafka_client_core::MembershipCycle::checked_next)
.unwrap_or_else(|| panic!("next membership cycle"));
let candidate = catalog
.prepare_follower_cycle(cycle, Arc::from("member-a"))
.unwrap_or_else(|error| panic!("reconciliation candidate: {error:?}"));
catalog
.prepare_classic_reconciliation_epoch(
&candidate,
&previous,
ClassicGeneration::try_from_raw(7).unwrap_or_else(|| panic!("old generation")),
ClassicGeneration::try_from_raw(8).unwrap_or_else(|| panic!("new generation")),
)
.unwrap_or_else(|| panic!("reconciliation epoch must prepare"))
.commit();
let retained = catalog
.live_assignment()
.unwrap_or_else(|| panic!("prior assignment remains live"));
assert_eq!(retained.partitions().as_ptr(), old_storage);
assert_eq!(catalog.membership_cycle(), owner.machine().active_cycle());
assert_eq!(catalog.classic_generation(), Some(8));
}