metatests, more readable errors

Author: domZippilli

lightning/src/util/persist.rs

@@ -223,27 +223,27 @@ impl From<KVStoreUpdatingPersisterError> for io::Error {
         match value {
             KVStoreUpdatingPersisterError::BadMonitorName { reason, context } => io::Error::new(
                 io::ErrorKind::InvalidInput,
-                format!("{}, context: {}'", reason, context),
+                format!("BadMonitorName, {}, context: {}'", reason, context),
             ),
             KVStoreUpdatingPersisterError::MonitorDecodeFailed { reason, context } => {
                 io::Error::new(
                     io::ErrorKind::InvalidData,
-                    format!("{}, context: {}'", reason, context),
+                    format!("MonitorDecodeFailed, {}, context: {}'", reason, context),
                 )
             }
             KVStoreUpdatingPersisterError::UpdateDecodeFailed { reason, context } => {
                 io::Error::new(
                     io::ErrorKind::InvalidData,
-                    format!("{}, context: {}'", reason, context),
+                    format!("UpdateDecodeFailed, {}, context: {}'", reason, context),
                 )
             }
             KVStoreUpdatingPersisterError::StorageReadFailed { reason, context } => io::Error::new(
                 io::ErrorKind::Other,
-                format!("{}, context: {}'", reason, context),
+                format!("StorageReadFailed, {}, context: {}'", reason, context),
             ),
             KVStoreUpdatingPersisterError::UpdateFailed { reason, context } => io::Error::new(
                 io::ErrorKind::InvalidData,
-                format!("{}, context: {}'", reason, context),
+                format!("UpdateFailed, {}, context: {}'", reason, context),
             ),
         }
     }
@@ -451,6 +451,8 @@ where
         }
     }
 
+
+
     /// Deserialize a channel monitor update.
     fn deserialize_monitor_update(
         &self,
@@ -607,10 +609,10 @@ mod tests {
             (21, "00000000000000000021"),
             (u64::MAX, "18446744073709551615"),
         ];
-        for (input, expected) in cases {
-            let update_name = UpdateName::from(input);
-            assert_eq!(update_name.0, expected);
-            assert_eq!(update_name.storage_key(), expected);
+        for (input, expected) in &cases {
+            let update_name = UpdateName::from(*input);
+            assert_eq!(update_name.0, *expected);
+            assert_eq!(update_name.storage_key(), *expected);
         }
     }
 
@@ -638,10 +640,10 @@ mod tests {
                 "f33dbeeff33dbeeff33dbeeff33dbeeff33dbeeff33dbeeff33dbeeff33dbeef_65535",
             ),
         ];
-        for (input, expected) in cases {
-            let monitor_name = MonitorName::from(input);
-            assert_eq!(monitor_name.0, expected);
-            assert_eq!(monitor_name.storage_key(), expected);
+        for (input, expected) in &cases {
+            let monitor_name = MonitorName::from(*input);
+            assert_eq!(monitor_name.0, *expected);
+            assert_eq!(monitor_name.storage_key(), *expected);
         }
     }
 

lightning/src/util/test_utils.rs

@@ -1227,3 +1227,66 @@ impl WalletSource for TestWalletSource {
 		Ok(tx)
 	}
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+	use std::io::Read;
+
+    #[test]
+    fn test_test_store_new() {
+        let store = TestStore::new(true);
+        assert!(store.read_only);
+    }
+
+    #[test]
+    fn test_test_store_get_persisted_bytes() {
+        let store = TestStore::new(false);
+        store.write("namespace", "key", &[1, 2, 3]).unwrap();
+        assert_eq!(store.get_persisted_bytes("namespace", "key"), Some(vec![1, 2, 3]));
+    }
+
+    #[test]
+    fn test_test_store_get_and_clear_did_persist() {
+        let store = TestStore::new(false);
+        assert!(!store.get_and_clear_did_persist());
+        store.write("namespace", "key", &[1, 2, 3]).unwrap();
+        assert!(store.get_and_clear_did_persist());
+    }
+
+    #[test]
+    fn test_test_store_read() {
+        let store = TestStore::new(false);
+        store.write("namespace", "key", &[1, 2, 3]).unwrap();
+        let mut reader = store.read("namespace", "key").unwrap();
+        let mut buf = vec![0; 3];
+        reader.read_exact(&mut buf).unwrap();
+        assert_eq!(buf, vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn test_test_store_write() {
+        let store = TestStore::new(false);
+        assert_eq!(store.get_persisted_bytes("namespace", "key"), None);
+        store.write("namespace", "key", &[1, 2, 3]).unwrap();
+        assert_eq!(store.get_persisted_bytes("namespace", "key"), Some(vec![1, 2, 3]));
+    }
+
+    #[test]
+    fn test_test_store_remove() {
+        let store = TestStore::new(false);
+        store.write("namespace", "key", &[1, 2, 3]).unwrap();
+        assert_eq!(store.get_persisted_bytes("namespace", "key"), Some(vec![1, 2, 3]));
+        store.remove("namespace","key").unwrap();
+        assert_eq!(store.get_persisted_bytes("namespace", "key"), None);
+    }
+
+    #[test]
+    fn test_test_store_list() {
+        let store = TestStore::new(false);
+        store.write("namespace", "key1", &[1, 2, 3]).unwrap();
+        store.write("namespace", "key2", &[1, 2, 3]).unwrap();
+        let keys = store.list("namespace").unwrap();
+        assert_eq!(keys, vec!["key1","key2"]);
+    }
+}