test: rm integration tests + unit tests for state

carsonfarmer · carsonfarmer · commit fcead6bcbc58 · 2024-02-01T16:27:43.000-08:00
Signed-off-by: Carson Farmer &lt;carson.farmer@gmail.com&gt;
diff --git a/fendermint/actors/objectstore/src/actor.rs b/fendermint/actors/objectstore/src/actor.rs
@@ -8,12 +8,11 @@ use fil_actors_runtime::builtin::singletons::SYSTEM_ACTOR_ADDR;
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
 use fil_actors_runtime::ActorDowncast;
 use fil_actors_runtime::ActorError;
-use fil_actors_runtime::Map;
 use fvm_ipld_hamt::BytesKey;
 use fvm_shared::error::ExitCode;
 
 use crate::DeleteObjectParams;
-use crate::{Method, PutObjectParams, State, BIT_WIDTH, OBJECTSTORE_ACTOR_NAME};
+use crate::{Method, PutObjectParams, State, OBJECTSTORE_ACTOR_NAME};
 
 fil_actors_runtime::wasm_trampoline!(Actor);
 
@@ -26,7 +25,10 @@ impl Actor {
         rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
 
         let state = State::new(rt.store()).map_err(|e| {
-            e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to create empty Hamt")
+            e.downcast_default(
+                ExitCode::USR_ILLEGAL_STATE,
+                "failed to construct empty store",
+            )
         })?;
 
         rt.create(&state)
@@ -37,37 +39,10 @@ impl Actor {
         rt.validate_immediate_caller_accept_any()?;
 
         rt.transaction(|st: &mut State, rt| {
-            // Load the root Hamt
-            let mut hamt = Map::<_, Vec<u8>>::load_with_bit_width(&st.root, rt.store(), BIT_WIDTH)
+            st.append(rt.store(), BytesKey(params.key), params.content)
                 .map_err(|e| {
-                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load Hamt root")
-                })?;
-
-            let key = BytesKey(params.key);
-
-            let new_content = match hamt.get(&key).map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to get object")
-            })? {
-                Some(existing) => {
-                    // Append the object to the existing object
-                    let mut new_content = existing.clone();
-                    new_content.extend(params.content);
-                    new_content
-                }
-                None => params.content,
-            };
-
-            // Put the new content into the Hamt
-            hamt.set(key, new_content).map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to update key")
-            })?;
-
-            // Save the new Hamt cid root
-            st.root = hamt.flush().map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to save root")
-            })?;
-
-            Ok(())
+                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to append to object")
+                })
         })?;
 
         Ok(())
@@ -78,25 +53,10 @@ impl Actor {
         rt.validate_immediate_caller_accept_any()?;
 
         rt.transaction(|st: &mut State, rt| {
-            // Load the root Hamt
-            let mut hamt =
-                Map::load_with_bit_width(&st.root, rt.store(), BIT_WIDTH).map_err(|e| {
-                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load Hamt root")
-                })?;
-
-            // Put the object into the Hamt
-            // TODO: We could use set_if_absent here to avoid overwriting existing objects.
-            hamt.set(BytesKey(params.key), params.content)
+            st.put(rt.store(), BytesKey(params.key), params.content)
                 .map_err(|e| {
-                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to update key")
-                })?;
-
-            // Save the new Hamt cid root
-            st.root = hamt.flush().map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to save root")
-            })?;
-
-            Ok(())
+                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to put object")
+                })
         })?;
 
         Ok(())
@@ -107,23 +67,9 @@ impl Actor {
         rt.validate_immediate_caller_accept_any()?;
 
         rt.transaction(|st: &mut State, rt| {
-            // Load the root Hamt
-            let mut hamt = Map::<_, Vec<u8>>::load_with_bit_width(&st.root, rt.store(), BIT_WIDTH)
-                .map_err(|e| {
-                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load Hamt root")
-                })?;
-
-            // Delete the object from the Hamt
-            hamt.delete(&BytesKey(params.key)).map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to delete object")
-            })?;
-
-            // Save the new Hamt cid root
-            st.root = hamt.flush().map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to save root")
-            })?;
-
-            Ok(())
+            st.delete(rt.store(), &BytesKey(params.key)).map_err(|e| {
+                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to delete to object")
+            })
         })?;
 
         Ok(())
