feat: Add SAS support and bump version to 0.4.0

This release introduces several significant changes, including:
- Updated version to 0.4.0 in Cargo.toml and Cargo.lock.
- Added support for constructing clients directly from SAS URLs.
- Removed deprecated methods and changed parameter types for better flexibility.
- Enhanced examples to demonstrate SAS token usage.
- Updated tests to validate SAS token functionality for both QueueClient and QueueServiceClient.

Author: lsiddiquee

Cargo.lock

@@ -1,5 +1,26 @@
 # Release History
 
+## 0.4.0 (Unreleased)
+
+### Features Added
+
+- Added support for client construction directly from URLs:
+  - `QueueClient::from_url()`
+  - `QueueServiceClient::from_url()`
+- Added support for SAS (shared access signature) URLs via the new `from_url()` methods.
+
+### Breaking Changes
+
+- Removed the `queue_name()` accessor on `QueueClient`.
+- Removed the `endpoint` struct field on all clients, as this value is now returned directly from the underlying generated client.
+- Changed the `queue_name` parameter from owned `String` to `&str` reference on `QueueClient::new()`.
+- The `credential` parameter is now `Option<Arc<dyn TokenCredential>>` on `new()` and `from_url()` client constructors, allowing for construction of public access clients and clients using SAS tokens.
+- Changed `QueueServiceClient::queue_client()` to return `Result<QueueClient>` instead of `QueueClient`.
+
+### Bugs Fixed
+
+### Other Changes
+
 ## 0.3.0 (Unreleased)
 
 ### Features Added

sdk/storage/azure_storage_queue/CHANGELOG.md

@@ -1,6 +1,6 @@
 [package]
 name = "azure_storage_queue"
-version = "0.3.0"
+version = "0.4.0"
 description = "Microsoft Azure Queue client library for Rust"
 readme = "README.md"
 authors.workspace = true

sdk/storage/azure_storage_queue/Cargo.toml

@@ -49,7 +49,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let queue_client = QueueClient::new(
         "https://<storage_account_name>.blob.core.windows.net/", // endpoint
         "queue-name",                                            // queue name
-        credential,                                              // credential
+        Some(credential),                                        // credential
         Some(QueueClientOptions::default()),                     // QueueClient options
     )?;
     Ok(())

sdk/storage/azure_storage_queue/README.md

@@ -1,6 +1,6 @@
 {
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "rust",
-  "Tag": "rust/azure_storage_queue_b234d5c152",
+  "Tag": "rust/azure_storage_queue_064e449006",
   "TagPrefix": "rust/azure_storage_queue"
 }

sdk/storage/azure_storage_queue/assets.json

@@ -7,3 +7,4 @@ This directory contains a set of example for the use of the Storage Queue client
 The following environment variables need to be set:
 
 - `AZURE_QUEUE_STORAGE_ACCOUNT_NAME=<storage_account_name>`
+- `AZURE_QUEUE_STORAGE_ACCOUNT_SAS_URL=<storage_account_sas_url>` (This is the queue service URL with a SAS token appended without the queue name)

sdk/storage/azure_storage_queue/examples/README.md

@@ -4,7 +4,7 @@
 use std::collections::HashMap;
 
 use azure_core::{
-    http::{Response, StatusCode, XmlFormat},
+    http::{Response, StatusCode, Url, XmlFormat},
     Error,
 };
 use azure_identity::DeveloperToolsCredential;
@@ -172,16 +172,7 @@ async fn peek_and_receive_messages(
     Ok(())
 }
 
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let credential = DeveloperToolsCredential::new(None)?;
-
-    // Retrieve the storage account endpoint from environment variable.
-    let endpoint = get_endpoint();
-
-    let queue_name = get_random_queue_name();
-    let queue_client = QueueClient::new(&endpoint, &queue_name, credential.clone(), None)?;
-
+async fn run_queue_tests(queue_client: &QueueClient) -> Result<(), Box<dyn std::error::Error>> {
     // Create and manage queue
     let result = queue_client.create(None).await;
     log_operation_result(&result, "create");
@@ -219,11 +210,84 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let result = queue_client.delete(None).await;
     log_operation_result(&result, "delete");
 
-    let non_existing_queue_client =
-        QueueClient::new(&endpoint, "non-existent-queue", credential.clone(), None)?;
+    Ok(())
+}
+
+async fn test_with_sas_token() -> Result<(), Box<dyn std::error::Error>> {
+    // Try to get SAS URL from environment variable
+    let sas_url = match std::env::var("AZURE_QUEUE_STORAGE_SAS_URL") {
+        Ok(url) => url,
+        Err(_) => {
+            println!("Skipping SAS token test - AZURE_QUEUE_STORAGE_SAS_URL not set");
+            return Ok(());
+        }
+    };
+
+    println!("\n=== Testing with SAS Token Authentication ===");
+
+    let parsed_url = Url::parse(&sas_url)?;
+    let queue_name = get_random_queue_name();
+
+    // Construct the queue URL by appending the queue name to the service URL
+    let mut queue_url = parsed_url.clone();
+    queue_url
+        .path_segments_mut()
+        .map_err(|_| {
+            azure_core::Error::with_message(azure_core::error::ErrorKind::Other, "Invalid SAS URL")
+        })?
+        .push(&queue_name);
+
+    let queue_client = QueueClient::from_url(queue_url, None, None)?;
+
+    // Run the same tests with SAS authentication
+    run_queue_tests(&queue_client).await?;
+
+    println!("=== SAS Token Authentication Test Complete ===\n");
+
+    // Test using the `new` constructor with SAS token
+    println!("=== Testing with SAS Token using new() constructor ===");
+
+    let queue_name = get_random_queue_name();
+    let queue_client = QueueClient::new(&sas_url, &queue_name, None, None)?;
+
+    // Run the same tests with SAS authentication using new constructor
+    run_queue_tests(&queue_client).await?;
+
+    println!("=== SAS Token new() Constructor Test Complete ===\n");
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let credential = DeveloperToolsCredential::new(None)?;
+
+    // Retrieve the storage account endpoint from environment variable.
+    let endpoint = get_endpoint();
+
+    let queue_name = get_random_queue_name();
+    let queue_client = QueueClient::new(&endpoint, &queue_name, Some(credential.clone()), None)?;
+
+    println!("=== Testing with Entra ID Authentication ===");
+
+    // Run tests with Entra ID authentication
+    run_queue_tests(&queue_client).await?;
+
+    // Check non-existent queue
+    let non_existing_queue_client = QueueClient::new(
+        &endpoint,
+        "non-existent-queue",
+        Some(credential.clone()),
+        None,
+    )?;
     let result = non_existing_queue_client.exists().await;
     log_operation_result(&result, "check_non_existent");
 
+    println!("=== Entra ID Authentication Test Complete ===\n");
+
+    // Test with SAS token authentication if available
+    test_with_sas_token().await?;
+
     Ok(())
 }
 

