Lib.rs

assert_cmd

Test CLI Applications

trybuild

Test harness for ui tests of compiler diagnostics

arbitrary

The trait for generating structured data from unstructured data

httpmock

HTTP mocking library for Rust

honggfuzz

Fuzz your Rust code with Google-developped Honggfuzz !

rusoto_mock

AWS SDK for Rust - Request Mocking Helpers

insta

A snapshot testing library for Rust

proptest

Hypothesis-like property-based testing and shrinking

cucumber

Cucumber testing framework for Rust, with async support. Fully native, no external test runners or dependencies.

fantoccini

High-level API for programmatically interacting with web pages through WebDriver

rstest

Rust fixture based test framework. It use procedural macro to implement fixtures and table based tests.

cargo-fuzz

A cargo subcommand for fuzzing with libFuzzer! Easy to use!

test-case

Provides #[test_case(…)] procedural macro attribute for generating parametrized test cases easily

mockall

A powerful mock object library for Rust

testcontainers

A library for integration-testing against docker containers from within Rust

faux

A library to mock structs

httptest

HTTP testing facilities including a mock server

fail

Fail points for rust

cargo-dinghy

Cross-compilation made easier

git-gamble

blend TCR + TDD to make sure to develop the right thing, babystep by babystep

mockito

HTTP mocking for Rust

serial_test

Allows for the creation of serialised Rust tests

thirtyfour

Thirtyfour is a Selenium / WebDriver library for Rust, for automated website UI testing. It supports the full W3C WebDriver spec

cross

Zero setup cross compilation and cross testing

junit-report

Create JUnit compatible XML reports

assert_fs

Filesystem fixtures and assertions for testing

grcov

Rust tool to collect and aggregate code coverage data for multiple source files

bolero-generator

value generator for testing and fuzzing

ntest

Testing framework for rust which enhances the built-in library with some useful features

cargo2junit

Converts cargo’s json output (from stdin) to JUnit XML (to stdout)

stubr-cli

Wiremock implemented in Rust

expectorate

Library for comparing output to file contents with simple updating

quickcheck

Automatic property based testing with shrinking

dylint_testing

Utilities for testing Dylint libraries

relm-test

Testing library for relm

expect-test

Minimalistic snapshot testing library

colored-diff

Format the difference between two strings with ANSI colors

test-strategy

Procedural macro to easily write higher-order strategies in proptest

pact_mock_server

Pact-Rust support library that implements in process mock server

readable-name-generator

Generate a readable name for throwaway infrastructure

mx-tester

A tool to help test Matrix bots and Synapse modules

differ

Differ is a library for finding the differences between two sequences

pact_verifier

Pact-Rust support library that implements provider verification functions

hamcrest2

A port of the Hamcrest testing library. Fork of original hamcrest-rust (which is unmaintained) with extra matchers, better docs etc.

cargo-mutants

Find inadequately-tested code that can be removed without any tests failing

test-log

A replacement of the #[test] attribute that initializes logging and/or tracing infrastructure before running tests

goldentests

A golden file testing library where tests can be configured within the same test file

libc-test

A test crate for the libc crate

inline-c

Write and execute C code inside Rust

libafl_targets

Common code for target instrumentation that can be used combined with LibAFL

fuzzcheck

A modular, structure-aware, and feedback-driven fuzzing engine for Rust functions

qtrac-retest

Retest makes it simple to automate black box regression testing on Windows and Unix

dicetest

Framework for writing tests with randomly generated test data

clevercloud-sdk

A rust client and structures to interact with the Clever-Cloud API

speculoos

Fluent test assertions

galvanic-assert

A comprehensive set of matcher-based assertions and expectations for easier testing. Supports checking properties of numbers, objects, enum variants, collections, panics, and more…

ran

Simple, fast random numbers generation

coppers

Coppers is a custom test harnass that measures the energy usage of your test suite

modelator

A framework and tools for model-based testing

deqp-runner

A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline

tracing-fluent-assertions

An fluent assertions framework for tracing

dockertest

A library to control docker containers when running your integration tests

coman

Easily run and test your programming contest solutions

term-transcript

Snapshotting and snapshot testing for CLI / REPL applications

x86test

Custom test runner for bare-metal x86 tests

nixmodule

Simple qemu wrapper to automatically test out-of-tree linux kernel modules across multiple kernel versions

apollo-smith

A GraphQL test case generator

test-span

macro and utilities to do snapshot tests on tracing spans

runt