@@ -132,37 +78,17 @@ impl Actor {
     fn get_object(rt: &impl Runtime, key: Vec<u8>) -> Result<Option<Vec<u8>>, ActorError> {
         let st: State = rt.state()?;
 
-        // Load the root Hamt
-        let hamt = Map::<_, Vec<u8>>::load_with_bit_width(&st.root, rt.store(), BIT_WIDTH)
-            .map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load Hamt root")
-            })?;
-
-        // Get the object from the Hamt
-        hamt.get(&BytesKey(key))
+        st.get(rt.store(), &BytesKey(key))
             .map_err(|e| e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to get object"))
-            .map(|v| v.map(|inner| inner.to_owned()))
     }
 
     fn list_objects(rt: &impl Runtime) -> Result<Option<Vec<Vec<u8>>>, ActorError> {
         let st: State = rt.state()?;
 
-        // Load the root Hamt
-        let hamt = Map::<_, Vec<u8>>::load_with_bit_width(&st.root, rt.store(), BIT_WIDTH)
-            .map_err(|e| {
-                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to load Hamt root")
-            })?;
-
-        let mut keys = Vec::new();
-
-        // List the keys from each item in the Hamt
-        hamt.for_each(|k, _| {
-            keys.push(k.0.to_owned());
-            Ok(())
-        })
-        .map_err(|e| e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to list objects"))?;
-
-        Ok(Some(keys))
+        let objects = st.list(rt.store()).map_err(|e| {
+            e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to list objects")
+        })?;
+        Ok(Some(objects))
     }
 }
 
diff --git a/fendermint/actors/objectstore/src/lib.rs b/fendermint/actors/objectstore/src/lib.rs
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 #[cfg(feature = "fil-actor")]
-pub mod actor;
+mod actor;
 mod shared;
 
 pub use shared::*;
diff --git a/fendermint/actors/objectstore/src/shared.rs b/fendermint/actors/objectstore/src/shared.rs
@@ -5,7 +5,7 @@
 use cid::Cid;
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::tuple::{Deserialize_tuple, Serialize_tuple};
-use fvm_ipld_hamt::Hamt;
+use fvm_ipld_hamt::{BytesKey, Hamt};
 use fvm_shared::METHOD_CONSTRUCTOR;
 use num_derive::FromPrimitive;
 
@@ -34,6 +34,74 @@ impl State {
 
         Ok(Self { root })
     }
+
+    pub fn append<BS: Blockstore>(
+        &mut self,
+        store: &BS,
+        key: BytesKey,
+        content: Vec<u8>,
+    ) -> anyhow::Result<()> {
+        let mut hamt = Hamt::<_, Vec<u8>>::load_with_bit_width(&self.root, store, BIT_WIDTH)?;
+
+        let new_content = match hamt.get(&key)? {
+            Some(existing) => {
+                // Append the object to the existing object
+                let mut new_content = existing.clone();
+                new_content.extend(content);
+                new_content
+            }
+            None => content,
+        };
+
+        hamt.set(key, new_content)?;
+        self.root = hamt.flush()?;
+        Ok(())
+    }
+
+    pub fn put<BS: Blockstore>(
+        &mut self,
+        store: &BS,
+        key: BytesKey,
+        content: Vec<u8>,
+    ) -> anyhow::Result<()> {
+        let mut hamt = Hamt::<_, Vec<u8>>::load_with_bit_width(&self.root, store, BIT_WIDTH)?;
+
+        // TODO: We could use set_if_absent here to avoid overwriting existing objects.
+        hamt.set(key, content)?;
+        self.root = hamt.flush()?;
+        Ok(())
+    }
+
+    pub fn delete<BS: Blockstore>(&mut self, store: &BS, key: &BytesKey) -> anyhow::Result<()> {
+        let mut hamt = Hamt::<_, Vec<u8>>::load_with_bit_width(&self.root, store, BIT_WIDTH)?;
+
+        hamt.delete(key)?;
+        self.root = hamt.flush()?;
+        Ok(())
+    }
+
+    pub fn get<BS: Blockstore>(
+        &self,
+        store: &BS,
+        key: &BytesKey,
+    ) -> anyhow::Result<Option<Vec<u8>>> {
+        let hamt = Hamt::<_, Vec<u8>>::load_with_bit_width(&self.root, store, BIT_WIDTH)?;
+
+        let value = hamt.get(key).map(|v| v.map(|inner| inner.to_owned()))?;
+        Ok(value)
+    }
+
+    pub fn list<BS: Blockstore>(&self, store: &BS) -> anyhow::Result<Vec<Vec<u8>>> {
+        let hamt = Hamt::<_, Vec<u8>>::load_with_bit_width(&self.root, store, BIT_WIDTH)?;
+
+        let mut keys = Vec::new();
+        hamt.for_each(|k, _| {
+            keys.push(k.0.to_owned());
+            Ok(())
+        })?;
+
+        Ok(keys)
+    }
 }
 
 pub const OBJECTSTORE_ACTOR_NAME: &str = "objectstore";
