use kafka_client_core::{
CreateTopicConfig, CreateTopicReplicaAssignment, CreateTopicResult, CreateTopicSpecification,
CreateTopicsPlan,
};
use kafka_wire::{CreateTopicsResponse, create_topics_response::CreatableTopicResult};
use super::create_topics::{
CreateTopicsProtocolFailure, CreateTopicsRequestError, create_topics_request,
normalize_create_topics_response_bounded, remaining_timeout_ms,
};
fn plan() -> CreateTopicsPlan {
CreateTopicsPlan::new(
vec![
CreateTopicSpecification::new(
"orders",
3,
2,
vec![
CreateTopicConfig::new("cleanup.policy", Some("compact".to_owned())),
CreateTopicConfig::new("retention.ms", None),
],
),
CreateTopicSpecification::new("audit", 1, -1, Vec::new()),
],
true,
)
.unwrap_or_else(|error| panic!("valid CreateTopics test plan: {error}"))
}
fn result(topic: &str, error_code: i16, message: Option<&str>) -> CreatableTopicResult {
let mut result = CreatableTopicResult::default();
result.name = topic.into();
result.error_code = error_code;
result.error_message = message.map(Into::into);
result
}
fn response(topics: Vec<CreatableTopicResult>) -> CreateTopicsResponse {
let mut response = CreateTopicsResponse::default();
response.topics = topics;
response
}
fn manual_plan() -> CreateTopicsPlan {
CreateTopicsPlan::new(
vec![CreateTopicSpecification::manual(
"placed",
vec![
CreateTopicReplicaAssignment::new(0, vec![7, 3]),
CreateTopicReplicaAssignment::new(1, vec![3, 9]),
],
None,
vec![CreateTopicConfig::new(
"cleanup.policy",
Some("compact".to_owned()),
)],
)],
false,
)
.unwrap_or_else(|error| panic!("valid manual CreateTopics plan: {error}"))
}
#[test]
fn generated_request_preserves_order_nullable_configs_and_broker_timeout() {
let request = create_topics_request(&plan(), 12_345)
.unwrap_or_else(|error| panic!("valid generated request: {error:?}"));
assert_eq!(request.timeout_ms, 12_345);
assert!(request.validate_only);
assert_eq!(request.topics[0].name.as_str(), "orders");
assert_eq!(request.topics[1].name.as_str(), "audit");
assert_eq!(request.topics[0].num_partitions, 3);
assert_eq!(request.topics[0].replication_factor, 2);
assert!(request.topics[0].assignments.is_empty());
assert_eq!(request.topics[0].configs[0].name.as_str(), "cleanup.policy");
assert!(matches!(
request.topics[0].configs[0].value.as_ref(),
Some(value) if value.as_str() == "compact"
));
assert_eq!(request.topics[0].configs[1].value, None);
assert_eq!(
create_topics_request(&plan(), -1),
Err(CreateTopicsRequestError::NegativeTimeout)
);
}
#[test]
fn generated_request_writes_manual_assignments_and_exact_sentinels() {
let request = create_topics_request(&manual_plan(), 4_321)
.unwrap_or_else(|error| panic!("valid generated manual request: {error:?}"));
let topic = &request.topics[0];
assert_eq!(topic.name.as_str(), "placed");
assert_eq!(topic.num_partitions, -1);
assert_eq!(topic.replication_factor, -1);
assert_eq!(topic.assignments.len(), 2);
assert_eq!(topic.assignments[0].partition_index, 0);
assert_eq!(topic.assignments[0].broker_ids, vec![7, 3]);
assert_eq!(topic.assignments[1].partition_index, 1);
assert_eq!(topic.assignments[1].broker_ids, vec![3, 9]);
assert_eq!(topic.configs[0].name.as_str(), "cleanup.policy");
}
#[test]
fn remaining_timeout_uses_the_original_absolute_deadline() {
assert_eq!(
remaining_timeout_ms(
kafka_client_core::Moment::from_tick(1_000_001),
kafka_client_core::Deadline::from_tick(2_000_000),
),
Ok(1)
);
assert_eq!(
remaining_timeout_ms(
kafka_client_core::Moment::from_tick(2_000_000),
kafka_client_core::Deadline::from_tick(2_000_000),
),
Err(CreateTopicsRequestError::DeadlineElapsed)
);
}
#[test]
fn response_is_reordered_to_request_order_and_unknown_code_is_lossless() {
let response = response(vec![
result("audit", -32_000, Some("future broker code")),
result("orders", 0, None),
]);
let outcomes = normalize_create_topics_response_bounded(&plan(), &response, usize::MAX)
.unwrap_or_else(|error| panic!("correlatable response: {error:?}"));
assert_eq!(outcomes[0].topic(), "orders");
assert_eq!(outcomes[0].result(), &CreateTopicResult::Created);
assert_eq!(outcomes[1].topic(), "audit");
let CreateTopicResult::Failed(error) = outcomes[1].result() else {
panic!("unknown broker code became a false success");
};
assert_eq!(error.code(), -32_000);
assert_eq!(error.message(), Some("future broker code"));
}
#[test]
fn structural_mismatches_never_bind_results_to_the_wrong_topic() {
let count = response(vec![result("orders", 0, None)]);
assert_eq!(
normalize_create_topics_response_bounded(&plan(), &count, usize::MAX),
Err(CreateTopicsProtocolFailure::TopicCount {
expected: 2,
actual: 1,
})
);
let unexpected = response(vec![result("orders", 0, None), result("payments", 0, None)]);
assert_eq!(
normalize_create_topics_response_bounded(&plan(), &unexpected, usize::MAX),
Err(CreateTopicsProtocolFailure::UnexpectedTopic {
topic: "payments".to_owned(),
})
);
let duplicate = response(vec![result("orders", 0, None), result("orders", 0, None)]);
assert_eq!(
normalize_create_topics_response_bounded(&plan(), &duplicate, usize::MAX),
Err(CreateTopicsProtocolFailure::DuplicateTopic {
topic: "orders".to_owned(),
})
);
}