[Storage] get_account_info all clients, set/get_tags for BlobClient, set_properties for BlobServiceClient

sdk/storage/azure_storage_blob/assets.json

@@ -1,6 +1,6 @@
 {
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "rust",
-  "Tag": "rust/azure_storage_blob_49079e88a1",
+  "Tag": "rust/azure_storage_blob_cb9b90a35f",
   "TagPrefix": "rust/azure_storage_blob"
 }

sdk/storage/azure_storage_blob/src/clients/blob_client.rs

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 use crate::{
-    deserialize_blob_tags,
     generated::clients::BlobClient as GeneratedBlobClient,
     generated::models::{
         BlobClientAcquireLeaseResult, BlobClientBreakLeaseResult, BlobClientChangeLeaseResult,
@@ -21,7 +20,7 @@ use crate::{
         BlockListType, BlockLookupList,
     },
     pipeline::StorageHeadersPolicy,
-    serialize_blob_tags, AppendBlobClient, BlobClientOptions, BlockBlobClient, PageBlobClient,
+    AppendBlobClient, BlobClientOptions, BlockBlobClient, PageBlobClient,
 };
 use azure_core::{
     credentials::TokenCredential,
@@ -325,7 +324,7 @@ impl BlobClient {
         tags: HashMap<String, String>,
         options: Option<BlobClientSetTagsOptions<'_>>,
     ) -> Result<Response<(), NoFormat>> {
-        let blob_tags = serialize_blob_tags(tags);
+        let blob_tags: BlobTags = tags.into();
         self.client
             .set_tags(RequestContent::try_from(blob_tags)?, options)
             .await
@@ -339,9 +338,8 @@ impl BlobClient {
     pub async fn get_tags(
         &self,
         options: Option<BlobClientGetTagsOptions<'_>>,
-    ) -> Result<Response<HashMap<String, String>, JsonFormat>> {
-        let response = self.client.get_tags(options).await?;
-        deserialize_blob_tags(response).await
+    ) -> Result<Response<BlobTags, XmlFormat>> {
+        self.client.get_tags(options).await
     }
 
     /// Gets information related to the Storage account in which the blob resides.

sdk/storage/azure_storage_blob/src/models/extensions.rs

@@ -1,7 +1,10 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-use crate::models::{AppendBlobClientCreateOptions, PageBlobClientCreateOptions};
+use crate::models::{
+    AppendBlobClientCreateOptions, BlobTag, BlobTags, PageBlobClientCreateOptions,
+};
+use std::collections::{BTreeMap, HashMap};
 
 /// Provides usage helpers for setting the `PageBlobClientCreateOptions` optional configurations.
 pub trait PageBlobClientCreateOptionsExt {
@@ -38,3 +41,42 @@ impl AppendBlobClientCreateOptionsExt for AppendBlobClientCreateOptions<'_> {
         }
     }
 }
+
+/// Converts a `BlobTags` struct into `HashMap<String, String>`.
+impl TryFrom<BlobTags> for HashMap<String, String> {
+    type Error = &'static str;
+
+    fn try_from(blob_tags: BlobTags) -> Result<Self, Self::Error> {
+        let mut map = HashMap::new();
+
+        if let Some(tags) = blob_tags.blob_tag_set {
+            for tag in tags {
+                match (tag.key, tag.value) {
+                    (Some(k), Some(v)) => {
+                        map.insert(k, v);
+                    }
+                    _ => return Err("BlobTag missing key or value"),
+                }
+            }
+        }
+
+        Ok(map)
+    }
+}
+
+/// Converts a `HashMap<String, String>` into a `BlobTags` struct.
+impl From<HashMap<String, String>> for BlobTags {
+    fn from(tags: HashMap<String, String>) -> Self {
+        let sorted_tags: BTreeMap<_, _> = tags.into_iter().collect();
+        let blob_tags = sorted_tags
+            .into_iter()
+            .map(|(k, v)| BlobTag {
+                key: Some(k),
+                value: Some(v),
+            })
+            .collect();
+        BlobTags {
+            blob_tag_set: Some(blob_tags),
+        }
+    }
+}

sdk/storage/azure_storage_blob/src/parsers.rs

@@ -40,51 +40,3 @@ pub fn format_page_range(offset: u64, length: u64) -> Result<String, Error> {
     let content_range = format!("bytes={}-{}", offset, end_range);
     Ok(content_range)
 }
-
-/// Takes in a HashMap of blob tags and serializes them into the `BlobTags` model.
-///
-/// # Arguments
-///
-/// * `tags` - A hash map containing the name-value pairs associated with the blob as tags.
-pub(crate) fn serialize_blob_tags(tags: HashMap<String, String>) -> BlobTags {
-    let sorted_tags: BTreeMap<_, _> = tags.into_iter().collect();
-    let blob_tags = sorted_tags
-        .into_iter()
-        .map(|(k, v)| BlobTag {
-            key: Some(k),
-            value: Some(v),
-        })
-        .collect();
-    BlobTags {
-        blob_tag_set: Some(blob_tags),
-    }
-}
-
-/// Takes in a `get_tags()` response and deserializes the `BlobTags` model into a HashMap of blob tags.
-///
-/// # Arguments
-///
-/// * `response` - The `get_tags()` response to be deserialized.
-pub(crate) async fn deserialize_blob_tags(
-    response: Response<BlobTags, XmlFormat>,
-) -> azure_core::Result<Response<HashMap<String, String>, JsonFormat>>
-where
-{
-    let mut blob_tags_map: HashMap<String, String> = HashMap::new();
-    let status = response.status();
-    let headers = response.headers().clone();
-    let blob_tags = response.into_body().await?;
-
-    if let Some(blob_tag_set) = blob_tags.blob_tag_set {
-        for tag in blob_tag_set {
-            if let (Some(k), Some(v)) = (tag.key, tag.value) {
-                blob_tags_map.insert(k, v);
-            }
-        }
-    }
-
-    let request_content: RequestContent<HashMap<String, String>> =
-        RequestContent::try_from(blob_tags_map)?;
-    let raw_response = RawResponse::from_bytes(status, headers, request_content.body());
-    Ok(raw_response.into())
-}

sdk/storage/azure_storage_blob/tests/blob_client.rs

@@ -442,14 +442,16 @@ async fn test_blob_tags(ctx: TestContext) -> Result<(), Box<dyn Error>> {
 
     // Assert
     let response_tags = blob_client.get_tags(None).await?.into_body().await?;
-    assert_eq!(blob_tags, response_tags);
+    let map: HashMap<String, String> = response_tags.try_into()?;
+    assert_eq!(blob_tags, map);
 
     // Set Tags with No Tags (Clear Tags)
     blob_client.set_tags(HashMap::new(), None).await?;
 
     // Assert
     let response_tags = blob_client.get_tags(None).await?.into_body().await?;
-    assert_eq!(HashMap::new(), response_tags);
+    let map: HashMap<String, String> = response_tags.try_into()?;
+    assert_eq!(HashMap::new(), map);
 
     container_client.delete_container(None).await?;
     Ok(())