use kafka_driver::{ApiVersion, CompletionError};
use kafka_wire::SyncGroupResponse;
use super::{
sync_group_calls::{AcceptedSyncGroupCall, TrackedSyncGroupCalls},
sync_group_settlement::{SyncGroupBeginError, SyncGroupConfirmationError, SyncGroupPoll},
sync_group_terminal::retain_sync_group_terminal,
sync_group_terminal_test::{deadline, key, key_with_deadline},
};
#[test]
fn same_cycle_and_deadline_from_another_group_cannot_take_settlement() {
let deadline = deadline();
let first = key_with_deadline(1, deadline);
let second = key_with_deadline(2, deadline);
let mut calls = terminal_calls(first);
let second_receipt = accepted(second);
assert_eq!(
calls.begin_sync_group_settlement(&second_receipt).err(),
Some(SyncGroupBeginError::KeyMismatch {
settled: first,
supplied: second,
})
);
assert_eq!(second_receipt.key(), second);
assert_eq!(
calls.poll_sync_group(),
Ok(SyncGroupPoll::TerminalReady { key: first })
);
}
#[test]
fn changed_deadline_receipt_cannot_take_settlement_and_remains_owned() {
let original_deadline = deadline();
let settled_key = key_with_deadline(1, original_deadline);
let changed_deadline = crate::clock::OperationDeadline::from_parts_for_test(
kafka_client_core::Deadline::from_tick(original_deadline.core().tick() + 1),
original_deadline.transport(),
);
let changed_key = key_with_deadline(1, changed_deadline);
let changed_receipt = accepted(changed_key);
let mut calls = terminal_calls(settled_key);
assert_eq!(
calls.begin_sync_group_settlement(&changed_receipt).err(),
Some(SyncGroupBeginError::KeyMismatch {
settled: settled_key,
supplied: changed_key,
})
);
assert_eq!(changed_receipt.key(), changed_key);
assert_eq!(
calls.poll_sync_group(),
Ok(SyncGroupPoll::TerminalReady { key: settled_key })
);
}
#[test]
fn failed_interpretation_can_restore_the_exact_raw_terminal() {
let key = key(1);
let mut calls = terminal_calls(key);
let accepted = accepted(key);
let terminal = calls
.begin_sync_group_settlement(&accepted)
.unwrap_or_else(|error| panic!("test settlement must begin: {error:?}"));
calls
.restore_sync_group_settlement(terminal)
.unwrap_or_else(|_failure| panic!("exact terminal must restore"));
let terminal = calls
.begin_sync_group_settlement(&accepted)
.unwrap_or_else(|error| panic!("restored settlement must begin: {error:?}"));
assert_eq!(terminal.selected_version(), Some(2));
calls
.confirm_sync_group_settlement(accepted)
.unwrap_or_else(|_failure| panic!("exact route confirmation must finish"));
assert_eq!(calls.retained_sync_group_count(), 0);
}
#[test]
fn mismatched_confirmation_returns_the_receipt_without_mutating_pending_ownership() {
let pending_key = key(1);
let mut calls = terminal_calls(pending_key);
let exact_receipt = accepted(pending_key);
let _terminal = calls
.begin_sync_group_settlement(&exact_receipt)
.unwrap_or_else(|error| panic!("test settlement must begin: {error:?}"));
let wrong_key = key(2);
let failure = calls
.confirm_sync_group_settlement(accepted(wrong_key))
.err()
.unwrap_or_else(|| panic!("cross-group receipt must be fenced"));
let (wrong_receipt, error) = failure.into_parts();
assert_eq!(wrong_receipt.key(), wrong_key);
assert_eq!(
error,
SyncGroupConfirmationError::KeyMismatch {
pending: pending_key,
supplied: wrong_key,
}
);
assert_eq!(
calls.poll_sync_group(),
Ok(SyncGroupPoll::ConfirmationPending { key: pending_key })
);
calls
.confirm_sync_group_settlement(exact_receipt)
.unwrap_or_else(|_failure| panic!("exact receipt must confirm"));
assert_eq!(calls.retained_sync_group_count(), 0);
}
#[test]
fn shutdown_recovery_consumes_registry_and_reuses_preallocated_active_storage() {
let mut calls = TrackedSyncGroupCalls::new(3);
let allocated_capacity = calls.calls.capacity();
let key = key(1);
calls.install_completion_failure_for_test(key, CompletionError::Closed);
let mut recovery = calls.recover_sync_groups_after_driver_shutdown();
assert!(allocated_capacity >= 3);
assert_eq!(
recovery.active_storage_capacity_for_test(),
allocated_capacity
);
let failure = recovery
.take_completion()
.unwrap_or_else(|| panic!("completion ownership must recover"));
assert_eq!(failure.key(), key);
failure
.reconcile_sync_group_after_driver_shutdown(accepted(key))
.unwrap_or_else(|_failure| panic!("exact completion owner must reconcile"));
assert!(recovery.is_empty());
}
#[test]
fn shutdown_recovery_preserves_settled_and_external_pending_ownership() {
let settled_key = key(1);
let settled_receipt = accepted(settled_key);
let settled_calls = terminal_calls(settled_key);
let mut settled_recovery = settled_calls.recover_sync_groups_after_driver_shutdown();
assert_eq!(settled_recovery.retained_count(), 1);
let settled = settled_recovery
.take_settled()
.unwrap_or_else(|| panic!("raw settled terminal must recover"));
assert_eq!(settled.key(), settled_key);
assert_eq!(settled_receipt.key(), settled_key);
settled
.reconcile_sync_group_after_driver_shutdown(settled_receipt)
.unwrap_or_else(|_failure| panic!("exact settled owner must reconcile"));
assert!(settled_recovery.is_empty());
let pending_key = key(2);
let mut pending_calls = terminal_calls(pending_key);
let pending_receipt = accepted(pending_key);
let external = pending_calls
.begin_sync_group_settlement(&pending_receipt)
.unwrap_or_else(|error| panic!("test settlement must begin: {error:?}"));
let mut pending_recovery = pending_calls.recover_sync_groups_after_driver_shutdown();
assert_eq!(pending_recovery.retained_count(), 1);
let pending = pending_recovery
.take_pending()
.unwrap_or_else(|| panic!("pending route owner must recover"));
assert_eq!(pending.key(), external.key());
assert_eq!(pending_receipt.key(), external.key());
assert_eq!(external.selected_version(), Some(2));
pending
.reconcile_sync_group_after_driver_shutdown(pending_receipt)
.unwrap_or_else(|_failure| panic!("exact pending owner must reconcile"));
assert!(pending_recovery.is_empty());
}
fn accepted(key: super::sync_group_terminal::SyncGroupCallKey) -> AcceptedSyncGroupCall {
AcceptedSyncGroupCall::from_key_for_test(key)
}
fn terminal_calls(key: super::sync_group_terminal::SyncGroupCallKey) -> TrackedSyncGroupCalls {
let mut calls = TrackedSyncGroupCalls::new(1);
let terminal = retain_sync_group_terminal(
key,
Some(ApiVersion::new(2)),
Ok(SyncGroupResponse::default()),
);
calls.install_terminal_for_test(
terminal.key(),
terminal.selected_version(),
terminal.into_parts().2,
);
calls
}