From 3862fe733aaebbd464ab64c0e0571df197155bf2 Mon Sep 17 00:00:00 2001 From: "zero.qn" Date: Thu, 23 Jul 2020 15:36:23 +0800 Subject: [PATCH] fix(storage): test batch receipts get panic --- core/storage/src/tests/adapter.rs | 59 +++++++---- core/storage/src/tests/mod.rs | 6 -- core/storage/src/tests/storage.rs | 162 ++++++++++++++++++++++++------ 3 files changed, 170 insertions(+), 57 deletions(-) diff --git a/core/storage/src/tests/adapter.rs b/core/storage/src/tests/adapter.rs index 6fc87375c..acbfd1b10 100644 --- a/core/storage/src/tests/adapter.rs +++ b/core/storage/src/tests/adapter.rs @@ -6,38 +6,43 @@ use crate::adapter::rocks::RocksAdapter; use crate::tests::{get_random_bytes, mock_signed_tx}; use crate::{CommonHashKey, TransactionSchema}; -#[test] -fn test_adapter_insert() { - adapter_insert_test(MemoryAdapter::new()); +#[tokio::test] +async fn test_adapter_insert() { + adapter_insert_test(MemoryAdapter::new()).await; adapter_insert_test(RocksAdapter::new("rocksdb/test_adapter_insert".to_string(), 64).unwrap()) + .await } -#[test] -fn test_adapter_batch_modify() { - adapter_batch_modify_test(MemoryAdapter::new()); +#[tokio::test] +async fn test_adapter_batch_modify() { + adapter_batch_modify_test(MemoryAdapter::new()).await; adapter_batch_modify_test( RocksAdapter::new("rocksdb/test_adapter_batch_modify".to_string(), 64).unwrap(), ) + .await } -#[test] -fn test_adapter_remove() { - adapter_remove_test(MemoryAdapter::new()); +#[tokio::test] +async fn test_adapter_remove() { + adapter_remove_test(MemoryAdapter::new()).await; adapter_remove_test(RocksAdapter::new("rocksdb/test_adapter_remove".to_string(), 64).unwrap()) + .await } -fn adapter_insert_test(db: impl StorageAdapter) { +async fn adapter_insert_test(db: impl StorageAdapter) { let tx_hash = Hash::digest(get_random_bytes(10)); let tx_key = CommonHashKey::new(1, tx_hash.clone()); let stx = mock_signed_tx(tx_hash.clone()); - exec!(db.insert::(tx_key.clone(), stx.clone())); - let stx = exec!(db.get::(tx_key)).unwrap(); + db.insert::(tx_key.clone(), stx.clone()) + .await + .unwrap(); + let stx = db.get::(tx_key).await.unwrap().unwrap(); assert_eq!(tx_hash, stx.tx_hash); } -fn adapter_batch_modify_test(db: impl StorageAdapter) { +async fn adapter_batch_modify_test(db: impl StorageAdapter) { let mut stxs = Vec::new(); let mut keys = Vec::new(); let mut inserts = Vec::new(); @@ -50,8 +55,10 @@ fn adapter_batch_modify_test(db: impl StorageAdapter) { inserts.push(StorageBatchModify::Insert::(stx)); } - exec!(db.batch_modify::(keys.clone(), inserts)); - let opt_stxs = exec!(db.get_batch::(keys)); + db.batch_modify::(keys.clone(), inserts) + .await + .unwrap(); + let opt_stxs = db.get_batch::(keys).await.unwrap(); for i in 0..10 { assert_eq!( @@ -61,18 +68,28 @@ fn adapter_batch_modify_test(db: impl StorageAdapter) { } } -fn adapter_remove_test(db: impl StorageAdapter) { +async fn adapter_remove_test(db: impl StorageAdapter) { let tx_hash = Hash::digest(get_random_bytes(10)); let tx_key = CommonHashKey::new(1, tx_hash.clone()); - let is_exist = exec!(db.contains::(tx_key.clone())); + let is_exist = db + .contains::(tx_key.clone()) + .await + .unwrap(); assert!(!is_exist); let stx = &mock_signed_tx(tx_hash); - exec!(db.insert::(tx_key.clone(), stx.clone())); - let is_exist = exec!(db.contains::(tx_key.clone())); + db.insert::(tx_key.clone(), stx.clone()) + .await + .unwrap(); + let is_exist = db + .contains::(tx_key.clone()) + .await + .unwrap(); assert!(is_exist); - exec!(db.remove::(tx_key.clone())); - let is_exist = exec!(db.contains::(tx_key)); + db.remove::(tx_key.clone()) + .await + .unwrap(); + let is_exist = db.contains::(tx_key).await.unwrap(); assert!(!is_exist); } diff --git a/core/storage/src/tests/mod.rs b/core/storage/src/tests/mod.rs index 0eef12d29..8fe1bb773 100644 --- a/core/storage/src/tests/mod.rs +++ b/core/storage/src/tests/mod.rs @@ -1,11 +1,5 @@ extern crate test; -macro_rules! exec { - ($func: expr) => { - futures::executor::block_on(async { $func.await.unwrap() }) - }; -} - mod adapter; mod storage; diff --git a/core/storage/src/tests/storage.rs b/core/storage/src/tests/storage.rs index 542904c73..2bcaf73b5 100644 --- a/core/storage/src/tests/storage.rs +++ b/core/storage/src/tests/storage.rs @@ -6,29 +6,31 @@ use test::Bencher; use protocol::traits::{Context, Storage}; use protocol::types::Hash; +use tokio::runtime::Runtime; use crate::adapter::memory::MemoryAdapter; use crate::tests::{get_random_bytes, mock_block, mock_proof, mock_receipt, mock_signed_tx}; use crate::ImplStorage; +use crate::BATCH_VALUE_DECODE_NUMBER; -#[test] -fn test_storage_block_insert() { +#[tokio::test] +async fn test_storage_block_insert() { let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); let height = 100; let block = mock_block(height, Hash::digest(get_random_bytes(10))); - exec!(storage.insert_block(Context::new(), block)); + storage.insert_block(Context::new(), block).await.unwrap(); - let block = exec!(storage.get_latest_block(Context::new())); + let block = storage.get_latest_block(Context::new()).await.unwrap(); assert_eq!(height, block.header.height); - let block = exec!(storage.get_block(Context::new(), height)); + let block = storage.get_block(Context::new(), height).await.unwrap(); assert_eq!(Some(height), block.map(|b| b.header.height)); } -#[test] -fn test_storage_receipts_insert() { +#[tokio::test] +async fn test_storage_receipts_insert() { let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); let height = 2077; @@ -42,8 +44,14 @@ fn test_storage_receipts_insert() { receipts.push(receipt); } - exec!(storage.insert_receipts(Context::new(), height, receipts.clone())); - let receipts_2 = exec!(storage.get_receipts(Context::new(), height, hashes)); + storage + .insert_receipts(Context::new(), height, receipts.clone()) + .await + .unwrap(); + let receipts_2 = storage + .get_receipts(Context::new(), height, hashes) + .await + .unwrap(); for i in 0..10 { assert_eq!( @@ -53,8 +61,42 @@ fn test_storage_receipts_insert() { } } -#[test] -fn test_storage_transactions_insert() { +#[tokio::test] +async fn test_storage_receipts_get_batch_decode() { + let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); + let height = 2077; + let count = BATCH_VALUE_DECODE_NUMBER + 100; + + let mut receipts = Vec::new(); + let mut hashes = Vec::new(); + + for _ in 0..count { + let tx_hash = Hash::digest(get_random_bytes(10)); + hashes.push(tx_hash.clone()); + let receipt = mock_receipt(tx_hash.clone()); + receipts.push(receipt); + } + + storage + .insert_receipts(Context::new(), height, receipts.clone()) + .await + .unwrap(); + + let receipts_2 = storage + .get_receipts(Context::new(), height, hashes) + .await + .unwrap(); + + for i in 0..count { + assert_eq!( + Some(receipts.get(i).unwrap()), + receipts_2.get(i).unwrap().as_ref() + ); + } +} + +#[tokio::test] +async fn test_storage_transactions_insert() { let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); let height = 2020; @@ -68,8 +110,14 @@ fn test_storage_transactions_insert() { transactions.push(transaction); } - exec!(storage.insert_transactions(Context::new(), height, transactions.clone())); - let transactions_2 = exec!(storage.get_transactions(Context::new(), height, hashes)); + storage + .insert_transactions(Context::new(), height, transactions.clone()) + .await + .unwrap(); + let transactions_2 = storage + .get_transactions(Context::new(), height, hashes) + .await + .unwrap(); for i in 0..10 { assert_eq!( @@ -79,26 +127,65 @@ fn test_storage_transactions_insert() { } } -#[test] -fn test_storage_latest_proof_insert() { +#[tokio::test] +async fn test_storage_transactions_get_batch_decode() { + let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); + let height = 2020; + let count = BATCH_VALUE_DECODE_NUMBER + 100; + + let mut transactions = Vec::new(); + let mut hashes = Vec::new(); + + for _ in 0..count { + let tx_hash = Hash::digest(get_random_bytes(10)); + hashes.push(tx_hash.clone()); + let transaction = mock_signed_tx(tx_hash.clone()); + transactions.push(transaction); + } + + storage + .insert_transactions(Context::new(), height, transactions.clone()) + .await + .unwrap(); + let transactions_2 = storage + .get_transactions(Context::new(), height, hashes) + .await + .unwrap(); + + for i in 0..count { + assert_eq!( + Some(transactions.get(i).unwrap()), + transactions_2.get(i).unwrap().as_ref() + ); + } +} + +#[tokio::test] +async fn test_storage_latest_proof_insert() { let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); let block_hash = Hash::digest(get_random_bytes(10)); let proof = mock_proof(block_hash); - exec!(storage.update_latest_proof(Context::new(), proof.clone())); - let proof_2 = exec!(storage.get_latest_proof(Context::new(),)); + storage + .update_latest_proof(Context::new(), proof.clone()) + .await + .unwrap(); + let proof_2 = storage.get_latest_proof(Context::new()).await.unwrap(); assert_eq!(proof.block_hash, proof_2.block_hash); } -#[test] -fn test_storage_wal_insert() { +#[tokio::test] +async fn test_storage_wal_insert() { let storage = ImplStorage::new(Arc::new(MemoryAdapter::new())); let info = get_random_bytes(64); - exec!(storage.update_overlord_wal(Context::new(), info.clone())); - let info_2 = exec!(storage.load_overlord_wal(Context::new(),)); + storage + .update_overlord_wal(Context::new(), info.clone()) + .await + .unwrap(); + let info_2 = storage.load_overlord_wal(Context::new()).await.unwrap(); assert_eq!(info, info_2); } @@ -122,8 +209,9 @@ fn bench_insert_10000_receipts(b: &mut Bencher) { .map(|_| mock_receipt(Hash::digest(get_random_bytes(10)))) .collect::>(); - b.iter(move || { - exec!(storage.insert_receipts(Context::new(), height, receipts.clone())); + let mut rt = Runtime::new().unwrap(); + b.iter(|| { + rt.block_on(storage.insert_receipts(Context::new(), height, receipts.clone())).unwrap() }) } @@ -136,8 +224,10 @@ fn bench_insert_20000_receipts(b: &mut Bencher) { .map(|_| mock_receipt(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_receipts(Context::new(), height, receipts.clone())); + rt.block_on(storage.insert_receipts(Context::new(), height, receipts.clone())) + .unwrap() }) } @@ -150,8 +240,10 @@ fn bench_insert_40000_receipts(b: &mut Bencher) { .map(|_| mock_receipt(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_receipts(Context::new(), height, receipts.clone())); + rt.block_on(storage.insert_receipts(Context::new(), height, receipts.clone())) + .unwrap() }) } @@ -164,8 +256,10 @@ fn bench_insert_80000_receipts(b: &mut Bencher) { .map(|_| mock_receipt(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_receipts(Context::new(), height, receipts.clone())); + rt.block_on(storage.insert_receipts(Context::new(), height, receipts.clone())) + .unwrap() }) } #[bench] @@ -177,8 +271,10 @@ fn bench_insert_10000_txs(b: &mut Bencher) { .map(|_| mock_signed_tx(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_transactions(Context::new(), height, txs.clone())); + rt.block_on(storage.insert_transactions(Context::new(), height, txs.clone())) + .unwrap() }) } @@ -191,8 +287,10 @@ fn bench_insert_20000_txs(b: &mut Bencher) { .map(|_| mock_signed_tx(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_transactions(Context::new(), height, txs.clone())); + rt.block_on(storage.insert_transactions(Context::new(), height, txs.clone())) + .unwrap() }) } @@ -205,8 +303,10 @@ fn bench_insert_40000_txs(b: &mut Bencher) { .map(|_| mock_signed_tx(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_transactions(Context::new(), height, txs.clone())); + rt.block_on(storage.insert_transactions(Context::new(), height, txs.clone())) + .unwrap() }) } @@ -219,7 +319,9 @@ fn bench_insert_80000_txs(b: &mut Bencher) { .map(|_| mock_signed_tx(Hash::digest(get_random_bytes(10)))) .collect::>(); + let mut rt = Runtime::new().unwrap(); b.iter(move || { - exec!(storage.insert_transactions(Context::new(), height, txs.clone())); + rt.block_on(storage.insert_transactions(Context::new(), height, txs.clone())) + .unwrap() }) }