'declare queue': handle unknown --type values better

This allows unknown types to be passed on as
they are via QueueType::Unsupported(String).

Alternatively we now have the infrastructure to
immediately return an error instead.

Author: michaelklishin

Cargo.lock

@@ -533,7 +533,8 @@ fn declare_subcommands() -> [Command; 12] {
                     .long("type")
                     .help("queue type")
                     .value_parser(value_parser!(QueueType))
-                    .required(false),
+                    .required(false)
+                    .default_value("classic"),
             )
             .arg(
                 Arg::new("durable")

src/cli.rs

@@ -28,7 +28,6 @@ use rabbitmq_http_client::requests::{
 use std::fs;
 use std::process;
 
-use crate::constants::DEFAULT_QUEUE_TYPE;
 use rabbitmq_http_client::commons::BindingDestinationType;
 use rabbitmq_http_client::commons::QueueType;
 use rabbitmq_http_client::{password_hashing, requests, responses};
@@ -629,10 +628,8 @@ pub fn declare_queue(
 ) -> ClientResult<()> {
     // the flag is required
     let name = command_args.get_one::<String>("name").unwrap();
-    let queue_type = command_args
-        .get_one::<QueueType>("type")
-        .cloned()
-        .unwrap_or(QueueType::from(DEFAULT_QUEUE_TYPE));
+    let queue_type = command_args.get_one::<QueueType>("type").cloned().unwrap();
+
     // these are optional
     let durable = command_args
         .get_one::<bool>("durable")

src/commands.rs

@@ -73,6 +73,8 @@ pub enum CommandRunError {
     ConflictingOptions { message: String },
     #[error("{message}")]
     MissingOptions { message: String },
+    #[error("Unsupported argument value for property (field) {property}")]
+    UnsupportedArgumentValue { property: String },
     #[error("This request produces an invalid HTTP header value")]
     InvalidHeaderValue { error: InvalidHeaderValue },
     #[error("encountered an error when performing an HTTP request")]
@@ -90,6 +92,9 @@ impl From<std::io::Error> for CommandRunError {
 impl From<HttpClientError> for CommandRunError {
     fn from(value: HttpClientError) -> Self {
         match value {
+            ApiClientError::UnsupportedArgumentValue { property } => {
+                Self::UnsupportedArgumentValue { property }
+            }
             ApiClientError::ClientErrorResponse { status_code, url, body, headers, .. } => {
                 Self::ClientError { status_code, url, body, headers }
             },

src/errors.rs

@@ -381,6 +381,7 @@ impl<'a> ResultHandler<'a> {
 // We cannot implement From<T> for two types in other crates, so…
 pub(crate) fn client_error_to_exit_code(error: &HttpClientError) -> ExitCode {
     match error {
+        ClientError::UnsupportedArgumentValue { .. } => ExitCode::DataErr,
         ClientError::ClientErrorResponse { .. } => ExitCode::DataErr,
         ClientError::ServerErrorResponse { .. } => ExitCode::Unavailable,
         ClientError::HealthCheckFailed { .. } => ExitCode::Unavailable,

src/output.rs

@@ -252,6 +252,25 @@ pub fn schema_definition_sync_status(status: SchemaDefinitionSyncStatus) -> Tabl
 
 pub fn failure_details(error: &HttpClientError) -> Table {
     match error {
+        HttpClientError::UnsupportedArgumentValue { property } => {
+            let message = format!(
+                "Unsupported argument value for property (field) {}",
+                property
+            );
+            let data = vec![
+                RowOfTwo {
+                    key: "result",
+                    value: "request was not executed",
+                },
+                RowOfTwo {
+                    key: "message",
+                    value: &message,
+                },
+            ];
+
+            let tb = Table::builder(data);
+            tb.build()
+        }
         HttpClientError::ClientErrorResponse {
             status_code,
             url,