A lightweight and parallel snapshot testing framework

mocktopus

Mocking framework for Rust

detect_flake

Run many instances of the same command in parallel to find abnormal behavior or check if a test is flaky

cov-mark

Manual coverage marks

assert-unmoved

A type that asserts that the underlying type is not moved after being pinned and mutably accessed

libcnb-test

An integration testing framework for buildpacks written with libcnb.rs

rstest_reuse

Reuse rstest attributes: create a set of tests and apply it to every scenario you want to test

libtest-mimic

Write your own test harness that looks and behaves like the built-in test harness used by rustc --test

readme-sync

Checks that your readme and documentation are synchronized

parameterized

Procedural macro which brings a compact parameterized testing implementation to Rust (inspired by JUnit @ParameterizedTest)

darkroom

A contract testing tool built in Rust

derive_arbitrary

Derives arbitrary traits

dockertest-server

A test framework built around dockertest for testing against server containers

tracing-test

Helper functions and macros that allow for easier testing of crates that use tracing

fakedata_generator

Generate fake data with various generators

rassert

Fluent, easy-to-extend test assertion library

subunit-rust

A subunit v2 protocol implementation in Rust

assay

A super powered testing macro for Rust

thirtyfour_sync

Thirtyfour is a Selenium / WebDriver library for Rust, for automated website UI testing. This crate is the synchronous version only. For async, see the thirtyfour crate instead.

tux

Test utilities for unit and integration tests

matrix-sdk-test

Helpers to write tests for the Matrix SDK

testcat

Macros for writing more readable tests

lit

Integrated testing tool, inspired by LLVM’s ‘lit’ testing script

nextest-metadata

Structured access to nextest machine-readable output

assert_fn

A proc macro for turning test helper functions into assert! style macros

pact_mock_server_cli

Standalone pact mock server for consumer pact tests

substance-framework

A testing framework designed to work without std, using only core features

testproxy

Tool for end-to-end testing of proxy servers

dinghy-test

Cross-compilation made easier - see main crate cargo-dinghy

otter-webdriver-tests

Otter game system; API tests crate

compiletest_rs

The compiletest utility from the Rust compiler as a standalone testing harness

mock-io

A crate with mock IO stream and listener implementations

json-minimal-tests

Extracts minimal tests from the source codes of a repository when there are differences between the metrics computed before and after an update of a language parser

exec-target

the simple invoke command for test

test_dir

Easy creation of temporary file structure for test purpose

hello_exercism

how to create an own crate

temp-env

Set environment variables temporarily

surf-vcr

Record and replay HTTP sessions for testing surf clients

libafl_cc

Commodity library to wrap compilers and link LibAFL

expectrl

A tool for automating terminal applications in Unix like Don libes expect

audit-filter

Filters npm audit output for use in CI

file_diff

An atomic utility for diffing files in testing

yuuang-test-napi

N-API bindings

ftzz

File Tree Fuzzer creates a pseudo-random directory hierarchy filled with some number of files

mockiato

A strict, yet friendly mocking library for Rust 2018

aliri_clock

Timing utilities used by the aliri family of crates

cucumber-codegen

Code generation for cucumber crate

wasmcloud-test-util

Test tools and utilities for wasmcloud

qutonium

simplify unit testing with a functional testing framework 📈

siderophile

Find the ideal fuzz targets in a Rust codebase

tester

A fork of Rust’s test crate that doesn’t require unstable language features

simple_test_case

A bare bones attribute macro for writing parameterised tests

datatest

Data-driven tests in Rust

pact_matching

Pact-Rust support library that implements request and response matching logic

double

Full-featured mocking library in Rust, including rich failure messages and argument matchers

mock-it

Make mocking reliable

monster-rs

Monster is a symbolic execution engine for 64-bit RISC-U code

stainless2

Organized, flexible testing framework

specker

Testing utility that simplifies file matching against bunch of templates

beacon-verifier

Compliance tool to verify beacon implementations

stubr

Wiremock implemented in Rust

mockstream

Stream (Read+Write traits) implementations to be used to mock real streams in tests

partial-io

Helpers to test partial, interrupted and would-block I/O operations

simulacrum

Minimal library for creating mock objects by hand using stable Rust

ctest2

Automated tests of FFI bindings

demonstrate

Declarative testing framework

junit-test

Converting cargo test output to junit xml

ensc-testsuite

Tool to generate TAP or JUnit reports

shoulds

An intuitive and simple library for writing test assertions in a natural and fluent language

