Eliminate another end-to-end test. (#4397)

## Motivation

The `test_publish_read_data_blob` was an end-to-end test.

## Proposal

The test is now moved to the `linera-core`.

## Test Plan

The CI.
It has been tested that the functionalities being tested in those
end-to-end tests are also tested
in those tests.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None

Author: MathieuDutSik

Cargo.lock

@@ -97,6 +97,7 @@ hex-game.workspace = true
 linera-core = { path = ".", default-features = false, features = ["test"] }
 linera-views.workspace = true
 meta-counter.workspace = true
+publish-read-data-blob.workspace = true
 serde_json.workspace = true
 sha3.workspace = true
 social.workspace = true

linera-core/Cargo.toml

@@ -21,9 +21,11 @@ use counter::CounterAbi;
 use fungible::{FungibleOperation, InitialState, Parameters};
 use hex_game::{HexAbi, Operation as HexOperation, Timeouts};
 use linera_base::{
-    crypto::InMemorySigner,
-    data_types::{Amount, BlockHeight, Bytecode, ChainDescription, Event, OracleResponse},
-    identifiers::{ApplicationId, BlobId, BlobType, ModuleId, StreamId, StreamName},
+    crypto::{CryptoHash, InMemorySigner},
+    data_types::{
+        Amount, BlobContent, BlockHeight, Bytecode, ChainDescription, Event, OracleResponse,
+    },
+    identifiers::{ApplicationId, BlobId, BlobType, DataBlobHash, ModuleId, StreamId, StreamName},
     ownership::{ChainOwnership, TimeoutConfig},
     vm::VmRuntime,
 };
@@ -989,3 +991,115 @@ where
         .await?;
     Ok(())
 }
+
+#[cfg_attr(feature = "wasmer", test_case(WasmRuntime::Wasmer ; "wasmer"))]
+#[cfg_attr(feature = "wasmtime", test_case(WasmRuntime::Wasmtime ; "wasmtime"))]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn test_memory_publish_read_data_blob(wasm_runtime: WasmRuntime) -> anyhow::Result<()> {
+    run_test_publish_read_data_blob(MemoryStorageBuilder::with_wasm_runtime(wasm_runtime)).await
+}
+
+#[ignore]
+#[cfg(feature = "storage-service")]
+#[cfg_attr(feature = "wasmer", test_case(WasmRuntime::Wasmer ; "wasmer"))]
+#[cfg_attr(feature = "wasmtime", test_case(WasmRuntime::Wasmtime ; "wasmtime"))]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn test_service_publish_read_data_blob(wasm_runtime: WasmRuntime) -> anyhow::Result<()> {
+    run_test_publish_read_data_blob(ServiceStorageBuilder::with_wasm_runtime(wasm_runtime).await)
+        .await
+}
+
+#[ignore]
+#[cfg(feature = "rocksdb")]
+#[cfg_attr(feature = "wasmer", test_case(WasmRuntime::Wasmer ; "wasmer"))]
+#[cfg_attr(feature = "wasmtime", test_case(WasmRuntime::Wasmtime ; "wasmtime"))]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn test_rocks_db_publish_read_data_blob(wasm_runtime: WasmRuntime) -> anyhow::Result<()> {
+    run_test_publish_read_data_blob(RocksDbStorageBuilder::with_wasm_runtime(wasm_runtime).await)
+        .await
+}
+
+#[ignore]
+#[cfg(feature = "dynamodb")]
+#[cfg_attr(feature = "wasmer", test_case(WasmRuntime::Wasmer ; "wasmer"))]
+#[cfg_attr(feature = "wasmtime", test_case(WasmRuntime::Wasmtime ; "wasmtime"))]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn test_dynamo_db_publish_read_data_blob(wasm_runtime: WasmRuntime) -> anyhow::Result<()> {
+    run_test_publish_read_data_blob(DynamoDbStorageBuilder::with_wasm_runtime(wasm_runtime)).await
+}
+
+#[ignore]
+#[cfg(feature = "scylladb")]
+#[cfg_attr(feature = "wasmer", test_case(WasmRuntime::Wasmer ; "wasmer"))]
+#[cfg_attr(feature = "wasmtime", test_case(WasmRuntime::Wasmtime ; "wasmtime"))]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn test_scylla_db_publish_read_data_blob(wasm_runtime: WasmRuntime) -> anyhow::Result<()> {
+    run_test_publish_read_data_blob(ScyllaDbStorageBuilder::with_wasm_runtime(wasm_runtime)).await
+}
+
+async fn run_test_publish_read_data_blob<B>(storage_builder: B) -> anyhow::Result<()>
+where
+    B: StorageBuilder,
+{
+    use publish_read_data_blob::PublishReadDataBlobAbi;
+
+    let keys = InMemorySigner::new(None);
+    let mut builder = TestBuilder::new(storage_builder, 4, 1, keys)
+        .await?
+        .with_policy(ResourceControlPolicy::all_categories());
+    let client = builder.add_root_chain(0, Amount::from_tokens(3)).await?;
+
+    let module_id = client
+        .publish_wasm_example("publish-read-data-blob")
+        .await?;
+    let module_id = module_id.with_abi::<PublishReadDataBlobAbi, (), ()>();
+
+    let (application_id, _) = client
+        .create_application(module_id, &(), &(), vec![])
+        .await
+        .unwrap_ok_committed();
+
+    // Method 1: Publishing and reading in different blocks.
+    let test_data = b"This is test data for method 1.".to_vec();
+
+    // publishing the data.
+    let publish_op = publish_read_data_blob::Operation::CreateDataBlob(test_data.clone());
+    client
+        .execute_operation(Operation::user(application_id, &publish_op)?)
+        .await
+        .unwrap_ok_committed();
+
+    // getting the hash
+    let content = BlobContent::new_data(test_data.clone());
+    let hash = DataBlobHash(CryptoHash::new(&content));
+
+    // reading and checking
+    let read_op = publish_read_data_blob::Operation::ReadDataBlob(hash, test_data);
+    client
+        .execute_operation(Operation::user(application_id, &read_op)?)
+        .await
+        .unwrap_ok_committed();
+
+    // Method 2: Publishing and reading in the same transaction
+    let test_data = b"This is test data for method 2.".to_vec();
+    let combined_op = publish_read_data_blob::Operation::CreateAndReadDataBlob(test_data);
+    client
+        .execute_operation(Operation::user(application_id, &combined_op)?)
+        .await
+        .unwrap_ok_committed();
+
+    // Method 3: Publishing and reading in the same block but different transactions
+    let test_data = b"This is test data for method 3.".to_vec();
+    let publish_op = publish_read_data_blob::Operation::CreateDataBlob(test_data.clone());
+    let content = BlobContent::new_data(test_data.clone());
+    let hash = DataBlobHash(CryptoHash::new(&content));
+    let read_op = publish_read_data_blob::Operation::ReadDataBlob(hash, test_data);
+    let op1 = Operation::user(application_id, &publish_op)?;
+    let op2 = Operation::user(application_id, &read_op)?;
+    client
+        .execute_operations(vec![op1, op2], vec![])
+        .await
+        .unwrap_ok_committed();
+
+    Ok(())
+}

