Add more context to QueueType::Unsupported

Implementing only TryFrom<T> would entail
a lot more changes that are difficult to justify.

This is a minimalis alternative to using
TryFrom<T> and Result<T> all over the place.

Author: michaelklishin

Diff for: src/commons.rs

@@ -338,7 +338,7 @@ impl From<ExchangeType> for String {
     }
 }
 
-#[derive(Eq, PartialEq, Debug, Serialize, Deserialize, Clone, Copy, Default)]
+#[derive(Eq, PartialEq, Debug, Serialize, Deserialize, Clone, Default)]
 #[serde(rename_all(serialize = "lowercase", deserialize = "PascalCase"))]
 pub enum QueueType {
     #[default]
@@ -348,28 +348,30 @@ pub enum QueueType {
     // Tanzu RabbitMQ-specific
     Delayed,
     // A type this client is not aware of
-    Unsupported
+    Unsupported(String),
 }
 
 impl From<&str> for QueueType {
     fn from(value: &str) -> Self {
-        match value.to_ascii_lowercase().as_str() {
+        let val = value.to_ascii_lowercase();
+        match val.as_str() {
             "classic" => QueueType::Classic,
             "quorum" => QueueType::Quorum,
             "stream" => QueueType::Stream,
             "delayed" => QueueType::Delayed,
-            _ => QueueType::Unsupported,
+            _ => QueueType::Unsupported(value.to_owned()),
         }
     }
 }
 
 impl From<String> for QueueType {
     fn from(value: String) -> Self {
-        match value.to_ascii_lowercase().as_str() {
+        let val = value.to_ascii_lowercase();
+        match val.as_str() {
             "classic" => QueueType::Classic,
             "quorum" => QueueType::Quorum,
             "stream" => QueueType::Stream,
-            _ => QueueType::Unsupported,
+            _ => QueueType::Unsupported(value),
         }
     }
 }
@@ -381,7 +383,7 @@ impl From<QueueType> for String {
             QueueType::Quorum => "quorum".to_owned(),
             QueueType::Stream => "stream".to_owned(),
             QueueType::Delayed => "delayed".to_owned(),
-            QueueType::Unsupported => "unsupported".to_owned(),
+            QueueType::Unsupported(val) => val.to_owned(),
         }
     }
 }
@@ -459,10 +461,10 @@ impl From<QueueType> for PolicyTarget {
     fn from(value: QueueType) -> Self {
         match value {
             QueueType::Classic => PolicyTarget::ClassicQueues,
-            QueueType::Quorum  => PolicyTarget::QuorumQueues,
-            QueueType::Stream  => PolicyTarget::Streams,
+            QueueType::Quorum => PolicyTarget::QuorumQueues,
+            QueueType::Stream => PolicyTarget::Streams,
             QueueType::Delayed => PolicyTarget::Queues,
-            QueueType::Unsupported => PolicyTarget::Queues,
+            QueueType::Unsupported(_) => PolicyTarget::Queues,
         }
     }
 }

Diff for: src/error.rs

@@ -53,9 +53,7 @@ pub enum Error<U, S, E, BT> {
     #[error("could not convert provided value into an HTTP header value")]
     InvalidHeaderValue { error: InvalidHeaderValue },
     #[error("Unsupported argument value for property (field) {property}")]
-    UnsupportedArgumentValue {
-        property: String
-    },
+    UnsupportedArgumentValue { property: String },
     #[error("encountered an error when performing an HTTP request")]
     RequestError { error: E, backtrace: BT },
     #[error("an unspecified error")]

Diff for: tests/unit_queue_tests.rs

@@ -33,7 +33,25 @@ fn test_unit_queue_type_from_str() {
     assert_eq!(QueueType::Delayed, QueueType::from("delayed"));
     assert_eq!(QueueType::Delayed, QueueType::from("Delayed"));
 
-    assert_eq!(QueueType::Unsupported, QueueType::from("%%a-non-existent-type"));
+    let unsupported_val1 = "%%a-non-existent-type".to_owned();
+    assert_eq!(
+        QueueType::Unsupported(unsupported_val1.clone()),
+        QueueType::from(unsupported_val1.clone())
+    );
+    assert_eq!(
+        QueueType::Unsupported(unsupported_val1.clone()),
+        QueueType::from(unsupported_val1.as_str())
+    );
+
+    let unsupported_val2 = "123123123".to_owned();
+    assert_eq!(
+        QueueType::Unsupported(unsupported_val2.clone()),
+        QueueType::from(unsupported_val2.clone())
+    );
+    assert_eq!(
+        QueueType::Unsupported(unsupported_val2.clone()),
+        QueueType::from(unsupported_val2.as_str())
+    );
 }
 
 #[test]