bevy_fuzz

Experimental high-performance fuzz-testing for bevy systems, emulating user UI interaction

test-context

A library for providing custom setup/teardown for Rust tests without needing a test harness

mutagen-plugin

Mutation testing for Rust – mutator plugin

goldie

Simple golden file testing

moq

Mock generator

cucumber_rust_codegen

Code generation for cucumber_rust crate

cargo-libafl

A cargo wrapper to fuzz Rust code with LibAFL

skeptic

Test your Rust markdown documentation via Cargo

sqlx-database-tester

Library for creation of unit / integration tests with sqlx database support

droptest

A helper crate for testing drop-semantics

failpoints

Failpoints for rust. Another fail-rs.

cargo-hongg

Fuzz your Rust code with Google-developped Honggfuzz! Alt implementation of cargo-hfuzz

fn-fixture

Procedural macro designed to quickly generate snapshots of a fixture

marionette

Library implementing the client side of Gecko’s Marionette remote automation protocol

claim

Assertion macros

fluent-asserter

A library write tests assertions with a fluent interface

conf_test

Run configuration tests from build.rs and set available features

rusty-forkfork

Cross-platform library for running Rust tests in sub-processes using a fork-like interface

serial_test_derive

Helper crate for serial_test

datatest-stable

Data-driven tests that work on stable Rust

test-toolbox

This library provides useful macros for unit testing

mock_instant

a simple way to mock an std::time::Instant

bolero

fuzz and property testing front-end

two-rusty-forks

Cross-platform library for running Rust tests in sub-processes using a fork-like interface

factori

A factory library for Rust, inspired by FactoryBot. 🤖

mockers

Mocking library

drop-tracker

Crate to check when a variable gets dropped. Useful for testing wrappers and containers that use unsafe memory management.

expectest

Crate provides matchers and matcher functions for unit testing

easy-assert

A library for readable assertions in your tests

assert_json

json testing made simple

http-test-server

Programatically create resources and pre-defined responses for tests

generic-tests

Procedural macro to define tests and benchmarks generically

otter-api-tests

Otter game system; API tests crates

test-case-macros

Provides #[test_case(…)] procedural macro attribute for generating parametrized test cases easily

hektor

A library for hekkin vectors

uselog-rs

use log for outputing log in test and not test mode with one line code

rusty-ci

A tool to generate buildbot projects from a YAML file

smoke

A framework for testing

tc_cli_client

An implementation of the testcontainers Docker trait that uses the Docker CLI to issue the necessary commands to the docker daemon

ftf

Run functional tests from a variety of formats

polish

Test-Driven Development done right

test_logs

Library to see logs in tests

flutils

Things for fledger that didn’t fit anywhere else

rspec

Write Rspec-like tests with stable rust

repeated-assert

Run assertions multiple times

rusty-fork

Cross-platform library for running Rust tests in sub-processes using a fork-like interface

mockall_derive

Procedural macros for Mockall

libafl

Slot your own fuzzers together and extend their features using Rust

fuzzcheck_mutators_derive

Procedural macros to generate fuzzcheck mutators

x86test-types

Common types for x86test runnter and the x86test procedural macro

diceprop

Mathematical properties for random testing

testdrop

A utility to help test drop implementations

nphysics_testbed3d

Testbed for the 3-dimensional physics engine in Rust

cargo-service-message

Seamless integration of cargo with TeamCity

term-transcript-cli

CLI wrapper for term-transcript

interpolate_name

Simple procedural macro attribute for repetitive tests

circus_test

Procedural macro to inject a seed in your tests

assert-panic

Assert that a panic happens, and optionally what (kind of) panic happens

test4a

Testing library that provides some tools to apply “Advanced” Arrange-Act-Assert testing design

ntest_test_cases

Test cases for ntest framework

ctest

Automated tests of FFI bindings

arbtest

A minimalist property-based testing library based on arbitrary

rst_app

rst: the requirements tracking tool made for developers

passt

passt is a cli tool and library to generate good-enough random passwords

adhesion

A set of macros for design by contact in Rust. The design of this library was inspired by D’s contract programming facilities.

mutagen

Mutation testing for Rust – Support library

doubter

A helper crate for testing Rust code blocks in Markdown

testcontainers-avk

A library for integration-testing against docker containers from within Rust

goldenfile

Simple goldenfile testing library

futures-test-sink

Test utilities for futures::sink

wraptest

A simple way to run code before and after every unit test

test-binary

Build a program in the same crate for integration tests

