fix: support httpmock generation for array types

Author: daniel.eades

Cargo.lock

@@ -32,6 +32,7 @@ futures = "0.3.31"
 futures-core = "0.3.31"
 heck = "0.5.0"
 http = "1.4.0"
+httpmock = "0.7.0"
 hyper = "1.8.1"
 indexmap = "2.12.1"
 openapiv3 = "2.2.0"

Cargo.toml

@@ -526,6 +526,19 @@ pub fn encode_path(pc: &str) -> String {
     percent_encoding::utf8_percent_encode(pc, PATH_SET).to_string()
 }
 
+#[doc(hidden)]
+pub fn query_param_pairs<T>(name: &str, value: &T) -> Result<Vec<(String, String)>, String>
+where
+    T: Serialize,
+{
+    let query = serde_urlencoded::to_string(QueryParam::new(name, value))
+        .map_err(|err| err.to_string())?;
+    if query.is_empty() {
+        return Ok(Vec::new());
+    }
+    serde_urlencoded::from_str::<Vec<(String, String)>>(&query).map_err(|err| err.to_string())
+}
+
 #[doc(hidden)]
 pub trait RequestBuilderExt<E> {
     fn form_urlencoded<T: Serialize + ?Sized>(self, body: &T) -> Result<RequestBuilder, Error<E>>;

progenitor-client/src/progenitor_client.rs

@@ -28,6 +28,7 @@ dropshot = { workspace = true }
 expectorate = { workspace = true }
 futures = { workspace = true }
 http = { workspace = true }
+httpmock = { workspace = true }
 hyper = { workspace = true }
 progenitor-client = { workspace = true }
 reqwest = { workspace = true }

progenitor-impl/Cargo.toml

@@ -87,6 +87,16 @@ impl Generator {
 
                 use #crate_path::*;
 
+                fn apply_query_param_pairs(
+                    mut when: ::httpmock::When,
+                    pairs: &[(String, String)],
+                ) -> ::httpmock::When {
+                    for (key, value) in pairs {
+                        when = when.query_param(key, value);
+                    }
+                    when
+                }
+
                 #(
                     pub struct #when(::httpmock::When);
                     #when_impl
@@ -189,7 +199,12 @@ impl Generator {
                     OperationParameterKind::Query(true) => (
                         true,
                         quote! {
-                            Self(self.0.query_param(#api_name, value.to_string()))
+                            let expected_pairs = ::progenitor_client::query_param_pairs(
+                                #api_name,
+                                &value,
+                            )
+                            .expect("failed to serialize query param");
+                            Self(apply_query_param_pairs(self.0, &expected_pairs))
                         },
                     ),
                     OperationParameterKind::Header(true) => (
@@ -203,10 +218,12 @@ impl Generator {
                         false,
                         quote! {
                             if let Some(value) = value.into() {
-                                Self(self.0.query_param(
+                                let expected_pairs = ::progenitor_client::query_param_pairs(
                                     #api_name,
-                                    value.to_string(),
-                                ))
+                                    &value,
+                                )
+                                .expect("failed to serialize query param");
+                                Self(apply_query_param_pairs(self.0, &expected_pairs))
                             } else {
                                 Self(self.0.matches(|req| {
                                     req.query_params

progenitor-impl/src/httpmock.rs

@@ -4,6 +4,17 @@ pub mod operations {
     #![doc = r" its inner type with a call to `into_inner()`. This can"]
     #![doc = r" be used to explicitly deviate from permitted values."]
     use crate::buildomat_builder::*;
+    fn apply_query_param_pairs(
+        mut when: ::httpmock::When,
+        pairs: &[(String, String)],
+    ) -> ::httpmock::When {
+        for (key, value) in pairs {
+            when = when.query_param(key, value);
+        }
+
+        when
+    }
+
     pub struct ControlHoldWhen(::httpmock::When);
     impl ControlHoldWhen {
         pub fn new(inner: ::httpmock::When) -> Self {
@@ -208,7 +219,9 @@ pub mod operations {
             T: Into<Option<u32>>,
         {
             if let Some(value) = value.into() {
-                Self(self.0.query_param("minseq", value.to_string()))
+                let expected_pairs = ::progenitor_client::query_param_pairs("minseq", &value)
+                    .expect("failed to serialize query param");
+                Self(apply_query_param_pairs(self.0, &expected_pairs))
             } else {
                 Self(self.0.matches(|req| {
                     req.query_params
@@ -761,7 +774,9 @@ pub mod operations {
             T: Into<Option<&'a types::GetThingOrThingsId>>,
         {
             if let Some(value) = value.into() {
-                Self(self.0.query_param("id", value.to_string()))
+                let expected_pairs = ::progenitor_client::query_param_pairs("id", &value)
+                    .expect("failed to serialize query param");
+                Self(apply_query_param_pairs(self.0, &expected_pairs))
             } else {
                 Self(self.0.matches(|req| {
                     req.query_params

progenitor-impl/tests/output/src/buildomat_httpmock.rs

@@ -4,6 +4,17 @@ pub mod operations {
     #![doc = r" its inner type with a call to `into_inner()`. This can"]
     #![doc = r" be used to explicitly deviate from permitted values."]
     use crate::cli_gen_builder::*;
+    fn apply_query_param_pairs(
+        mut when: ::httpmock::When,
+        pairs: &[(String, String)],
+    ) -> ::httpmock::When {
+        for (key, value) in pairs {
+            when = when.query_param(key, value);
+        }
+
+        when
+    }
+
     pub struct UnoWhen(::httpmock::When);
     impl UnoWhen {
         pub fn new(inner: ::httpmock::When) -> Self {
@@ -19,7 +30,9 @@ pub mod operations {
         }
 
         pub fn gateway(self, value: &str) -> Self {
-            Self(self.0.query_param("gateway", value.to_string()))
+            let expected_pairs = ::progenitor_client::query_param_pairs("gateway", &value)
+                .expect("failed to serialize query param");
+            Self(apply_query_param_pairs(self.0, &expected_pairs))
         }
 
         pub fn body(self, value: &types::UnoBody) -> Self {

progenitor-impl/tests/output/src/cli_gen_httpmock.rs

@@ -0,0 +1,187 @@
+#[allow(unused_imports)]
+use progenitor_client::{encode_path, ClientHooks, OperationInfo, RequestBuilderExt};
+#[allow(unused_imports)]
+pub use progenitor_client::{ByteStream, ClientInfo, Error, ResponseValue};
+/// Types used as operation parameters and responses.
+#[allow(clippy::all)]
+pub mod types {
+    /// Error types.
+    pub mod error {
+        /// Error from a `TryFrom` or `FromStr` implementation.
+        pub struct ConversionError(::std::borrow::Cow<'static, str>);
+        impl ::std::error::Error for ConversionError {}
+        impl ::std::fmt::Display for ConversionError {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
+                ::std::fmt::Display::fmt(&self.0, f)
+            }
+        }
+
+        impl ::std::fmt::Debug for ConversionError {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
+                ::std::fmt::Debug::fmt(&self.0, f)
+            }
+        }
+
+        impl From<&'static str> for ConversionError {
+            fn from(value: &'static str) -> Self {
+                Self(value.into())
+            }
+        }
+
+        impl From<String> for ConversionError {
+            fn from(value: String) -> Self {
+                Self(value.into())
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+///Client for httpmock-query-array
+///
+///Version: 0.0.0
+pub struct Client {
+    pub(crate) baseurl: String,
+    pub(crate) client: reqwest::Client,
+}
+
+impl Client {
+    /// Create a new client.
+    ///
+    /// `baseurl` is the base URL provided to the internal
+    /// `reqwest::Client`, and should include a scheme and hostname,
+    /// as well as port and a path stem if applicable.
+    pub fn new(baseurl: &str) -> Self {
+        #[cfg(not(target_arch = "wasm32"))]
+        let client = {
+            let dur = ::std::time::Duration::from_secs(15u64);
+            reqwest::ClientBuilder::new()
+                .connect_timeout(dur)
+                .timeout(dur)
+        };
+        #[cfg(target_arch = "wasm32")]
+        let client = reqwest::ClientBuilder::new();
+        Self::new_with_client(baseurl, client.build().unwrap())
+    }
+
+    /// Construct a new client with an existing `reqwest::Client`,
+    /// allowing more control over its configuration.
+    ///
+    /// `baseurl` is the base URL provided to the internal
+    /// `reqwest::Client`, and should include a scheme and hostname,
+    /// as well as port and a path stem if applicable.
+    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
+        Self {
+            baseurl: baseurl.to_string(),
+            client,
+        }
+    }
+}
+
+impl ClientInfo<()> for Client {
+    fn api_version() -> &'static str {
+        "0.0.0"
+    }
+
+    fn baseurl(&self) -> &str {
+        self.baseurl.as_str()
+    }
+
+    fn client(&self) -> &reqwest::Client {
+        &self.client
+    }
+
+    fn inner(&self) -> &() {
+        &()
+    }
+}
+
+impl ClientHooks<()> for &Client {}
+impl Client {
+    ///Sends a `GET` request to `/widgets`
+    ///
+    ///```ignore
+    /// let response = client.list_widgets()
+    ///    .tags(tags)
+    ///    .send()
+    ///    .await;
+    /// ```
+    pub fn list_widgets(&self) -> builder::ListWidgets<'_> {
+        builder::ListWidgets::new(self)
+    }
+}
+
+/// Types for composing operation parameters.
+#[allow(clippy::all)]
+pub mod builder {
+    use super::types;
+    #[allow(unused_imports)]
+    use super::{
+        encode_path, ByteStream, ClientHooks, ClientInfo, Error, OperationInfo, RequestBuilderExt,
+        ResponseValue,
+    };
+    ///Builder for [`Client::list_widgets`]
+    ///
+    ///[`Client::list_widgets`]: super::Client::list_widgets
+    #[derive(Debug, Clone)]
+    pub struct ListWidgets<'a> {
+        client: &'a super::Client,
+        tags: Result<::std::vec::Vec<::std::string::String>, String>,
+    }
+
+    impl<'a> ListWidgets<'a> {
+        pub fn new(client: &'a super::Client) -> Self {
+            Self {
+                client: client,
+                tags: Err("tags was not initialized".to_string()),
+            }
+        }
+
+        pub fn tags<V>(mut self, value: V) -> Self
+        where
+            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
+        {
+            self.tags = value.try_into().map_err(|_| {
+                "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for tags \
+                 failed"
+                    .to_string()
+            });
+            self
+        }
+
+        ///Sends a `GET` request to `/widgets`
+        pub async fn send(self) -> Result<ResponseValue<()>, Error<()>> {
+            let Self { client, tags } = self;
+            let tags = tags.map_err(Error::InvalidRequest)?;
+            let url = format!("{}/widgets", client.baseurl,);
+            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
+            header_map.append(
+                ::reqwest::header::HeaderName::from_static("api-version"),
+                ::reqwest::header::HeaderValue::from_static(super::Client::api_version()),
+            );
+            #[allow(unused_mut)]
+            let mut request = client
+                .client
+                .get(url)
+                .query(&progenitor_client::QueryParam::new("tags", &tags))
+                .headers(header_map)
+                .build()?;
+            let info = OperationInfo {
+                operation_id: "list_widgets",
+            };
+            client.pre(&mut request, &info).await?;
+            let result = client.exec(request, &info).await;
+            client.post(&result, &info).await?;
+            let response = result?;
+            match response.status().as_u16() {
+                204u16 => Ok(ResponseValue::empty(response)),
+                _ => Err(Error::UnexpectedResponse(response)),
+            }
+        }
+    }
+}
+
+/// Items consumers will typically use such as the Client.
+pub mod prelude {
+    pub use self::super::Client;
+}