Move the create-and-call test case from end-to-end to integration test. (#4394)

## Motivation

The end-to-end tests are relatively expensive in CI. So, it is
advantageous to move them to integration tests.

## Proposal

We do the following:
* We remove the `&self` of `ActiveChain` that is not needed.
* We make the function `ActiveChain` public to be used in the
operational test.
* We introduce the function to return `Bytecode` since to instantiate,
we cannot use the compressed bytecode.
* We introduce the test that exercises the `create-and-call` smart
contract.

## Test Plan

The CI.

The PR that introduces the `create-and-call` also addresses the
persistence of the contract and service blobs
that have been created. We tested that this integration test fails if
the correction is removed.

## Release Plan

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

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -305,7 +305,6 @@ amm = { path = "./examples/amm" }
 call-evm-counter = { path = "./examples/call-evm-counter" }
 counter = { path = "./examples/counter" }
 counter-no-graphql = { path = "./examples/counter-no-graphql" }
-create-and-call = { path = "./examples/create-and-call" }
 crowd-funding = { path = "./examples/crowd-funding" }
 ethereum-tracker = { path = "./examples/ethereum-tracker" }
 fungible = { path = "./examples/fungible" }

Cargo.toml

@@ -11,11 +11,7 @@ serde.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 linera-sdk = { workspace = true, features = ["test", "wasmer"] }
-tokio = { workspace = true, features = ["rt", "sync"] }
-
-[dev-dependencies]
-assert_matches.workspace = true
-linera-sdk = { workspace = true, features = ["test"] }
+tokio.workspace = true
 
 [[bin]]
 name = "create_and_call_contract"

examples/Cargo.lock

@@ -0,0 +1,63 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Integration tests for the Create and Call application.
+
+#![cfg(not(target_arch = "wasm32"))]
+
+use linera_sdk::test::{ActiveChain, TestValidator};
+
+/// Test creating and calling a counter application dynamically.
+///
+/// This test publishes the counter-no-graphql bytecode, then uses the create-and-call
+/// application to dynamically create an instance of the counter and increment it.
+/// The test verifies that the counter is correctly initialized and incremented.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_create_and_call() {
+    let (validator, create_call_module_id) =
+        TestValidator::with_current_module::<create_and_call::CreateAndCallAbi, (), ()>().await;
+    let mut chain = validator.new_chain().await;
+
+    // Step 1: Get the bytecode for "counter-no-graphql" by compiling it from its directory
+    let counter_no_graphql_path = std::path::Path::new("../counter-no-graphql");
+    let counter_no_graphql_path = std::fs::canonicalize(counter_no_graphql_path)
+        .expect("Failed to get absolute path to counter-no-graphql");
+
+    // Build and find the counter-no-graphql bytecode files
+    ActiveChain::build_bytecode_files_in(&counter_no_graphql_path).await;
+    let (counter_contract, counter_service) =
+        ActiveChain::find_bytecode_files_in(&counter_no_graphql_path).await;
+
+    // Extract the raw bytes from the bytecode
+    let counter_contract_bytes = counter_contract.bytes.to_vec();
+    let counter_service_bytes = counter_service.bytes.to_vec();
+
+    // Step 2: Create the "create-and-call" application
+    let application_id = chain
+        .create_application(create_call_module_id, (), (), vec![])
+        .await;
+
+    // Step 3: Call the CreateAndCall operation with the counter bytecode,
+    // initialization value of 43, and increment of 5
+    let initialization_value = 43;
+    let increment_value = 5;
+    let create_and_call_operation = create_and_call::CreateAndCallOperation::CreateAndCall(
+        counter_contract_bytes,
+        counter_service_bytes,
+        initialization_value,
+        increment_value,
+    );
+
+    chain
+        .add_block(|block| {
+            block.with_operation(application_id, create_and_call_operation);
+        })
+        .await;
+
+    // Step 4: Query the create-and-call application to get the result (should be 48 = 43 + 5)
+    let query_request = create_and_call::CreateAndCallRequest::Query;
+    let outcome = chain.query(application_id, query_request).await;
+
+    let expected_value = 48; // 43 + 5
+    assert_eq!(outcome.response, expected_value);
+}

examples/create-and-call/Cargo.toml

