Init test porting

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(())
     }

vm/actor/src/builtin/init/mod.rs

@@ -90,6 +90,7 @@ impl Actor {
         rt.create_actor(&params.code_cid, &id_address)?;
 
         // Invoke constructor
+
         rt.send(
             &id_address,
             METHOD_CONSTRUCTOR,

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]);
 

vm/actor/tests/common/mod.rs

@@ -12,22 +12,21 @@ 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};
 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,
     pub id_addresses: HashMap<Address, Address>,
     pub actor_code_cids: HashMap<Address, Cid>,
     pub new_actor_addr: Option<Address>,
+    pub message: UnsignedMessage,
 
     // TODO: syscalls: syscaller
 
@@ -69,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(),
@@ -80,6 +77,12 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
             actor_code_cids: HashMap::new(),
             new_actor_addr: None,
 
+            message: UnsignedMessage::builder()
+                .to(receiver.clone())
+                .from(Address::default())
+                .build()
+                .unwrap(),
+
             state: None,
             balance: 0u8.into(),
 
@@ -231,12 +234,29 @@ 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.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);
+    }
 }
 
 impl<BS: BlockStore> Runtime<BS> for MockRuntime<'_, BS> {
     fn message(&self) -> &UnsignedMessage {
         self.require_in_call();
-        todo!();
+        &self.message
     }
 
     fn curr_epoch(&self) -> ChainEpoch {
@@ -275,7 +295,7 @@ impl<BS: BlockStore> Runtime<BS> 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(());
             }
@@ -285,7 +305,8 @@ impl<BS: BlockStore> Runtime<BS> for MockRuntime<'_, BS> {
             ExitCode::ErrForbidden,
             format!(
                 "caller address {:?} forbidden, allowed: {:?}",
-                self.caller, &addrs
+                self.message().from(),
+                &addrs
             ),
         ));
     }
@@ -385,6 +406,7 @@ impl<BS: BlockStore> Runtime<BS> 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)
     }
 
@@ -418,7 +440,7 @@ impl<BS: BlockStore> Runtime<BS> 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(
@@ -431,7 +453,12 @@ impl<BS: BlockStore> Runtime<BS> 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::new(x, "Expected message Fail".to_string()));
+            }
+        }
     }
 
     fn abort<S: AsRef<str>>(&self, exit_code: ExitCode, msg: S) -> ActorError {

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: BlockStore>(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;
 }