@@ -59,3 +127,103 @@ pub enum Method {
     DeleteObject = frc42_dispatch::method_hash!("DeleteObject"),
     ListObjects = frc42_dispatch::method_hash!("ListObjects"),
 }
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn test_constructor() {
+        let store = fvm_ipld_blockstore::MemoryBlockstore::default();
+        let state = State::new(&store);
+        assert!(state.is_ok());
+        assert_eq!(
+            state.unwrap().root,
+            Cid::from_str("bafy2bzaceamp42wmmgr2g2ymg46euououzfyck7szknvfacqscohrvaikwfay")
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_put_object() {
+        let store = fvm_ipld_blockstore::MemoryBlockstore::default();
+        let mut state = State::new(&store).unwrap();
+        let params = PutObjectParams {
+            key: vec![1, 2, 3],
+            content: vec![4, 5, 6],
+        };
+        assert!(state
+            .put(&store, BytesKey(params.key), params.content)
+            .is_ok());
+
+        assert_eq!(
+            state.root,
+            Cid::from_str("bafy2bzacedojzjpwtx565wt43ard7e3kordcw4hf7bbpywpnkctasuwfh7c5m")
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_append_object() {
+        let store = fvm_ipld_blockstore::MemoryBlockstore::default();
+        let mut state = State::new(&store).unwrap();
+        let params = PutObjectParams {
+            key: vec![1, 2, 3],
+            content: vec![4, 5, 6],
+        };
+        assert!(state
+            .append(&store, BytesKey(params.key), params.content)
+            .is_ok());
+    }
+
+    #[test]
+    fn test_get_object() {
+        let store = fvm_ipld_blockstore::MemoryBlockstore::default();
+        let mut state = State::new(&store).unwrap();
+        let params = PutObjectParams {
+            key: vec![1, 2, 3],
+            content: vec![4, 5, 6],
+        };
+
+        let key = BytesKey(params.key);
+        state.put(&store, key.clone(), params.content).unwrap();
+        let result = state.get(&store, &key);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Some(vec![4, 5, 6]));
+    }
+
+    #[test]
+    fn test_delete_object() {
+        let store = fvm_ipld_blockstore::MemoryBlockstore::default();
+        let mut state = State::new(&store).unwrap();
+        let params = PutObjectParams {
+            key: vec![1, 2, 3],
+            content: vec![4, 5, 6],
+        };
+        let key = BytesKey(params.key);
+        state.put(&store, key.clone(), params.content).unwrap();
+        assert!(state.delete(&store, &key).is_ok());
+
+        let result = state.get(&store, &key);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), None);
+    }
+
+    #[test]
+    fn test_list_objects() {
+        let store = fvm_ipld_blockstore::MemoryBlockstore::default();
+        let mut state = State::new(&store).unwrap();
+        let params = PutObjectParams {
+            key: vec![1, 2, 3],
+            content: vec![4, 5, 6],
+        };
+        state
+            .put(&store, BytesKey(params.key), params.content)
+            .unwrap();
+        let result = state.list(&store);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), vec![vec![1, 2, 3]]);
+    }
+}
diff --git a/fendermint/actors/objectstore/tests/objectstore_actor_test.rs b/fendermint/actors/objectstore/tests/objectstore_actor_test.rs
