test-coverage-advisor

Identify gaps in Rust test coverage and suggest missing test cases.

2|1|Updated Oct 31, 2025
One-click install
npx skills add https://github.com/EmilLindfors/claude-marketplace --skill test-coverage-advisor
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: test-coverage-advisor
Source: https://github.com/EmilLindfors/claude-marketplace/tree/main/plugins/rust-testing/skills/test-coverage-advisor
Command: npx skills add https://github.com/EmilLindfors/claude-marketplace --skill test-coverage-advisor

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps ensure comprehensive test coverage by identifying missing cases, error-path tests, and edge cases in Rust code.

Core Features & Use Cases

  • Success Path Testing: ensures happy path tests exist.
  • Error Path Testing: adds tests for error variants.
  • Edge Cases: boundary-case tests for empty collections and large inputs.
  • Async Function Testing: patterns for async tests.

Quick Start

Add tests for error paths and edge cases; run with cargo nextest for best results.

Frequently Asked Questions about test-coverage-advisor

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify missing test cases in my Rust code?

Test coverage analysis examines your existing Rust tests against source code to reveal gaps in success paths, error handling, edge cases, and async scenarios. This Skill scans your repository to pinpoint untested code branches and suggests concrete test templates you can implement immediately.

What types of tests does Rust coverage analysis typically miss?

Common coverage gaps include error path tests for Result and Option variants, boundary cases like empty collections and maximum values, async function behavior under concurrent load, and table-driven test patterns. This Skill identifies these specific gaps and provides templates tailored to your codebase.

How do I test async functions effectively in Rust?

Async test coverage requires patterns that verify concurrent execution, timeout handling, and cancellation behavior. This Skill suggests async-specific test templates and integration patterns compatible with cargo-nextest, ensuring your async code behaves correctly under real concurrency conditions.

Can I use this coverage analysis with cargo-nextest?

Yes. This Skill is optimized for cargo-nextest, Rust's modern test runner, and provides test templates that integrate seamlessly with it. Running your suggested tests through cargo-nextest gives accurate coverage metrics and faster test execution.

What do I need before I can analyze test coverage gaps?

You need a Rust repository with existing source code and test modules. This Skill uses Grep and Glob to locate and read your code and tests, then generates coverage suggestions without requiring additional tooling or configuration beyond a standard Rust project.

Why should I test error paths separately from success paths?

Error path testing ensures your error handling logic actually executes and behaves correctly. Testing error variants, recovery mechanisms, and edge cases separately from happy-path tests prevents production failures and ensures robust error handling in your Rust applications.