filecheck

Library for writing tests for utilities that read text files and produce text output

tls-api-test

TLS API without implementation

laboratory

A simple, expressive unit test framework for Rust

pact_mock_server_ffi

Pact mock server interface for foreign languages [DEPRECATED, replaced with pact_ffi]

rusty-driver

A high level async API for controlling a web browser with webdriver

tmac

Macros that help with testing, e.g. asserting float equality

speculate

An RSpec inspired minimal testing framework for Rust

galvanic-test

A testing framework for setting up and tearing up test fixtures/environments with support for parameterised test cases. This crate is part of galvanic—a complete test framework for Rust

libafl_frida

Frida backend library for LibAFL

pseudo

A small mocking library for Rust

quickcheck_derive

Derives quickcheck traits

actix-actor-expect

Utility for unit testing actix actors

cargo-docgen

run and format small doctest snippets

monarch

A (currently) barebones metamorphic testing utility

toml-test

Verify Rust TOML parsers

il2-test-utils

InterlockLedger’s Unit-Test utilities for Rust

nitrokey-test

Supporting test infrastructure for the nitrokey crate and others using it

nafta

Creates temporary SQLite database for testing using diesel

grillon

Grillon offers an elegant and natural way to approach end-to-end HTTP API testing in Rust

anarchist-readable-name-generator-lib

Generate a readable name from something with with famous anarchist writers

blurmock

Bluetooth mock lib for Rust

gha-runner

Run Github Actions workflows locally or on a custom backend

testing_logger

Supports writing tests to verify log crate calls

totems

A collection of assertion macros for unit testing or otherwise

panic-control

Utilities to test code with intentional panics

afterparty

A github webhook server

temp_test

A library for temporary test utils for rust 🔨

trycmd

Snapshot testing for a herd of CLI tests

cargo-suity

Utility to automate test runs and report results in JUnit format

weldmock

Full fake REST API generator

waltz

Extract code blocks from Markdown and save them as files

conformer

A simple framework for authoring conformance test suites

mockery

Generate mock data based on a specification file for a variety of purposes

testwriter

A simple library and tool to generate a function that seeks to reproduce a received dbus signal message. This may be useful in writing unit tests in a TDD workflow.

driftwood

a log on the tide

this_is_a_test

This is a test

assertify

Make tests from simple expressions without boilerplate

siderunner

A library for execution of .side files produced by Selenium IDE

contrafact

A trait for highly composable constraints (“facts”) which can be used both to verify data and to generate arbitrary data within those constraints

temp_testdir

Little crate to use temp directory in crate. You can chose if delete it after use or not to debugging purpose.

chronobreak

Rust mocks for deterministic time testing

cql_storage_type_testing_lib

Testing library for CQL Database storage types

covers

Lightweight library allowing to mock functions in Rust

jsonprima

RFC 8259 compliant JSON validator in Rust

geckodriver

Proxy for using WebDriver clients to interact with Gecko-based browsers

tcp-test

Test your TCP code

frizz

curl alternative written in rust

assert2ify

A one-liner solution to replace assertions in tests by the expressive assertions of the assert2 crate

rustyaid

A small library providing random data for testing puposes

fluid

An human readable test library

merfolk_backend_in_process

A Backend for merfolk using in process channels. Mostly used for testing.

dragondance

Code coverage file format for the dragondance ghidra plugin

pty_closure

Run functions and closures in a pseudoterminal

picterm

TUI image viewer

conjecture

Core engine for Hypothesis implementations

yare

Minimal parameterized testing library for Rust 💖

latte

Macro crate that expands Mocha syntax to standard Rust syntax

maelstrom_rs

A Rust crate to write toy distributed systems with Maelstrom as Actors

invalidstring

just for testing invalid string data

test-cert-gen

Utility to generate certificates for tests (e. g. for TLS)

rs_unit

RsUnit is a testing crate similar to Elixirs ExUnit

tc_parity_parity

Testcontainers image for the parity/parity docker image

pipebuilder_mock

pipebuilder api mock server

egress

A super simple, bare-bones regression testing crate

capture-logger

log implementation for testing

assert-not-modified

Macro which, given a variable and a block of code, executes the block of code and checks that the variable has not changed

borrowing_exerci

how to understand the borrowing in rust

offstage

Runs commands against staged Git files

debug-tag

Debug-only tagging for tracking values

kurtosis-rust-lib

The Rust bindings library for the Kurtosis testing framework

surf-cookie-middleware

