New helper fns for declaring and deleting multiple policies

purely for convenience.

Author: michaelklishin

CHANGELOG.md

@@ -5,7 +5,10 @@
 ### Enhancements
 
  * Support for a new deprecated feature flag state column, introduced in [rabbitmq/rabbitmq-server#14227](https://github.com/rabbitmq/rabbitmq-server/pull/14227)
-
+ * `Client#declare_policies` and `Client#declare_operator_policies` are two new helper functions for declaring multiple policies at once.
+    Note that both functions will still issue the same number of API requests, so it only exists for convenience
+ * `Client#delete_policies_in` and `Client#delete_operator_policies_in` are two new helper functions for deleting multiple policies at once.
+    Note that both functions will still issue the same number of API requests, so it only exists for convenience
 
 ## v0.38.0 (Jul 11, 2025)
 

src/api.rs

@@ -1193,12 +1193,15 @@ where
         Ok(response)
     }
 
+    /// Lists all policies in the cluster (across all virtual hosts), taking the user's
+    /// permissions into account.
     pub async fn list_policies(&self) -> Result<Vec<responses::Policy>> {
         let response = self.http_get("policies", None, None).await?;
         let response = response.json().await?;
         Ok(response)
     }
 
+    /// Lists policies in a virtual host.
     pub async fn list_policies_in(&self, vhost: &str) -> Result<Vec<responses::Policy>> {
         let response = self.http_get(path!("policies", vhost), None, None).await?;
         let response = response.json().await?;
@@ -1217,6 +1220,17 @@ where
         Ok(())
     }
 
