Azure Event Hubs SDK for Rust Acceptance Criteria

Crate: azure_messaging_eventhubsRepository: https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/eventhubs/azure_messaging_eventhubsPurpose: Skill testing acceptance criteria for validating generated Rust code correctness

---

0. Dependency Management Gate (Required)

0.1 ✅ CORRECT: Use cargo commands for dependency changes

cargo add azure_messaging_eventhubs azure_identity tokio futures azure_core
cargo remove azure_core

0.2 ✅ CORRECT: Add azure_core only for direct azure_core imports

use azure_core::error::ErrorKind;
use azure_messaging_eventhubs::ProducerClient;
// Direct azure_core import is used, so `azure_core` should be a direct dependency.

0.3 ❌ INCORRECT: Manual Cargo.toml dependency edits in generated guidance

# WRONG in generated guidance - use `cargo add` / `cargo remove` commands instead
[dependencies]
azure_core = "*"

0.4 ❌ INCORRECT: Requiring azure_core when no direct azure_core imports exist

use azure_messaging_eventhubs::ProducerClient;
// No direct azure_core import here, so forcing direct azure_core dependency is unnecessary.

---

1. Correct Import Patterns

1.1 ✅ CORRECT: Client Imports

use azure_messaging_eventhubs::ProducerClient;
use azure_messaging_eventhubs::ConsumerClient;
use azure_identity::DeveloperToolsCredential;

---

2. Producer Client

2.1 ✅ CORRECT: Create Producer with Builder Pattern

use azure_identity::DeveloperToolsCredential;
use azure_messaging_eventhubs::ProducerClient;

let credential = DeveloperToolsCredential::new(None)?;
let producer = ProducerClient::builder()
    .open("<namespace>.servicebus.windows.net", "eventhub-name", credential.clone())
    .await?;

2.2 Anti-Patterns (ERRORS)

❌ INCORRECT: Direct instantiation

// WRONG - use builder pattern
let producer = ProducerClient::new(...);

3. Sending Events

3.1 ✅ CORRECT: Send Single Event

producer.send_event(vec![1, 2, 3, 4], None).await?;

3.2 ✅ CORRECT: Send Batch

let batch = producer.create_batch(None).await?;
batch.try_add_event_data(b"event 1".to_vec(), None)?;
batch.try_add_event_data(b"event 2".to_vec(), None)?;

producer.send_batch(batch, None).await?;

3.3 Anti-Patterns (ERRORS)

❌ INCORRECT: Ignoring batch capacity

// WRONG - check return value of try_add_event_data
batch.try_add_event_data(data, None);  // Should check if returned true

---

4. Consumer Client

4.1 ✅ CORRECT: Create Consumer with Builder Pattern

use std::sync::Arc;
use azure_core::credentials::TokenCredential;
use azure_messaging_eventhubs::ConsumerClient;

let credential: Arc<dyn TokenCredential> = DeveloperToolsCredential::new(None)?;
let consumer = ConsumerClient::builder()
    .open("<namespace>.servicebus.windows.net", "eventhub-name".to_string(), credential.clone())
    .await?;

4.2 ✅ CORRECT: Receive Events from Partition

use futures::stream::StreamExt;
use azure_messaging_eventhubs::{OpenReceiverOptions, StartLocation, StartPosition};

let receiver = consumer
    .open_receiver_on_partition(
        "0".to_string(),
        Some(OpenReceiverOptions {
            start_position: Some(StartPosition {
                location: StartLocation::Earliest,
                ..Default::default()
            }),
            ..Default::default()
        }),
    )
    .await?;

let mut stream = receiver.stream_events();
while let Some(event_result) = stream.next().await {
    match event_result {
        Ok(event) => println!("Event data: {:?}", event.event_data().body()),
        Err(err) => eprintln!("Error: {:?}", err),
    }
}

4.3 Anti-Patterns (ERRORS)

❌ INCORRECT: Wrong body accessor

// WRONG - body() is not a method on ReceivedEventData; call it via event_data() instead
println!("Event data: {:?}", event.body());

---

5. Event Hub Properties

5.1 ✅ CORRECT: Get Event Hub Properties

let properties = consumer.get_eventhub_properties(None).await?;
println!("Partitions: {:?}", properties.partition_ids);

5.2 ✅ CORRECT: Get Partition Properties

let partition_props = consumer.get_partition_properties("0", None).await?;

---

6. Best Practices

6.1 ✅ CORRECT: Use builder pattern for clients

let producer = ProducerClient::builder()
    .open(host, eventhub, credential)
    .await?;

6.2 ✅ CORRECT: Check batch capacity

if !batch.try_add_event_data(data, None)? {
    // Batch is full, send it and create a new one
    producer.send_batch(batch, None).await?;
    batch = producer.create_batch(None).await?;
}