surf cookie middleware, does what it says on the tin

kevlar

A simple Test Harness for writing integration / regression tests in Rust

bintest

Testing the executables build by a bin crate

trait_tests

A compiler plugin to allow tests to be defined agaist traits

mockers_codegen

Compiler plugin for ‘mockers’ mocking library

oas3

Structures and tools to parse, navigate and validate OpenAPI v3 specifications

obey

Test utilities for collections

cargo-testify

Tool to automatically run tests on your Rust project and notify about the result

proptest-derive

Custom-derive for the Arbitrary trait of proptest

static_test

Attribute macro for writing tests which check that a given condition ALWAYS holds true or that a given code path is ALWAYS unreachable

assert_panic_free

Assert that some code is panic-free. Fast to compile, no syn or macros etc…

test_deps

Allows developers to define dependencies among tests

phony

generates phony data

awaitility

Awaitility for Rust

icinga-mock

A server mocking icinga responses for testing

flipdot-testing

Tools for testing and debugging Luminator sign communications

afl

Fuzzing Rust code with american-fuzzy-lop

hamcrest

A port of the Hamcrest testing library

tracing-test-macro

A procedural macro that allow for easier testing of crates that use tracing. Internal crate, should only be used through the tracing-test crate

lw-webdriver

A lightweight webdriver client

nextest-filtering

Filtering DSL for cargo-nextest

rifling

A library for creating Github/Gitlab webhook listener

radamsa

Radamsa made available to Rust via FFI

moq_derive

Mock generator (macro implementations)

hawkbit_mock

Mock server implementation of Eclipse hawkBit

data-test

Simple data-test (aka table-test), without custom test to run with your test runner

conformance

Conformance testing for fn(&str) -> impl Serialize

ocaml-boxroot-sys

Bindings for ocaml-boxroot

risect

A simple bisection tool

cargo-bolero

cargo command for running bolero fuzz tests

muc

A test client for UDP multicast

rotor-test

An utility library which helps writing tests for rotor-based applications and libraries

cargo-flake

a tool to detect flakey tests

rust_rest_test

An executable that can be used to run “unit tests” on a rust api

festive

Run your tests in isolation

mutants

Decorator attributes to be used with cargo-mutants

pharaoh

A dead simple functional testing tool for command line applications

snowpatch

continuous integration for patch-based workflows

bintest_helper

Rebuild your binary when unit-testing with e.g. assert_cmd

assert

The package provides assertions for testing

substance-macro

The macro crate for the Substance Framework testing suite

assay-proc-macro

A super powered testing macro for Rust

mockall_double

Test double adapter for Mockall

is-travis

Check if your code is running on Travis CI

cross-test

Native and web testing in a single framework

dinghy-lib

Cross-compilation made easier - see main crate cargo-dinghy

testpath

companinon crate to bintest/testcall, augments Paths for testing

magne-flame

Multi-thread (Multi-process) Extensible fuzzing framework

caplog

Capture log messages for testing

test-fuzz-internal

junitxml2subunit

A tool to convert junitxml files to subunit v2

tc_dynamodb_local

Testcontainers image for local dynamodb

morq

TDD/BDD assertion interface

assert_contains_cli

very simple cli to assert a string is contained or not contained in a stream

quickcheck_seedable

Automatic property based testing with shrinking

waitfor

Retry a function until it succeeds, errors out, or a timeout/deadline is reached

hongg

Fuzz your Rust code with Google-developped Honggfuzz !

catchr-core

Core library of catchr the testing framework

fuzzcheck_common

Common components for both cargo-fuzzcheck and fuzzcheck

test-patience

Synchronize the startup of applications that are part of an integration test

parameterized-macro

Attribute macro crate for parameterized tests

fantoccini-stable

High-level API for programmatically interacting with web pages through WebDriver

ntest_proc_macro_helper

Provide helper functions for the procedural macros used in ntest

test_double

Procedural macro for substituting one type for another when testing

libafl_qemu

QEMU user backend library for LibAFL

reqwest_mock

Provides a mockable reqwest-like HTTP client

rstest_test

Provides some utilities used by to write rstest crate’s tests

stubr-build

Stubr build plugin

cargo-mutagen

Mutation testing for Rust – Runner

galvanic-mock

A behaviour-driven mocking framework for generic traits. Create mocks for (multiple) traits in a behaviour-driven development mocking framework. Define the behaviour of mocks and expected…

two-rusty-forks-macro

Proc-macro library for rusty-fork