Add tests

Author: aumetra

packages/schema-derive/src/cw_serde.rs

@@ -73,6 +73,42 @@ mod tests {
     use super::*;
     use syn::parse_quote;
 
+    #[test]
+    fn crate_rename() {
+        let expanded = cw_serde_impl(
+            Options {
+                crate_path: parse_quote!(::my_crate::cw_schema),
+            },
+            parse_quote! {
+                pub struct InstantiateMsg {
+                    pub verifier: String,
+                    pub beneficiary: String,
+                }
+            },
+        )
+        .unwrap();
+
+        let expected = parse_quote! {
+            #[derive(
+                ::my_crate::cw_schema::serde::Serialize,
+                ::my_crate::cw_schema::serde::Deserialize,
+                ::std::clone::Clone,
+                ::std::fmt::Debug,
+                ::std::cmp::PartialEq,
+                ::my_crate::cw_schema::schemars::JsonSchema
+            )]
+            #[allow(clippy::derive_partial_eq_without_eq)]
+            #[serde(deny_unknown_fields, crate = ":: my_crate :: cw_schema::serde")]
+            #[schemars(crate = ":: my_crate :: cw_schema::schemars")]
+            pub struct InstantiateMsg {
+                pub verifier: String,
+                pub beneficiary: String,
+            }
+        };
+
+        assert_eq!(expanded, expected);
+    }
+
     #[test]
     fn structs() {
         let expanded = cw_serde_impl(

packages/schema-derive/src/generate_api.rs

@@ -233,6 +233,32 @@ impl Parse for Options {
 mod tests {
     use super::*;
 
+    #[test]
+    fn crate_rename() {
+        assert_eq!(
+            generate_api_impl(&parse_quote! {
+                crate_name: ::my_crate::cw_schema,
+                instantiate: InstantiateMsg,
+                execute: ExecuteMsg,
+                query: QueryMsg,
+                migrate: MigrateMsg,
+                sudo: SudoMsg,
+            }),
+            parse_quote! {
+                ::my_crate::cw_schema::Api {
+                    contract_name: ::std::env!("CARGO_PKG_NAME").to_string(),
+                    contract_version: ::std::env!("CARGO_PKG_VERSION").to_string(),
+                    instantiate: Some(::my_crate::cw_schema::schema_for!(InstantiateMsg)),
+                    execute: Some(::my_crate::cw_schema::schema_for!(ExecuteMsg)),
+                    query: Some(::my_crate::cw_schema::schema_for!(QueryMsg)),
+                    migrate: Some(::my_crate::cw_schema::schema_for!(MigrateMsg)),
+                    sudo: Some(::my_crate::cw_schema::schema_for!(SudoMsg)),
+                    responses: Some(<QueryMsg as ::my_crate::cw_schema::QueryResponses>::response_schemas().unwrap()),
+                }
+            }
+        );
+    }
+
     #[test]
     fn api_object_minimal() {
         assert_eq!(

packages/schema-derive/src/query_responses.rs

@@ -162,6 +162,69 @@ mod tests {
         }
     }
 
+    #[test]
+    fn crate_rename() {
+        let input: ItemEnum = parse_quote! {
+            #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema, QueryResponses)]
+            #[serde(rename_all = "snake_case")]
+            #[query_responses(crate = "::my_crate::cw_schema")]
+            pub enum QueryMsg {
+                #[returns(some_crate::AnotherType)]
+                Supply {},
+                #[returns(SomeType)]
+                Balance {},
+            }
+        };
+
+        assert_eq!(
+            query_responses_derive_impl(input).unwrap(),
+            parse_quote! {
+                #[automatically_derived]
+                #[cfg(not(target_arch = "wasm32"))]
+                impl ::my_crate::cw_schema::QueryResponses for QueryMsg {
+                    fn response_schemas_impl() -> ::std::collections::BTreeMap<String, ::my_crate::cw_schema::schemars::schema::RootSchema> {
+                        ::std::collections::BTreeMap::from([
+                            ("supply".to_string(), ::my_crate::cw_schema::schema_for!(some_crate::AnotherType)),
+                            ("balance".to_string(), ::my_crate::cw_schema::schema_for!(SomeType)),
+                        ])
+                    }
+                }
+            }
+        );
+    }
+
+    #[test]
+    fn crate_rename_nested() {
+        let input: ItemEnum = parse_quote! {
+            #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema, QueryResponses)]
+            #[serde(untagged)]
+            #[query_responses(crate = "::my_crate::cw_schema", nested)]
+            pub enum ContractQueryMsg {
+                Cw1(QueryMsg1),
+                Whitelist(whitelist::QueryMsg),
+                Cw1WhitelistContract(QueryMsg),
+            }
+        };
+        let result = query_responses_derive_impl(input).unwrap();
+        assert_eq!(
+            result,
+            parse_quote! {
+                #[automatically_derived]
+                #[cfg(not(target_arch = "wasm32"))]
+                impl ::my_crate::cw_schema::QueryResponses for ContractQueryMsg {
+                    fn response_schemas_impl() -> ::std::collections::BTreeMap<String, ::my_crate::cw_schema::schemars::schema::RootSchema> {
+                        let subqueries = [
+                            <QueryMsg1 as ::my_crate::cw_schema::QueryResponses>::response_schemas_impl(),
+                            <whitelist::QueryMsg as ::my_crate::cw_schema::QueryResponses>::response_schemas_impl(),
+                            <QueryMsg as ::my_crate::cw_schema::QueryResponses>::response_schemas_impl(),
+                        ];
+                        ::my_crate::cw_schema::combine_subqueries::<3usize, ContractQueryMsg>(subqueries)
+                    }
+                }
+            }
+        );
+    }
+
     #[test]
     fn happy_path() {
         let input: ItemEnum = parse_quote! {

packages/schema-derive/src/query_responses/context.rs

@@ -31,23 +31,16 @@ pub fn get_context(input: &ItemEnum) -> syn::Result<Context> {
         let meta_list = attr.meta.require_list()?;
         meta_list.parse_nested_meta(|param| {
             if param.path.is_ident("no_bounds_for") {
-                let meta_list: syn::MetaList = param.input.parse()?;
-                meta_list.parse_nested_meta(|item| {
-                    let syn::Meta::Path(p) = item.input.parse()? else {
-                        bail!(
-                            item.input.span(),
-                            "`no_bounds_for` only accepts a list of type params"
-                        );
-                    };
-
-                    ctx.no_bounds_for.insert(p.get_ident().unwrap().clone());
+                param.parse_nested_meta(|item| {
+                    ctx.no_bounds_for
+                        .insert(item.path.get_ident().unwrap().clone());
 
                     Ok(())
                 })?;
             } else if param.path.is_ident("nested") {
                 ctx.is_nested = true;
             } else if param.path.is_ident("crate") {
-                let crate_name_str: LitStr = param.input.parse()?;
+                let crate_name_str: LitStr = param.value()?.parse()?;
                 ctx.crate_name = crate_name_str.parse()?;
             } else {
                 bail!(param.path, "unrecognized QueryResponses param");
@@ -59,3 +52,31 @@ pub fn get_context(input: &ItemEnum) -> syn::Result<Context> {
 
     Ok(ctx)
 }
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashSet;
+
+    use quote::format_ident;
+    use syn::parse_quote;
+
+    use super::get_context;
+
+    #[test]
+    fn parse_context() {
+        let input = parse_quote! {
+            #[query_responses(crate = "::my_crate::cw_schema")]
+            #[query_responses(nested)]
+            #[query_responses(no_bounds_for(Item1, Item2))]
+            enum Test {}
+        };
+        let context = get_context(&input).unwrap();
+
+        assert_eq!(context.crate_name, parse_quote!(::my_crate::cw_schema));
+        assert!(context.is_nested);
+        assert_eq!(
+            context.no_bounds_for,
+            HashSet::from([format_ident!("Item1"), format_ident!("Item2")])
+        );
+    }
+}