kafka-client-engine 0.0.1

Execution and driver-integration layer for the native Kafka client
Documentation
//! Focused evidence for strict generated ACL response normalization.

use kafka_wire::{
    DescribeAclsResponse,
    describe_acls_response::{AclDescription, DescribeAclsResource},
};
use kafka_wire_core::StrBytes;

use super::{
    DescribeAclsResponseFailure, normalize_describe_acls_response,
    retention::{MAX_DIAGNOSTIC_BYTES, MAX_RESOURCE_NAME_BYTES, MAX_RESOURCES},
};

#[test]
fn response_flattens_and_orders_bindings_by_bytes_then_scalars() {
    let response = response(vec![
        resource(
            2,
            "orders",
            3,
            vec![acl("User:z", "*", 8, 3), acl("User:a", "10.0.0.1", -7, -8)],
        ),
        resource(-1, "audit", -2, vec![acl("User:m", "*", -3, -4)]),
    ]);

    let normalized = normalize_describe_acls_response(3, &response, usize::MAX)
        .unwrap_or_else(|error| panic!("valid response: {error:?}"));
    assert_eq!(normalized.throttle_time_ms, 7);
    assert_eq!(normalized.error_code, 0);
    assert_eq!(normalized.bindings.len(), 3);

    let audit = &normalized.bindings[0];
    assert_eq!(audit.resource_name, "audit");
    assert_eq!(audit.principal, "User:m");
    assert_eq!(audit.host, "*");
    assert_eq!(
        (
            audit.resource_type,
            audit.pattern_type,
            audit.operation,
            audit.permission_type,
        ),
        (-1, -2, -3, -4)
    );

    assert_eq!(normalized.bindings[1].resource_name, "orders");
    assert_eq!(normalized.bindings[1].principal, "User:a");
    assert_eq!(normalized.bindings[2].principal, "User:z");
}

#[test]
fn response_preserves_signed_top_level_error_and_utf8_bounded_diagnostic() {
    let diagnostic = format!("{}é", "x".repeat(MAX_DIAGNOSTIC_BYTES - 1));
    let mut response = response(Vec::new());
    response.error_code = -42;
    response.error_message = Some(StrBytes::from(diagnostic.as_str()));

    let normalized = normalize_describe_acls_response(1, &response, usize::MAX)
        .unwrap_or_else(|error| panic!("bounded broker rejection: {error:?}"));
    assert_eq!(normalized.error_code, -42);
    assert_eq!(
        normalized.error_message.as_deref().map(str::len),
        Some(MAX_DIAGNOSTIC_BYTES - 1)
    );
    assert!(normalized.error_message_truncated);
    assert!(normalized.bindings.is_empty());
}

#[test]
fn response_rejects_versions_and_negative_throttle() {
    let response = response(Vec::new());
    assert_eq!(
        normalize_describe_acls_response(0, &response, usize::MAX),
        Err(DescribeAclsResponseFailure::UnsupportedApiVersion { actual: 0 })
    );
    assert_eq!(
        normalize_describe_acls_response(4, &response, usize::MAX),
        Err(DescribeAclsResponseFailure::UnsupportedApiVersion { actual: 4 })
    );

    let mut response = response;
    response.throttle_time_ms = -1;
    assert_eq!(
        normalize_describe_acls_response(2, &response, usize::MAX),
        Err(DescribeAclsResponseFailure::NegativeThrottleTime { actual: -1 })
    );
}

#[test]
fn response_rejects_resources_beside_top_level_error() {
    let mut response = response(vec![resource(
        2,
        "orders",
        3,
        vec![acl("User:a", "*", 3, 3)],
    )]);
    response.error_code = 31;

    assert_eq!(
        normalize_describe_acls_response(2, &response, usize::MAX),
        Err(DescribeAclsResponseFailure::ResourcesWithTopLevelError { actual: 1 })
    );
}

#[test]
fn response_rejects_duplicate_resource_and_acl_shapes() {
    let duplicate_resource = response(vec![
        resource(2, "orders", 3, vec![acl("User:a", "*", 3, 3)]),
        resource(2, "orders", 3, vec![acl("User:b", "*", 3, 3)]),
    ]);
    assert_eq!(
        normalize_describe_acls_response(2, &duplicate_resource, usize::MAX),
        Err(DescribeAclsResponseFailure::DuplicateResource)
    );

    let duplicate_acl = response(vec![resource(
        2,
        "orders",
        3,
        vec![acl("User:a", "*", 3, 3), acl("User:a", "*", 3, 3)],
    )]);
    assert_eq!(
        normalize_describe_acls_response(2, &duplicate_acl, usize::MAX),
        Err(DescribeAclsResponseFailure::DuplicateAcl)
    );
}

