Refactor the input handling logic (#48)

* Add support for wrapper types

* Move `FilesWithExtensionIterator` to `core::common`

* Remove unneeded use of two `HashMap`s

* Make metadata structs more typed

* Impl new_from for wrapper types

* Implement the new input handling logic

* Fix edge-case in input handling

* Ignore macro doc comment tests

* Correct comment

* Fix edge-case in deployment order

crates/format/src/case.rs

@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-use crate::{input::Input, mode::Mode};
+use crate::{define_wrapper_type, input::Input, mode::Mode};
 
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
@@ -10,3 +10,9 @@ pub struct Case {
     pub inputs: Vec<Input>,
     pub group: Option<String>,
 }
+
+define_wrapper_type!(
+    /// A wrapper type for the index of test cases found in metadata file.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    CaseIdx(usize);
+);

crates/format/src/input.rs

@@ -13,13 +13,15 @@ use serde_json::Value;
 
 use revive_dt_node_interaction::EthereumNode;
 
+use crate::metadata::ContractInstance;
+
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
     #[serde(default = "default_caller")]
     pub caller: Address,
     pub comment: Option<String>,
     #[serde(default = "default_instance")]
-    pub instance: String,
+    pub instance: ContractInstance,
     pub method: Method,
     pub calldata: Option<Calldata>,
     pub expected: Option<Expected>,
@@ -71,109 +73,138 @@ pub enum Method {
     FunctionName(String),
 }
 
+impl Calldata {
+    pub fn find_all_contract_instances(&self, vec: &mut Vec<ContractInstance>) {
+        if let Calldata::Compound(compound) = self {
+            for item in compound {
+                if let Some(instance) = item.strip_suffix(".address") {
+                    vec.push(ContractInstance::new_from(instance))
+                }
+            }
+        }
+    }
+}
+
+impl ExpectedOutput {
+    pub fn find_all_contract_instances(&self, vec: &mut Vec<ContractInstance>) {
+        if let Some(ref cd) = self.return_data {
+            cd.find_all_contract_instances(vec);
+        }
+    }
+}
+
 impl Input {
     fn instance_to_address(
         &self,
-        instance: &str,
-        deployed_contracts: &HashMap<String, Address>,
+        instance: &ContractInstance,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
     ) -> anyhow::Result<Address> {
         deployed_contracts
             .get(instance)
-            .copied()
-            .ok_or_else(|| anyhow::anyhow!("instance {instance} not deployed"))
+            .map(|(a, _)| *a)
+            .ok_or_else(|| anyhow::anyhow!("instance {instance:?} not deployed"))
     }
 
     pub fn encoded_input(
         &self,
-        deployed_abis: &HashMap<String, JsonAbi>,
-        deployed_contracts: &HashMap<String, Address>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
         chain_state_provider: &impl EthereumNode,
     ) -> anyhow::Result<Bytes> {
-        let Method::FunctionName(ref function_name) = self.method else {
-            return Ok(Bytes::default()); // fallback or deployer — no input
-        };
+        match self.method {
+            Method::Deployer | Method::Fallback => {
+                let calldata_args = match &self.calldata {
+                    Some(Calldata::Compound(args)) => args,
+                    _ => anyhow::bail!("Expected compound calldata for function call"),
+                };
 
-        let Some(abi) = deployed_abis.get(&self.instance) else {
-            tracing::error!(
-                contract_name = self.instance,
-                available_abis = ?deployed_abis.keys().collect::<Vec<_>>(),
-                "Attempted to lookup ABI of contract but it wasn't found"
-            );
-            anyhow::bail!("ABI for instance '{}' not found", &self.instance);
-        };
-
-        tracing::trace!("ABI found for instance: {}", &self.instance);
-
-        // We follow the same logic that's implemented in the matter-labs-tester where they resolve
-        // the function name into a function selector and they assume that he function doesn't have
-        // any existing overloads.
-        // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
-        let function = abi
-            .functions()
-            .find(|function| function.name.starts_with(function_name))
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Function with name {:?} not found in ABI for the instance {:?}",
-                    function_name,
-                    &self.instance
-                )
-            })?;
-
-        tracing::trace!("Functions found for instance: {}", &self.instance);
-
-        let calldata_args = match &self.calldata {
-            Some(Calldata::Compound(args)) => args,
-            _ => anyhow::bail!("Expected compound calldata for function call"),
-        };
-
-        if calldata_args.len() != function.inputs.len() {
-            anyhow::bail!(
-                "Function expects {} args, but got {}",
-                function.inputs.len(),
-                calldata_args.len()
-            );
-        }
-
-        tracing::trace!(
-            "Starting encoding ABI's parameters for instance: {}",
-            &self.instance
-        );
-
-        // Allocating a vector that we will be using for the calldata. The vector size will be:
-        // 4 bytes for the function selector.
-        // function.inputs.len() * 32 bytes for the arguments (each argument is a U256).
-        //
-        // We're using indices in the following code in order to avoid the need for us to allocate
-        // a new buffer for each one of the resolved arguments.
-        let mut calldata = Vec::<u8>::with_capacity(4 + calldata_args.len() * 32);
-        calldata.extend(function.selector().0);
-
-        for (arg_idx, arg) in calldata_args.iter().enumerate() {
-            match resolve_argument(arg, deployed_contracts, chain_state_provider) {
-                Ok(resolved) => {
-                    calldata.extend(resolved.to_be_bytes::<32>());
+                let mut calldata = Vec::<u8>::with_capacity(calldata_args.len() * 32);
+                for (arg_idx, arg) in calldata_args.iter().enumerate() {
+                    match resolve_argument(arg, deployed_contracts, chain_state_provider) {
+                        Ok(resolved) => {
+                            calldata.extend(resolved.to_be_bytes::<32>());
+                        }
+                        Err(error) => {
+                            tracing::error!(arg, arg_idx, ?error, "Failed to resolve argument");
+                            return Err(error);
+                        }
+                    };
                 }
-                Err(error) => {
-                    tracing::error!(arg, arg_idx, ?error, "Failed to resolve argument");
-                    return Err(error);
-                }
-            };
-        }
 
-        Ok(calldata.into())
+                Ok(calldata.into())
+            }
+            Method::FunctionName(ref function_name) => {
+                let Some(abi) = deployed_contracts.get(&self.instance).map(|(_, a)| a) else {
+                    tracing::error!(
+                        contract_name = self.instance.as_ref(),
+                        available_abis = ?deployed_contracts.keys().collect::<Vec<_>>(),
+                        "Attempted to lookup ABI of contract but it wasn't found"
+                    );
+                    anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
+                };
+
+                tracing::trace!("ABI found for instance: {}", &self.instance.as_ref());
+
+                // We follow the same logic that's implemented in the matter-labs-tester where they resolve
+                // the function name into a function selector and they assume that he function doesn't have
+                // any existing overloads.
+                // https://github.com/matter-labs/era-compiler-tester/blob/1dfa7d07cba0734ca97e24704f12dd57f6990c2c/compiler_tester/src/test/case/input/mod.rs#L158-L190
+                let function = abi
+                    .functions()
+                    .find(|function| function.name.starts_with(function_name))
+                    .ok_or_else(|| {
+                        anyhow::anyhow!(
+                            "Function with name {:?} not found in ABI for the instance {:?}",
+                            function_name,
+                            &self.instance
+                        )
+                    })?;
+
+                tracing::trace!("Functions found for instance: {}", self.instance.as_ref());
+
+                let calldata_args = match &self.calldata {
+                    Some(Calldata::Compound(args)) => args,
+                    _ => anyhow::bail!("Expected compound calldata for function call"),
+                };
+
+                tracing::trace!(
+                    "Starting encoding ABI's parameters for instance: {}",
+                    self.instance.as_ref()
+                );
+
+                // Allocating a vector that we will be using for the calldata. The vector size will be:
+                // 4 bytes for the function selector.
+                // function.inputs.len() * 32 bytes for the arguments (each argument is a U256).
+                //
+                // We're using indices in the following code in order to avoid the need for us to allocate
+                // a new buffer for each one of the resolved arguments.
+                let mut calldata = Vec::<u8>::with_capacity(4 + calldata_args.len() * 32);
+                calldata.extend(function.selector().0);
+
+                for (arg_idx, arg) in calldata_args.iter().enumerate() {
+                    match resolve_argument(arg, deployed_contracts, chain_state_provider) {
+                        Ok(resolved) => {
+                            calldata.extend(resolved.to_be_bytes::<32>());
+                        }
+                        Err(error) => {
+                            tracing::error!(arg, arg_idx, ?error, "Failed to resolve argument");
+                            return Err(error);
+                        }
+                    };
+                }
+
+                Ok(calldata.into())
+            }
+        }
     }
 
     /// Parse this input into a legacy transaction.
     pub fn legacy_transaction(
         &self,
-        nonce: u64,
-        deployed_contracts: &HashMap<String, Address>,
-        deployed_abis: &HashMap<String, JsonAbi>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
         chain_state_provider: &impl EthereumNode,
     ) -> anyhow::Result<TransactionRequest> {
-        let input_data =
-            self.encoded_input(deployed_abis, deployed_contracts, chain_state_provider)?;
-        let transaction_request = TransactionRequest::default().nonce(nonce);
+        let input_data = self.encoded_input(deployed_contracts, chain_state_provider)?;
+        let transaction_request = TransactionRequest::default();
         match self.method {
             Method::Deployer => Ok(transaction_request.with_deploy_code(input_data)),
             _ => Ok(transaction_request
@@ -181,10 +212,35 @@ impl Input {
                 .input(input_data.into())),
         }
     }
+
+    pub fn find_all_contract_instances(&self) -> Vec<ContractInstance> {
+        let mut vec = Vec::new();
+        vec.push(self.instance.clone());
+
+        if let Some(ref cd) = self.calldata {
+            cd.find_all_contract_instances(&mut vec);
+        }
+        match &self.expected {
+            Some(Expected::Calldata(cd)) => {
+                cd.find_all_contract_instances(&mut vec);
+            }
+            Some(Expected::Expected(expected)) => {
+                expected.find_all_contract_instances(&mut vec);
+            }
+            Some(Expected::ExpectedMany(expected)) => {
+                for expected in expected {
+                    expected.find_all_contract_instances(&mut vec);
+                }
+            }
+            None => {}
+        }
+
+        vec
+    }
 }
 
