From 83ebe741f5b05c1916a5de0a1a679aa346172aed Mon Sep 17 00:00:00 2001 From: DragonMural Date: Tue, 21 Apr 2020 20:25:05 -0400 Subject: [PATCH 01/20] Adding skeleton code and some functionality --- vm/actor/tests/init_actor_test.rs | 110 ++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 vm/actor/tests/init_actor_test.rs diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs new file mode 100644 index 000000000000..512e7ea0d555 --- /dev/null +++ b/vm/actor/tests/init_actor_test.rs @@ -0,0 +1,110 @@ +// Copyright 2020 ChainSafe Systems +// SPDX-License-Identifier: Apache-2.0, MIT + +// Has all of the common things needed to test inlcuding MockRuntime +mod common; +use common::*; +use cid::{multihash::Blake2b256, Cid}; +use ipld_blockstore::BlockStore; +use actor::{ + SYSTEM_ACTOR_ADDR, + INIT_ACTOR_CODE_ID, + init::{ConstructorParams,ExecParams} , +}; + +use vm::{ActorError,Serialized}; + +// Test to make sure we abort actors that can not call the exec function +#[test] +fn abort_cant_call_exec() { + assert_eq!(true, true); +} + +#[test] +fn create_2_payment_channels() { + assert_eq!(true, true); +} + +#[test] +fn create_storage_miner() { + assert_eq!(true, true); +} +#[test] +fn create_multisig_actor() { + + //let bs = MemoryDB::default(); + + // rt := builder.Build(t) + // actor.constructAndVerify(rt) + // // actor creating the multisig actor + // someAccountActor := tutil.NewIDAddr(t, 1234) + // rt.SetCaller(someAccountActor, builtin.AccountActorCodeID) + + // uniqueAddr := tutil.NewActorAddr(t, "multisig") + + // rt.SetNewActorAddress(uniqueAddr) + // // next id address + // expectedIdAddr := tutil.NewIDAddr(t, 100) + // rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) + // // expect a send to the multisig actor constructor + // rt.ExpectSend(expectedIdAddr, builtin.MethodConstructor, fakeParams, big.Zero(), nil, exitcode.Ok) + // execRet := actor.execAndVerify(rt, builtin.MultisigActorCodeID, fakeParams) + + // assert_eq!(uniqueAddr, execRet.RobustAddress) + // assert_eq!(expectedIdAddr, execRet.IDAddress) + + assert_eq!(true, true); +} + +#[test] +fn sending_constructor_failure() { + assert_eq!(true, true); +} + +fn construct_and_verify(rt: &mut MockRuntime<'_, BS>) { + rt.expect_validate_caller_addr(&[SYSTEM_ACTOR_ADDR.clone()]); + let params = ConstructorParams { + network_name:"mock".to_string() + }; + let ret = rt.call( + &*INIT_ACTOR_CODE_ID, + 1, + &Serialized::serialize(¶ms).unwrap(), + ).unwrap(); + + let initial_state = Serialized::default(); + assert_eq!(initial_state, ret); + rt.verify(); + + + let state_data = match rt.get_state() { + Err(E) => assert_eq!(true, false,"Failed to get State Data"), + Ok(T) => T + }; + //fn store(&self) -> &BS { + + //fn make_map(store: &'_ BS) -> Hamt<'_, BytesKey, BS> { + //Remaining Go lines to port over + //emptyMap, err := adt.AsMap(adt.AsStore(rt), st.AddressMap) + //assert.NoError(h.t, err) + //assert.Equal(h.t, tutil.MustRoot(h.t, emptyMap), st.AddressMap) + //assert.Equal(h.t, abi.ActorID(builtin.FirstNonSingletonActorId), st.NextID) + + //assert_eq!("mock".to_string(), state_data.NetworkName) +} + +fn exec_and_verify(rt: &mut MockRuntime<'_, BS>, code_id : Cid , params: &ConstructorParams) -> Result{ + rt.expect_validate_caller_any(); + let exec_params = ExecParams { + code_cid: code_id, + constructor_params: Serialized::serialize(¶ms).unwrap() + }; + + let ret = rt.call( + &*INIT_ACTOR_CODE_ID, + 2, + &Serialized::serialize(&exec_params).unwrap() + ); + rt.verify(); + ret +} From 612d12604a24bf3b320464c8b279ffd668514b33 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Thu, 23 Apr 2020 14:34:33 -0400 Subject: [PATCH 02/20] Changing from private to public. --- vm/actor/src/builtin/init/state.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vm/actor/src/builtin/init/state.rs b/vm/actor/src/builtin/init/state.rs index 5b299dd4f86c..31a786906210 100644 --- a/vm/actor/src/builtin/init/state.rs +++ b/vm/actor/src/builtin/init/state.rs @@ -12,9 +12,9 @@ use vm::ActorID; /// State is reponsible for creating pub struct State { - address_map: Cid, - next_id: ActorID, - network_name: String, + pub address_map: Cid, + pub next_id: ActorID, + pub network_name: String, } impl State { From 291d545d6fa291b1116c6598f65d9baf9f26922c Mon Sep 17 00:00:00 2001 From: DragonMural Date: Thu, 23 Apr 2020 22:45:24 -0400 Subject: [PATCH 03/20] Added the construct and verification function. Tried to make a test function --- vm/actor/tests/init_actor_test.rs | 150 ++++++++++++++++++++---------- 1 file changed, 101 insertions(+), 49 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 512e7ea0d555..a464604dcf1a 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -3,107 +3,159 @@ // Has all of the common things needed to test inlcuding MockRuntime mod common; -use common::*; -use cid::{multihash::Blake2b256, Cid}; -use ipld_blockstore::BlockStore; +use db::MemoryDB; +//use crate::{builtin::singleton::FIRST_NON_SINGLETON_ADDR}; + use actor::{ - SYSTEM_ACTOR_ADDR, - INIT_ACTOR_CODE_ID, - init::{ConstructorParams,ExecParams} , + init::{ConstructorParams, ExecParams, State}, + INIT_ACTOR_CODE_ID, SYSTEM_ACTOR_ADDR, SYSTEM_ACTOR_CODE_ID, FIRST_NON_SINGLETON_ADDR, MULTISIG_ACTOR_CODE_ID, POWER_ACTOR_CODE_ID,ACCOUNT_ACTOR_CODE_ID, + Multimap }; -use vm::{ActorError,Serialized}; + +use cid::{multihash::Identity, Cid, Codec}; +use common::*; +use ipld_blockstore::BlockStore; +//use ipld_hamt::Hamt; +use address::Address; +use vm::{ActorError, Serialized}; + + +fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { + let receiver = Address::new_id(1000).unwrap(); + let mut rt = MockRuntime::new(bs, receiver.clone()); + rt.caller = SYSTEM_ACTOR_ADDR.clone(); + rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); + return rt; +} + // Test to make sure we abort actors that can not call the exec function #[test] fn abort_cant_call_exec() { - assert_eq!(true, true); + let bs = MemoryDB::default(); + let mut rt = construct_runtime(&bs); + construct_and_verify(&mut rt); + let anne = Address::new_id(1001).unwrap(); + + //Set caller + rt.caller = anne; + rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + + match exec_and_verify(&mut rt, POWER_ACTOR_CODE_ID.clone(), &ConstructorParams { network_name: String::new() } ) { + Err(E) => assert_eq!(false, true), + Ok(T) => () + } + + // Didnt see a undef cid like in the go implmentation. If there is replace the not_a_actor token. Need to ask about this + let undef_cid = Cid::new_v1(Codec::Raw, Identity::digest(b"fil/1/notaactor")); + match exec_and_verify(&mut rt, undef_cid , &ConstructorParams { network_name: String::new() } ) { + Err(E) => assert_eq!(false, true), + Ok(T) => () + } + } #[test] fn create_2_payment_channels() { + let bs = MemoryDB::default(); + let mut rt = construct_runtime(&bs); + construct_and_verify(&mut rt); + let anne = Address::new_id(1001).unwrap(); + + //Set caller + rt.caller = anne; + rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + + // Change balances not sure how to do i saw the send function, but idk if thats all i need + + let uniq_addr_1 = Address::new_actor(b"paych"); + rt.new_actor_addr = Some(uniq_addr_1.unwrap()); + + + + // next id address + //let expected_id_addr_1 = Address::new_id(100); + + //rt.create_actor(uniq_addr_1, expected_id_addr_1); + //rt.expect_validate_caller_addr(&vec![SYSTEM_ACTOR_ADDR.clone()]); + + + + assert_eq!(true, true); } #[test] fn create_storage_miner() { + let bs = MemoryDB::default(); + let mut rt = construct_runtime(&bs); + construct_and_verify(&mut rt); + assert_eq!(true, true); } #[test] fn create_multisig_actor() { + let bs = MemoryDB::default(); + let mut rt = construct_runtime(&bs); + construct_and_verify(&mut rt); - //let bs = MemoryDB::default(); - // rt := builder.Build(t) - // actor.constructAndVerify(rt) - // // actor creating the multisig actor - // someAccountActor := tutil.NewIDAddr(t, 1234) - // rt.SetCaller(someAccountActor, builtin.AccountActorCodeID) - - // uniqueAddr := tutil.NewActorAddr(t, "multisig") - - // rt.SetNewActorAddress(uniqueAddr) - // // next id address - // expectedIdAddr := tutil.NewIDAddr(t, 100) - // rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) - // // expect a send to the multisig actor constructor - // rt.ExpectSend(expectedIdAddr, builtin.MethodConstructor, fakeParams, big.Zero(), nil, exitcode.Ok) - // execRet := actor.execAndVerify(rt, builtin.MultisigActorCodeID, fakeParams) - - // assert_eq!(uniqueAddr, execRet.RobustAddress) - // assert_eq!(expectedIdAddr, execRet.IDAddress) assert_eq!(true, true); } #[test] fn sending_constructor_failure() { + let bs = MemoryDB::default(); + let mut rt = construct_runtime(&bs); + construct_and_verify(&mut rt); + assert_eq!(true, true); } fn construct_and_verify(rt: &mut MockRuntime<'_, BS>) { rt.expect_validate_caller_addr(&[SYSTEM_ACTOR_ADDR.clone()]); let params = ConstructorParams { - network_name:"mock".to_string() + network_name: "mock".to_string(), }; - let ret = rt.call( - &*INIT_ACTOR_CODE_ID, - 1, - &Serialized::serialize(¶ms).unwrap(), - ).unwrap(); + let ret = rt + .call( + &*INIT_ACTOR_CODE_ID, + 1, + &Serialized::serialize(¶ms).unwrap(), + ) + .unwrap(); let initial_state = Serialized::default(); assert_eq!(initial_state, ret); rt.verify(); + let state_data : State = rt.get_state().unwrap(); - let state_data = match rt.get_state() { - Err(E) => assert_eq!(true, false,"Failed to get State Data"), - Ok(T) => T - }; - //fn store(&self) -> &BS { - - //fn make_map(store: &'_ BS) -> Hamt<'_, BytesKey, BS> { - //Remaining Go lines to port over - //emptyMap, err := adt.AsMap(adt.AsStore(rt), st.AddressMap) - //assert.NoError(h.t, err) - //assert.Equal(h.t, tutil.MustRoot(h.t, emptyMap), st.AddressMap) - //assert.Equal(h.t, abi.ActorID(builtin.FirstNonSingletonActorId), st.NextID) + // Gets the Result(CID) + let empty_map = Multimap::from_root(rt.store, &state_data.address_map).unwrap().root(); - //assert_eq!("mock".to_string(), state_data.NetworkName) + assert_eq!(empty_map.unwrap(), state_data.address_map); + assert_eq!(FIRST_NON_SINGLETON_ADDR, state_data.next_id); + assert_eq!("mock".to_string(), state_data.network_name); } -fn exec_and_verify(rt: &mut MockRuntime<'_, BS>, code_id : Cid , params: &ConstructorParams) -> Result{ +fn exec_and_verify( + rt: &mut MockRuntime<'_, BS>, + code_id: Cid, + params: &ConstructorParams, +) -> Result { rt.expect_validate_caller_any(); let exec_params = ExecParams { code_cid: code_id, - constructor_params: Serialized::serialize(¶ms).unwrap() + constructor_params: Serialized::serialize(¶ms).unwrap(), }; let ret = rt.call( &*INIT_ACTOR_CODE_ID, 2, - &Serialized::serialize(&exec_params).unwrap() + &Serialized::serialize(&exec_params).unwrap(), ); rt.verify(); ret From 2c67947dfcaf250e0c7084ad068b4d1bbd2dda6a Mon Sep 17 00:00:00 2001 From: DragonMural Date: Sat, 25 Apr 2020 12:53:18 -0400 Subject: [PATCH 04/20] Some more changes. --- vm/actor/tests/init_actor_test.rs | 276 ++++++++++++++++++++++++++---- 1 file changed, 241 insertions(+), 35 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index a464604dcf1a..169ae2a9a0aa 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -7,19 +7,19 @@ use db::MemoryDB; //use crate::{builtin::singleton::FIRST_NON_SINGLETON_ADDR}; use actor::{ - init::{ConstructorParams, ExecParams, State}, - INIT_ACTOR_CODE_ID, SYSTEM_ACTOR_ADDR, SYSTEM_ACTOR_CODE_ID, FIRST_NON_SINGLETON_ADDR, MULTISIG_ACTOR_CODE_ID, POWER_ACTOR_CODE_ID,ACCOUNT_ACTOR_CODE_ID, - Multimap + init::{ConstructorParams, ExecParams, ExecReturn, State}, + Multimap, ACCOUNT_ACTOR_CODE_ID, FIRST_NON_SINGLETON_ADDR, INIT_ACTOR_CODE_ID, + MINER_ACTOR_CODE_ID, MULTISIG_ACTOR_CODE_ID, PAYCH_ACTOR_CODE_ID, POWER_ACTOR_CODE_ID, + STORAGE_POWER_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, SYSTEM_ACTOR_CODE_ID, }; - +//use serde::{Deserialize, Deserializer, Serialize, Serializer}; use cid::{multihash::Identity, Cid, Codec}; use common::*; use ipld_blockstore::BlockStore; //use ipld_hamt::Hamt; use address::Address; -use vm::{ActorError, Serialized}; - +use vm::{ActorError, ExitCode, Serialized}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(1000).unwrap(); @@ -29,59 +29,124 @@ fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { return rt; } - // Test to make sure we abort actors that can not call the exec function #[test] fn abort_cant_call_exec() { let bs = MemoryDB::default(); let mut rt = construct_runtime(&bs); construct_and_verify(&mut rt); - let anne = Address::new_id(1001).unwrap(); + let anne = Address::new_id(1001).unwrap(); //Set caller rt.caller = anne; rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); - match exec_and_verify(&mut rt, POWER_ACTOR_CODE_ID.clone(), &ConstructorParams { network_name: String::new() } ) { - Err(E) => assert_eq!(false, true), - Ok(T) => () + // TODO : Implement Message and then uncoment + match exec_and_verify( + &mut rt, + POWER_ACTOR_CODE_ID.clone(), + &ConstructorParams { + network_name: String::new(), + }, + ) { + Err(error) => { + let error_exit_code = error.exit_code(); + assert_eq!( + error_exit_code, + ExitCode::ErrForbidden, + "Error code returned is not ErrForbidden" + ); + } + Ok(_) => assert_eq!(true, false, "Failed to fail"), } - // Didnt see a undef cid like in the go implmentation. If there is replace the not_a_actor token. Need to ask about this - let undef_cid = Cid::new_v1(Codec::Raw, Identity::digest(b"fil/1/notaactor")); - match exec_and_verify(&mut rt, undef_cid , &ConstructorParams { network_name: String::new() } ) { - Err(E) => assert_eq!(false, true), - Ok(T) => () + // Didnt see a undef cid like in the go implmentation. If there is replace the not_a_actor token. Need to ask about thi + // Can porbbaly get rid of this + let undef_cid = Cid::new_v1(Codec::Raw, Identity::digest(b"fil/1/notaactor")); + match exec_and_verify( + &mut rt, + undef_cid, + &ConstructorParams { + network_name: String::new(), + }, + ) { + Err(error) => { + assert_eq!(false, true); + let error_exit_code = error.exit_code(); + assert_eq!( + error_exit_code, + ExitCode::ErrForbidden, + "Error code returned is not ErrForbidden" + ); + } + Ok(_) => assert_eq!(true, false, "Failed to Fail"), } - } #[test] fn create_2_payment_channels() { let bs = MemoryDB::default(); - let mut rt = construct_runtime(&bs); + let mut rt : MockRuntime = construct_runtime(&bs); construct_and_verify(&mut rt); - let anne = Address::new_id(1001).unwrap(); + let anne = Address::new_id(1001).unwrap(); //Set caller rt.caller = anne; rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); - // Change balances not sure how to do i saw the send function, but idk if thats all i need + // Change balances not sure how to do i saw the send function, but idk if thats all i need - let uniq_addr_1 = Address::new_actor(b"paych"); - rt.new_actor_addr = Some(uniq_addr_1.unwrap()); + //// Go test does 2 payment channel tests + for n in 0..2 { + //let pay_channel = String::from("paych") + n.to_string(); + let pay_channel_string = format!("paych_{}", n); + let paych = pay_channel_string.as_bytes(); + let uniq_addr_1 = Address::new_actor(paych); + rt.new_actor_addr = Some(Address::new_actor(paych).unwrap()); + let expected_id_addr_1 = Address::new_id(100 + n).unwrap(); - // next id address - //let expected_id_addr_1 = Address::new_id(100); - - //rt.create_actor(uniq_addr_1, expected_id_addr_1); - //rt.expect_validate_caller_addr(&vec![SYSTEM_ACTOR_ADDR.clone()]); + let v = rt.create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1); + let fake_params = ConstructorParams { + network_name: String::from("fake_param"), + }; + // expect anne creating a payment channel to trigger a send to the payment channels constructor + rt.expect_send( + expected_id_addr_1.clone(), + 1, + Serialized::serialize(&fake_params).unwrap(), + 0u8.into(), + Serialized::default(), + ExitCode::Ok, + ); + + let exec_ret = exec_and_verify(&mut rt, PAYCH_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); + assert_eq!( + uniq_addr_1, + Ok(exec_ret.robust_address), + "Robust Address does not match" + ); + assert_eq!( + expected_id_addr_1, exec_ret.id_address, + "Id address does not match" + ); + + let state: State = rt.get_state().unwrap(); + match state.resolve_address(rt.store, &uniq_addr_1.unwrap()) { + Ok(returned_address) => { + assert_eq!( + returned_address, expected_id_addr_1, + "Wrong Address returned" + ); + } + Err(_) => assert_eq!(true, false, "Address should have been found"), + } + } assert_eq!(true, true); } @@ -92,7 +157,62 @@ fn create_storage_miner() { let mut rt = construct_runtime(&bs); construct_and_verify(&mut rt); - assert_eq!(true, true); + // only the storage power actor can create a miner + rt.caller = STORAGE_POWER_ACTOR_ADDR.clone(); + rt.caller_type = POWER_ACTOR_CODE_ID.clone(); + + let uniq_addr_1 = Address::new_actor(b"miner").unwrap(); + rt.new_actor_addr = Some(uniq_addr_1.clone()); + + let expected_id_addr_1 = Address::new_id(100).unwrap(); + + // Add expect create actor + + let fake_params = ConstructorParams { + network_name: String::from("fake_param"), + }; + // expect storage power actor creating a storage miner actor to trigger a send to the storage miner actors constructor + rt.expect_send( + expected_id_addr_1.clone(), + 1, + Serialized::serialize(&fake_params).unwrap(), + 0u8.into(), + Serialized::default(), + ExitCode::Ok, + ); + // Make sure addresses returend are as expected + let exec_ret = exec_and_verify(&mut rt, MULTISIG_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); + assert_eq!( + uniq_addr_1, exec_ret.robust_address, + "Robust address does not match" + ); + assert_eq!( + expected_id_addr_1, exec_ret.id_address, + "Id address does not match" + ); + + // Address should be resolved + let state: State = rt.get_state().unwrap(); + match state.resolve_address(rt.store, &uniq_addr_1) { + Ok(returned_address) => { + assert_eq!(returned_address, uniq_addr_1, "Wrong Address returned"); + } + Err(_) => assert_eq!(true, false, "Address should have been found"), + } + + // Should return error since the address of flurbo is unknown + let unknown_addr = Address::new_actor(b"flurbo").unwrap(); + match state.resolve_address(rt.store, &unknown_addr) { + Err(returned_address) => { + // Address not found error is returned as string + assert_eq!( + returned_address, "Address not found", + "Wrong Address returned" + ); + } + Ok(_) => assert_eq!(true, false, "Address should have not been found"), + } } #[test] fn create_multisig_actor() { @@ -100,9 +220,44 @@ fn create_multisig_actor() { let mut rt = construct_runtime(&bs); construct_and_verify(&mut rt); + // Actor creating multisig actor + let some_acc_actor = Address::new_id(1234).unwrap(); + rt.caller = some_acc_actor; + rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + //Assign addresses + let uniq_addr_1 = Address::new_actor(b"multisig").unwrap(); + rt.new_actor_addr = Some(uniq_addr_1.clone()); - assert_eq!(true, true); + // Next id + let expected_id_addr_1 = Address::new_id(100).unwrap(); + // call expect create actor + //Go Code : rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) + + let fake_params = ConstructorParams { + network_name: String::from("fake_param"), + }; + // Expect a send to the multisig actor constructor + rt.expect_send( + expected_id_addr_1.clone(), + 1, + Serialized::serialize(&fake_params).unwrap(), + 0u8.into(), + Serialized::default(), + ExitCode::Ok, + ); + + // Return should have been successful. Check the returned addresses + let exec_ret = exec_and_verify(&mut rt, MULTISIG_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); + assert_eq!( + uniq_addr_1, exec_ret.robust_address, + "Robust address does not macth" + ); + assert_eq!( + expected_id_addr_1, exec_ret.id_address, + "Id address does not match" + ); } #[test] @@ -111,7 +266,57 @@ fn sending_constructor_failure() { let mut rt = construct_runtime(&bs); construct_and_verify(&mut rt); - assert_eq!(true, true); + // Only the storage power actor can create a miner + rt.caller = STORAGE_POWER_ACTOR_ADDR.clone(); + rt.caller_type = POWER_ACTOR_CODE_ID.clone(); + + //Assign new address for the storage actor miner + let uniq_addr_1 = Address::new_actor(b"miner").unwrap(); + rt.new_actor_addr = Some(uniq_addr_1.clone()); + + // Create the next id address + let expected_id_addr_1 = Address::new_id(100).unwrap(); + + // call expect create actor + //Go Code : rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) + + let fake_params = ConstructorParams { + network_name: String::from("fake_param"), + }; + rt.expect_send( + expected_id_addr_1.clone(), + 1, + Serialized::serialize(&fake_params).unwrap(), + 0u8.into(), + Serialized::default(), + ExitCode::ErrIllegalState.clone(), + ); + + // Only thr storage power actor can create a storage miner. Init actor creating it should result in failure + match exec_and_verify(&mut rt, POWER_ACTOR_CODE_ID.clone(), &fake_params) { + Err(error) => { + let error_exit_code = error.exit_code(); + assert_eq!( + error_exit_code, + ExitCode::ErrIllegalState, + "Exit Code that is returned is not ErrIllegalState" + ); + } + Ok(_) => assert_eq!(true, false, "Failed to fail"), + } + + // The send command from earlier should have failed. So you shouldnt be able to see the address + let state: State = rt.get_state().unwrap(); + match state.resolve_address(rt.store, &uniq_addr_1) { + Err(returned_address) => { + // Error is returned as string. Doing it in the lazy way for this PR + assert_eq!( + returned_address, "Address not found", + "Addresses should have not been found" + ); + } + Ok(_) => assert_eq!(true, false, "Failed to fail address resolution"), + } } fn construct_and_verify(rt: &mut MockRuntime<'_, BS>) { @@ -127,16 +332,17 @@ fn construct_and_verify(rt: &mut MockRuntime<'_, BS>) { ) .unwrap(); - let initial_state = Serialized::default(); - assert_eq!(initial_state, ret); + assert_eq!(Serialized::default(), ret); rt.verify(); - let state_data : State = rt.get_state().unwrap(); + let state_data: State = rt.get_state().unwrap(); // Gets the Result(CID) - let empty_map = Multimap::from_root(rt.store, &state_data.address_map).unwrap().root(); + let empty_map = Multimap::from_root(rt.store, &state_data.address_map) + .unwrap() + .root(); - assert_eq!(empty_map.unwrap(), state_data.address_map); + assert_eq!(empty_map.unwrap(), state_data.address_map); assert_eq!(FIRST_NON_SINGLETON_ADDR, state_data.next_id); assert_eq!("mock".to_string(), state_data.network_name); } From 3c09aa4b9819543736c6c98ad721b67f37bdbef9 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Sat, 25 Apr 2020 12:54:23 -0400 Subject: [PATCH 05/20] Some more changes. --- vm/actor/tests/init_actor_test.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 169ae2a9a0aa..c1488fcdfc01 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -86,7 +86,7 @@ fn abort_cant_call_exec() { #[test] fn create_2_payment_channels() { let bs = MemoryDB::default(); - let mut rt : MockRuntime = construct_runtime(&bs); + let mut rt: MockRuntime = construct_runtime(&bs); construct_and_verify(&mut rt); let anne = Address::new_id(1001).unwrap(); @@ -107,8 +107,7 @@ fn create_2_payment_channels() { let expected_id_addr_1 = Address::new_id(100 + n).unwrap(); - let v = rt.create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1); - + let v = rt.create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1); let fake_params = ConstructorParams { network_name: String::from("fake_param"), From 450ff50a6c2f64a93ca562fcd2b7542efc9f419a Mon Sep 17 00:00:00 2001 From: DragonMural Date: Sat, 25 Apr 2020 18:58:10 -0400 Subject: [PATCH 06/20] More test changes --- vm/actor/tests/init_actor_test.rs | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index c1488fcdfc01..6b8e6defdc79 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -19,7 +19,7 @@ use common::*; use ipld_blockstore::BlockStore; //use ipld_hamt::Hamt; use address::Address; -use vm::{ActorError, ExitCode, Serialized}; +use vm::{ActorError, ExitCode, Serialized, TokenAmount}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(1000).unwrap(); @@ -93,6 +93,7 @@ fn create_2_payment_channels() { //Set caller rt.caller = anne; rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + // Change balances not sure how to do i saw the send function, but idk if thats all i need @@ -107,18 +108,22 @@ fn create_2_payment_channels() { let expected_id_addr_1 = Address::new_id(100 + n).unwrap(); - let v = rt.create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1); + rt.expect_create_actor( PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); + + //let v = rt.create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; // expect anne creating a payment channel to trigger a send to the payment channels constructor + let balance = TokenAmount::new(vec![1,0,0]); + rt.expect_send( expected_id_addr_1.clone(), 1, Serialized::serialize(&fake_params).unwrap(), - 0u8.into(), + balance, Serialized::default(), ExitCode::Ok, ); @@ -164,6 +169,7 @@ fn create_storage_miner() { rt.new_actor_addr = Some(uniq_addr_1.clone()); let expected_id_addr_1 = Address::new_id(100).unwrap(); + rt.expect_create_actor(POWER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); // Add expect create actor @@ -230,6 +236,8 @@ fn create_multisig_actor() { // Next id let expected_id_addr_1 = Address::new_id(100).unwrap(); + rt.expect_create_actor( MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); + // call expect create actor //Go Code : rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) @@ -275,6 +283,8 @@ fn sending_constructor_failure() { // Create the next id address let expected_id_addr_1 = Address::new_id(100).unwrap(); + rt.expect_create_actor(POWER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); + // call expect create actor //Go Code : rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) From 2cb23be17296ac992e1fa430e99322836a598a87 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Tue, 28 Apr 2020 12:13:19 -0400 Subject: [PATCH 07/20] 4 Tests are still failing --- vm/actor/src/builtin/init/mod.rs | 5 +- vm/actor/tests/common/mod.rs | 33 +++++++++- vm/actor/tests/init_actor_test.rs | 105 ++++++++++++++++++------------ 3 files changed, 94 insertions(+), 49 deletions(-) diff --git a/vm/actor/src/builtin/init/mod.rs b/vm/actor/src/builtin/init/mod.rs index e2a47c961e47..b0798f88d4ca 100644 --- a/vm/actor/src/builtin/init/mod.rs +++ b/vm/actor/src/builtin/init/mod.rs @@ -71,10 +71,6 @@ impl Actor { )); } - // Compute a re-org-stable address. - // This address exists for use by messages coming from outside the system, in order to - // stably address the newly created actor even if a chain re-org causes it to end up with - // a different ID. let robust_address = rt.new_actor_address()?; // Allocate an ID for this actor. @@ -90,6 +86,7 @@ impl Actor { rt.create_actor(¶ms.code_cid, &id_address)?; // Invoke constructor + rt.send( &id_address, METHOD_CONSTRUCTOR, diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index b66a3f0ad8c9..1e470660d4aa 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -28,6 +28,7 @@ pub struct MockRuntime<'a, BS: BlockStore> { pub id_addresses: HashMap, pub actor_code_cids: HashMap, pub new_actor_addr: Option
, + pub message: UnsignedMessage, // TODO: syscalls: syscaller @@ -80,6 +81,18 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { actor_code_cids: HashMap::new(), new_actor_addr: None, + message: UnsignedMessage::builder() + .to(Address::new_id(100).unwrap()) + .from(Address::new_id(100).unwrap()) + .sequence(0) // optional + .value(TokenAmount::from(0u8)) // optional + .method_num(MethodNum::default()) // optional + .params(Serialized::default()) // optional + .gas_limit(0) // optional + .gas_price(TokenAmount::from(0u8)) // optional + .build() + .unwrap(), + state: None, balance: 0u8.into(), @@ -231,12 +244,26 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { exit_code, }) } + + #[allow(dead_code)] + pub fn expect_create_actor(&mut self, code_id: Cid, address: Address) { + let a = ExpectCreateActor { code_id, address }; + self.expect_create_actor = Some(a); + } + + #[allow(dead_code)] + pub fn set_caller(&mut self, code_id: Cid, address: Address) { + self.caller = address.clone(); + self.caller_type = code_id.clone(); + self.actor_code_cids + .insert(address.clone(), code_id.clone()); + } } impl Runtime for MockRuntime<'_, BS> { + // Cuasing a test to fail have to implement to pass. Ask about the fn message(&self) -> &UnsignedMessage { - self.require_in_call(); - todo!(); + &self.message } fn curr_epoch(&self) -> ChainEpoch { @@ -399,7 +426,7 @@ impl Runtime for MockRuntime<'_, BS> { params: &Serialized, value: &TokenAmount, ) -> Result { - self.require_in_call(); + //self.require_in_call(); if self.in_transaction { return Err(self.abort( ExitCode::SysErrorIllegalActor, diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 6b8e6defdc79..b83804c08b6d 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -3,6 +3,7 @@ // Has all of the common things needed to test inlcuding MockRuntime mod common; +//use runtime::Runtime; use db::MemoryDB; //use crate::{builtin::singleton::FIRST_NON_SINGLETON_ADDR}; @@ -19,7 +20,8 @@ use common::*; use ipld_blockstore::BlockStore; //use ipld_hamt::Hamt; use address::Address; -use vm::{ActorError, ExitCode, Serialized, TokenAmount}; +use message::UnsignedMessage; +use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(1000).unwrap(); @@ -38,8 +40,15 @@ fn abort_cant_call_exec() { let anne = Address::new_id(1001).unwrap(); //Set caller - rt.caller = anne; - rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); + //rt.caller = anne; + //rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + + rt.new_actor_addr = Some(Address::new_id(1001).unwrap()); + rt.actor_code_cids.insert( + Address::new_id(1001).unwrap(), + ACCOUNT_ACTOR_CODE_ID.clone(), + ); // TODO : Implement Message and then uncoment match exec_and_verify( @@ -62,6 +71,7 @@ fn abort_cant_call_exec() { // Didnt see a undef cid like in the go implmentation. If there is replace the not_a_actor token. Need to ask about thi // Can porbbaly get rid of this + // GO implementation has a undef actor so when this test runs it should return illegal actor let undef_cid = Cid::new_v1(Codec::Raw, Identity::digest(b"fil/1/notaactor")); match exec_and_verify( &mut rt, @@ -71,12 +81,11 @@ fn abort_cant_call_exec() { }, ) { Err(error) => { - assert_eq!(false, true); let error_exit_code = error.exit_code(); assert_eq!( error_exit_code, - ExitCode::ErrForbidden, - "Error code returned is not ErrForbidden" + ExitCode::SysErrorIllegalActor, + "Error code returned is not SysErrorIllegalActor" ); } Ok(_) => assert_eq!(true, false, "Failed to Fail"), @@ -91,11 +100,9 @@ fn create_2_payment_channels() { let anne = Address::new_id(1001).unwrap(); //Set caller - rt.caller = anne; - rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); - + rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); - // Change balances not sure how to do i saw the send function, but idk if thats all i need + // TODO : Change balances not sure how to do i saw the send function, but idk if thats all i need //// Go test does 2 payment channel tests for n in 0..2 { @@ -108,20 +115,18 @@ fn create_2_payment_channels() { let expected_id_addr_1 = Address::new_id(100 + n).unwrap(); - rt.expect_create_actor( PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); - - //let v = rt.create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1); + rt.expect_create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; // expect anne creating a payment channel to trigger a send to the payment channels constructor - let balance = TokenAmount::new(vec![1,0,0]); - + let balance = TokenAmount::new(vec![1, 0, 0]); + rt.expect_send( expected_id_addr_1.clone(), - 1, + METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), balance, Serialized::default(), @@ -158,35 +163,36 @@ fn create_2_payment_channels() { #[test] fn create_storage_miner() { let bs = MemoryDB::default(); - let mut rt = construct_runtime(&bs); + let mut rt: MockRuntime = construct_runtime(&bs); construct_and_verify(&mut rt); - // only the storage power actor can create a miner - rt.caller = STORAGE_POWER_ACTOR_ADDR.clone(); - rt.caller_type = POWER_ACTOR_CODE_ID.clone(); + // // only the storage power actor can create a miner + rt.set_caller( + POWER_ACTOR_CODE_ID.clone(), + STORAGE_POWER_ACTOR_ADDR.clone(), + ); let uniq_addr_1 = Address::new_actor(b"miner").unwrap(); rt.new_actor_addr = Some(uniq_addr_1.clone()); let expected_id_addr_1 = Address::new_id(100).unwrap(); - rt.expect_create_actor(POWER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); - - // Add expect create actor + rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; - // expect storage power actor creating a storage miner actor to trigger a send to the storage miner actors constructor + rt.expect_send( expected_id_addr_1.clone(), - 1, + METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), Serialized::default(), ExitCode::Ok, ); - // Make sure addresses returend are as expected - let exec_ret = exec_and_verify(&mut rt, MULTISIG_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + + let exec_ret = exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); + let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!( uniq_addr_1, exec_ret.robust_address, @@ -218,6 +224,7 @@ fn create_storage_miner() { } Ok(_) => assert_eq!(true, false, "Address should have not been found"), } + assert_eq!(true, true); } #[test] fn create_multisig_actor() { @@ -227,8 +234,7 @@ fn create_multisig_actor() { // Actor creating multisig actor let some_acc_actor = Address::new_id(1234).unwrap(); - rt.caller = some_acc_actor; - rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); + rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), some_acc_actor); //Assign addresses let uniq_addr_1 = Address::new_actor(b"multisig").unwrap(); @@ -236,10 +242,7 @@ fn create_multisig_actor() { // Next id let expected_id_addr_1 = Address::new_id(100).unwrap(); - rt.expect_create_actor( MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); - - // call expect create actor - //Go Code : rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) + rt.expect_create_actor(MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), @@ -247,7 +250,7 @@ fn create_multisig_actor() { // Expect a send to the multisig actor constructor rt.expect_send( expected_id_addr_1.clone(), - 1, + METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), Serialized::default(), @@ -274,8 +277,10 @@ fn sending_constructor_failure() { construct_and_verify(&mut rt); // Only the storage power actor can create a miner - rt.caller = STORAGE_POWER_ACTOR_ADDR.clone(); - rt.caller_type = POWER_ACTOR_CODE_ID.clone(); + rt.set_caller( + POWER_ACTOR_CODE_ID.clone(), + STORAGE_POWER_ACTOR_ADDR.clone(), + ); //Assign new address for the storage actor miner let uniq_addr_1 = Address::new_actor(b"miner").unwrap(); @@ -283,18 +288,16 @@ fn sending_constructor_failure() { // Create the next id address let expected_id_addr_1 = Address::new_id(100).unwrap(); - rt.expect_create_actor(POWER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone() ); - - // call expect create actor - //Go Code : rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) + //rt.actor_code_cids.insert(expected_id_addr_1.clone(), POWER_ACTOR_CODE_ID.clone() ); + rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; rt.expect_send( expected_id_addr_1.clone(), - 1, + METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), Serialized::default(), @@ -302,7 +305,7 @@ fn sending_constructor_failure() { ); // Only thr storage power actor can create a storage miner. Init actor creating it should result in failure - match exec_and_verify(&mut rt, POWER_ACTOR_CODE_ID.clone(), &fake_params) { + match exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params) { Err(error) => { let error_exit_code = error.exit_code(); assert_eq!( @@ -366,12 +369,30 @@ fn exec_and_verify( code_cid: code_id, constructor_params: Serialized::serialize(¶ms).unwrap(), }; + println!("Passed first part"); + + rt.message = UnsignedMessage::builder() + .to(rt.receiver.clone()) + .from(rt.caller.clone()) + .sequence(0) // optional + .value(TokenAmount::from(0u8)) // optional + .method_num(2) // optional + .params(Serialized::serialize(&exec_params).unwrap()) // optional + .gas_limit(0) // optional + .gas_price(TokenAmount::from(0u8)) // optional + .build() + .unwrap(); + rt.expect_create_actor = None; + + println!("Passed second part"); let ret = rt.call( &*INIT_ACTOR_CODE_ID, 2, &Serialized::serialize(&exec_params).unwrap(), ); + println!("{:?}", rt.expect_sends); + rt.verify(); ret } From a66432d3f75e5096ab54ab459735698c7968531b Mon Sep 17 00:00:00 2001 From: austinabell Date: Tue, 28 Apr 2020 14:14:52 -0400 Subject: [PATCH 08/20] Fix in_transaction mock runtime field --- vm/actor/tests/common/mod.rs | 1 + vm/actor/tests/init_actor_test.rs | 20 ++++---------------- 2 files changed, 5 insertions(+), 16 deletions(-) diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 1e470660d4aa..395b504502e5 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -412,6 +412,7 @@ impl Runtime for MockRuntime<'_, BS> { self.in_transaction = true; let ret = f(&mut read_only, &self); self.state = Some(self.put(&read_only).unwrap()); + self.in_transaction = false; Ok(ret) } diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index b83804c08b6d..1b8609ae81bd 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -1,11 +1,7 @@ // Copyright 2020 ChainSafe Systems // SPDX-License-Identifier: Apache-2.0, MIT -// Has all of the common things needed to test inlcuding MockRuntime mod common; -//use runtime::Runtime; -use db::MemoryDB; -//use crate::{builtin::singleton::FIRST_NON_SINGLETON_ADDR}; use actor::{ init::{ConstructorParams, ExecParams, ExecReturn, State}, @@ -13,13 +9,11 @@ use actor::{ MINER_ACTOR_CODE_ID, MULTISIG_ACTOR_CODE_ID, PAYCH_ACTOR_CODE_ID, POWER_ACTOR_CODE_ID, STORAGE_POWER_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, SYSTEM_ACTOR_CODE_ID, }; - -//use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use address::Address; use cid::{multihash::Identity, Cid, Codec}; use common::*; +use db::MemoryDB; use ipld_blockstore::BlockStore; -//use ipld_hamt::Hamt; -use address::Address; use message::UnsignedMessage; use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR}; @@ -374,15 +368,9 @@ fn exec_and_verify( rt.message = UnsignedMessage::builder() .to(rt.receiver.clone()) .from(rt.caller.clone()) - .sequence(0) // optional - .value(TokenAmount::from(0u8)) // optional - .method_num(2) // optional - .params(Serialized::serialize(&exec_params).unwrap()) // optional - .gas_limit(0) // optional - .gas_price(TokenAmount::from(0u8)) // optional + .value(rt.value_received.clone()) .build() .unwrap(); - rt.expect_create_actor = None; println!("Passed second part"); @@ -391,7 +379,7 @@ fn exec_and_verify( 2, &Serialized::serialize(&exec_params).unwrap(), ); - println!("{:?}", rt.expect_sends); + println!("{:?}", ret); rt.verify(); ret From 9d2178eb8a184129d86f0e3fbdb2711b2a4773a7 Mon Sep 17 00:00:00 2001 From: austinabell Date: Tue, 28 Apr 2020 14:30:18 -0400 Subject: [PATCH 09/20] Clean up test file --- vm/actor/tests/init_actor_test.rs | 138 +++++++++++++----------------- 1 file changed, 58 insertions(+), 80 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 1b8609ae81bd..7febe2ad029b 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -35,8 +35,6 @@ fn abort_cant_call_exec() { //Set caller rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); - //rt.caller = anne; - //rt.caller_type = ACCOUNT_ACTOR_CODE_ID.clone(); rt.new_actor_addr = Some(Address::new_id(1001).unwrap()); rt.actor_code_cids.insert( @@ -44,46 +42,41 @@ fn abort_cant_call_exec() { ACCOUNT_ACTOR_CODE_ID.clone(), ); - // TODO : Implement Message and then uncoment - match exec_and_verify( + let error = exec_and_verify( &mut rt, POWER_ACTOR_CODE_ID.clone(), &ConstructorParams { network_name: String::new(), }, - ) { - Err(error) => { - let error_exit_code = error.exit_code(); - assert_eq!( - error_exit_code, - ExitCode::ErrForbidden, - "Error code returned is not ErrForbidden" - ); - } - Ok(_) => assert_eq!(true, false, "Failed to fail"), - } + ) + .unwrap_err(); + + let error_exit_code = error.exit_code(); + assert_eq!( + error_exit_code, + ExitCode::ErrForbidden, + "Error code returned is not ErrForbidden" + ); // Didnt see a undef cid like in the go implmentation. If there is replace the not_a_actor token. Need to ask about thi // Can porbbaly get rid of this // GO implementation has a undef actor so when this test runs it should return illegal actor let undef_cid = Cid::new_v1(Codec::Raw, Identity::digest(b"fil/1/notaactor")); - match exec_and_verify( + let error = exec_and_verify( &mut rt, undef_cid, &ConstructorParams { network_name: String::new(), }, - ) { - Err(error) => { - let error_exit_code = error.exit_code(); - assert_eq!( - error_exit_code, - ExitCode::SysErrorIllegalActor, - "Error code returned is not SysErrorIllegalActor" - ); - } - Ok(_) => assert_eq!(true, false, "Failed to Fail"), - } + ) + .expect_err("Exec should have failed"); + + let error_exit_code = error.exit_code(); + assert_eq!( + error_exit_code, + ExitCode::SysErrorIllegalActor, + "Error code returned is not SysErrorIllegalActor" + ); } #[test] @@ -98,7 +91,7 @@ fn create_2_payment_channels() { // TODO : Change balances not sure how to do i saw the send function, but idk if thats all i need - //// Go test does 2 payment channel tests + // Go test does 2 payment channel tests for n in 0..2 { //let pay_channel = String::from("paych") + n.to_string(); let pay_channel_string = format!("paych_{}", n); @@ -140,18 +133,15 @@ fn create_2_payment_channels() { ); let state: State = rt.get_state().unwrap(); - match state.resolve_address(rt.store, &uniq_addr_1.unwrap()) { - Ok(returned_address) => { - assert_eq!( - returned_address, expected_id_addr_1, - "Wrong Address returned" - ); - } - Err(_) => assert_eq!(true, false, "Address should have been found"), - } - } + let returned_address = state + .resolve_address(rt.store, &uniq_addr_1.unwrap()) + .expect("Address should have been found"); - assert_eq!(true, true); + assert_eq!( + returned_address, expected_id_addr_1, + "Wrong Address returned" + ); + } } #[test] @@ -199,27 +189,23 @@ fn create_storage_miner() { // Address should be resolved let state: State = rt.get_state().unwrap(); - match state.resolve_address(rt.store, &uniq_addr_1) { - Ok(returned_address) => { - assert_eq!(returned_address, uniq_addr_1, "Wrong Address returned"); - } - Err(_) => assert_eq!(true, false, "Address should have been found"), - } + let returned_address = state + .resolve_address(rt.store, &uniq_addr_1) + .expect("Address should have been found"); + assert_eq!(returned_address, uniq_addr_1, "Wrong Address returned"); // Should return error since the address of flurbo is unknown let unknown_addr = Address::new_actor(b"flurbo").unwrap(); - match state.resolve_address(rt.store, &unknown_addr) { - Err(returned_address) => { - // Address not found error is returned as string - assert_eq!( - returned_address, "Address not found", - "Wrong Address returned" - ); - } - Ok(_) => assert_eq!(true, false, "Address should have not been found"), - } - assert_eq!(true, true); + let returned_address = state + .resolve_address(rt.store, &unknown_addr) + .expect_err("Address should have not been found"); + // Address not found error is returned as string + assert_eq!( + returned_address, "Address not found", + "Wrong Address returned" + ); } + #[test] fn create_multisig_actor() { let bs = MemoryDB::default(); @@ -299,30 +285,25 @@ fn sending_constructor_failure() { ); // Only thr storage power actor can create a storage miner. Init actor creating it should result in failure - match exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params) { - Err(error) => { - let error_exit_code = error.exit_code(); - assert_eq!( - error_exit_code, - ExitCode::ErrIllegalState, - "Exit Code that is returned is not ErrIllegalState" - ); - } - Ok(_) => assert_eq!(true, false, "Failed to fail"), - } + let error = exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params) + .expect_err("sending constructor should have failed"); + let error_exit_code = error.exit_code(); + assert_eq!( + error_exit_code, + ExitCode::ErrIllegalState, + "Exit Code that is returned is not ErrIllegalState" + ); // The send command from earlier should have failed. So you shouldnt be able to see the address let state: State = rt.get_state().unwrap(); - match state.resolve_address(rt.store, &uniq_addr_1) { - Err(returned_address) => { - // Error is returned as string. Doing it in the lazy way for this PR - assert_eq!( - returned_address, "Address not found", - "Addresses should have not been found" - ); - } - Ok(_) => assert_eq!(true, false, "Failed to fail address resolution"), - } + let returned_address = state + .resolve_address(rt.store, &uniq_addr_1) + .expect_err("Address resolution should have failed"); + // Error is returned as string. Doing it in the lazy way for this PR + assert_eq!( + returned_address, "Address not found", + "Addresses should have not been found" + ); } fn construct_and_verify(rt: &mut MockRuntime<'_, BS>) { @@ -363,7 +344,6 @@ fn exec_and_verify( code_cid: code_id, constructor_params: Serialized::serialize(¶ms).unwrap(), }; - println!("Passed first part"); rt.message = UnsignedMessage::builder() .to(rt.receiver.clone()) @@ -372,8 +352,6 @@ fn exec_and_verify( .build() .unwrap(); - println!("Passed second part"); - let ret = rt.call( &*INIT_ACTOR_CODE_ID, 2, From f421bd78403c9a8aed0537f3d2633a2b9de38657 Mon Sep 17 00:00:00 2001 From: austinabell Date: Tue, 28 Apr 2020 15:42:51 -0400 Subject: [PATCH 10/20] Fix storage miner test --- vm/actor/tests/common/mod.rs | 3 +- vm/actor/tests/init_actor_test.rs | 94 ++++++++++++++----------------- 2 files changed, 43 insertions(+), 54 deletions(-) diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 395b504502e5..de966f2ec7d1 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -255,8 +255,7 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { pub fn set_caller(&mut self, code_id: Cid, address: Address) { self.caller = address.clone(); self.caller_type = code_id.clone(); - self.actor_code_cids - .insert(address.clone(), code_id.clone()); + self.actor_code_cids.insert(address, code_id); } } diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 7febe2ad029b..8a111207c3e3 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -15,6 +15,7 @@ use common::*; use db::MemoryDB; use ipld_blockstore::BlockStore; use message::UnsignedMessage; +use serde::Serialize; use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { @@ -86,7 +87,7 @@ fn create_2_payment_channels() { construct_and_verify(&mut rt); let anne = Address::new_id(1001).unwrap(); - //Set caller + // Set caller rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); // TODO : Change balances not sure how to do i saw the send function, but idk if thats all i need @@ -97,12 +98,12 @@ fn create_2_payment_channels() { let pay_channel_string = format!("paych_{}", n); let paych = pay_channel_string.as_bytes(); - let uniq_addr_1 = Address::new_actor(paych); + let unique_address = Address::new_actor(paych); rt.new_actor_addr = Some(Address::new_actor(paych).unwrap()); - let expected_id_addr_1 = Address::new_id(100 + n).unwrap(); + let expected_id_addr = Address::new_id(100 + n).unwrap(); - rt.expect_create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); + rt.expect_create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), @@ -112,7 +113,7 @@ fn create_2_payment_channels() { let balance = TokenAmount::new(vec![1, 0, 0]); rt.expect_send( - expected_id_addr_1.clone(), + expected_id_addr.clone(), METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), balance, @@ -123,24 +124,21 @@ fn create_2_payment_channels() { let exec_ret = exec_and_verify(&mut rt, PAYCH_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!( - uniq_addr_1, + unique_address, Ok(exec_ret.robust_address), "Robust Address does not match" ); assert_eq!( - expected_id_addr_1, exec_ret.id_address, + expected_id_addr, exec_ret.id_address, "Id address does not match" ); let state: State = rt.get_state().unwrap(); let returned_address = state - .resolve_address(rt.store, &uniq_addr_1.unwrap()) + .resolve_address(rt.store, &unique_address.unwrap()) .expect("Address should have been found"); - assert_eq!( - returned_address, expected_id_addr_1, - "Wrong Address returned" - ); + assert_eq!(returned_address, expected_id_addr, "Wrong Address returned"); } } @@ -150,24 +148,24 @@ fn create_storage_miner() { let mut rt: MockRuntime = construct_runtime(&bs); construct_and_verify(&mut rt); - // // only the storage power actor can create a miner + // only the storage power actor can create a miner rt.set_caller( POWER_ACTOR_CODE_ID.clone(), STORAGE_POWER_ACTOR_ADDR.clone(), ); - let uniq_addr_1 = Address::new_actor(b"miner").unwrap(); - rt.new_actor_addr = Some(uniq_addr_1.clone()); + let unique_address = Address::new_actor(b"miner").unwrap(); + rt.new_actor_addr = Some(unique_address.clone()); - let expected_id_addr_1 = Address::new_id(100).unwrap(); - rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); + let expected_id_addr = Address::new_id(100).unwrap(); + rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; rt.expect_send( - expected_id_addr_1.clone(), + expected_id_addr.clone(), METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), @@ -178,32 +176,21 @@ fn create_storage_miner() { let exec_ret = exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); - assert_eq!( - uniq_addr_1, exec_ret.robust_address, - "Robust address does not match" - ); - assert_eq!( - expected_id_addr_1, exec_ret.id_address, - "Id address does not match" - ); + assert_eq!(unique_address, exec_ret.robust_address); + assert_eq!(expected_id_addr, exec_ret.id_address); // Address should be resolved let state: State = rt.get_state().unwrap(); let returned_address = state - .resolve_address(rt.store, &uniq_addr_1) + .resolve_address(rt.store, &unique_address) .expect("Address should have been found"); - assert_eq!(returned_address, uniq_addr_1, "Wrong Address returned"); + assert_eq!(expected_id_addr, returned_address); // Should return error since the address of flurbo is unknown let unknown_addr = Address::new_actor(b"flurbo").unwrap(); - let returned_address = state + state .resolve_address(rt.store, &unknown_addr) .expect_err("Address should have not been found"); - // Address not found error is returned as string - assert_eq!( - returned_address, "Address not found", - "Wrong Address returned" - ); } #[test] @@ -217,19 +204,19 @@ fn create_multisig_actor() { rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), some_acc_actor); //Assign addresses - let uniq_addr_1 = Address::new_actor(b"multisig").unwrap(); - rt.new_actor_addr = Some(uniq_addr_1.clone()); + let unique_address = Address::new_actor(b"multisig").unwrap(); + rt.new_actor_addr = Some(unique_address.clone()); // Next id - let expected_id_addr_1 = Address::new_id(100).unwrap(); - rt.expect_create_actor(MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); + let expected_id_addr = Address::new_id(100).unwrap(); + rt.expect_create_actor(MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; // Expect a send to the multisig actor constructor rt.expect_send( - expected_id_addr_1.clone(), + expected_id_addr.clone(), METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), @@ -241,11 +228,11 @@ fn create_multisig_actor() { let exec_ret = exec_and_verify(&mut rt, MULTISIG_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!( - uniq_addr_1, exec_ret.robust_address, + unique_address, exec_ret.robust_address, "Robust address does not macth" ); assert_eq!( - expected_id_addr_1, exec_ret.id_address, + expected_id_addr, exec_ret.id_address, "Id address does not match" ); } @@ -263,20 +250,20 @@ fn sending_constructor_failure() { ); //Assign new address for the storage actor miner - let uniq_addr_1 = Address::new_actor(b"miner").unwrap(); - rt.new_actor_addr = Some(uniq_addr_1.clone()); + let unique_address = Address::new_actor(b"miner").unwrap(); + rt.new_actor_addr = Some(unique_address.clone()); // Create the next id address - let expected_id_addr_1 = Address::new_id(100).unwrap(); + let expected_id_addr = Address::new_id(100).unwrap(); - //rt.actor_code_cids.insert(expected_id_addr_1.clone(), POWER_ACTOR_CODE_ID.clone() ); - rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr_1.clone()); + //rt.actor_code_cids.insert(expected_id_addr.clone(), POWER_ACTOR_CODE_ID.clone() ); + rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { network_name: String::from("fake_param"), }; rt.expect_send( - expected_id_addr_1.clone(), + expected_id_addr.clone(), METHOD_CONSTRUCTOR, Serialized::serialize(&fake_params).unwrap(), 0u8.into(), @@ -297,7 +284,7 @@ fn sending_constructor_failure() { // The send command from earlier should have failed. So you shouldnt be able to see the address let state: State = rt.get_state().unwrap(); let returned_address = state - .resolve_address(rt.store, &uniq_addr_1) + .resolve_address(rt.store, &unique_address) .expect_err("Address resolution should have failed"); // Error is returned as string. Doing it in the lazy way for this PR assert_eq!( @@ -334,15 +321,18 @@ fn construct_and_verify(rt: &mut MockRuntime<'_, BS>) { assert_eq!("mock".to_string(), state_data.network_name); } -fn exec_and_verify( +fn exec_and_verify( rt: &mut MockRuntime<'_, BS>, code_id: Cid, - params: &ConstructorParams, -) -> Result { + params: &S, +) -> Result +where + S: Serialize, +{ rt.expect_validate_caller_any(); let exec_params = ExecParams { code_cid: code_id, - constructor_params: Serialized::serialize(¶ms).unwrap(), + constructor_params: Serialized::serialize(params).unwrap(), }; rt.message = UnsignedMessage::builder() From c3034d5e208b6520d456a6587ab354925b640c09 Mon Sep 17 00:00:00 2001 From: austinabell Date: Tue, 28 Apr 2020 16:07:17 -0400 Subject: [PATCH 11/20] Fix payment channel tests --- vm/actor/tests/init_actor_test.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 8a111207c3e3..d662038fe521 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -92,17 +92,17 @@ fn create_2_payment_channels() { // TODO : Change balances not sure how to do i saw the send function, but idk if thats all i need - // Go test does 2 payment channel tests for n in 0..2 { - //let pay_channel = String::from("paych") + n.to_string(); let pay_channel_string = format!("paych_{}", n); let paych = pay_channel_string.as_bytes(); + rt.balance = TokenAmount::from(100u8); + rt.value_received = TokenAmount::from(100u8); + let unique_address = Address::new_actor(paych); rt.new_actor_addr = Some(Address::new_actor(paych).unwrap()); let expected_id_addr = Address::new_id(100 + n).unwrap(); - rt.expect_create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { @@ -110,7 +110,7 @@ fn create_2_payment_channels() { }; // expect anne creating a payment channel to trigger a send to the payment channels constructor - let balance = TokenAmount::new(vec![1, 0, 0]); + let balance = TokenAmount::from(100u8); rt.expect_send( expected_id_addr.clone(), From 5378d4340fe535490f3f0a80d6b52062542220d9 Mon Sep 17 00:00:00 2001 From: austinabell Date: Tue, 28 Apr 2020 16:26:53 -0400 Subject: [PATCH 12/20] Fix abort test --- vm/actor/tests/init_actor_test.rs | 50 +++---------------------------- 1 file changed, 4 insertions(+), 46 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index d662038fe521..27212353291f 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -10,7 +10,7 @@ use actor::{ STORAGE_POWER_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, SYSTEM_ACTOR_CODE_ID, }; use address::Address; -use cid::{multihash::Identity, Cid, Codec}; +use cid::Cid; use common::*; use db::MemoryDB; use ipld_blockstore::BlockStore; @@ -34,50 +34,11 @@ fn abort_cant_call_exec() { construct_and_verify(&mut rt); let anne = Address::new_id(1001).unwrap(); - //Set caller rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); - rt.new_actor_addr = Some(Address::new_id(1001).unwrap()); - rt.actor_code_cids.insert( - Address::new_id(1001).unwrap(), - ACCOUNT_ACTOR_CODE_ID.clone(), - ); - - let error = exec_and_verify( - &mut rt, - POWER_ACTOR_CODE_ID.clone(), - &ConstructorParams { - network_name: String::new(), - }, - ) - .unwrap_err(); - - let error_exit_code = error.exit_code(); - assert_eq!( - error_exit_code, - ExitCode::ErrForbidden, - "Error code returned is not ErrForbidden" - ); - - // Didnt see a undef cid like in the go implmentation. If there is replace the not_a_actor token. Need to ask about thi - // Can porbbaly get rid of this - // GO implementation has a undef actor so when this test runs it should return illegal actor - let undef_cid = Cid::new_v1(Codec::Raw, Identity::digest(b"fil/1/notaactor")); - let error = exec_and_verify( - &mut rt, - undef_cid, - &ConstructorParams { - network_name: String::new(), - }, - ) - .expect_err("Exec should have failed"); - - let error_exit_code = error.exit_code(); - assert_eq!( - error_exit_code, - ExitCode::SysErrorIllegalActor, - "Error code returned is not SysErrorIllegalActor" - ); + let err = exec_and_verify(&mut rt, POWER_ACTOR_CODE_ID.clone(), &"") + .expect_err("Exec should have failed"); + assert_eq!(err.exit_code(), ExitCode::ErrForbidden); } #[test] @@ -87,11 +48,8 @@ fn create_2_payment_channels() { construct_and_verify(&mut rt); let anne = Address::new_id(1001).unwrap(); - // Set caller rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); - // TODO : Change balances not sure how to do i saw the send function, but idk if thats all i need - for n in 0..2 { let pay_channel_string = format!("paych_{}", n); let paych = pay_channel_string.as_bytes(); From c87846586cb5ddc124800290ef58bc164a2b7596 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Mon, 4 May 2020 18:37:02 -0400 Subject: [PATCH 13/20] Init actor tests are passing --- vm/actor/src/builtin/init/mod.rs | 26 +++++++++++++++----------- vm/actor/tests/common/mod.rs | 13 +++++++++++-- vm/actor/tests/init_actor_test.rs | 22 ++++++++++++++++------ vm/src/error.rs | 6 +++--- 4 files changed, 45 insertions(+), 22 deletions(-) diff --git a/vm/actor/src/builtin/init/mod.rs b/vm/actor/src/builtin/init/mod.rs index b0798f88d4ca..058dcbb23b98 100644 --- a/vm/actor/src/builtin/init/mod.rs +++ b/vm/actor/src/builtin/init/mod.rs @@ -87,18 +87,22 @@ impl Actor { // Invoke constructor - rt.send( - &id_address, - METHOD_CONSTRUCTOR, - ¶ms.constructor_params, - &rt.message().value().clone(), - ) - .map_err(|err| rt.abort(err.exit_code(), "constructor failed"))?; + let v = rt + .send( + &id_address, + 1, + ¶ms.constructor_params, + &rt.message().value().clone(), + ) + .map_err(|err| rt.abort(err.exit_code(), "constructor failed")); - Ok(ExecReturn { - id_address, - robust_address, - }) + match v { + Ok(_) => Ok(ExecReturn { + id_address, + robust_address, + }), + Err(e) => Err(e), + } } } diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index de966f2ec7d1..e12d79b1ca61 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -426,7 +426,7 @@ impl Runtime for MockRuntime<'_, BS> { params: &Serialized, value: &TokenAmount, ) -> Result { - //self.require_in_call(); + self.require_in_call(); if self.in_transaction { return Err(self.abort( ExitCode::SysErrorIllegalActor, @@ -458,7 +458,16 @@ impl Runtime for MockRuntime<'_, BS> { } self.balance -= value; - return Ok(expected_msg.send_return); + match expected_msg.exit_code { + ExitCode::Ok => return Ok(expected_msg.send_return), + x => { + return Err(ActorError { + fatal: false, + exit_code: x, + msg: "Expected message Fail".to_string(), + }); + } + } } fn abort>(&self, exit_code: ExitCode, msg: S) -> ActorError { diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 27212353291f..f53dc1e0e522 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -213,8 +213,6 @@ fn sending_constructor_failure() { // Create the next id address let expected_id_addr = Address::new_id(100).unwrap(); - - //rt.actor_code_cids.insert(expected_id_addr.clone(), POWER_ACTOR_CODE_ID.clone() ); rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { @@ -229,22 +227,23 @@ fn sending_constructor_failure() { ExitCode::ErrIllegalState.clone(), ); - // Only thr storage power actor can create a storage miner. Init actor creating it should result in failure let error = exec_and_verify(&mut rt, MINER_ACTOR_CODE_ID.clone(), &fake_params) .expect_err("sending constructor should have failed"); + let error_exit_code = error.exit_code(); + assert_eq!( error_exit_code, ExitCode::ErrIllegalState, "Exit Code that is returned is not ErrIllegalState" ); - // The send command from earlier should have failed. So you shouldnt be able to see the address let state: State = rt.get_state().unwrap(); + let returned_address = state .resolve_address(rt.store, &unique_address) .expect_err("Address resolution should have failed"); - // Error is returned as string. Doing it in the lazy way for this PR + assert_eq!( returned_address, "Address not found", "Addresses should have not been found" @@ -300,12 +299,23 @@ where .build() .unwrap(); + //Get the previous state so if call fails u can revert + let prev_state = rt.state.clone(); + let ret = rt.call( &*INIT_ACTOR_CODE_ID, 2, &Serialized::serialize(&exec_params).unwrap(), ); - println!("{:?}", ret); + + // Revert state if call fails + let ret = match ret { + Ok(v) => Ok(v), + Err(e) => { + rt.state = prev_state; + Err(e) + } + }; rt.verify(); ret diff --git a/vm/src/error.rs b/vm/src/error.rs index 2ac55c27c146..9361e7480a11 100644 --- a/vm/src/error.rs +++ b/vm/src/error.rs @@ -11,11 +11,11 @@ use crate::ExitCode; #[error("ActorError(fatal: {fatal}, exit_code: {exit_code:?}, msg: {msg})")] pub struct ActorError { /// Is this a fatal error. - fatal: bool, + pub fatal: bool, /// The exit code for this invocation, must not be `0`. - exit_code: ExitCode, + pub exit_code: ExitCode, /// Message for debugging purposes, - msg: String, + pub msg: String, } impl ActorError { From 9beb78379637984b485bd55e33862003c086aa26 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Mon, 4 May 2020 20:31:31 -0400 Subject: [PATCH 14/20] FIxed Cron actor test error --- vm/actor/src/builtin/cron/mod.rs | 4 ++-- vm/actor/tests/common/mod.rs | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/vm/actor/src/builtin/cron/mod.rs b/vm/actor/src/builtin/cron/mod.rs index 698b1bf72488..8811bcd840d6 100644 --- a/vm/actor/src/builtin/cron/mod.rs +++ b/vm/actor/src/builtin/cron/mod.rs @@ -74,12 +74,12 @@ impl Actor { let st: State = rt.state()?; for entry in st.entries { - rt.send( + let _v = rt.send( &entry.receiver, entry.method_num, &Serialized::default(), &TokenAmount::from(0u8), - )?; + ); } Ok(()) } diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index e12d79b1ca61..d16276bb5b74 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -242,7 +242,8 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { value, send_return, exit_code, - }) + }); + () } #[allow(dead_code)] From 8e4f52d7047a0eaad87320ab4fe57745bafef27f Mon Sep 17 00:00:00 2001 From: DragonMural Date: Wed, 6 May 2020 00:50:47 -0400 Subject: [PATCH 15/20] Addding some changes suggets by AUstin --- vm/actor/src/builtin/init/mod.rs | 33 +++++++++++++++---------------- vm/actor/tests/common/mod.rs | 19 ++++++------------ vm/actor/tests/init_actor_test.rs | 31 ++++++++++++++--------------- 3 files changed, 37 insertions(+), 46 deletions(-) diff --git a/vm/actor/src/builtin/init/mod.rs b/vm/actor/src/builtin/init/mod.rs index 058dcbb23b98..ba01391f2775 100644 --- a/vm/actor/src/builtin/init/mod.rs +++ b/vm/actor/src/builtin/init/mod.rs @@ -70,7 +70,11 @@ impl Actor { ), )); } - + + // Compute a re-org-stable address. + // This address exists for use by messages coming from outside the system, in order to + // stably address the newly created actor even if a chain re-org causes it to end up with + // a different ID. let robust_address = rt.new_actor_address()?; // Allocate an ID for this actor. @@ -87,22 +91,17 @@ impl Actor { // Invoke constructor - let v = rt - .send( - &id_address, - 1, - ¶ms.constructor_params, - &rt.message().value().clone(), - ) - .map_err(|err| rt.abort(err.exit_code(), "constructor failed")); - - match v { - Ok(_) => Ok(ExecReturn { - id_address, - robust_address, - }), - Err(e) => Err(e), - } + rt.send( + &id_address, + 1, + ¶ms.constructor_params, + &rt.message().value().clone(), + ) + .map_err(|err| rt.abort(err.exit_code(), "constructor failed")) + .map(|_| ExecReturn { + id_address, + robust_address, + }) } } diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index d16276bb5b74..6393deb8d6bd 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -82,16 +82,10 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { new_actor_addr: None, message: UnsignedMessage::builder() - .to(Address::new_id(100).unwrap()) - .from(Address::new_id(100).unwrap()) - .sequence(0) // optional - .value(TokenAmount::from(0u8)) // optional - .method_num(MethodNum::default()) // optional - .params(Serialized::default()) // optional - .gas_limit(0) // optional - .gas_price(TokenAmount::from(0u8)) // optional - .build() - .unwrap(), + .to(Address::new_id(100)) + .from(Address::new_id(100)) + .build() + .unwrap(), state: None, balance: 0u8.into(), @@ -242,8 +236,7 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { value, send_return, exit_code, - }); - () + }) } #[allow(dead_code)] @@ -261,8 +254,8 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { } impl Runtime for MockRuntime<'_, BS> { - // Cuasing a test to fail have to implement to pass. Ask about the fn message(&self) -> &UnsignedMessage { + self.require_in_call(); &self.message } diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index f53dc1e0e522..4b8eca98e99f 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -19,7 +19,7 @@ use serde::Serialize; use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { - let receiver = Address::new_id(1000).unwrap(); + let receiver = Address::new_id(1000); let mut rt = MockRuntime::new(bs, receiver.clone()); rt.caller = SYSTEM_ACTOR_ADDR.clone(); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); @@ -32,7 +32,7 @@ fn abort_cant_call_exec() { let bs = MemoryDB::default(); let mut rt = construct_runtime(&bs); construct_and_verify(&mut rt); - let anne = Address::new_id(1001).unwrap(); + let anne = Address::new_id(1001); rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); @@ -46,7 +46,7 @@ fn create_2_payment_channels() { let bs = MemoryDB::default(); let mut rt: MockRuntime = construct_runtime(&bs); construct_and_verify(&mut rt); - let anne = Address::new_id(1001).unwrap(); + let anne = Address::new_id(1001); rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), anne); @@ -58,9 +58,9 @@ fn create_2_payment_channels() { rt.value_received = TokenAmount::from(100u8); let unique_address = Address::new_actor(paych); - rt.new_actor_addr = Some(Address::new_actor(paych).unwrap()); + rt.new_actor_addr = Some(Address::new_actor(paych)); - let expected_id_addr = Address::new_id(100 + n).unwrap(); + let expected_id_addr = Address::new_id(100 + n); rt.expect_create_actor(PAYCH_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { @@ -82,8 +82,7 @@ fn create_2_payment_channels() { let exec_ret = exec_and_verify(&mut rt, PAYCH_ACTOR_CODE_ID.clone(), &fake_params).unwrap(); let exec_ret: ExecReturn = Serialized::deserialize(&exec_ret).unwrap(); assert_eq!( - unique_address, - Ok(exec_ret.robust_address), + unique_address, exec_ret.robust_address, "Robust Address does not match" ); assert_eq!( @@ -93,7 +92,7 @@ fn create_2_payment_channels() { let state: State = rt.get_state().unwrap(); let returned_address = state - .resolve_address(rt.store, &unique_address.unwrap()) + .resolve_address(rt.store, &unique_address) .expect("Address should have been found"); assert_eq!(returned_address, expected_id_addr, "Wrong Address returned"); @@ -112,10 +111,10 @@ fn create_storage_miner() { STORAGE_POWER_ACTOR_ADDR.clone(), ); - let unique_address = Address::new_actor(b"miner").unwrap(); + let unique_address = Address::new_actor(b"miner"); rt.new_actor_addr = Some(unique_address.clone()); - let expected_id_addr = Address::new_id(100).unwrap(); + let expected_id_addr = Address::new_id(100); rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { @@ -145,7 +144,7 @@ fn create_storage_miner() { assert_eq!(expected_id_addr, returned_address); // Should return error since the address of flurbo is unknown - let unknown_addr = Address::new_actor(b"flurbo").unwrap(); + let unknown_addr = Address::new_actor(b"flurbo"); state .resolve_address(rt.store, &unknown_addr) .expect_err("Address should have not been found"); @@ -158,15 +157,15 @@ fn create_multisig_actor() { construct_and_verify(&mut rt); // Actor creating multisig actor - let some_acc_actor = Address::new_id(1234).unwrap(); + let some_acc_actor = Address::new_id(1234); rt.set_caller(ACCOUNT_ACTOR_CODE_ID.clone(), some_acc_actor); //Assign addresses - let unique_address = Address::new_actor(b"multisig").unwrap(); + let unique_address = Address::new_actor(b"multisig"); rt.new_actor_addr = Some(unique_address.clone()); // Next id - let expected_id_addr = Address::new_id(100).unwrap(); + let expected_id_addr = Address::new_id(100); rt.expect_create_actor(MULTISIG_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { @@ -208,11 +207,11 @@ fn sending_constructor_failure() { ); //Assign new address for the storage actor miner - let unique_address = Address::new_actor(b"miner").unwrap(); + let unique_address = Address::new_actor(b"miner"); rt.new_actor_addr = Some(unique_address.clone()); // Create the next id address - let expected_id_addr = Address::new_id(100).unwrap(); + let expected_id_addr = Address::new_id(100); rt.expect_create_actor(MINER_ACTOR_CODE_ID.clone(), expected_id_addr.clone()); let fake_params = ConstructorParams { From fd7280c70f9ac606387a9857914f110fbe94fe0f Mon Sep 17 00:00:00 2001 From: DragonMural Date: Wed, 6 May 2020 00:55:55 -0400 Subject: [PATCH 16/20] FOrgot to add lint chnages --- vm/actor/src/builtin/init/mod.rs | 2 +- vm/actor/tests/common/mod.rs | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/vm/actor/src/builtin/init/mod.rs b/vm/actor/src/builtin/init/mod.rs index ba01391f2775..30d1022b632d 100644 --- a/vm/actor/src/builtin/init/mod.rs +++ b/vm/actor/src/builtin/init/mod.rs @@ -70,7 +70,7 @@ impl Actor { ), )); } - + // Compute a re-org-stable address. // This address exists for use by messages coming from outside the system, in order to // stably address the newly created actor even if a chain re-org causes it to end up with diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 6393deb8d6bd..6dcfe288e597 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -82,10 +82,10 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { new_actor_addr: None, message: UnsignedMessage::builder() - .to(Address::new_id(100)) - .from(Address::new_id(100)) - .build() - .unwrap(), + .to(Address::new_id(100)) + .from(Address::new_id(100)) + .build() + .unwrap(), state: None, balance: 0u8.into(), From f6a74bdea6c99038c48e0cf126de6ec7b56441b3 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Wed, 6 May 2020 23:09:30 -0400 Subject: [PATCH 17/20] Adding minor code changes and removed caller and reciever members to be used in message --- vm/actor/src/builtin/init/mod.rs | 7 ++++--- vm/actor/tests/account_actor_test.rs | 3 ++- vm/actor/tests/common/mod.rs | 29 +++++++++++++--------------- vm/actor/tests/cron_actor_test.rs | 10 +++++++--- vm/actor/tests/init_actor_test.rs | 12 ++++++++---- vm/src/error.rs | 6 +++--- 6 files changed, 37 insertions(+), 30 deletions(-) diff --git a/vm/actor/src/builtin/init/mod.rs b/vm/actor/src/builtin/init/mod.rs index 30d1022b632d..764036224599 100644 --- a/vm/actor/src/builtin/init/mod.rs +++ b/vm/actor/src/builtin/init/mod.rs @@ -93,12 +93,13 @@ impl Actor { rt.send( &id_address, - 1, + METHOD_CONSTRUCTOR, ¶ms.constructor_params, &rt.message().value().clone(), ) - .map_err(|err| rt.abort(err.exit_code(), "constructor failed")) - .map(|_| ExecReturn { + .map_err(|err| rt.abort(err.exit_code(), "constructor failed"))?; + + Ok(ExecReturn { id_address, robust_address, }) diff --git a/vm/actor/tests/account_actor_test.rs b/vm/actor/tests/account_actor_test.rs index d179718522b4..d57221d68685 100644 --- a/vm/actor/tests/account_actor_test.rs +++ b/vm/actor/tests/account_actor_test.rs @@ -7,6 +7,7 @@ use actor::{account::State, ACCOUNT_ACTOR_CODE_ID, SYSTEM_ACTOR_ADDR, SYSTEM_ACT use address::Address; use common::*; use db::MemoryDB; +use message::UnsignedMessage; use vm::{ExitCode, Serialized}; macro_rules! account_tests { @@ -19,7 +20,7 @@ macro_rules! account_tests { let bs = MemoryDB::default(); let receiver = Address::new_id(100); let mut rt = MockRuntime::new(&bs, receiver.clone()); - rt.caller = *SYSTEM_ACTOR_ADDR; + rt.message = UnsignedMessage::builder().to(receiver.clone()).from(SYSTEM_ACTOR_ADDR.clone()).build().unwrap(); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); rt.expect_validate_caller_addr(&[*SYSTEM_ACTOR_ADDR]); diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 6dcfe288e597..8be9338aff55 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -12,7 +12,7 @@ use clock::ChainEpoch; use crypto::DomainSeparationTag; use encoding::{de::DeserializeOwned, Cbor}; use ipld_blockstore::BlockStore; -use message::UnsignedMessage; +use message::{Message, UnsignedMessage}; use runtime::{ActorCode, Runtime, Syscalls}; use std::cell::{Cell, RefCell}; use std::collections::{HashMap, VecDeque}; @@ -20,8 +20,6 @@ use vm::{ActorError, ExitCode, MethodNum, Randomness, Serialized, TokenAmount}; pub struct MockRuntime<'a, BS: BlockStore> { pub epoch: ChainEpoch, - pub receiver: Address, - pub caller: Address, pub caller_type: Cid, pub miner: Address, pub value_received: TokenAmount, @@ -70,8 +68,6 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { pub fn new(bs: &'a BS, receiver: Address) -> Self { Self { epoch: 0, - receiver: receiver, - caller: Address::default(), caller_type: Cid::default(), miner: Address::default(), @@ -82,8 +78,8 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { new_actor_addr: None, message: UnsignedMessage::builder() - .to(Address::new_id(100)) - .from(Address::new_id(100)) + .to(receiver.clone()) + .from(Address::default()) .build() .unwrap(), @@ -247,7 +243,11 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { #[allow(dead_code)] pub fn set_caller(&mut self, code_id: Cid, address: Address) { - self.caller = address.clone(); + self.message = UnsignedMessage::builder() + .to(self.message.to().clone()) + .from(address.clone()) + .build() + .unwrap(); self.caller_type = code_id.clone(); self.actor_code_cids.insert(address, code_id); } @@ -295,7 +295,7 @@ impl Runtime for MockRuntime<'_, BS> { ); for expected in &addrs { - if &self.caller == expected { + if self.message().from() == expected { *self.expect_validate_caller_addr.borrow_mut() = None; return Ok(()); } @@ -305,7 +305,8 @@ impl Runtime for MockRuntime<'_, BS> { ExitCode::ErrForbidden, format!( "caller address {:?} forbidden, allowed: {:?}", - self.caller, &addrs + self.message().from(), + &addrs ), )); } @@ -439,7 +440,7 @@ impl Runtime for MockRuntime<'_, BS> { let expected_msg = self.expect_sends.pop_front().unwrap(); - assert!(&expected_msg.to == to && expected_msg.method == method && &expected_msg.params == params && &expected_msg.value == value, "expectedMessage being sent does not match expectation.\nMessage -\t to: {:?} method: {:?} value: {:?} params: {:?}\nExpected -\t {:?}", to, method, value, params, &self.expect_sends[0]); + assert!(&expected_msg.to == to && expected_msg.method == method && &expected_msg.params == params && &expected_msg.value == value, "expectedMessage being sent does not match expectation.\nMessage -\t to: {:?} method: {:?} value: {:?} params: {:?}\nExpected -\t {:?}", to, method, value, params, self.expect_sends[0]); if value > &self.balance { return Err(self.abort( @@ -455,11 +456,7 @@ impl Runtime for MockRuntime<'_, BS> { match expected_msg.exit_code { ExitCode::Ok => return Ok(expected_msg.send_return), x => { - return Err(ActorError { - fatal: false, - exit_code: x, - msg: "Expected message Fail".to_string(), - }); + return Err(ActorError::new(x, "Expected message Fail".to_string())); } } } diff --git a/vm/actor/tests/cron_actor_test.rs b/vm/actor/tests/cron_actor_test.rs index 9150ec93400d..74a22e5359aa 100644 --- a/vm/actor/tests/cron_actor_test.rs +++ b/vm/actor/tests/cron_actor_test.rs @@ -10,13 +10,17 @@ use address::Address; use common::*; use db::MemoryDB; use ipld_blockstore::BlockStore; -use vm::ExitCode; -use vm::Serialized; +use message::UnsignedMessage; +use vm::{ExitCode, Serialized}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(100); let mut rt = MockRuntime::new(bs, receiver); - rt.caller = *SYSTEM_ACTOR_ADDR; + rt.message = UnsignedMessage::builder() + .from(SYSTEM_ACTOR_ADDR.clone()) + .to(receiver.clone()) + .build() + .unwrap(); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); return rt; } diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 4b8eca98e99f..79813cf2a4cd 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -14,14 +14,18 @@ use cid::Cid; use common::*; use db::MemoryDB; use ipld_blockstore::BlockStore; -use message::UnsignedMessage; +use message::{Message, UnsignedMessage}; use serde::Serialize; use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(1000); let mut rt = MockRuntime::new(bs, receiver.clone()); - rt.caller = SYSTEM_ACTOR_ADDR.clone(); + rt.message = UnsignedMessage::builder() + .to(receiver.clone()) + .from(SYSTEM_ACTOR_ADDR.clone()) + .build() + .unwrap(); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); return rt; } @@ -292,8 +296,8 @@ where }; rt.message = UnsignedMessage::builder() - .to(rt.receiver.clone()) - .from(rt.caller.clone()) + .to(rt.message.to().clone()) + .from(rt.message.from().clone()) .value(rt.value_received.clone()) .build() .unwrap(); diff --git a/vm/src/error.rs b/vm/src/error.rs index 9361e7480a11..2ac55c27c146 100644 --- a/vm/src/error.rs +++ b/vm/src/error.rs @@ -11,11 +11,11 @@ use crate::ExitCode; #[error("ActorError(fatal: {fatal}, exit_code: {exit_code:?}, msg: {msg})")] pub struct ActorError { /// Is this a fatal error. - pub fatal: bool, + fatal: bool, /// The exit code for this invocation, must not be `0`. - pub exit_code: ExitCode, + exit_code: ExitCode, /// Message for debugging purposes, - pub msg: String, + msg: String, } impl ActorError { From 130153ded0924a0f23cce8327f3e0e031b44d70a Mon Sep 17 00:00:00 2001 From: DragonMural Date: Thu, 7 May 2020 11:02:23 -0400 Subject: [PATCH 18/20] Adding some final touches --- vm/actor/tests/account_actor_test.rs | 4 ++-- vm/actor/tests/common/mod.rs | 19 ++++++++++--------- vm/actor/tests/cron_actor_test.rs | 5 +++-- vm/actor/tests/init_actor_test.rs | 15 +++++++++++---- 4 files changed, 26 insertions(+), 17 deletions(-) diff --git a/vm/actor/tests/account_actor_test.rs b/vm/actor/tests/account_actor_test.rs index d57221d68685..3032cdf76df1 100644 --- a/vm/actor/tests/account_actor_test.rs +++ b/vm/actor/tests/account_actor_test.rs @@ -19,8 +19,8 @@ macro_rules! account_tests { let bs = MemoryDB::default(); let receiver = Address::new_id(100); - let mut rt = MockRuntime::new(&bs, receiver.clone()); - rt.message = UnsignedMessage::builder().to(receiver.clone()).from(SYSTEM_ACTOR_ADDR.clone()).build().unwrap(); + let message = UnsignedMessage::builder().to(receiver.clone()).from(SYSTEM_ACTOR_ADDR.clone()).build().unwrap(); + let mut rt = MockRuntime::new(&bs, message); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); rt.expect_validate_caller_addr(&[*SYSTEM_ACTOR_ADDR]); diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 8be9338aff55..787791aa543d 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -22,7 +22,7 @@ pub struct MockRuntime<'a, BS: BlockStore> { pub epoch: ChainEpoch, pub caller_type: Cid, pub miner: Address, - pub value_received: TokenAmount, + //pub value_received: TokenAmount, pub id_addresses: HashMap, pub actor_code_cids: HashMap, pub new_actor_addr: Option
, @@ -65,24 +65,24 @@ pub struct ExpectedMessage { } impl<'a, BS: BlockStore> MockRuntime<'a, BS> { - pub fn new(bs: &'a BS, receiver: Address) -> Self { + pub fn new(bs: &'a BS, message: UnsignedMessage) -> Self { Self { epoch: 0, caller_type: Cid::default(), miner: Address::default(), - value_received: 0u8.into(), id_addresses: HashMap::new(), actor_code_cids: HashMap::new(), new_actor_addr: None, - message: UnsignedMessage::builder() - .to(receiver.clone()) - .from(Address::default()) - .build() - .unwrap(), - + message: message, + // UnsignedMessage::builder() + // .to(receiver.clone()) + // .from(Address::default()) + // .value(0u8.into()) + // .build() + // .unwrap(), state: None, balance: 0u8.into(), @@ -246,6 +246,7 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { self.message = UnsignedMessage::builder() .to(self.message.to().clone()) .from(address.clone()) + .value(self.message.value().clone()) .build() .unwrap(); self.caller_type = code_id.clone(); diff --git a/vm/actor/tests/cron_actor_test.rs b/vm/actor/tests/cron_actor_test.rs index 74a22e5359aa..1eaa22cf2462 100644 --- a/vm/actor/tests/cron_actor_test.rs +++ b/vm/actor/tests/cron_actor_test.rs @@ -15,12 +15,13 @@ use vm::{ExitCode, Serialized}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(100); - let mut rt = MockRuntime::new(bs, receiver); - rt.message = UnsignedMessage::builder() + + let message = UnsignedMessage::builder() .from(SYSTEM_ACTOR_ADDR.clone()) .to(receiver.clone()) .build() .unwrap(); + let mut rt = MockRuntime::new(bs, message); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); return rt; } diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 79813cf2a4cd..f295c45724e8 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -20,12 +20,13 @@ use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR}; fn construct_runtime(bs: &BS) -> MockRuntime<'_, BS> { let receiver = Address::new_id(1000); - let mut rt = MockRuntime::new(bs, receiver.clone()); - rt.message = UnsignedMessage::builder() + + let message = UnsignedMessage::builder() .to(receiver.clone()) .from(SYSTEM_ACTOR_ADDR.clone()) .build() .unwrap(); + let mut rt = MockRuntime::new(bs, message); rt.caller_type = SYSTEM_ACTOR_CODE_ID.clone(); return rt; } @@ -59,7 +60,13 @@ fn create_2_payment_channels() { let paych = pay_channel_string.as_bytes(); rt.balance = TokenAmount::from(100u8); - rt.value_received = TokenAmount::from(100u8); + + rt.message = UnsignedMessage::builder() + .to(rt.message.to().clone()) + .from(rt.message.from().clone()) + .value(TokenAmount::from(100u8)) + .build() + .unwrap(); let unique_address = Address::new_actor(paych); rt.new_actor_addr = Some(Address::new_actor(paych)); @@ -298,7 +305,7 @@ where rt.message = UnsignedMessage::builder() .to(rt.message.to().clone()) .from(rt.message.from().clone()) - .value(rt.value_received.clone()) + .value(rt.message.value().clone()) .build() .unwrap(); From dfcd35ec7ed85f8eba00aaaf1f0e0f096b9a5155 Mon Sep 17 00:00:00 2001 From: DragonMural Date: Thu, 7 May 2020 18:43:57 -0400 Subject: [PATCH 19/20] Adding more cosmetic changes --- vm/actor/src/builtin/init/mod.rs | 1 - vm/actor/tests/common/mod.rs | 6 ------ vm/actor/tests/init_actor_test.rs | 21 +++++---------------- 3 files changed, 5 insertions(+), 23 deletions(-) diff --git a/vm/actor/src/builtin/init/mod.rs b/vm/actor/src/builtin/init/mod.rs index 764036224599..e2a47c961e47 100644 --- a/vm/actor/src/builtin/init/mod.rs +++ b/vm/actor/src/builtin/init/mod.rs @@ -90,7 +90,6 @@ impl Actor { rt.create_actor(¶ms.code_cid, &id_address)?; // Invoke constructor - rt.send( &id_address, METHOD_CONSTRUCTOR, diff --git a/vm/actor/tests/common/mod.rs b/vm/actor/tests/common/mod.rs index 787791aa543d..72bc4bfaa9f1 100644 --- a/vm/actor/tests/common/mod.rs +++ b/vm/actor/tests/common/mod.rs @@ -77,12 +77,6 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> { new_actor_addr: None, message: message, - // UnsignedMessage::builder() - // .to(receiver.clone()) - // .from(Address::default()) - // .value(0u8.into()) - // .build() - // .unwrap(), state: None, balance: 0u8.into(), diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index f295c45724e8..9585ac62f140 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -302,13 +302,6 @@ where constructor_params: Serialized::serialize(params).unwrap(), }; - rt.message = UnsignedMessage::builder() - .to(rt.message.to().clone()) - .from(rt.message.from().clone()) - .value(rt.message.value().clone()) - .build() - .unwrap(); - //Get the previous state so if call fails u can revert let prev_state = rt.state.clone(); @@ -318,15 +311,11 @@ where &Serialized::serialize(&exec_params).unwrap(), ); - // Revert state if call fails - let ret = match ret { - Ok(v) => Ok(v), - Err(e) => { - rt.state = prev_state; - Err(e) - } - }; - + // Revert state if call + if ret.is_err(){ + rt.state = prev_state; + } + rt.verify(); ret } From 12d8192f8e7bd19396b342b54826cc223ffbdaba Mon Sep 17 00:00:00 2001 From: DragonMural Date: Thu, 7 May 2020 18:56:20 -0400 Subject: [PATCH 20/20] Adding minor changes --- vm/actor/tests/init_actor_test.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vm/actor/tests/init_actor_test.rs b/vm/actor/tests/init_actor_test.rs index 9585ac62f140..4240e985d94a 100644 --- a/vm/actor/tests/init_actor_test.rs +++ b/vm/actor/tests/init_actor_test.rs @@ -311,11 +311,11 @@ where &Serialized::serialize(&exec_params).unwrap(), ); - // Revert state if call - if ret.is_err(){ + // Revert state if call + if ret.is_err() { rt.state = prev_state; } - + rt.verify(); ret }