use kafka_client_core::{
BatchExecutionGeneration, BatchExecutionId, BatchId, Deadline, Moment,
ProducerBrokerFailureKind, ProducerInput,
};
use kafka_wire::{
ProduceResponse,
produce_response::{PartitionProduceResponse, TopicProduceResponse},
};
use super::{
super::produce_call_entries::{TrackedProduceEntries, TrackedProduceEntry},
settlement::SettledProduceCall,
};
#[test]
fn aggregate_routing_failure_never_claims_partition_refresh() {
let mut settled = SettledProduceCall::from_terminal(
TrackedProduceEntries::batch(vec![entry(1, 90, 0), entry(2, 40, 1)]),
Ok(response()),
Moment::from_tick(10),
None,
);
assert_eq!(settled.refresh_deadline(), None);
assert!(matches!(
settled.input(),
ProducerInput::BrokerSucceeded { execution: actual, .. } if actual == execution(1)
));
assert!(settled.advance(Moment::from_tick(12)));
assert!(matches!(
settled.input(),
ProducerInput::BrokerFailed {
execution: actual,
failure,
route_refreshed: false,
..
} if actual == execution(2) && failure.kind() == ProducerBrokerFailureKind::Routing
));
assert!(!settled.advance(Moment::from_tick(13)));
}
#[test]
fn aggregate_preserves_each_routing_failure_without_shared_retry_authority() {
let mut settled = SettledProduceCall::from_terminal(
TrackedProduceEntries::batch(vec![entry(1, 20, 0), entry(2, 40, 1), entry(3, 70, 2)]),
Ok(response_with_two_routing_failures()),
Moment::from_tick(10),
None,
);
assert_eq!(settled.refresh_deadline(), None);
assert!(matches!(
settled.input(),
ProducerInput::BrokerSucceeded { execution: actual, .. } if actual == execution(1)
));
assert!(settled.advance(Moment::from_tick(20)));
assert!(matches!(
settled.input(),
ProducerInput::BrokerFailed {
execution: actual,
failure,
route_refreshed: false,
..
} if actual == execution(2) && failure.kind() == ProducerBrokerFailureKind::Routing
));
assert!(settled.advance(Moment::from_tick(41)));
assert!(matches!(
settled.input(),
ProducerInput::BrokerFailed {
execution: actual,
failure,
route_refreshed: false,
..
} if actual == execution(3) && failure.kind() == ProducerBrokerFailureKind::Routing
));
assert!(!settled.advance(Moment::from_tick(42)));
}
#[test]
fn aggregate_shutdown_recovery_retains_and_seals_every_execution() {
let settled = SettledProduceCall::from_terminal(
TrackedProduceEntries::batch(vec![entry(1, 20, 0), entry(2, 20, 1), entry(3, 20, 2)]),
Ok(response_with_two_routing_failures()),
Moment::from_tick(10),
None,
);
let recovered = settled.recover_after_driver_shutdown();
assert_eq!(
recovered.executions().collect::<Vec<_>>(),
vec![execution(1), execution(2), execution(3)]
);
recovered.seal();
}
fn entry(batch: u64, deadline: u64, partition: i32) -> TrackedProduceEntry {
TrackedProduceEntry {
execution: execution(batch),
deadline: Deadline::from_tick(deadline),
topic: "orders".into(),
partition,
}
}
fn execution(batch: u64) -> BatchExecutionId {
BatchExecutionId::new(
BatchId::from_raw(batch),
BatchExecutionGeneration::initial(),
)
}
fn response() -> ProduceResponse {
let mut success = PartitionProduceResponse::default();
success.index = 0;
success.base_offset = 41;
let mut routing_failure = PartitionProduceResponse::default();
routing_failure.index = 1;
routing_failure.error_code = 6;
let mut topic = TopicProduceResponse::default();
topic.name = "orders".into();
topic.partition_responses = vec![success, routing_failure];
let mut response = ProduceResponse::default();
response.responses.push(topic);
response
}
fn response_with_two_routing_failures() -> ProduceResponse {
let mut response = response();
let mut routing_failure = PartitionProduceResponse::default();
routing_failure.index = 2;
routing_failure.error_code = 6;
response.responses[0]
.partition_responses
.push(routing_failure);
response
}