fixed contract bug

fixing integration tests

Cargo.toml

@@ -29,7 +29,7 @@ overflow-checks = true
 [features]
 default = ["cranelift"]
 # for more explicit tests, cargo test --features=backtraces
-backtraces = ["cosmwasm-std/backtraces"]
+backtraces = ["cosmwasm-std/backtraces", "cosmwasm-vm/backtraces"]
 cranelift = ["cosmwasm-vm/default-cranelift"]
 singlepass = ["cosmwasm-vm/default-singlepass"]
 
@@ -44,7 +44,7 @@ assert = { version = "0.2.1" }
 thiserror = { version = "1.0.22" }
 
 [dev-dependencies]
-cosmwasm-vm = { version = "0.11.1", default-features = false }
+cosmwasm-vm = { version = "0.11.2", default-features = false, features = ["iterator", "staking"] }
 cosmwasm-schema = { version = "0.11.2" }
 
 

src/contract.rs

@@ -23,12 +23,10 @@ pub fn init<S: Storage, A: Api, Q: Querier>(
     msg: InitMsg,
 ) -> Result<InitResponse, MyCustomError> {
     // set_contract_version(&mut deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
-    let bonsai_list = BonsaiList::grow_bonsais(msg.number, env.block.height, msg.price);
+    let bonsai_list = BonsaiList::grow_bonsais(msg.number, env.block.height, msg.price.clone());
     bonsai_store(&mut deps.storage).save(&bonsai_list)?;
-
     let mut res = InitResponse::default();
     res.attributes = vec![attr("action", "grown_bonsais")];
-
     Ok(res)
 }
 
