Change the tests of the linera-views and put the tombstone test for the RocksDb. (#3302)

## Motivation

The tests of the `linera-views` can be made shorter in terms of code.

The tombstone problem has emerged as a problem for `RocksDb`. We extend
this test by supporting some read operations and adding it to the suite
of tests for `RocksDb`.

## Proposal

We propose the following changes:
* Add the testing of read keys to the tombstone key test.
* Iterate the reading of the keys from the store to see the evolution of
the performance.
* Introduce the tombstone test for RocksDb.

Besides, there are a number of changes for the tests:
* Simplification of the `MemoryContext::new_for_testing` function since
the calls always took the same arguments.
* Elimination of requirement for `Debug` in the error type since it was
not used.
* Put the creation of the testing store in the benchmark code.
Therefore, only the type is used in the argument which makes the code
simpler.

## Test Plan

The CI is the object of those changes.

## Release Plan

Not relevant to TestNet / DevNet.

## Links

None.

Author: MathieuDutSik

linera-chain/src/unit_tests/chain_tests.rs

@@ -31,8 +31,7 @@ use linera_execution::{
 };
 use linera_views::{
     context::{Context as _, MemoryContext, ViewContext},
-    memory::{MemoryStore, TEST_MEMORY_MAX_STREAM_QUERIES},
-    random::generate_test_namespace,
+    memory::MemoryStore,
     views::{View, ViewError},
 };
 use test_case::test_case;
@@ -54,12 +53,7 @@ where
     pub async fn new(chain_id: ChainId) -> Self {
         let exec_runtime_context =
             TestExecutionRuntimeContext::new(chain_id, ExecutionRuntimeConfig::default());
-        let namespace = generate_test_namespace();
-        let context = MemoryContext::new_for_testing(
-            TEST_MEMORY_MAX_STREAM_QUERIES,
-            &namespace,
-            exec_runtime_context,
-        );
+        let context = MemoryContext::new_for_testing(exec_runtime_context);
         Self::load(context)
             .await
             .expect("Loading from memory should work")

linera-execution/src/test_utils/system_execution_state.rs

@@ -16,7 +16,6 @@ use linera_base::{
 };
 use linera_views::{
     context::{Context, MemoryContext},
-    memory::TEST_MEMORY_MAX_STREAM_QUERIES,
     random::generate_test_namespace,
     views::{CryptoHashView, View, ViewError},
 };
@@ -115,9 +114,7 @@ impl SystemExecutionState {
             extra.user_services().insert(id, mock_application.into());
         }
 
-        let namespace = generate_test_namespace();
-        let context =
-            MemoryContext::new_for_testing(TEST_MEMORY_MAX_STREAM_QUERIES, &namespace, extra);
+        let context = MemoryContext::new_for_testing(extra);
         let mut view = ExecutionStateView::load(context)
             .await
             .expect("Loading from memory should work");

linera-storage-service/benches/store.rs

@@ -3,34 +3,32 @@
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use linera_storage_service::client::ServiceStoreClient;
-use linera_views::{store::TestKeyValueStore as _, test_utils::performance};
+use linera_views::test_utils::performance;
 use tokio::runtime::Runtime;
 
 fn bench_storage_service(criterion: &mut Criterion) {
     criterion.bench_function("store_storage_service_contains_key", |bencher| {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ServiceStoreClient::new_test_store().await.unwrap();
-                performance::contains_key(store, iterations, black_box).await
+                performance::contains_key::<ServiceStoreClient, _>(iterations, black_box).await
             })
     });
 
     criterion.bench_function("store_storage_service_contains_keys", |bencher| {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ServiceStoreClient::new_test_store().await.unwrap();
-                performance::contains_keys(store, iterations, black_box).await
+                performance::contains_keys::<ServiceStoreClient, _>(iterations, black_box).await
             })
     });
 
     criterion.bench_function("store_storage_service_find_keys_by_prefix", |bencher| {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ServiceStoreClient::new_test_store().await.unwrap();
-                performance::find_keys_by_prefix(store, iterations, black_box).await
+                performance::find_keys_by_prefix::<ServiceStoreClient, _>(iterations, black_box)
+                    .await
             })
     });
 
@@ -40,8 +38,10 @@ fn bench_storage_service(criterion: &mut Criterion) {
             bencher
                 .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
                 .iter_custom(|iterations| async move {
-                    let store = ServiceStoreClient::new_test_store().await.unwrap();
-                    performance::find_key_values_by_prefix(store, iterations, black_box).await
+                    performance::find_key_values_by_prefix::<ServiceStoreClient, _>(
+                        iterations, black_box,
+                    )
+                    .await
                 })
         },
     );
