Test wasms should be loaded via namada_test_utils crate

.changelog/unreleased/testing/893-namada-test-utils-wasms.md

@@ -0,0 +1,2 @@
+- Add utility code for working with test wasms
+  ([#893](https://github.com/anoma/namada/pull/893))

apps/Cargo.toml

@@ -154,6 +154,7 @@ rust_decimal_macros = "1.26.1"
 
 [dev-dependencies]
 namada = {path = "../shared", default-features = false, features = ["testing", "wasm-runtime"]}
+namada_test_utils = {path = "../test_utils"}
 bit-set = "0.5.2"
 # A fork with state machime testing
 proptest = {git = "https://github.com/heliaxdev/proptest", branch = "tomas/sm"}

apps/src/lib/node/ledger/shell/finalize_block.rs

@@ -472,6 +472,7 @@ mod test_finalize_block {
         InitProposalData, VoteProposalData,
     };
     use namada::types::transaction::{EncryptionKey, Fee, WrapperTx, MIN_FEE};
+    use namada_test_utils::TestWasms;
 
     use super::*;
     use crate::node::ledger::shell::test_utils::*;
@@ -703,10 +704,7 @@ mod test_finalize_block {
             .unwrap();
 
         // create two decrypted txs
-        let mut wasm_path = top_level_directory();
-        wasm_path.push("wasm_for_tests/tx_no_op.wasm");
-        let tx_code = std::fs::read(wasm_path)
-            .expect("Expected a file at given code path");
+        let tx_code = TestWasms::TxNoOp.read_bytes();
         for i in 0..2 {
             let raw_tx = Tx::new(
                 tx_code.clone(),

shared/Cargo.toml

@@ -135,6 +135,7 @@ assert_matches = "1.5.0"
 async-trait = {version = "0.1.51"}
 byte-unit = "4.0.13"
 libsecp256k1 = {git = "https://github.com/heliaxdev/libsecp256k1", rev = "bbb3bd44a49db361f21d9db80f9a087c194c0ae9"}
+namada_test_utils = {path = "../test_utils"}
 pretty_assertions = "0.7.2"
 # A fork with state machine testing
 proptest = {git = "https://github.com/heliaxdev/proptest", branch = "tomas/sm"}

shared/src/ledger/queries/shell.rs

@@ -344,15 +344,14 @@ where
 #[cfg(test)]
 mod test {
     use borsh::BorshDeserialize;
+    use namada_test_utils::TestWasms;
 
     use crate::ledger::queries::testing::TestClient;
     use crate::ledger::queries::RPC;
     use crate::ledger::storage_api::{self, StorageWrite};
     use crate::proto::Tx;
     use crate::types::{address, token};
 
-    const TX_NO_OP_WASM: &str = "../wasm_for_tests/tx_no_op.wasm";
-
     #[test]
     fn test_shell_queries_router_paths() {
         let path = RPC.shell().epoch_path();
@@ -386,7 +385,7 @@ mod test {
         assert_eq!(current_epoch, read_epoch);
 
         // Request dry run tx
-        let tx_no_op = std::fs::read(TX_NO_OP_WASM).expect("cannot load wasm");
+        let tx_no_op = TestWasms::TxNoOp.read_bytes();
         let tx = Tx::new(tx_no_op, None);
         let tx_bytes = tx.to_bytes();
         let result = RPC

shared/src/vm/wasm/compilation_cache/common.rs

@@ -557,23 +557,18 @@ mod test {
     use std::cmp::max;
 
     use byte_unit::Byte;
+    use namada_test_utils::TestWasms;
     use tempfile::{tempdir, TempDir};
     use test_log::test;
 
     use super::*;
     use crate::vm::WasmCacheRwAccess;
 
-    const TX_NO_OP: &str = "../wasm_for_tests/tx_no_op.wasm";
-    const TX_READ_STORAGE_KEY: &str =
-        "../wasm_for_tests/tx_read_storage_key.wasm";
-    const VP_ALWAYS_TRUE: &str = "../wasm_for_tests/vp_always_true.wasm";
-    const VP_EVAL: &str = "../wasm_for_tests/vp_eval.wasm";
-
     #[test]
     fn test_fetch_or_compile_valid_wasm() {
         // Load some WASMs and find their hashes and in-memory size
-        let tx_read_storage_key = load_wasm(TX_READ_STORAGE_KEY);
-        let tx_no_op = load_wasm(TX_NO_OP);
+        let tx_read_storage_key = load_wasm(TestWasms::TxReadStorageKey.path());
+        let tx_no_op = load_wasm(TestWasms::TxNoOp.path());
 
         // Create a new cache with the limit set to
         // `max(tx_read_storage_key.size, tx_no_op.size) + 1`
@@ -789,8 +784,8 @@ mod test {
     #[test]
     fn test_pre_compile_valid_wasm() {
         // Load some WASMs and find their hashes and in-memory size
-        let vp_always_true = load_wasm(VP_ALWAYS_TRUE);
-        let vp_eval = load_wasm(VP_EVAL);
+        let vp_always_true = load_wasm(TestWasms::VpAlwaysTrue.path());
+        let vp_eval = load_wasm(TestWasms::VpEval.path());
 
         // Create a new cache with the limit set to
         // `max(vp_always_true.size, vp_eval.size) + 1 + extra_bytes`
@@ -933,7 +928,7 @@ mod test {
     }
 
     /// Get the WASM code bytes, its hash and find the compiled module's size
-    fn load_wasm(file: impl AsRef<str>) -> WasmWithMeta {
+    fn load_wasm(file: impl AsRef<Path>) -> WasmWithMeta {
         // When `WeightScale` calls `loupe::size_of_val` in the cache, for some
         // reason it returns 8 bytes more than the same call in here.
         let extra_bytes = 8;
@@ -952,7 +947,7 @@ mod test {
         };
         println!(
             "Compiled module {} size including the hash: {} ({})",
-            file,
+            file.to_string_lossy(),
             Byte::from_bytes(size as u128).get_appropriate_unit(true),
             size,
         );

shared/src/vm/wasm/run.rs

@@ -409,6 +409,7 @@ fn get_gas_rules() -> rules::Set {
 mod tests {
     use borsh::BorshSerialize;
     use itertools::Either;
+    use namada_test_utils::TestWasms;
     use test_log::test;
     use wasmer_vm::TrapCode;
 
@@ -417,16 +418,6 @@ mod tests {
     use crate::types::validity_predicate::EvalVp;
     use crate::vm::wasm;
 
-    const TX_MEMORY_LIMIT_WASM: &str = "../wasm_for_tests/tx_memory_limit.wasm";
-    const TX_NO_OP_WASM: &str = "../wasm_for_tests/tx_no_op.wasm";
-    const TX_READ_STORAGE_KEY_WASM: &str =
-        "../wasm_for_tests/tx_read_storage_key.wasm";
-    const VP_ALWAYS_TRUE_WASM: &str = "../wasm_for_tests/vp_always_true.wasm";
-    const VP_EVAL_WASM: &str = "../wasm_for_tests/vp_eval.wasm";
-    const VP_MEMORY_LIMIT_WASM: &str = "../wasm_for_tests/vp_memory_limit.wasm";
-    const VP_READ_STORAGE_KEY_WASM: &str =
-        "../wasm_for_tests/vp_read_storage_key.wasm";
-
     /// Test that when a transaction wasm goes over the stack-height limit, the
     /// execution is aborted.
     #[test]
@@ -477,8 +468,7 @@ mod tests {
         let tx_index = TxIndex::default();
 
         // This code will allocate memory of the given size
-        let tx_code =
-            std::fs::read(TX_MEMORY_LIMIT_WASM).expect("cannot load wasm");
+        let tx_code = TestWasms::TxMemoryLimit.read_bytes();
 
         // Assuming 200 pages, 12.8 MiB limit
         assert_eq!(memory::TX_MEMORY_MAX_PAGES, 200);
@@ -534,10 +524,9 @@ mod tests {
         let tx_index = TxIndex::default();
 
         // This code will call `eval` with the other VP below
-        let vp_eval = std::fs::read(VP_EVAL_WASM).expect("cannot load wasm");
+        let vp_eval = TestWasms::VpEval.read_bytes();
         // This code will allocate memory of the given size
-        let vp_memory_limit =
-            std::fs::read(VP_MEMORY_LIMIT_WASM).expect("cannot load wasm");
+        let vp_memory_limit = TestWasms::VpMemoryLimit.read_bytes();
 
         // Assuming 200 pages, 12.8 MiB limit
         assert_eq!(memory::VP_MEMORY_MAX_PAGES, 200);
@@ -615,8 +604,7 @@ mod tests {
         let tx_index = TxIndex::default();
 
         // This code will allocate memory of the given size
-        let vp_code =
-            std::fs::read(VP_MEMORY_LIMIT_WASM).expect("cannot load wasm");
+        let vp_code = TestWasms::VpMemoryLimit.read_bytes();
 
         // Assuming 200 pages, 12.8 MiB limit
         assert_eq!(memory::VP_MEMORY_MAX_PAGES, 200);
@@ -674,7 +662,7 @@ mod tests {
         let mut gas_meter = BlockGasMeter::default();
         let tx_index = TxIndex::default();
 
-        let tx_no_op = std::fs::read(TX_NO_OP_WASM).expect("cannot load wasm");
+        let tx_no_op = TestWasms::TxNoOp.read_bytes();
 
         // Assuming 200 pages, 12.8 MiB limit
         assert_eq!(memory::TX_MEMORY_MAX_PAGES, 200);
@@ -728,8 +716,7 @@ mod tests {
         let verifiers = BTreeSet::new();
         let tx_index = TxIndex::default();
 
-        let vp_code =
-            std::fs::read(VP_ALWAYS_TRUE_WASM).expect("cannot load wasm");
+        let vp_code = TestWasms::VpAlwaysTrue.read_bytes();
 
         // Assuming 200 pages, 12.8 MiB limit
         assert_eq!(memory::VP_MEMORY_MAX_PAGES, 200);
@@ -785,8 +772,7 @@ mod tests {
         let mut gas_meter = BlockGasMeter::default();
         let tx_index = TxIndex::default();
 
-        let tx_read_key =
-            std::fs::read(TX_READ_STORAGE_KEY_WASM).expect("cannot load wasm");
+        let tx_read_key = TestWasms::TxReadStorageKey.read_bytes();
 
         // Allocating `2^24` (16 MiB) for a value in storage that the tx
         // attempts to read should be above the memory limit and should
@@ -832,8 +818,7 @@ mod tests {
         let verifiers = BTreeSet::new();
         let tx_index = TxIndex::default();
 
-        let vp_read_key =
-            std::fs::read(VP_READ_STORAGE_KEY_WASM).expect("cannot load wasm");
+        let vp_read_key = TestWasms::VpReadStorageKey.read_bytes();
 
         // Allocating `2^24` (16 MiB) for a value in storage that the tx
         // attempts to read should be above the memory limit and should
@@ -883,10 +868,9 @@ mod tests {
         let tx_index = TxIndex::default();
 
         // This code will call `eval` with the other VP below
-        let vp_eval = std::fs::read(VP_EVAL_WASM).expect("cannot load wasm");
+        let vp_eval = TestWasms::VpEval.read_bytes();
         // This code will read value from the storage
-        let vp_read_key =
-            std::fs::read(VP_READ_STORAGE_KEY_WASM).expect("cannot load wasm");
+        let vp_read_key = TestWasms::VpReadStorageKey.read_bytes();
 
         // Allocating `2^24` (16 MiB) for a value in storage that the tx
         // attempts to read should be above the memory limit and should

test_utils/Cargo.toml

@@ -9,3 +9,4 @@ version = "0.14.0"
 [dependencies]
 borsh = "0.9.0"
 namada_core = { path = "../core" }
+strum = {version = "0.24", features = ["derive"]}