@@ -386,7 +386,7 @@ impl ActiveChain {
             .await
             .expect("Failed to obtain absolute application repository path");
         Self::build_bytecode_files_in(&repository_path).await;
-        let (contract, service) = self.find_bytecode_files_in(&repository_path).await;
+        let (contract, service) = Self::find_compressed_bytecode_files_in(&repository_path).await;
         let contract_blob = Blob::new_contract_bytecode(contract);
         let service_blob = Blob::new_service_bytecode(service);
         let contract_blob_hash = contract_blob.id().hash;
@@ -412,7 +412,7 @@ impl ActiveChain {
     }
 
     /// Compiles the crate in the `repository` path.
-    async fn build_bytecode_files_in(repository: &Path) {
+    pub async fn build_bytecode_files_in(repository: &Path) {
         let output = std::process::Command::new("cargo")
             .args(["build", "--release", "--target", "wasm32-unknown-unknown"])
             .current_dir(repository)
@@ -431,12 +431,9 @@ impl ActiveChain {
     /// Searches the Cargo manifest of the crate calling this method for binaries to use as the
     /// contract and service bytecode files.
     ///
-    /// Returns a tuple with the loaded contract and service [`CompressedBytecode`]s,
+    /// Returns a tuple with the loaded contract and service [`Bytecode`]s,
     /// ready to be published.
-    async fn find_bytecode_files_in(
-        &self,
-        repository: &Path,
-    ) -> (CompressedBytecode, CompressedBytecode) {
+    pub async fn find_bytecode_files_in(repository: &Path) -> (Bytecode, Bytecode) {
         let manifest_path = repository.join("Cargo.toml");
         let cargo_manifest =
             Manifest::from_path(manifest_path).expect("Failed to load Cargo.toml manifest");
@@ -461,8 +458,7 @@ impl ActiveChain {
             (&binaries[1], &binaries[0])
         };
 
-        let base_path = self
-            .find_output_directory_of(repository)
+        let base_path = Self::find_output_directory_of(repository)
             .await
             .expect("Failed to look for output binaries");
         let contract_path = base_path.join(format!("{}.wasm", contract_binary));
@@ -474,7 +470,15 @@ impl ActiveChain {
         let service = Bytecode::load_from_file(service_path)
             .await
             .expect("Failed to load service bytecode from file");
+        (contract, service)
+    }
 
+    /// Returns a tuple with the loaded contract and service [`CompressedBytecode`]s,
+    /// ready to be published.
+    pub async fn find_compressed_bytecode_files_in(
+        repository: &Path,
+    ) -> (CompressedBytecode, CompressedBytecode) {
+        let (contract, service) = Self::find_bytecode_files_in(repository).await;
         tokio::task::spawn_blocking(move || (contract.compress(), service.compress()))
             .await
             .expect("Failed to compress bytecode files")
@@ -486,7 +490,7 @@ impl ActiveChain {
     /// `target/wasm32-unknown-unknown/release` sub-directory. However, since the crate with the
     /// binaries could be part of a workspace, that output sub-directory must be searched in parent
     /// directories as well.
-    async fn find_output_directory_of(&self, repository: &Path) -> Result<PathBuf, io::Error> {
+    async fn find_output_directory_of(repository: &Path) -> Result<PathBuf, io::Error> {
         let output_sub_directory = Path::new("target/wasm32-unknown-unknown/release");
         let mut current_directory = repository;
         let mut output_path = current_directory.join(output_sub_directory);

examples/create-and-call/tests/test_create_and_call.rs

@@ -134,7 +134,6 @@ base64.workspace = true
 call-evm-counter.workspace = true
 counter.workspace = true
 counter-no-graphql.workspace = true
-create-and-call.workspace = true
 criterion = { workspace = true, features = ["async_tokio"] }
 crowd-funding.workspace = true
 ethereum-tracker.workspace = true

linera-sdk/src/test/chain.rs

@@ -1736,80 +1736,6 @@ async fn test_wasm_end_to_end_counter_no_graphql(config: impl LineraNetConfig) -
     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(all(feature = "rocksdb", feature = "scylladb"), test_case(LocalNetConfig::new_test(Database::DualRocksDbScyllaDb, Network::Grpc) ; "dualrocksdbscylladb_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_create_and_call_end_to_end(config: impl LineraNetConfig) -> Result<()> {
-    use create_and_call::{CreateAndCallAbi, CreateAndCallRequest};
-    use linera_base::data_types::Bytecode;
-
-    let _guard = INTEGRATION_TEST_GUARD.lock().await;
-    tracing::info!("Starting test {}", test_name!());
-
-    let (mut net, client) = config.instantiate().await?;
-
-    // Step 1: Download the contract and service of "counter-no-graphql" as Vec<u8>
-    let (counter_contract_path, counter_service_path) =
-        client.build_example("counter-no-graphql").await?;
-    let counter_contract_bytecode = Bytecode::load_from_file(&counter_contract_path).await?;
-    let counter_service_bytecode = Bytecode::load_from_file(&counter_service_path).await?;
-    let contract_bytes = counter_contract_bytecode.bytes;
-    let service_bytes = counter_service_bytecode.bytes;
-
-    // Step 2: Instantiate the contract "create-and-call"
-    let chain = client.load_wallet()?.default_chain().unwrap();
-    let (create_call_contract, create_call_service) =
-        client.build_example("create-and-call").await?;
-
-    let application_id = client
-        .publish_and_create::<CreateAndCallAbi, (), ()>(
-            create_call_contract,
-            create_call_service,
-            VmRuntime::Wasm,
-            &(),
-            &(), // Initial value
-            &[],
-            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?;
-
-    // Step 3: Call a mutation that takes the Vec<u8> of "contract", "service",
-    // the initialization value of 43 and the increment of 5
-    let initialization_value = 43;
-    let increment_value = 5;
-
-    let mutation_request = CreateAndCallRequest::CreateAndCall(
-        contract_bytes,
-        service_bytes,
-        initialization_value,
-        increment_value,
-    );
-
-    application.run_json_query(&mutation_request).await?;
-
-    // Step 4: Query the contract and see if we obtain 48 (43 + 5)
-    let query_request = CreateAndCallRequest::Query;
-    let result_value = application.run_json_query(&query_request).await?;
-    assert_eq!(result_value, 48);
-
-    node_service.ensure_is_running()?;
-    net.ensure_is_running().await?;
-    net.terminate().await?;
-
-    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"))]