-fn default_instance() -> String {
-    "Test".to_string()
+fn default_instance() -> ContractInstance {
+    ContractInstance::new_from("Test")
 }
 
 fn default_caller() -> Address {
@@ -201,13 +257,14 @@ fn default_caller() -> Address {
 /// https://github.com/matter-labs/era-compiler-tester/blob/0ed598a27f6eceee7008deab3ff2311075a2ec69/compiler_tester/src/test/case/input/value.rs#L43-L146
 fn resolve_argument(
     value: &str,
-    deployed_contracts: &HashMap<String, Address>,
+    deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
     chain_state_provider: &impl EthereumNode,
 ) -> anyhow::Result<U256> {
     if let Some(instance) = value.strip_suffix(".address") {
         Ok(U256::from_be_slice(
             deployed_contracts
-                .get(instance)
+                .get(&ContractInstance::new_from(instance))
+                .map(|(a, _)| *a)
                 .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))?
                 .as_ref(),
         ))
@@ -357,19 +414,19 @@ mod tests {
             .0;
 
         let input = Input {
-            instance: "Contract".to_string(),
+            instance: ContractInstance::new_from("Contract"),
             method: Method::FunctionName("store".to_owned()),
             calldata: Some(Calldata::Compound(vec!["42".into()])),
             ..Default::default()
         };
 
-        let mut deployed_abis = HashMap::new();
-        deployed_abis.insert("Contract".to_string(), parsed_abi);
-        let deployed_contracts = HashMap::new();
+        let mut contracts = HashMap::new();
+        contracts.insert(
+            ContractInstance::new_from("Contract"),
+            (Address::ZERO, parsed_abi),
+        );
 
-        let encoded = input
-            .encoded_input(&deployed_abis, &deployed_contracts, &DummyEthereumNode)
-            .unwrap();
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (u64,);
@@ -399,7 +456,7 @@ mod tests {
             .0;
 
         let input: Input = Input {
-            instance: "Contract".to_string(),
+            instance: ContractInstance::new_from("Contract"),
             method: Method::FunctionName("send".to_owned()),
             calldata: Some(Calldata::Compound(vec![
                 "0x1000000000000000000000000000000000000001".to_string(),
@@ -407,13 +464,13 @@ mod tests {
             ..Default::default()
         };
 
-        let mut abis = HashMap::new();
-        abis.insert("Contract".to_string(), parsed_abi);
-        let contracts = HashMap::new();
+        let mut contracts = HashMap::new();
+        contracts.insert(
+            ContractInstance::new_from("Contract"),
+            (Address::ZERO, parsed_abi),
+        );
 
-        let encoded = input
-            .encoded_input(&abis, &contracts, &DummyEthereumNode)
-            .unwrap();
+        let encoded = input.encoded_input(&contracts, &DummyEthereumNode).unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (alloy_primitives::Address,);

crates/format/src/lib.rs

@@ -3,5 +3,6 @@
 pub mod case;
 pub mod corpus;
 pub mod input;
+pub mod macros;
 pub mod metadata;
 pub mod mode;

crates/format/src/macros.rs

@@ -0,0 +1,106 @@
+/// Defines wrappers around types.
+///
+/// For example, the macro invocation seen below:
+///
+/// ```rust,ignore
+/// define_wrapper_type!(CaseId => usize);
+/// ```
+///
+/// Would define a wrapper type that looks like the following:
+///
+/// ```rust,ignore
+/// pub struct CaseId(usize);
+/// ```
+///
+/// And would also implement a number of methods on this type making it easier
+/// to use.
+///
+/// These wrapper types become very useful as they make the code a lot easier
+/// to read.
+///
+/// Take the following as an example:
+///
+/// ```rust,ignore
+/// struct State {
+///     contracts: HashMap<usize, HashMap<String, Vec<u8>>>
+/// }
+/// ```
+///
+/// In the above code it's hard to understand what the various types refer to or
+/// what to expect them to contain.
+///
+/// With these wrapper types we're able to create code that's self-documenting
+/// in that the types tell us what the code is referring to. The above code is
+/// transformed into
+///
+/// ```rust,ignore
+/// struct State {
+///     contracts: HashMap<CaseId, HashMap<ContractName, ContractByteCode>>
+/// }
+/// ```
+#[macro_export]
+macro_rules! define_wrapper_type {
+    (
+        $(#[$meta: meta])*
+        $ident: ident($ty: ty) $(;)?
+    ) => {
+        $(#[$meta])*
+        pub struct $ident($ty);
+
+        impl $ident {
+            pub fn new(value: $ty) -> Self {
+                Self(value)
+            }
+
+            pub fn new_from<T: Into<$ty>>(value: T) -> Self {
+                Self(value.into())
+            }
+
+            pub fn into_inner(self) -> $ty {
+                self.0
+            }
+
+            pub fn as_inner(&self) -> &$ty {
+                &self.0
+            }
+        }
+
+        impl AsRef<$ty> for $ident {
+            fn as_ref(&self) -> &$ty {
+                &self.0
+            }
+        }
+
+        impl AsMut<$ty> for $ident {
+            fn as_mut(&mut self) -> &mut $ty {
+                &mut self.0
+            }
+        }
+
+        impl std::ops::Deref for $ident {
+            type Target = $ty;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl std::ops::DerefMut for $ident {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.0
+            }
+        }
+
+        impl From<$ty> for $ident {
+            fn from(value: $ty) -> Self {
+                Self(value)
+            }
+        }
+
+        impl From<$ident> for $ty {
+            fn from(value: $ident) -> Self {
+                value.0
+            }
+        }
+    };
+}

crates/format/src/metadata.rs

@@ -1,14 +1,17 @@
 use std::{
     collections::BTreeMap,
+    fmt::Display,
     fs::{File, read_to_string},
     ops::Deref,
     path::{Path, PathBuf},
+    str::FromStr,
 };
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 use crate::{
     case::Case,
+    define_wrapper_type,
     mode::{Mode, SolcMode},
 };
 
@@ -42,7 +45,8 @@ impl Deref for MetadataFile {
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct Metadata {
     pub cases: Vec<Case>,
-    pub contracts: Option<BTreeMap<String, String>>,
+    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdentifier>>,
+    // TODO: Convert into wrapper types for clarity.
     pub libraries: Option<BTreeMap<String, BTreeMap<String, String>>>,
     pub ignore: Option<bool>,
     pub modes: Option<Vec<Mode>>,
@@ -77,28 +81,35 @@ impl Metadata {
             .to_path_buf())
     }
 
-    /// Extract the contract sources.
-    ///
-    /// Returns a mapping of contract IDs to their source path and contract name.
-    pub fn contract_sources(&self) -> anyhow::Result<BTreeMap<String, (PathBuf, String)>> {
+    /// Returns the contract sources with canonicalized paths for the files
+    pub fn contract_sources(
+        &self,
+    ) -> anyhow::Result<BTreeMap<ContractInstance, ContractPathAndIdentifier>> {
         let directory = self.directory()?;
         let mut sources = BTreeMap::new();
         let Some(contracts) = &self.contracts else {
             return Ok(sources);
         };
 
-        for (id, contract) in contracts {
-            // TODO: broken if a colon is in the dir name..
-            let mut parts = contract.split(':');
-            let (Some(file_name), Some(contract_name)) = (parts.next(), parts.next()) else {
-                anyhow::bail!("metadata contains invalid contract: {contract}");
-            };
-            let file = directory.to_path_buf().join(file_name);
-            if !file.is_file() {
-                anyhow::bail!("contract {id} is not a file: {}", file.display());
-            }
+        for (
+            alias,
+            ContractPathAndIdentifier {
+                contract_source_path,
+                contract_ident,
+            },
+        ) in contracts
+        {
+            let alias = alias.clone();
+            let absolute_path = directory.join(contract_source_path).canonicalize()?;
+            let contract_ident = contract_ident.clone();
 
-            sources.insert(id.clone(), (file, contract_name.to_string()));
+            sources.insert(
+                alias,
+                ContractPathAndIdentifier {
+                    contract_source_path: absolute_path,
+                    contract_ident,
+                },
+            );
         }
 
         Ok(sources)
@@ -178,12 +189,16 @@ impl Metadata {
         match serde_json::from_str::<Self>(&spec) {
             Ok(mut metadata) => {
                 metadata.file_path = Some(path.to_path_buf());
-                let name = path
-                    .file_name()
-                    .expect("this should be the path to a Solidity file")
-                    .to_str()
-                    .expect("the file name should be valid UTF-8k");
-                metadata.contracts = Some([(String::from("Test"), format!("{name}:Test"))].into());
+                metadata.contracts = Some(
+                    [(
+                        ContractInstance::new_from("test"),
+                        ContractPathAndIdentifier {
+                            contract_source_path: path.to_path_buf(),
+                            contract_ident: ContractIdent::new_from("Test"),
+                        },
+                    )]
+                    .into(),
+                );
                 Some(metadata)
             }
             Err(error) => {
@@ -196,3 +211,139 @@ impl Metadata {
         }
     }
 }
+
+define_wrapper_type!(
+    /// Represents a contract instance found a metadata file.
+    ///
+    /// Typically, this is used as the key to the "contracts" field of metadata files.
+    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    ContractInstance(String);
+);
+
+define_wrapper_type!(
+    /// Represents a contract identifier found a metadata file.
+    ///
+    /// A contract identifier is the name of the contract in the source code.
+    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    ContractIdent(String);
+);
+
+/// Represents an identifier used for contracts.
+///
+/// The type supports serialization from and into the following string format:
+///
+/// ```text
+/// ${path}:${contract_ident}
+/// ```
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(try_from = "String", into = "String")]
+pub struct ContractPathAndIdentifier {
+    /// The path of the contract source code relative to the directory containing the metadata file.
+    pub contract_source_path: PathBuf,
+
+    /// The identifier of the contract.
+    pub contract_ident: ContractIdent,
+}
+
+impl Display for ContractPathAndIdentifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}:{}",
+            self.contract_source_path.display(),
+            self.contract_ident.as_ref()
+        )
+    }
+}
+
+impl FromStr for ContractPathAndIdentifier {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut splitted_string = s.split(":").peekable();
+        let mut path = None::<String>;
+        let mut identifier = None::<String>;
+        loop {
+            let Some(next_item) = splitted_string.next() else {
+                break;
+            };
+            if splitted_string.peek().is_some() {
+                match path {
+                    Some(ref mut path) => {
+                        path.push(':');
+                        path.push_str(next_item);
+                    }
+                    None => path = Some(next_item.to_owned()),
+                }
+            } else {
+                identifier = Some(next_item.to_owned())
+            }
+        }
+        let Some(path) = path else {
+            anyhow::bail!("Path is not defined");
+        };
+        let Some(identifier) = identifier else {
+            anyhow::bail!("Contract identifier is not defined")
+        };
+        Ok(Self {
+            contract_source_path: PathBuf::from(path),
+            contract_ident: ContractIdent::new(identifier),
+        })
+    }
+}
+
+impl TryFrom<String> for ContractPathAndIdentifier {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::from_str(&value)
+    }
+}
+
+impl From<ContractPathAndIdentifier> for String {
+    fn from(value: ContractPathAndIdentifier) -> Self {
+        value.to_string()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn contract_identifier_respects_roundtrip_property() {
+        // Arrange
+        let string = "ERC20/ERC20.sol:ERC20";
+
+        // Act
+        let identifier = ContractPathAndIdentifier::from_str(string);
+
+        // Assert
+        let identifier = identifier.expect("Failed to parse");
+        assert_eq!(
+            identifier.contract_source_path.display().to_string(),
+            "ERC20/ERC20.sol"
+        );
+        assert_eq!(identifier.contract_ident, "ERC20".to_owned().into());
+
+        // Act
+        let reserialized = identifier.to_string();
+
+        // Assert
+        assert_eq!(string, reserialized);
+    }
+
+    #[test]
+    fn complex_metadata_file_can_be_deserialized() {
+        // Arrange
+        const JSON: &str = include_str!("../../../assets/test_metadata.json");
+
+        // Act
+        let metadata = serde_json::from_str::<Metadata>(JSON);
+
+        // Assert
+        metadata.expect("Failed to deserialize metadata");
+    }
+}