#[test]
fn response_rejects_empty_and_oversized_text_shapes() {
    let empty_resource = response(vec![resource(2, "", 3, vec![acl("User:a", "*", 3, 3)])]);
    assert_eq!(
        normalize_describe_acls_response(2, &empty_resource, usize::MAX),
        Err(DescribeAclsResponseFailure::EmptyResourceName)
    );

    let empty_acls = response(vec![resource(2, "orders", 3, Vec::new())]);
    assert_eq!(
        normalize_describe_acls_response(2, &empty_acls, usize::MAX),
        Err(DescribeAclsResponseFailure::EmptyResourceAcls)
    );

    let empty_principal = response(vec![resource(2, "orders", 3, vec![acl("", "*", 3, 3)])]);
    assert_eq!(
        normalize_describe_acls_response(2, &empty_principal, usize::MAX),
        Err(DescribeAclsResponseFailure::EmptyPrincipal)
    );

    let empty_host = response(vec![resource(
        2,
        "orders",
        3,
        vec![acl("User:a", "", 3, 3)],
    )]);
    assert_eq!(
        normalize_describe_acls_response(2, &empty_host, usize::MAX),
        Err(DescribeAclsResponseFailure::EmptyHost)
    );

    let oversized = "x".repeat(MAX_RESOURCE_NAME_BYTES + 1);
    let oversized_resource = response(vec![resource(
        2,
        &oversized,
        3,
        vec![acl("User:a", "*", 3, 3)],
    )]);
    assert_eq!(
        normalize_describe_acls_response(2, &oversized_resource, usize::MAX),
        Err(DescribeAclsResponseFailure::ResourceNameTooLong {
            actual: MAX_RESOURCE_NAME_BYTES + 1,
            max: MAX_RESOURCE_NAME_BYTES,
        })
    );
}

#[test]
fn response_rejects_hostile_resource_count_before_entry_validation() {
    let response = response(vec![DescribeAclsResource::default(); MAX_RESOURCES + 1]);

    assert_eq!(
        normalize_describe_acls_response(2, &response, usize::MAX),
        Err(DescribeAclsResponseFailure::TooManyResources {
            actual: MAX_RESOURCES + 1,
            max: MAX_RESOURCES,
        })
    );
}

#[test]
fn response_checks_peak_scratch_and_output_capacity_before_copying() {
    let response = response(vec![resource(
        2,
        "orders",
        3,
        vec![acl("User:a", "*", 3, 3)],
    )]);
    let normalized = normalize_describe_acls_response(2, &response, usize::MAX)
        .unwrap_or_else(|error| panic!("measure peak: {error:?}"));
    let required = normalized.retained_bytes;

    assert_eq!(
        normalize_describe_acls_response(2, &response, required - 1),
        Err(DescribeAclsResponseFailure::RetainedBytes {
            required,
            limit: required - 1,
        })
    );
    assert!(normalize_describe_acls_response(2, &response, required).is_ok());
}

fn response(resources: Vec<DescribeAclsResource>) -> DescribeAclsResponse {
    let mut response = DescribeAclsResponse::default();
    response.throttle_time_ms = 7;
    response.error_code = 0;
    response.error_message = None;
    response.resources = resources;
    response
}

fn resource(
    resource_type: i8,
    resource_name: &str,
    pattern_type: i8,
    acls: Vec<AclDescription>,
) -> DescribeAclsResource {
    let mut resource = DescribeAclsResource::default();
    resource.resource_type = resource_type;
    resource.resource_name = StrBytes::from(resource_name);
    resource.pattern_type = pattern_type;
    resource.acls = acls;
    resource
}

fn acl(principal: &str, host: &str, operation: i8, permission_type: i8) -> AclDescription {
    let mut acl = AclDescription::default();
    acl.principal = StrBytes::from(principal);
    acl.host = StrBytes::from(host);
    acl.operation = operation;
    acl.permission_type = permission_type;
    acl
}