use std::{sync::Arc, time::Duration};
use kafka_client_core::{AssignedConsumerEffect, FetchFailure, NextFetchOffset, StartPosition};
use super::{
assigned_close_error::AssignedCloseSlotPhase,
assigned_event::AssignedConsumerEventStoreError,
assigned_owner_effect::FrontEffect,
assigned_owner_model::AssignedConsumerOwnerError,
assigned_owner_test::{input, owner},
};
#[test]
fn assignment_commits_topics_only_after_core_accepts() {
let mut owner = owner(2);
let epoch = owner
.replace_assignment(
vec![input("orders", 0, StartPosition::Offset(offset(4)))],
Duration::from_secs(10),
)
.unwrap_or_else(|error| panic!("assign: {error:?}"));
assert_eq!(owner.machine.assignment_epoch(), Some(epoch));
assert_eq!(owner.topics.retained_topic_count(), 1);
assert!(matches!(
owner.effects.front(),
Some(AssignedConsumerEffect::FetchReady { .. })
));
}
#[test]
fn close_reserves_before_core_acceptance_and_rolls_back_core_rejection() {
let mut accepted = owner(1);
let _observer = accepted
.begin_close()
.unwrap_or_else(|error| panic!("begin close: {error:?}"));
assert_eq!(accepted.close.phase(), AssignedCloseSlotPhase::Reserved);
let mut rejected = owner(1);
rejected
.machine
.apply(kafka_client_core::AssignedConsumerInput::BeginClose)
.unwrap_or_else(|error| panic!("close core fixture: {error}"));
assert!(matches!(
rejected.begin_close(),
Err(AssignedConsumerOwnerError::Core(
kafka_client_core::AssignedConsumerMachineError::ConsumerClosed
))
));
assert_eq!(rejected.close.phase(), AssignedCloseSlotPhase::Vacant);
}
#[test]
fn rejected_duplicate_assignment_does_not_commit_staged_names() {
let mut owner = owner(2);
let result = owner.replace_assignment(
vec![
input("orders", 0, StartPosition::Beginning),
input("orders", 0, StartPosition::End),
],
Duration::from_secs(10),
);
assert!(matches!(result, Err(AssignedConsumerOwnerError::Core(_))));
assert_eq!(owner.topics.retained_topic_count(), 0);
assert_eq!(owner.events.retained(), (0, 0));
assert!(owner.effects.is_empty());
}
#[test]
fn event_capacity_rejection_precedes_core_and_topic_mutation() {
let mut owner = owner(1);
let epoch = owner
.replace_assignment(
vec![input("orders", 0, StartPosition::Offset(offset(4)))],
Duration::from_secs(10),
)
.unwrap_or_else(|error| panic!("assign: {error:?}"));
let fence = match owner.effects.pop_front() {
Some(AssignedConsumerEffect::FetchReady { fence, .. }) => fence,
effect => panic!("initial Fetch claim, got {effect:?}"),
};
let topic = Arc::clone(
owner
.topics
.name(fence.position().partition().topic_id())
.unwrap_or_else(|error| panic!("topic: {error:?}")),
);
owner
.events
.retain_terminal(
topic,
AssignedConsumerEffect::FetchFailed {
fence,
failure: FetchFailure::Transport,
},
)
.unwrap_or_else(|(error, _topic)| panic!("retain event: {error:?}"));
assert_eq!(
owner.replace_assignment(
vec![input("orders", 1, StartPosition::Offset(offset(8)))],
Duration::from_secs(10),
),
Err(AssignedConsumerOwnerError::Event(
AssignedConsumerEventStoreError::Capacity
))
);
assert_eq!(owner.machine.assignment_epoch(), Some(epoch));
assert_eq!(owner.topics.retained_topic_count(), 1);
assert_eq!(owner.events.retained(), (0, 1));
}
#[test]
fn replacement_revoke_does_not_cancel_new_epoch_event_claim() {
let mut owner = owner(1);
let old_epoch = owner
.replace_assignment(
vec![input("orders", 0, StartPosition::Offset(offset(4)))],
Duration::from_secs(10),
)
.unwrap_or_else(|error| panic!("initial assignment: {error:?}"));
assert_eq!(owner.interpret_front_effect(), FrontEffect::Interpreted);
let new_epoch = owner
.replace_assignment(
vec![input("orders", 0, StartPosition::Offset(offset(8)))],
Duration::from_secs(10),
)
.unwrap_or_else(|error| panic!("replacement assignment: {error:?}"));
assert!(new_epoch > old_epoch);
assert!(matches!(
owner.effects.front(),
Some(AssignedConsumerEffect::Revoke {
assignment_epoch,
..
}) if *assignment_epoch == old_epoch
));
assert_eq!(owner.events.retained(), (1, 0));
assert_eq!(owner.interpret_front_effect(), FrontEffect::Interpreted);
assert_eq!(owner.events.retained(), (1, 0));
assert_eq!(owner.interpret_front_effect(), FrontEffect::Interpreted);
assert_eq!(owner.events.retained(), (1, 0));
}
fn offset(value: i64) -> NextFetchOffset {
NextFetchOffset::try_from_raw(value).unwrap_or_else(|| panic!("nonnegative test offset"))
}