+    /// Declares multiple policies. Note that this function will still issue
+    /// as many HTTP API requests as there are policies to declare.
+    pub async fn declare_policies(&self, params: Vec<&PolicyParams<'_>>) -> Result<()> {
+        for p in params {
+            let _response = self
+                .http_put(path!("policies", p.vhost, p.name), p, None, None)
+                .await?;
+        }
+        Ok(())
+    }
+
     pub async fn delete_policy(&self, vhost: &str, name: &str) -> Result<()> {
         let _response = self
             .http_delete(
@@ -1228,6 +1242,21 @@ where
         Ok(())
     }
 
+    /// Deletes multiple policies. Note that this function will still issue
+    /// as many HTTP API requests as there are policies to delete.
+    pub async fn delete_policies_in(&self, vhost: &str, names: Vec<&str>) -> Result<()> {
+        for name in names {
+            let _response = self
+                .http_delete(
+                    path!("policies", vhost, name),
+                    Some(StatusCode::NOT_FOUND),
+                    None,
+                )
+                .await?;
+        }
+        Ok(())
+    }
+
     pub async fn get_operator_policy(&self, vhost: &str, name: &str) -> Result<responses::Policy> {
         let response = self
             .http_get(path!("operator-policies", vhost, name), None, None)
@@ -1262,6 +1291,15 @@ where
         Ok(())
     }
 
+    pub async fn declare_operator_policies(&self, params: Vec<&PolicyParams<'_>>) -> Result<()> {
+        for p in params {
+            let _response = self
+                .http_put(path!("operator-policies", p.vhost, p.name), p, None, None)
+                .await?;
+        }
+        Ok(())
+    }
+
     pub async fn delete_operator_policy(&self, vhost: &str, name: &str) -> Result<()> {
         let _response = self
             .http_delete(
@@ -1273,6 +1311,19 @@ where
         Ok(())
     }
 
+    pub async fn delete_operator_policies_in(&self, vhost: &str, names: Vec<&str>) -> Result<()> {
+        for name in names {
+            let _response = self
+                .http_delete(
+                    path!("operator-policies", vhost, name),
+                    Some(StatusCode::NOT_FOUND),
+                    None,
+                )
+                .await?;
+        }
+        Ok(())
+    }
+
     pub async fn list_permissions(&self) -> Result<Vec<responses::Permissions>> {
         let response = self.http_get("permissions", None, None).await?;
         let response = response.json().await?;

src/blocking_api.rs

@@ -1048,12 +1048,15 @@ where
         Ok(response)
     }
 
+    /// Lists all policies in the cluster (across all virtual hosts), taking the user's
+    /// permissions into account.
     pub fn list_policies(&self) -> Result<Vec<responses::Policy>> {
         let response = self.http_get("policies", None, None)?;
         let response = response.json()?;
         Ok(response)
     }
 
+    /// Lists policies in a virtual host.
     pub fn list_policies_in(&self, vhost: &str) -> Result<Vec<responses::Policy>> {
         let response = self.http_get(path!("policies", vhost), None, None)?;
         let response = response.json()?;
@@ -1070,6 +1073,15 @@ where
         Ok(())
     }
 
+    /// Declares multiple policies. Note that this function will still issue
+    /// as many HTTP API requests as there are policies to declare.
+    pub fn declare_policies(&self, params: Vec<&PolicyParams>) -> Result<()> {
+        for p in params {
+            let _response = self.http_put(path!("policies", p.vhost, p.name), p, None, None)?;
+        }
+        Ok(())
+    }
+
     pub fn delete_policy(&self, vhost: &str, name: &str) -> Result<()> {
         let _response = self.http_delete(
             path!("policies", vhost, name),
@@ -1079,6 +1091,19 @@ where
         Ok(())
     }
 
+    /// Deletes multiple policies. Note that this function will still issue
+    /// as many HTTP API requests as there are policies to delete.
+    pub fn delete_policies_in(&self, vhost: &str, names: Vec<&str>) -> Result<()> {
+        for name in names {
+            let _response = self.http_delete(
+                path!("policies", vhost, name),
+                Some(StatusCode::NOT_FOUND),
+                None,
+            )?;
+        }
+        Ok(())
+    }
+
     pub fn get_operator_policy(&self, vhost: &str, name: &str) -> Result<responses::Policy> {
         let response = self.http_get(path!("operator-policies", vhost, name), None, None)?;
         let response = response.json()?;
@@ -1107,6 +1132,16 @@ where
         Ok(())
     }
 
+    /// Declares multiple operator policies. Note that this function will still issue
+    /// as many HTTP API requests as there are operator policies to declare.
+    pub fn declare_operator_policies(&self, params: Vec<&PolicyParams>) -> Result<()> {
+        for p in params {
+            let _response =
+                self.http_put(path!("operator-policies", p.vhost, p.name), p, None, None)?;
+        }
+        Ok(())
+    }
+
     pub fn delete_operator_policy(&self, vhost: &str, name: &str) -> Result<()> {
         let _response = self.http_delete(
             path!("operator-policies", vhost, name),
@@ -1116,6 +1151,19 @@ where
         Ok(())
     }
 
+    /// Deletes multiple operator policies. Note that this function will still issue
+    /// as many HTTP API requests as there are operator policies to delete.
+    pub fn delete_operator_policies_in(&self, vhost: &str, names: Vec<&str>) -> Result<()> {
+        for name in names {
+            let _response = self.http_delete(
+                path!("operator-policies", vhost, name),
+                Some(StatusCode::NOT_FOUND),
+                None,
+            )?;
+        }
+        Ok(())
+    }
+
     pub fn list_permissions(&self) -> Result<Vec<responses::Permissions>> {
         let response = self.http_get("permissions", None, None)?;
         let response = response.json()?;

src/requests.rs

@@ -404,7 +404,7 @@ impl From<PolDef> for PolicyDefinition {
 }
 
 /// Represents a [policy](https://rabbitmq.com/docs/parameters/#policies).
-#[derive(Serialize)]
+#[derive(Serialize, Debug)]
 pub struct PolicyParams<'a> {
     pub vhost: &'a str,
     pub name: &'a str,
@@ -429,7 +429,7 @@ impl<'a> From<&'a Policy> for PolicyParams<'a> {
 }
 
 /// Represents a user's [permission in a particular virtual host](https://rabbitmq.com/docs/access-control/).
-#[derive(Serialize)]
+#[derive(Serialize, Debug)]
 pub struct Permissions<'a> {
     pub user: &'a str,
     pub vhost: &'a str,

src/responses.rs

@@ -2175,7 +2175,7 @@ pub struct DeprecatedFeature {
     pub doc_url: String,
     pub provided_by: String,
     #[cfg_attr(feature = "tabled", tabled(display = "display_option"))]
-    pub state: Option<String>
+    pub state: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]

tests/async_policy_tests.rs

@@ -75,6 +75,61 @@ async fn test_async_dlx_policy() {
     let _ = rc.delete_vhost(vh_params.name, false).await;
 }
 
+#[tokio::test]
+async fn test_async_multiple_policies_case1() {
+    let endpoint = endpoint();
+    let rc = Client::new(endpoint.as_str(), USERNAME, PASSWORD);
+
+    let mut map1 = Map::<String, Value>::new();
+    map1.insert("dead-letter-exchange".to_owned(), json!("my-dlx"));
+    let policy_definition1 = map1.clone();
+
+    let mut map2 = Map::<String, Value>::new();
+    map2.insert("message-ttl".to_owned(), json!(10_000));
+    let policy_definition2 = map2.clone();
+
+    let vh_params = VirtualHostParams::named("test_blocking_multiple_policies_case1");
+    let _ = rc.delete_vhost(vh_params.name, false).await;
+    let result1 = rc.create_vhost(&vh_params).await;
+    assert!(result1.is_ok());
+
+    let dlx_policy = PolicyParams {
+        vhost: vh_params.name,
+        name: "dlx_policy",
+        pattern: ".*",
+        apply_to: PolicyTarget::QuorumQueues,
+        priority: 3,
+        definition: policy_definition1,
+    };
+    let message_ttl_policy = PolicyParams {
+        vhost: vh_params.name,
+        name: "message_ttl_policy",
+        pattern: ".*",
+        apply_to: PolicyTarget::QuorumQueues,
+        priority: 3,
+        definition: policy_definition2,
+    };
+
+    let result1 = rc
+        .declare_policies(vec![&dlx_policy, &message_ttl_policy])
+        .await;
+    assert!(result1.is_ok());
+
+    let result2 = rc.list_policies_in(vh_params.name).await;
+    assert!(result2.is_ok());
+    assert_eq!(result2.unwrap().len(), 2);
+
+    let result3 = rc
+        .delete_policies_in(
+            vh_params.name,
+            vec![dlx_policy.name, message_ttl_policy.name],
+        )
+        .await;
+    assert!(result3.is_ok());
+
+    let _ = rc.delete_vhost(vh_params.name, false).await;
+}
+
 #[tokio::test]
 async fn test_async_operator_policy() {
     let endpoint = endpoint();
@@ -102,6 +157,69 @@ async fn test_async_operator_policy() {
     let _ = rc.delete_vhost(vh_params.name, true).await;
 }
 
+#[tokio::test]
+async fn test_async_multiple_operator_policies_case1() {
+    let endpoint = endpoint();
+    let rc = Client::new(endpoint.as_str(), USERNAME, PASSWORD);
+
+    let mut map1 = Map::<String, Value>::new();
+    map1.insert("delivery-limit".to_owned(), json!(13));
+    let policy_definition1 = map1.clone();
+
+    let mut map2 = Map::<String, Value>::new();
+    map2.insert("delivery-limit".to_owned(), json!(67));
+    let policy_definition2 = map2.clone();
+
+    let vh_params = VirtualHostParams::named("test_async_multiple_operator_policies_case1");
+    let _ = rc.delete_vhost(vh_params.name, false).await;
+    let result0 = rc.create_vhost(&vh_params).await;
+    assert!(result0.is_ok());
+
+    let dlx_policy = PolicyParams {
+        vhost: vh_params.name,
+        name: "operator_policy.1",
+        pattern: ".*",
+        apply_to: PolicyTarget::QuorumQueues,
+        priority: 2,
+        definition: policy_definition1,
+    };
+    let message_ttl_policy = PolicyParams {
+        vhost: vh_params.name,
+        name: "message_ttl_policy",
+        pattern: ".*",
+        apply_to: PolicyTarget::QuorumQueues,
+        priority: 3,
+        definition: policy_definition2,
+    };
+
+    let result1 = rc
+        .declare_operator_policies(vec![&dlx_policy, &message_ttl_policy])
+        .await;
+    assert!(result1.is_ok());
+
+    let result2 = rc.list_operator_policies_in(vh_params.name).await;
+    assert!(result2.is_ok());
+    assert_eq!(result2.unwrap().len(), 2);
+
+    let result3 = rc
+        .delete_operator_policies_in(
+            vh_params.name,
+            vec![dlx_policy.name, message_ttl_policy.name],
+        )
+        .await;
+    assert!(result3.is_ok());
+
+    let result4 = rc.list_operator_policies_in(vh_params.name).await;
+    assert!(result4.is_ok());
+    assert_eq!(result4.unwrap().len(), 0);
+
+    let _ = rc.delete_vhost(vh_params.name, false).await;
+}
+
+//
+// Implementation
+//
+
 async fn test_a_policy(rc: &Client<&str, &str, &str>, policy: &PolicyParams<'_>) {
     // initially, there should be no such policy
     let policies = rc.list_policies_in(policy.vhost).await.unwrap();