Testing Frameworks in denoland/celld: A Complete Runtime Stack Breakdown

The denoland/celld repository uses Rust's built-in test harness with proptest for property-based testing and tokio for async test support.

The celld project is a Rust-based serverless runtime from the Deno ecosystem. Understanding its testing stack helps contributors write effective tests and shows how modern Rust projects combine multiple frameworks for comprehensive coverage. This guide examines the exact testing frameworks used in denoland/celld, where they're configured, and how they work together.

Core Testing Stack Overview

The celld codebase relies on three integrated components rather than a single external framework. This layered approach covers synchronous unit tests, asynchronous runtime behavior, and property-based validation.

Rust's Native #[test] Harness

The foundation is Rust's built-in test framework, activated through standard #[test] attributes and #[cfg(test)] modules. No additional dependencies are required—this is the default for all Rust projects.

#[test]
fn basic_cell_write() {
    // ... test logic ...
}

Tests using this harness appear throughout the crate source files, typically in inline test modules guarded by #[cfg(test)].

Property-Based Testing with proptest

The proptest crate extends celld's testing capabilities with property-based testing, automatically generating diverse inputs to verify protocol correctness.

Where It's Configured

In Cargo.toml at the workspace root, proptest is listed as a development dependency:

[dev-dependencies]
proptest = { version = "1.0", features = ["timeout"] }

This entry appears at lines 105-107 of the workspace manifest.

How It's Used

Property-based tests define invariants that must hold for any valid input, letting proptest generate edge cases that hand-written tests might miss:

use proptest::prelude::*;

proptest! {
    #[test]
    fn write_roundtrip(data: Vec<u8>) {
        // ... verify that a write followed by a read returns the same data ...
    }
}

This approach is particularly valuable for celld's core storage and networking protocols, where unexpected input combinations could expose bugs.

Async Testing with tokio

Since celld is an asynchronous runtime, it needs first-class support for async tests. The tokio crate provides this through the #[tokio::test] attribute macro.

Configuration and Dependencies

tokio appears in the main dependencies list at lines 128-131 of Cargo.toml, with features enabling both runtime functionality and test utilities:

[dependencies]
tokio = { version = "1", features = ["full"] }

Async Test Pattern

Tests that spawn tasks, use async I/O, or interact with the runtime use this pattern:

#[tokio::test]
async fn async_cell_operation() {
    // ... async test logic ...
}

The #[tokio::test] macro automatically sets up a runtime for each test, eliminating boilerplate that would otherwise be required.

Differential Testing Against workerd

Beyond the unit testing stack, celld employs differential testing as described in docs/testing.md (lines 17-24). This strategy compares celld's output against Cloudflare's workerd runtime to ensure compatibility.

Importantly, this verification layer builds on the same standard Rust test framework—it does not introduce additional testing dependencies. The differential approach is implemented as regular test functions that orchestrate both runtimes and assert on behavioral equivalence.

Key Files and Their Roles

File	Purpose
Cargo.toml	Workspace manifest declaring proptest and tokio dependencies
docs/testing.md	Documents testing strategy including differential tests against workerd
Crate source files with #[cfg(test)] modules	Contain concrete unit and async tests

Comparison: When to Use Each Testing Framework in celld

Framework	Best For	Example Use Case
Native #[test]	Simple, synchronous logic	Pure functions, data structure validation
tokio	Async runtime interaction	I/O operations, task scheduling, timers
proptest	Input space exploration	Protocol parsers, serialization roundtrips

Summary

• Rust's built-in harness provides the foundation for all tests in denoland/celld through #[test] and #[cfg(test)].
• proptest enables property-based testing for robust protocol verification, configured in Cargo.toml lines 105-107.
• tokio powers async testing via #[tokio::test], declared at lines 128-131 of the workspace manifest.
• Differential testing against workerd leverages this same stack rather than adding external frameworks.
• This three-layer approach covers synchronous, asynchronous, and generative testing needs without framework sprawl.

Frequently Asked Questions

Does celld use a custom testing framework?

No. Celld uses standard Rust testing infrastructure with two well-known crates. The proptest and tokio dependencies enhance capabilities but do not replace Rust's native test harness.

Where are the testing dependencies declared?

Both proptest and tokio are declared in the workspace-level Cargo.toml. proptest appears under [dev-dependencies] at lines 105-107, while tokio is in [dependencies] at lines 128-131 for runtime and async test support.

How does celld test compatibility with other runtimes?

The project uses differential testing, comparing celld's behavior against Cloudflare's workerd runtime. This is documented in docs/testing.md and implemented as standard Rust tests that orchestrate both systems—no additional testing framework is required for this verification.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}