@@ -50,26 +50,24 @@ fn bench_storage_service(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ServiceStoreClient::new_test_store().await.unwrap();
-                performance::read_value_bytes(store, iterations, black_box).await
+                performance::read_value_bytes::<ServiceStoreClient, _>(iterations, black_box).await
             })
     });
 
     criterion.bench_function("store_storage_service_read_multi_values_bytes", |bencher| {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ServiceStoreClient::new_test_store().await.unwrap();
-                performance::read_multi_values_bytes(store, iterations, black_box).await
+                performance::read_multi_values_bytes::<ServiceStoreClient, _>(iterations, black_box)
+                    .await
             })
     });
 
     criterion.bench_function("store_storage_service_write_batch", |bencher| {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ServiceStoreClient::new_test_store().await.unwrap();
-                performance::write_batch(store, iterations).await
+                performance::write_batch::<ServiceStoreClient>(iterations).await
             })
     });
 }

linera-views/benches/queue_view.rs

@@ -1,10 +1,7 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{
-    fmt::Debug,
-    time::{Duration, Instant},
-};
+use std::time::{Duration, Instant};
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 #[cfg(with_dynamodb)]
@@ -19,7 +16,7 @@ use linera_views::{
     memory::MemoryStore,
     queue_view::QueueView,
     random::{make_deterministic_rng, DeterministicRng},
-    store::{KeyValueStore, TestKeyValueStore as _},
+    store::TestKeyValueStore,
     views::{CryptoHashRootView, RootView, View},
 };
 use rand::Rng;
@@ -58,13 +55,13 @@ pub struct QueueStateView<C> {
     pub queue: QueueView<C, u8>,
 }
 
-pub async fn performance_queue_view<S: KeyValueStore + Clone + Sync + 'static>(
-    store: S,
+pub async fn performance_queue_view<S: TestKeyValueStore + Clone + Sync + 'static>(
     iterations: u64,
 ) -> Duration
 where
-    S::Error: Debug + Send + Sync + 'static,
+    S::Error: Send + Sync,
 {
+    let store = S::new_test_store().await.unwrap();
     let context = ViewContext::<(), S>::create_root_context(store, ())
         .await
         .unwrap();
@@ -101,8 +98,7 @@ fn bench_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = MemoryStore::new_test_store().await.unwrap();
-                performance_queue_view(store, iterations).await
+                performance_queue_view::<MemoryStore>(iterations).await
             })
     });
 
@@ -111,8 +107,7 @@ fn bench_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = RocksDbStore::new_test_store().await.unwrap();
-                performance_queue_view(store, iterations).await
+                performance_queue_view::<RocksDbStore>(iterations).await
             })
     });
 
@@ -121,8 +116,7 @@ fn bench_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = DynamoDbStore::new_test_store().await.unwrap();
-                performance_queue_view(store, iterations).await
+                performance_queue_view::<DynamoDbStore>(iterations).await
             })
     });
 
@@ -131,8 +125,7 @@ fn bench_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ScyllaDbStore::new_test_store().await.unwrap();
-                performance_queue_view(store, iterations).await
+                performance_queue_view::<ScyllaDbStore>(iterations).await
             })
     });
 }
@@ -142,13 +135,13 @@ pub struct BucketQueueStateView<C> {
     pub queue: BucketQueueView<C, u8, 100>,
 }
 
-pub async fn performance_bucket_queue_view<S: KeyValueStore + Clone + Sync + 'static>(
-    store: S,
+pub async fn performance_bucket_queue_view<S: TestKeyValueStore + Clone + Sync + 'static>(
     iterations: u64,
 ) -> Duration
 where
-    S::Error: Debug + Send + Sync + 'static,
+    S::Error: Send + Sync,
 {
+    let store = S::new_test_store().await.unwrap();
     let context = ViewContext::<(), S>::create_root_context(store, ())
         .await
         .unwrap();
@@ -186,8 +179,7 @@ fn bench_bucket_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = MemoryStore::new_test_store().await.unwrap();
-                performance_bucket_queue_view(store, iterations).await
+                performance_bucket_queue_view::<MemoryStore>(iterations).await
             })
     });
 
@@ -196,8 +188,7 @@ fn bench_bucket_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = RocksDbStore::new_test_store().await.unwrap();
-                performance_bucket_queue_view(store, iterations).await
+                performance_bucket_queue_view::<RocksDbStore>(iterations).await
             })
     });
 
@@ -206,8 +197,7 @@ fn bench_bucket_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = DynamoDbStore::new_test_store().await.unwrap();
-                performance_bucket_queue_view(store, iterations).await
+                performance_bucket_queue_view::<DynamoDbStore>(iterations).await
             })
     });
 
@@ -216,8 +206,7 @@ fn bench_bucket_queue_view(criterion: &mut Criterion) {
         bencher
             .to_async(Runtime::new().expect("Failed to create Tokio runtime"))
             .iter_custom(|iterations| async move {
-                let store = ScyllaDbStore::new_test_store().await.unwrap();
-                performance_bucket_queue_view(store, iterations).await
+                performance_bucket_queue_view::<ScyllaDbStore>(iterations).await
             })
     });
 }