Remote Workshop: Testing for Rust projects – going beyond the basics

No application is an island: you need to interact with third-party APIs, databases and who knows what else. Testing those interactions is tricky, to say the least! This workshop will focus on expanding your Rust testing toolkit, going beyond the basic techniques you're already familiar with. At the end of the session, you'll have a strategy to test most of the scenarios that are relevant for a complex Rust application.

The workshop is designed for software developers who have a good understanding of Rust's basic concepts and want to move beyond the built-in testing toolkit.


Additional Information

Mainmatter Workshop: Testing for Rust projects – going beyond the basics

Duration & location

The workshop takes place over two afternoons on April 15th, and 16th, 14:00 to 18:00 CET each. That allows participants to use the mornings to exercise or keep up with work.

The workshop is run completely online and remote.

Number of participants

To ensure the highest quality, we accept up to 15 participants.

For whom?

The workshop is designed for software developers who have a good understanding of Rust’s basic concepts and want to move beyond the built-in testing toolkit.


We will send a detailed list of instructions for preparation, including the installation of tools, etc. Additionally, we will share a Github project with workshop materials. This information will be provided closer to the workshop date.

Workshop Contents

Part I: Expanding your testing toolbox

  1. Better assertions: The Rust standard library provides a few macros to perform assertions in your tests: assert!, assert_eq!, etc. They are good enough to get started, but the error messages they produce will often fail to keep up with the complexity of your assertions: we’ll explore different libraries to boost the clarify of your test failures.
  2. Snapshot testing: Snapshot testing is a technique that allows us to capture the output of a system under test and compare it with a previously saved version. It is quite useful when working with complex data that might change frequently, such as HTML or error messages. We will explore how to use the insta crate to implement snapshot testing and manage the snapshots lifecycle.

Part II: Isolating your tests

  1. Filesystem: All tests in Rust share the same filesystem as the underlying host, a problematic situation when multiple tests want to interact with the “same” files or touch directories that could affect the behavior of the system they are being executed from. We will explore various techniques to manage this scenario, including the tempfile crate.
  2. The database: The database is another shared resource that can cause problems when running tests in parallel. We will explore how to use Docker to run an isolated database instance for each test, and how to use the sqlx crate to manage the database lifecycle.
  3. HTTP mocking: It is undesirable to have tests that hit real HTTP endpoints from third-party APIs, for a variety of reasons. We will explore how to use the wiremock crate to shield our tests from the outside world and make assertions on the HTTP requests that are being sent.
  4. Mocks, stubs, and fakes: In order to isolate the behavior of a system under test, it is not unusual to replace some of its dependencies with “fake” implementations. We will explore the different types of fakes and how to use them in Rust. We will review, in particular, the mockall crate and the testing implications of using generics and dynamic dispatch for polymorphism.

Part III: Custom test runners

  1. What is a test?: We will take a look under the hood to understand how the Rust built-in testing framework works. Armed with this knowledge, we will explore the runtime implications of different approaches for test organization. We will also cover alternative test runners, such as cargo-nextest.
  2. Executing logic before and after a test run: It is often desirable to execute the same logic before and after each test in our suite. We will explore a variety of techniques to achieve this, from a bespoke #[test_case] procedural macro to a custom test harness (via libtest_mimic).
  3. Capstone project: We will combine everything we have learned so far into an easy-to-use setup that allows you to run black-box tests against a real database and a real HTTP server, without having to orchestrate multiple commands—just cargo test and you are good to go!

Workshop facilitator

Luca Palmieri builds technology products for a living and is Mainmatter's Principal Engineering Consultant. His current focus is on backend development, software architecture and the Rust programming language. He is the author of "Zero to Production in Rust" and Mainmatter's Rust expert.

About Mainmatter

Mainmatter is a consultancy that focuses on Rust on the backend: APIs, data pipelines and web solutions. We offer strategic advice, training, and team reinforcement. We also organize the EuroRust conference.