sdk/storage/azure_storage_queue/examples/queue_client.rs

@@ -3,7 +3,10 @@
 
 use std::sync::Arc;
 
-use azure_core::{http::StatusCode, Error};
+use azure_core::{
+    http::{StatusCode, Url},
+    Error,
+};
 use azure_storage_queue::{
     models::{
         CorsRule, ListQueuesIncludeType, ListQueuesResponse, QueueServiceClientListQueuesOptions,
@@ -104,7 +107,7 @@ async fn get_statistics(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let secondary_endpoint = get_secondary_endpoint();
     let secondary_queue_client =
-        QueueServiceClient::new(&secondary_endpoint, credential.clone(), None)?;
+        QueueServiceClient::new(&secondary_endpoint, Some(credential.clone()), None)?;
     let result = secondary_queue_client.get_statistics(None).await;
     log_operation_result(&result, "get_statistics");
 
@@ -123,6 +126,78 @@ async fn get_statistics(
     Ok(())
 }
 
+async fn test_sas_token() -> Result<(), Box<dyn std::error::Error>> {
+    // Try to get SAS URL from environment variable
+    let sas_url = match std::env::var("AZURE_QUEUE_STORAGE_ACCOUNT_SAS_URL") {
+        Ok(url) => url,
+        Err(_) => {
+            println!("Skipping SAS token test - AZURE_QUEUE_STORAGE_ACCOUNT_SAS_URL not set");
+            return Ok(());
+        }
+    };
+
+    println!("\n=== Testing SAS Token Authentication ===");
+
+    let parsed_url = Url::parse(&sas_url)?;
+    let queue_client = QueueServiceClient::from_url(parsed_url, None, None)?;
+
+    let queue_name = get_random_queue_name();
+
+    // Create queue using SAS token
+    let result = queue_client.create_queue(&queue_name, None).await;
+    log_operation_result(&result, "create_queue_with_sas");
+
+    // List queues and validate the created queue exists
+    let list_result = queue_client.list_queues(None);
+    match list_result {
+        Ok(pager) => {
+            let mut found = false;
+            let mut pager = pager.into_pages();
+            while let Some(page_result) = pager.next().await {
+                match page_result {
+                    Ok(response) => {
+                        let queue_list: ListQueuesResponse = response.into_model()?;
+                        for queue in queue_list.queue_items {
+                            if queue.name.as_ref() == Some(&queue_name) {
+                                found = true;
+                                println!(
+                                    "Successfully validated queue '{}' exists in list",
+                                    queue_name
+                                );
+                                break;
+                            }
+                        }
+                        if found {
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        eprintln!("Error listing queues with SAS: {}", e);
+                        break;
+                    }
+                }
+            }
+            if !found {
+                eprintln!(
+                    "Warning: Queue '{}' was created but not found in list",
+                    queue_name
+                );
+            }
+        }
+        Err(e) => {
+            eprintln!("Error listing queues with SAS: {}", e);
+        }
+    }
+
+    // Delete queue using SAS token
+    let result = queue_client.delete_queue(&queue_name, None).await;
+    log_operation_result(&result, "delete_queue_with_sas");
+
+    println!("=== SAS Token Authentication Test Complete ===\n");
+
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
@@ -131,7 +206,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let endpoint = get_endpoint();
 
     let queue_name = get_random_queue_name();
-    let queue_client = QueueServiceClient::new(&endpoint, credential.clone(), None)?;
+    let queue_client = QueueServiceClient::new(&endpoint, Some(credential.clone()), None)?;
 
     // Create and manage queue
     let result = queue_client.create_queue(&queue_name, None).await;
@@ -149,6 +224,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let result = queue_client.delete_queue(&queue_name, None).await;
     log_operation_result(&result, "delete_queue");
 
+    // Test SAS token authentication if available
+    test_sas_token().await?;
+
     Ok(())
 }