fix raw_query for mock (#400)

contracts/mock_contract/Cargo.toml

@@ -17,6 +17,7 @@ interface = []
 
 [dependencies]
 cosmwasm-std = { workspace = true }
+cw2 = { version = "1.1.2" }
 serde = { workspace = true }
 schemars = "0.8.10"
 serde_json = "1.0.79"

contracts/mock_contract/README.md

@@ -1 +1,3 @@
-This folder is used for testing.
+# Mock Contract test
+
+This folder is used for testing.

contracts/mock_contract/src/lib.rs

@@ -65,11 +65,12 @@ pub struct MigrateMsg {
 
 #[cfg_attr(feature = "export", cosmwasm_std::entry_point)]
 pub fn instantiate(
-    _deps: DepsMut,
+    deps: DepsMut,
     _env: Env,
     _info: MessageInfo,
     _msg: InstantiateMsg,
 ) -> StdResult<Response> {
+    cw2::set_contract_version(deps.storage, "mock-contract", "0")?;
     Ok(Response::new().add_attribute("action", "instantiate"))
 }
 
@@ -163,7 +164,7 @@ pub mod interface {
 mod test {
     use super::MockContract as LocalMockContract;
     use super::*;
-    use cosmwasm_std::coins;
+    use cosmwasm_std::{coins, from_json};
     use cw_orch::prelude::*;
 
     #[test]
@@ -196,4 +197,30 @@ mod test {
 
         Ok(())
     }
+
+    #[test]
+    fn raw_query() -> Result<(), CwOrchError> {
+        // We need to check we can still call the execute msgs conveniently
+        let sender = Addr::unchecked("sender");
+        let mock = Mock::new(&sender);
+        mock.set_balance(&sender, coins(156 * 2, "ujuno"))?;
+        let contract = LocalMockContract::new("mock-contract", mock.clone());
+
+        contract.upload()?;
+        contract.instantiate(&InstantiateMsg {}, None, None)?;
+
+        let cw2_info: cw2::ContractVersion = from_json(
+            mock.wasm_querier()
+                .raw_query(contract.address()?, b"contract_info".to_vec())?,
+        )?;
+
+        assert_eq!(
+            cw2_info,
+            cw2::ContractVersion {
+                contract: "mock-contract".to_owned(),
+                version: "0".to_owned()
+            }
+        );
+        Ok(())
+    }
 }

packages/cw-orch-mock/src/queriers/wasm.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 use std::{cell::RefCell, rc::Rc};
 
 use cosmwasm_std::testing::MockApi;
-use cosmwasm_std::{instantiate2_address, Api};
+use cosmwasm_std::{instantiate2_address, Api, Binary, ContractResult, StdError, SystemResult};
 use cosmwasm_std::{to_json_binary, ContractInfoResponse, HexBinary};
 use cw_orch_core::{
     contract::interface_traits::{ContractInstance, Uploadable},
@@ -67,21 +67,31 @@ fn local_hash<Chain: TxHandler + QueryHandler, T: Uploadable + ContractInstance<
     Ok(hash.into())
 }
 
+/// Copied implementation from [`cosmwasm_std::QuerierWrapper::query`] but without deserialization
 fn raw_query<A: Api, S: StateInterface>(
     querier: &MockWasmQuerier<A, S>,
     address: impl Into<String>,
     query_data: Vec<u8>,
 ) -> Result<Vec<u8>, CwEnvError> {
-    Ok(querier
-        .app
-        .borrow()
-        .wrap()
-        .query(&cosmwasm_std::QueryRequest::Wasm(
-            cosmwasm_std::WasmQuery::Raw {
-                contract_addr: address.into(),
-                key: query_data.into(),
-            },
-        ))?)
+    let raw = to_json_binary(&cosmwasm_std::QueryRequest::<cosmwasm_std::Empty>::Wasm(
+        cosmwasm_std::WasmQuery::Raw {
+            contract_addr: address.into(),
+            key: query_data.into(),
+        },
+    ))
+    .map_err(|serialize_err| {
+        StdError::generic_err(format!("Serializing QueryRequest: {serialize_err}"))
+    })?;
+    let res: Result<Binary, StdError> = match querier.app.borrow().wrap().raw_query(&raw) {
+        SystemResult::Err(system_err) => Err(StdError::generic_err(format!(
+            "Querier system error: {system_err}"
+        ))),
+        SystemResult::Ok(ContractResult::Err(contract_err)) => Err(StdError::generic_err(format!(
+            "Querier contract error: {contract_err}"
+        ))),
+        SystemResult::Ok(ContractResult::Ok(value)) => Ok(value),
+    };
+    Ok(res?.0)
 }
 
 fn smart_query<A: Api, S: StateInterface, Q, T>(