Use TryFrom traits for YAML for better error handling (#27)

Author: axic

src/main.rs

@@ -11,6 +11,7 @@ use primitive_types::U256;
 use rustc_hex::{FromHex, ToHex};
 use serde::{Deserialize, Serialize};
 use ssz::{Decode, Encode};
+use std::convert::{TryFrom, TryInto};
 use std::env;
 use std::error::Error;
 use std::fmt;
@@ -34,6 +35,22 @@ impl From<std::io::Error> for ScoutError {
     }
 }
 
+impl From<rustc_hex::FromHexError> for ScoutError {
+    fn from(error: rustc_hex::FromHexError) -> Self {
+        ScoutError {
+            0: error.description().to_string(),
+        }
+    }
+}
+
+impl From<serde_yaml::Error> for ScoutError {
+    fn from(error: serde_yaml::Error) -> Self {
+        ScoutError {
+            0: error.description().to_string(),
+        }
+    }
+}
+
 impl From<wasmi::Error> for ScoutError {
     fn from(error: wasmi::Error) -> Self {
         ScoutError {
@@ -705,117 +722,131 @@ struct TestFile {
     deposit_receipts: Vec<TestDeposit>,
 }
 
-fn hex_to_slice(input: &str, output: &mut [u8]) {
-    let tmp = input.from_hex().expect("invalid hex data");
-    assert!(tmp.len() == output.len());
+fn hex_to_slice(input: &str, output: &mut [u8]) -> Result<(), ScoutError> {
+    let tmp = input.from_hex()?;
+    if tmp.len() != output.len() {
+        return Err(ScoutError("Length mismatch from hex input".to_string()));
+    }
     output.copy_from_slice(&tmp[..]);
+    Ok(())
 }
 
-impl From<&String> for Bytes32 {
-    fn from(input: &String) -> Self {
+impl TryFrom<&String> for Bytes32 {
+    type Error = ScoutError;
+    fn try_from(input: &String) -> Result<Self, Self::Error> {
         let mut ret = Bytes32::default();
-        hex_to_slice(input, &mut ret.bytes);
-        ret
+        hex_to_slice(input, &mut ret.bytes)?;
+        Ok(ret)
     }
 }
 
-impl From<String> for Hash {
-    fn from(input: String) -> Self {
+impl TryFrom<String> for Hash {
+    type Error = ScoutError;
+    fn try_from(input: String) -> Result<Self, Self::Error> {
         let mut ret = Hash::default();
-        hex_to_slice(&input, &mut ret.0);
-        ret
+        hex_to_slice(&input, &mut ret.0)?;
+        Ok(ret)
     }
 }
 
-impl From<String> for BLSPubKey {
-    fn from(input: String) -> Self {
+impl TryFrom<String> for BLSPubKey {
+    type Error = ScoutError;
+    fn try_from(input: String) -> Result<Self, Self::Error> {
         let mut ret = BLSPubKey::default();
-        hex_to_slice(&input, &mut ret.0);
-        ret
+        hex_to_slice(&input, &mut ret.0)?;
+        Ok(ret)
     }
 }
 
-impl From<String> for BLSSignature {
-    fn from(input: String) -> Self {
+impl TryFrom<String> for BLSSignature {
+    type Error = ScoutError;
+    fn try_from(input: String) -> Result<Self, Self::Error> {
         let mut ret = BLSSignature::default();
-        hex_to_slice(&input, &mut ret.0);
-        ret
+        hex_to_slice(&input, &mut ret.0)?;
+        Ok(ret)
     }
 }
 
-impl From<TestBeaconState> for BeaconState {
-    fn from(input: TestBeaconState) -> Self {
-        BeaconState {
-            execution_scripts: input
-                .execution_scripts
-                .iter()
-                .map(|filename| ExecutionScript {
-                    code: std::fs::read(filename).expect("to load file"),
+impl TryFrom<TestBeaconState> for BeaconState {
+    type Error = ScoutError;
+    fn try_from(input: TestBeaconState) -> Result<Self, Self::Error> {
+        let scripts: Result<Vec<ExecutionScript>, ScoutError> = input
+            .execution_scripts
+            .iter()
+            .map(|filename| {
+                Ok(ExecutionScript {
+                    code: std::fs::read(filename)?,
                 })
-                .collect(),
-        }
+            })
+            .collect();
+        Ok(BeaconState {
+            execution_scripts: scripts?,
+        })
     }
 }
 
-impl From<TestShardBlock> for ShardBlock {
-    fn from(input: TestShardBlock) -> Self {
-        ShardBlock {
+impl TryFrom<TestShardBlock> for ShardBlock {
+    type Error = ScoutError;
+    fn try_from(input: TestShardBlock) -> Result<Self, Self::Error> {
+        Ok(ShardBlock {
             env: input.env,
             data: ShardBlockBody {
-                data: input.data.from_hex().expect("invalid hex data"),
+                data: input.data.from_hex()?,
             },
-        }
+        })
     }
 }
 
-impl From<TestShardState> for ShardState {
-    fn from(input: TestShardState) -> Self {
-        ShardState {
-            exec_env_states: input
-                .exec_env_states
-                .iter()
-                .map(|state| state.into())
-                .collect(),
+impl TryFrom<TestShardState> for ShardState {
+    type Error = ScoutError;
+    fn try_from(input: TestShardState) -> Result<Self, Self::Error> {
+        let states: Result<Vec<Bytes32>, ScoutError> = input
+            .exec_env_states
+            .iter()
+            .map(|state| state.try_into())
+            .collect();
+
+        Ok(ShardState {
+            exec_env_states: states?,
             slot: 0,
             parent_block: ShardBlockHeader {},
-        }
+        })
     }
 }
 
-impl From<TestDeposit> for Deposit {
-    fn from(input: TestDeposit) -> Self {
-        Deposit {
-            pubkey: input.pubkey.into(),
-            withdrawal_credentials: input.withdrawal_credentials.into(),
+impl TryFrom<TestDeposit> for Deposit {
+    type Error = ScoutError;
+    fn try_from(input: TestDeposit) -> Result<Self, Self::Error> {
+        Ok(Deposit {
+            pubkey: input.pubkey.try_into()?,
+            withdrawal_credentials: input.withdrawal_credentials.try_into()?,
             amount: input.amount,
-            signature: input.signature.into(),
-        }
+            signature: input.signature.try_into()?,
+        })
     }
 }
 
-fn process_yaml_test(filename: &str) {
+fn process_yaml_test(filename: &str) -> Result<(), ScoutError> {
     info!("Processing {}...", filename);
-    let content = std::fs::read(&filename).expect("to load file");
-    let test_file: TestFile =
-        serde_yaml::from_slice::<TestFile>(&content[..]).expect("expected valid yaml");
+    let content = std::fs::read(&filename)?;
+    let test_file: TestFile = serde_yaml::from_slice::<TestFile>(&content[..])?;
     debug!("{:#?}", test_file);
 
-    let beacon_state: BeaconState = test_file.beacon_state.into();
-    let pre_state: ShardState = test_file.shard_pre_state.into();
-    let post_state: ShardState = test_file.shard_post_state.into();
-    let expected_deposit_receipts: Vec<Deposit> = test_file
+    let beacon_state: BeaconState = test_file.beacon_state.try_into()?;
+    let pre_state: ShardState = test_file.shard_pre_state.try_into()?;
+    let post_state: ShardState = test_file.shard_post_state.try_into()?;
+    let expected_deposit_receipts: Result<Vec<Deposit>, ScoutError> = test_file
         .deposit_receipts
         .into_iter()
-        .map(|deposit| deposit.into())
+        .map(|deposit| deposit.try_into())
         .collect();
+    let expected_deposit_receipts = expected_deposit_receipts?;
 
     let mut shard_state = pre_state;
     let mut deposit_receipts = Vec::new();
     for block in test_file.shard_blocks {
         deposit_receipts.append(
-            process_shard_block(&mut shard_state, &beacon_state, Some(block.into()))
-                .expect("processing shard block to succeed")
-                .as_mut(),
+            process_shard_block(&mut shard_state, &beacon_state, Some(block.try_into()?))?.as_mut(),
         );
     }
 
@@ -827,26 +858,33 @@ fn process_yaml_test(filename: &str) {
     } else {
         println!("Expected deposit receipts: {:?}", expected_deposit_receipts);
         println!("Got deposit receipts: {:?}", deposit_receipts);
-        std::process::exit(1);
+        // TODO: make this an error?
+        return Ok(());
     }
 
     debug!("{}", shard_state);
     if shard_state != post_state {
         println!("Expected state: {}", post_state);
         println!("Got state: {}", shard_state);
-        std::process::exit(1);
+        // TODO: make this an error?
+        return Ok(());
     } else {
         println!("Matching state.");
     }
+
+    Ok(())
 }
 
 fn main() {
     env_logger::init();
 
     let args: Vec<String> = env::args().collect();
-    process_yaml_test(if args.len() != 2 {
+    let ret = process_yaml_test(if args.len() != 2 {
         "test.yaml"
     } else {
         &args[1]
     });
+    if ret.is_err() {
+        println!("Unexpected test failure: {:?}", ret.err().unwrap())
+    }
 }