added base WasmMockQuerier implementation (QueryRequest::Stargate)

contracts/dao/neutron-chain-manager/src/testing/mock_querier.rs

@@ -0,0 +1,64 @@
+use std::marker::PhantomData;
+use cosmwasm_std::{ContractResult, Empty, from_json, OwnedDeps, Querier, QuerierResult, QueryRequest, SystemError, SystemResult, to_json_binary};
+use cosmwasm_std::testing::{MockApi, MockQuerier, MockStorage};
+use crate::msg::{ParamsCron, ParamsResponseCron};
+
+pub fn mock_dependencies() -> OwnedDeps<MockStorage, MockApi, WasmMockQuerier> {
+    let custom_storage = MockStorage::default();
+    let custom_querier = WasmMockQuerier::new(MockQuerier::new(&[]));
+
+    OwnedDeps {
+        storage: custom_storage,
+        api: MockApi::default(),
+        querier: custom_querier,
+        custom_query_type: PhantomData,
+    }
+}
+
+pub struct WasmMockQuerier {
+    base: MockQuerier,
+}
+
+impl Querier for WasmMockQuerier {
+    fn raw_query(&self, bin_request: &[u8]) -> QuerierResult {
+        let request: QueryRequest<Empty> = match from_json(bin_request) {
+            Ok(v) => v,
+            Err(e) => {
+                return QuerierResult::Err(SystemError::InvalidRequest {
+                    error: format!("Parsing query request: {}", e),
+                    request: bin_request.into(),
+                });
+            }
+        };
+        self.handle_query(&request)
+    }
+}
+
+impl WasmMockQuerier {
+    pub fn handle_query(&self, request: &QueryRequest<Empty>) -> QuerierResult {
+        match &request {
+            QueryRequest::Stargate { path, data: _} => {
+                match path.as_str() {
+                    "/neutron.cron.Query/Params" => {
+                        let resp = to_json_binary(&ParamsResponseCron{
+                            params: ParamsCron{
+                                security_address: "neutron_dao_address".to_string(),
+                                limit: 10,
+                            }
+                        });
+                        SystemResult::Ok(ContractResult::from(resp))
+                    }
+                    _ => todo!()
+                }
+            }
+            _ => self.base.handle_query(request),
+        }
+    }
+}
+
+impl WasmMockQuerier {
+    fn new(base: MockQuerier) -> WasmMockQuerier {
+        WasmMockQuerier { base }
+    }
+}
+

contracts/dao/neutron-chain-manager/src/testing/mod.rs

@@ -1 +1,2 @@
 mod tests;
+mod mock_querier;

contracts/dao/neutron-chain-manager/src/testing/tests.rs

@@ -1,11 +1,13 @@
-use crate::contract::{execute_add_strategy, execute_remove_strategy, instantiate};
+use crate::contract::{execute_add_strategy, execute_execute_messages, execute_remove_strategy, instantiate};
 use crate::error::ContractError::{InvalidDemotion, InvalidInitialStrategy, Unauthorized};
-use crate::msg::{CronPermission as CronPermissionType};
-use crate::msg::Permission::CronPermission;
+use crate::msg::{CronPermission as CronPermissionType, CronUpdateParamsPermission};
+use crate::msg::Permission::{CronPermission, UpdateParamsPermission};
 use crate::msg::{InstantiateMsg, Strategy};
-use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
+use cosmwasm_std::testing::{mock_env, mock_info};
 use cosmwasm_std::{Addr, CosmosMsg};
 use neutron_sdk::bindings::msg::{AdminProposal, NeutronMsg, ProposalExecuteMessage};
+use crate::msg::UpdateParamsPermission::CronUpdateParamsPermission as CronUpdateParamsPermissionEnumField;
+use crate::testing::mock_querier::mock_dependencies;
 
 #[test]
 fn test_instantiate() {
@@ -317,21 +319,48 @@ fn test_remove_strategy_invalid_demotion() {
 
 #[test]
 pub fn test_execute_execute_message() {
-    let _msg = CosmosMsg::Custom(NeutronMsg::SubmitAdminProposal {
+    let msg = CosmosMsg::Custom(NeutronMsg::SubmitAdminProposal {
         admin_proposal: AdminProposal::ProposalExecuteMessage(ProposalExecuteMessage {
             message: r#"{"@type":"/neutron.cron.MsgUpdateParams", "authority":"neutron1hxskfdxpp5hqgtjj6am6nkjefhfzj359x0ar3z", "params": {"security_address": "neutron1hxskfdxpp5hqgtjj6am6nkjefhfzj359x0ar3z", "limit": 16}}"#.to_string(),
         }),
     });
 
-    // let json_message = r#"{"@type":"/neutron.cron.MsgUpdateParams", "authority":"neutron1hxskfdxpp5hqgtjj6am6nkjefhfzj359x0ar3z", "params": {"security_address": "neutron1hxskfdxpp5hqgtjj6am6nkjefhfzj359x0ar3z", "limit": 16}}"#;
-    // let typed_proposal_payload: ProposalExecuteMessageJSON = serde_json::from_str(json_message).unwrap();
-    // println!("{:?}", typed_proposal_payload);
-    //
-    // match typed_proposal_payload.type_field.as_str() {
-    //     "/neutron.cron.MsgUpdateParams" => {
-    //         let msg_update_params: MsgUpdateParamsCron = serde_json::from_str(json_message).unwrap();
-    //         println!("{} -------- {}", msg_update_params.params.limit, msg_update_params.params.security_address)
-    //     }
-    //     _ => {}
-    // }
+    let mut deps = mock_dependencies();
+    let env = mock_env();
+    let info = mock_info("neutron_dao_address", &[]);
+
+    instantiate(
+        deps.as_mut(),
+        env.clone(),
+        info.clone(),
+        InstantiateMsg {
+            initial_strategy: Strategy {
+                address: Addr::unchecked("neutron_dao_address".to_string()),
+                permissions: vec![],
+            },
+        },
+    )
+        .unwrap();
+
+    let info = mock_info("neutron_dao_address", &[]);
+    execute_add_strategy(
+        deps.as_mut(),
+        info.clone(),
+        Strategy {
+            address: Addr::unchecked("addr1".to_string()),
+            permissions: vec![
+                UpdateParamsPermission(CronUpdateParamsPermissionEnumField(CronUpdateParamsPermission{
+                    security_address: true,
+                    limit: true,
+                }))
+            ],
+        },
+    ).unwrap();
+
+    let info = mock_info("addr1", &[]);
+    execute_execute_messages(
+        deps.as_mut(),
+        info.clone(),
+        vec![msg],
+    ).unwrap();
 }