Testing, Clippy & Production Patterns

Overview

cargo test is the behavior gate. rustc already refused the memory bugs. clippy refuses a class of designs that still compile. rustfmt keeps the diff about the change. Public APIs take wide inputs, return Result, and document any panic.

Comparative

flowchart TB
  A["Step 1 Unit tests in a cfg(test) module Ready"]
  B["Step 2 Integration tests in tests/ - public API only Ready"]
  C["Step 3 Doc tests run the examples Ready"]
  D["Step 4 cargo clippy -D warnings Ready"]
  E["Step 5 cargo fmt --check Ready"]
  F["Step 6 All gates green Ready"]
  G["Step 7 Merge and release Ready"]
  X["Failure path - CI blocks the merge Ready"]
  A -->|continues| B
  B -->|continues| C
  C -->|continues| D
  D -->|continues| E
  E -->|continues| F
  F -->|yes| G
  F -->|no| X

Press Run. Snippets must be self-contained — no network, files, or native modules.

Rosetta — a unit test

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn adds() {
        assert_eq!(add(2, 2), 4);
    }
}

export function add(a: number, b: number): number {
  return a + b;
}
if (add(2, 2) !== 4) throw new Error("add");

def add(a: int, b: int) -> int:
    return a + b

def test_adds() -> None:
    assert add(2, 2) == 4

The Rust module can see add even if it were private. A file under tests/ could not. TypeScript and pytest tests are arranged by the runner, not by a cfg gate inside the compiler.

Rosetta — a fallible API under test

pub fn parse_port(s: &str) -> Result<u16, std::num::ParseIntError> {
    s.parse()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses() {
        assert_eq!(parse_port("8080").unwrap(), 8080);
    }
}

export function parsePort(s: string): number {
  const n = Number.parseInt(s, 10);
  if (Number.isNaN(n)) throw new Error(s);
  return n;
}

def parse_port(s: str) -> int:
    return int(s)

def test_parse_port() -> None:
    assert parse_port("8080") == 8080

unwrap in the test is fine. unwrap in parse_port would be the library bug from the error-handling page.

Rosetta — the three commands

cargo fmt --check
cargo clippy -- -D warnings
cargo test

npx prettier --check .
npx eslint .
npx tsc --noEmit

ruff format --check .
ruff check .
pytest

clippy is semantic. An allow attribute is debt. rustfmt is the formatter, closer to prettier or ruff format.

Production checklist

1. edition = "2024" and a rust-version MSRV, with CI on rustc 1.98.1 or newer.
2. Features stay intentional.
3. Libraries log through a facade, not println.
4. Typed errors inside the crate, context at the binary.
5. CI runs fmt, clippy with warnings denied, and test.
6. Examples exist for the public API.
7. Release profile for binaries you benchmark.
8. Audit dependencies.
9. Timeouts and shutdown for anything that serves.
10. SemVer and a license.

Interview Q&A

Pitfalls

• Only testing private helpers.
• Allowing clippy instead of changing the clone.
• A public function that panics on ordinary input.
• A path argument that requires PathBuf.
• Default features that pull a runtime.

Go Deeper

• The Book — Writing Automated Tests
• Rust API Guidelines
• Clippy