Integration Tests

Integration tests are tests that include the integration between components, and so test a larger scope such as other contracts.

The Soroban Rust SDK makes it just as easy to integration test by providing utilities for testing against real contracts fetched from mainnet, testnet, or the local file system.

How to Write Integration Tests

The following is an example of a test that includes a dependency contract into the test, rather than mock it. The test is written to test the increment-with-pause contract and the pause contract. The contract has an increment function that increases a counter value by one on every invocation. The contract depends on the pause contract to control whether the increment functionality is paused.

The following tests set up the increment-with-pause contract, as well as import and register the real pause contract using it's wasm file.

1. Use the [stellar contract fetch] command to fetch the dependency contract that's already deployed on testnet or mainnet.

   stellar contract fetch --id C... > pause.wasm

2. Import the contract into the tests with the contractimport! macro.

   mod pause {
       soroban_sdk::contractimport!(file = "pause.wasm");
   }

3. Write a test similar to the following that registers not only the increment-with-pause contract, but also the pause contract that was imported. The test checks that when the pause contract is not paused that the increment contract operates as expected. When it is paused, the increment function errors. Once it's unpaused the function operates as expected.

   #[test]
   fn test() {
       let env = Env::default();
   
       let pause_id = env.register(pause::WASM, ());
       let pause_client = pause::Client::new(&env, &pause_id);
   
       let contract_id = env.register(
           IncrementContract,
           IncrementContractArgs::__constructor(&pause_id),
       );
       let client = IncrementContractClient::new(&env, &contract_id);
   
       pause_client.set(&false);
       assert_eq!(client.increment(), 1);
   
       pause_client.set(&true);
       assert_eq!(client.try_increment(), Err(Ok(Error::Paused)));
   
       pause_client.set(&false);
       assert_eq!(client.increment(), 2);
   }

Most tests, whether they're unit, mocks, or integration tests, will look very similar to the test above. The tests will do four things:

1. Create an environment, the Env.
2. Register the contract(s) to be tested.
3. Invoke functions using the generated client.
4. Assert the outcome.