linera-core/src/unit_tests/wasm_client_tests.rs

@@ -154,7 +154,6 @@ native-fungible.workspace = true
 non-fungible.workspace = true
 prometheus.workspace = true
 proptest.workspace = true
-publish-read-data-blob.workspace = true
 reqwest = { workspace = true, features = ["json"] }
 social.workspace = true
 test-case.workspace = true

linera-service/Cargo.toml

@@ -4657,78 +4657,3 @@ async fn test_end_to_end_repeated_transfers(config: impl LineraNetConfig) -> Res
 
     Ok(())
 }
-
-#[cfg_attr(feature = "storage-service", test_case(LocalNetConfig::new_test(Database::Service, Network::Grpc) ; "storage_test_service_grpc"))]
-#[cfg_attr(feature = "scylladb", test_case(LocalNetConfig::new_test(Database::ScyllaDb, Network::Grpc) ; "scylladb_grpc"))]
-#[cfg_attr(feature = "dynamodb", test_case(LocalNetConfig::new_test(Database::DynamoDb, Network::Grpc) ; "aws_grpc"))]
-#[cfg_attr(feature = "kubernetes", test_case(SharedLocalKubernetesNetTestingConfig::new(Network::Grpc, BuildArg::Build) ; "kubernetes_grpc"))]
-#[cfg_attr(feature = "remote-net", test_case(RemoteNetTestingConfig::new(None) ; "remote_net_grpc"))]
-#[test_log::test(tokio::test)]
-async fn test_wasm_end_to_end_publish_read_data_blob(config: impl LineraNetConfig) -> Result<()> {
-    use publish_read_data_blob::{PublishReadDataBlobAbi, ServiceQuery};
-
-    let _guard = INTEGRATION_TEST_GUARD.lock().await;
-    tracing::info!("Starting test {}", test_name!());
-
-    let (mut net, client) = config.instantiate().await?;
-
-    let chain = client.load_wallet()?.default_chain().unwrap();
-    let (contract, service) = client.build_example("publish-read-data-blob").await?;
-
-    let application_id = client
-        .publish_and_create::<PublishReadDataBlobAbi, (), ()>(
-            contract,
-            service,
-            VmRuntime::Wasm,
-            &(),
-            &(),
-            &[],
-            None,
-        )
-        .await?;
-
-    let port = get_node_port().await;
-    let mut node_service = client.run_node_service(port, ProcessInbox::Skip).await?;
-
-    let application = node_service
-        .make_application(&chain, &application_id)
-        .await?;
-
-    // Method 1: Publishing and reading in different blocks.
-
-    let test_data = b"This is test data for method 1.".to_vec();
-
-    // publishing the data.
-    let mutation = ServiceQuery::PublishDataBlob(test_data.clone());
-    application.run_json_query(&mutation).await?;
-
-    // getting the hash
-    let content = BlobContent::new_data(test_data.clone());
-    let hash = DataBlobHash(CryptoHash::new(&content));
-
-    // reading and checking
-    let mutation = ServiceQuery::ReadDataBlob(hash, test_data);
-    application.run_json_query(&mutation).await?;
-
-    // Method 2: Publishing and reading in the same transaction
-
-    let test_data = b"This is test data for method 2.".to_vec();
-
-    let mutation = ServiceQuery::PublishAndCreateOneOperation(test_data);
-    application.run_json_query(&mutation).await?;
-
-    // Method 3: Publishing and reading in the same block but different transactions
-
-    let test_data = b"This is test data for method 3.".to_vec();
-
-    let mutation = ServiceQuery::PublishAndCreateTwoOperations(test_data);
-    application.run_json_query(&mutation).await?;
-
-    // Winding down
-
-    node_service.ensure_is_running()?;
-    net.ensure_is_running().await?;
-    net.terminate().await?;
-
-    Ok(())
-}