@@ -78,7 +76,7 @@ pub fn handle_become_gardener<S: Storage, A: Api, Q: Querier>(
 fn remove_bonsai<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     address: CanonicalAddr,
-    bonsai_id: String,
+    bonsai_id: u64,
 ) {
     let _ = gardeners_store(&mut deps.storage).update::<_, StdError>(
         address.as_slice(),
@@ -94,7 +92,7 @@ pub fn handle_buy_bonsai<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     env: Env,
     info: MessageInfo,
-    id: String,
+    id: u64,
 ) -> Result<HandleResponse, MyCustomError> {
     // try to load bonsai list if present otherwise returns error
     let bonsai_list = bonsai_store(&mut deps.storage).load()?;
@@ -109,7 +107,10 @@ pub fn handle_buy_bonsai<S: Storage, A: Api, Q: Querier>(
     // check if the gardener has enough funds to buy the bonsai
     let denom = deps.querier.query_bonded_denom()?;
     let balance = deps.querier.query_balance(&info.sender, &denom.as_str())?;
+    deps.api.debug(info.sender.clone().as_str());
     if balance.amount < bonsai.price.amount {
+        deps.api.debug(balance.amount.clone().to_string().as_str());
+        deps.api.debug(bonsai.price.amount.clone().to_string().as_str());
         return Err(MyCustomError::Std(StdError::generic_err(
             "Insufficient funds to buy the bonsai",
         )));
@@ -155,7 +156,7 @@ pub fn handle_sell_bonsai<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     info: MessageInfo,
     buyer: HumanAddr,
-    id: String,
+    id: u64,
 ) -> Result<HandleResponse, MyCustomError> {
     // convert human_addr to canonical
     let seller_addr = &deps.api.canonical_address(&info.sender)?;
@@ -207,10 +208,10 @@ pub fn handle_sell_bonsai<S: Storage, A: Api, Q: Querier>(
 pub fn handle_cut_bonsai<S: Storage, A: Api, Q: Querier>(
     deps: &mut Extern<S, A, Q>,
     info: MessageInfo,
-    id: String,
+    id: u64,
 ) -> Result<HandleResponse, MyCustomError> {
     let owner_addr = deps.api.canonical_address(&info.sender)?;
-    remove_bonsai(deps, owner_addr, id.clone());
+    remove_bonsai(deps, owner_addr, id);
 
     let mut res = HandleResponse::default();
     res.attributes = vec![

src/contract_tests.rs

@@ -54,11 +54,11 @@ fn setup_test<S: Storage, A: Api, Q: Querier>(
 }
 
 // return a random bonsai id
-fn get_random_bonsai_id<S: Storage, A: Api, Q: Querier>(deps: &mut Extern<S, A, Q>) -> String {
+fn get_random_bonsai_id<S: Storage, A: Api, Q: Querier>(deps: &mut Extern<S, A, Q>) -> u64 {
     let bonsais = query_bonsais(deps).unwrap().bonsais;
     let rand_bonsai = bonsais.choose(&mut rand::thread_rng()).unwrap();
 
-    rand_bonsai.id.clone()
+    rand_bonsai.id
 }
 
 #[test]
@@ -238,7 +238,7 @@ fn test_cut_bonsai_works() {
     setup_test(&mut deps, &env, bonsai_price.clone(), 10);
 
     let canonical_addr = &deps.api.canonical_address(&info.sender.clone()).unwrap();
-    let bonsai = Bonsai::new(bonsai_height, bonsai_price);
+    let bonsai = Bonsai::new(10,bonsai_height, bonsai_price);
     let gardener = Gardener::new(
         "leo".to_string(),
         canonical_addr.clone(),
@@ -290,7 +290,7 @@ fn query_gardener_works() {
     let env = mock_env_height(bonsai_height);
     setup_test(&mut deps, &env, bonsai_price.clone(), 10);
 
-    let bonsai = Bonsai::new(bonsai_height, bonsai_price);
+    let bonsai = Bonsai::new(10,bonsai_height, bonsai_price);
     let canonical_addr = &deps.api.canonical_address(&sender_addr).unwrap();
 
     let gardener = Gardener::new("leo".to_string(), canonical_addr.clone(), vec![bonsai]);
@@ -312,7 +312,7 @@ fn query_all_gardeners_works() {
     let env = mock_env_height(bonsai_height);
     setup_test(&mut deps, &env, bonsai_price.clone(), 10);
 
-    let bonsai = Bonsai::new(bonsai_height, bonsai_price);
+    let bonsai = Bonsai::new(10,bonsai_height, bonsai_price);
     let canonical_addr = &deps.api.canonical_address(&sender_addr).unwrap();
     let other_addr = HumanAddr::from("addr0002");
     let other_addr = &deps.api.canonical_address(&other_addr).unwrap();

src/msg.rs

@@ -13,9 +13,9 @@ pub struct InitMsg {
 #[serde(rename_all = "snake_case")]
 pub enum HandleMsg {
     BecomeGardener { name: String },
-    BuyBonsai { b_id: String },
-    SellBonsai { recipient: HumanAddr, b_id: String },
-    CutBonsai { b_id: String },
+    BuyBonsai { b_id: u64 },
+    SellBonsai { recipient: HumanAddr, b_id: u64 },
+    CutBonsai { b_id: u64 },
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]

src/state.rs

@@ -7,25 +7,20 @@ use cosmwasm_storage::{
     Singleton,
 };
 
-use rand::distributions::Alphanumeric;
-use rand::{thread_rng, Rng};
-
 pub static BONSAI_KEY: &[u8] = b"bonsai";
 pub static GARDENERS_KEY: &[u8] = b"gardener";
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct Bonsai {
-    pub id: String,
+    pub id: u64,
     // block height at which the bonsai was created
     pub birth_date: u64,
     pub price: Coin,
 }
 
 impl Bonsai {
     // not a method but an associate function
-    pub fn new(birth_date: u64, price: Coin) -> Bonsai {
-        let id: String = thread_rng().sample_iter(&Alphanumeric).take(8).collect();
-
+    pub fn new(id: u64, birth_date: u64, price: Coin) -> Bonsai {
         Bonsai {
             id,
             birth_date,
@@ -43,14 +38,12 @@ impl BonsaiList {
     /// grow some bonsais from a given number, watering each one of those
     pub fn grow_bonsais(number: u64, birth_date: u64, price: Coin) -> BonsaiList {
         let mut i = 0;
-        let mut bonsai_list = BonsaiList { bonsais: vec![] };
+        let mut bonsais: Vec<Bonsai> = Vec::with_capacity(number as usize);
         while i < number {
-            bonsai_list
-                .bonsais
-                .push(Bonsai::new(birth_date, price.clone()));
+            bonsais.push(Bonsai::new(i, birth_date, price.clone()));
             i += 1;
         }
-        bonsai_list
+        BonsaiList{ bonsais }
     }
 }
 

src/state_tests.rs

@@ -1,16 +1,16 @@
-use crate::state::{Bonsai, BonsaiList, Gardener};
+use crate::state::{Bonsai, Gardener};
 use cosmwasm_std::testing::MockApi;
 use cosmwasm_std::{coin, Api, HumanAddr};
 
 #[test]
 fn new_bonsai() {
     let mut exp_bonsai = Bonsai {
-        id: "".to_string(),
+        id: 1,
         birth_date: 100,
         price: coin(145, "testCoin"),
     };
 
-    let cur_bonsai = Bonsai::new(100, exp_bonsai.price.clone());
+    let cur_bonsai = Bonsai::new(1,100, exp_bonsai.price.clone());
 
     exp_bonsai.id = cur_bonsai.id.clone();
 
@@ -38,6 +38,6 @@ fn new_gardener() {
 
 #[test]
 fn grow_bonsais() {
-    let bonsai_list = BonsaiList::grow_bonsais(4, 415000, coin(145, "testCoin"));
-    assert_eq!(4, bonsai_list.bonsais.len())
+    //let bonsai_list = BonsaiList::grow_bonsais(20, 100, coin(20, "bonsai"), mock_dependencies(&[]););
+    //assert_eq!(20, bonsai_list.bonsais.len())
 }

tests/integration.rs

@@ -21,9 +21,7 @@ use cosmwasm_std::{
     HandleResponse, HumanAddr, InitResponse, MessageInfo, QueryResponse,
 };
 use cosmwasm_storage::to_length_prefixed;
-use cosmwasm_vm::testing::{
-    handle, init, mock_env, mock_info, mock_instance, query, MockApi, MockQuerier, MockStorage,
-};
+use cosmwasm_vm::testing::{handle, init, mock_env, mock_info, mock_instance, query, MockApi, MockQuerier, MockStorage, mock_instance_with_balances};
 use cosmwasm_vm::{Instance, Storage};
 use my_first_contract::msg::{HandleMsg, InitMsg, QueryMsg};
 use my_first_contract::state::{BonsaiList, Gardener, BONSAI_KEY};
@@ -44,25 +42,25 @@ fn mock_env_height(height: u64) -> Env {
 fn setup_test(
     deps: &mut Instance<MockStorage, MockApi, MockQuerier>,
     env: &Env,
+    info: MessageInfo,
     bonsai_price: Coin,
     bonsai_number: u64,
 ) {
     let init_msg = InitMsg {
         price: bonsai_price,
         number: bonsai_number,
     };
-    let info = mock_info("creator", &coins(10, BOND_DENOM));
     let _res: InitResponse = init(deps, env.clone(), info, init_msg).unwrap();
 }
 
 // return a random bonsai id
-fn get_random_bonsai_id(deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> String {
+fn get_random_bonsai_id(deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> u64 {
     let result = query(deps, mock_env(), QueryMsg::GetBonsais {}).unwrap();
 
     let bonsais: BonsaiList = from_binary(&result).unwrap();
     let rand_bonsai = bonsais.bonsais.choose(&mut rand::thread_rng()).unwrap();
 
-    rand_bonsai.id.clone()
+    rand_bonsai.id
 }
 
 fn become_gardener(name: String, info: MessageInfo, env: Env, deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> HandleResponse {
@@ -71,7 +69,7 @@ fn become_gardener(name: String, info: MessageInfo, env: Env, deps: &mut Instanc
     res
 }
 
-fn buy_bonsai(bonsai_id: String, info: MessageInfo, env: Env, deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> HandleResponse {
+fn buy_bonsai(bonsai_id: u64, info: MessageInfo, env: Env, deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> HandleResponse {
     let msg = HandleMsg::BuyBonsai { b_id: bonsai_id };
     let res: HandleResponse = handle(deps, env, info, msg).unwrap();
     res
@@ -120,15 +118,15 @@ fn test_become_gardener_works() {
     let bonsai_price = coin(10, BOND_DENOM);
     let env = mock_env_height(100);
     let info = mock_info(&sender_addr, &coins(1000, BOND_DENOM));
-    setup_test(&mut deps, &env, bonsai_price.clone(), 10);
+    setup_test(&mut deps, &env, info.clone(), bonsai_price.clone(), 10);
 
     let mut exp_res = HandleResponse::default();
     exp_res.attributes = vec![
         attr("action", "become_gardener"),
         attr("gardener_addr", &sender_addr),
     ];
 
-    let res = become_gardener("leo".to_string(), info, env.clone(), &mut deps);
+    let res = become_gardener("leo".to_string(), info.clone(), env.clone(), &mut deps);
 
     // verify that the result attributes are equals to the expected ones
     assert_eq!(exp_res, res);
@@ -140,18 +138,20 @@ fn test_become_gardener_works() {
 
 #[test]
 fn test_buy_bonsai_works() {
-    let mut deps = mock_instance(WASM, &[]);
-
     let sender_addr = HumanAddr::from("addr0001");
     let bonsai_price = coin(10, BOND_DENOM);
+
+    let mut deps = mock_instance_with_balances(WASM,
+                                               &[(&sender_addr.clone(), &coins(1000, BOND_DENOM))]);
     let env = mock_env_height(100);
-    let info = mock_info(sender_addr, &coins(1000, BOND_DENOM));
+    let info = mock_info(sender_addr, &coins(15, BOND_DENOM));
 
     // setup test environment
-    setup_test(&mut deps, &env, bonsai_price.clone(), 10);
+    setup_test(&mut deps, &env, info.clone(), bonsai_price.clone(), 10);
 
     let _res = become_gardener("leo".to_string(), info.clone(), env.clone(), &mut deps);
 
+
     let bonsai_id = get_random_bonsai_id(&mut deps);
 
     let exp_res = HandleResponse {
@@ -169,13 +169,13 @@ fn test_buy_bonsai_works() {
         data: None,
     };
 
-    let res = buy_bonsai(bonsai_id.clone(), info.clone(), env.clone(), &mut deps);
+    let res = buy_bonsai(bonsai_id, info.clone(), env.clone(), &mut deps);
     assert_eq!(exp_res, res);
 
     // check if the gardeners was saved
     let gardener: Gardener = query_gardener(&mut deps, env.clone(), info.sender.clone());
     assert_eq!("leo", gardener.name);
-    assert_eq!(bonsai_id.clone(), gardener.bonsais[0].id)
+    assert_eq!(bonsai_id, gardener.bonsais[0].id)
 }
 
 #[test]
@@ -189,7 +189,7 @@ fn test_sell_bonsai_works() {
     let info = mock_info(sender_addr, &coins(1000, BOND_DENOM));
 
     // setup test environment
-    setup_test(&mut deps, &env, bonsai_price.clone(), 10);
+    setup_test(&mut deps, &env, info.clone(), bonsai_price.clone(), 10);
 
     let bonsai_id = get_random_bonsai_id(&mut deps);
 
@@ -212,7 +212,7 @@ fn test_sell_bonsai_works() {
 
     let msg = HandleMsg::SellBonsai {
         recipient: buyer_addr.clone(),
-        b_id: bonsai_id.clone(),
+        b_id: bonsai_id,
     };
     let res: HandleResponse = handle(&mut deps, env.clone(), info.clone(), msg).unwrap();
 
@@ -239,15 +239,15 @@ fn test_cut_bonsai_works() {
     let info = mock_info(sender_addr, &coins(100, BOND_DENOM));
 
     // setup test environment
-    setup_test(&mut deps, &env, bonsai_price.clone(), 10);
+    setup_test(&mut deps, &env, info.clone(), bonsai_price.clone(), 10);
 
     let bonsai_id = get_random_bonsai_id(&mut deps);
     let _res = become_gardener("leo".to_string(), info.clone(), env.clone(), &mut deps);
 
-    let _res = buy_bonsai(bonsai_id.clone(), info.clone(), env.clone(), &mut deps);
+    let _res = buy_bonsai(bonsai_id, info.clone(), env.clone(), &mut deps);
 
     let msg = HandleMsg::CutBonsai {
-        b_id: bonsai_id.clone(),
+        b_id: bonsai_id,
     };
 
     let res: HandleResponse = handle(&mut deps, env.clone(), info.clone(), msg).unwrap();
@@ -256,7 +256,7 @@ fn test_cut_bonsai_works() {
     exp_res.attributes = vec![
         attr("action", "cut_bonsai"),
         attr("owner", info.sender.clone()),
-        attr("bonsai_id", bonsai_id.clone()),
+        attr("bonsai_id", bonsai_id),
     ];
 
     assert_eq!(exp_res, res);