dotnet-test

Plugin dotnet-test from marketplace pmcro-colony in ShawnDelaineBellazanLoop/PMCR-O-Marketplace. Commands read from the repo's manifest — 1 month ago.

Skills (20)

• assertion-quality

  MANDATORY for reviewing assertion strength, depth, and variety in existing tests. Invoke when the user asks whether individual assertions are weak, shallow, trivial, always true, self-referential, or diverse; asks which tests are assertion-free or rely only on presence/truthiness checks; or requests

• code-testing-agent

  MANDATORY ENTRY POINT for generating or writing tests. Invoke this skill before editing files whenever the user asks to generate tests, write/add unit tests, scaffold a test project or suite, improve/achieve coverage, extend an existing suite to cover an untested method, or test an app, API, service

• code-testing-extensions

  Provides file paths to language-specific extension files for the code-testing pipeline. Call this skill to discover available extension guidance files (e.g., dotnet.md for .NET, cpp.md for C++). Do not use directly — invoked by code-testing agents and skills that need language-specific references.

• coverage-analysis

  Project-wide code coverage and CRAP (Change Risk Anti-Patterns) score analysis for .NET projects. Calculates CRAP scores per method and surfaces risk hotspots — complex code with low coverage that is dangerous to modify. Use to diagnose why coverage is stuck or plateaued, identify what methods block

• crap-score

  Calculates targeted CRAP (Change Risk Anti-Patterns) scores for a named .NET method, class, or single source file. Use when the user explicitly asks to compute CRAP scores or assess risky untested code for a specific target, combining Cobertura coverage data with cyclomatic complexity analysis. DO N

• detect-static-dependencies

  Scan C# source files for hard-to-test static dependencies — DateTime.Now/UtcNow, File.*, Directory.*, Environment.*, HttpClient, Console.*, Process.*, and other untestable statics. Produces a ranked report of static call sites by frequency. USE FOR: find untestable statics, scan for static dependenc

• filter-syntax

  Reference data for test filter syntax across all platform and framework combinations: VSTest --filter expressions, MTP filters for MSTest/NUnit/xUnit v3/TUnit, and VSTest-to-MTP filter translation. DO NOT USE directly — loaded by run-tests, mtp-hot-reload, and migrate-vstest-to-mtp when they need fi

• find-untested-sources

  MANDATORY for static requests to find, identify, or list untested source files or modules, sources without tests, source-to-test pairing, test-gap worklists, or suggested test locations. Invoke even for a tiny package; do not substitute manual globbing. Uses Roslyn for C#/.NET and tree-sitter for Py

• generate-testability-wrappers

  Generate wrapper interfaces and DI registration for hard-to-test static dependencies in C#, when the abstraction does NOT exist yet. Produces IFileSystem, IEnvironmentProvider, IConsole, IProcessRunner wrappers, or guides first-time adoption of TimeProvider and IHttpClientFactory. With no DI contain

• grade-tests

  Grades a specified set of test methods individually and produces a concise table mapping each test (fully-qualified name) to a letter grade (A–F), a score band, and a one-line note — designed to be posted as a PR comment. Use when the caller wants per-test feedback on a curated list of methods (for

• migrate-static-to-wrapper

  Replace existing static dependency call sites with a wrapper or built-in abstraction that already exists or is registered in DI, across a bounded scope (file, project, namespace). USE FOR: replace DateTime.UtcNow/DateTime.Now with TimeProvider and add the constructor parameter, migrate static call s

• mtp-hot-reload

  Suggests using Microsoft Testing Platform (MTP) hot reload to iterate fixes on failing tests without rebuilding. Use when user says "hot reload tests", "iterate on test fix", "run tests without rebuilding", "speed up test loop", "fix test faster", or needs to set up MTP hot reload to rapidly iterate

• platform-detection

  Reference data for detecting the test platform (VSTest vs Microsoft.Testing.Platform) and test framework (MSTest, xUnit, NUnit, TUnit) from project files. DO NOT USE directly — loaded by run-tests, mtp-hot-reload, and migrate-vstest-to-mtp when they need detection logic.

• run-tests

  Recommend or run the exact `dotnet test` command. ALWAYS use when the user asks to run, filter, or troubleshoot .NET tests or wants the precise command, flags, or argument order — the right syntax depends on the test platform (VSTest vs Microsoft.Testing.Platform) and SDK version and is easy to get

• test-analysis-extensions

  Provides file paths to language-specific reference files for the test ANALYSIS skills (assertion-quality, test-anti-patterns, test-gap-analysis, test-smell-detection, test-tagging). Call this skill to discover available extension files (e.g., dotnet.md for .NET/MSTest/xUnit/NUnit/TUnit, python.md fo

• test-anti-patterns

  Audits an existing test file or suite in any language for anti-patterns and quality issues — produces a severity-ranked report (Critical/Warning/Info). INVOKE whenever asked to audit or review tests, find what's wrong with a suite, judge whether tests are any good, or check for: tests that pass but

• test-gap-analysis

  Performs pseudo-mutation analysis on production code in any language to find gaps in existing tests. Use when the user asks to find weak or shallow tests, discover untested edge cases, or check whether tests would catch a bug — e.g. \"would my tests catch it if someone changed the code\", \"would a

• test-smell-detection

  Deep-dive audit using the full testsmells.org 19-smell academic catalog for tests in any language. Every finding maps to a named, citable smell from the research literature (Assertion Roulette, Duplicate Assert, Mystery Guest, Eager Test, Sensitive Equality, Conditional Test Logic, Sleepy Test, Magi

• test-tagging

  Analyzes test suites in any language and tags each test with standardized traits (positive, negative, critical-path, boundary, smoke, regression, integration, performance, security). Use when the user wants to categorize, audit, or label tests with traits. Works across .NET (MSTest/xUnit/NUnit/TUnit

• writing-mstest-tests

  Write, create, modernize, or fix comprehensive MSTest unit tests with MSTest 3.x/4.x APIs. USE FOR: write, create, review, or modernize MSTest tests and assertions, better MSTest assertion than Assert.IsTrue, replace hard cast with IsInstanceOfType, MSTest assertion APIs (Contains, ContainsSingle, H

Subagents (10)

• code-testing-builder

  Runs build/compile commands for any language and reports results. Use when: compiling code, running dotnet build, checking for compilation errors, verifying project builds successfully.

• code-testing-fixer

  Fixes compilation errors in source or test files. Use when: resolving build errors, fixing CS/TS error codes, adding missing imports, correcting type mismatches, fixing compilation failures.

• code-testing-generator

  Internal implementation agent for the code-testing-agent skill. Orchestrates the Research-Plan-Implement pipeline after that public entry-point skill delegates a test-generation request. Do not route user prompts here directly. - code-testing-researcher - code-testing-planner - code-testing-implemen

• code-testing-implementer

  Implements a single phase from the test plan. Writes test files and verifies they compile and pass. Use when: executing a plan phase, writing test files, running build-test-fix cycle for generated tests. - code-testing-builder - code-testing-tester - code-testing-fixer - code-testing-linter

• code-testing-linter

  Runs code formatting and linting for any language. Use when: formatting code, running dotnet format, fixing style issues, applying lint fixes.

• code-testing-planner

  Creates structured test implementation plans from research findings. Use when: organizing tests into phases, prioritizing test generation, creating .testagent/plan.md from research.

• code-testing-researcher

  Analyzes codebases to understand structure, testing patterns, and testability. Use when: researching project structure, identifying source files to test, discovering test frameworks and build commands, producing .testagent/research.md.

• code-testing-tester

  Runs test commands for any language and reports pass/fail results. Use when: running dotnet test, executing tests, verifying tests pass, checking test results and failures.

• test-quality-auditor

  Runs multi-skill audit pipelines for comprehensive test suite assessment across a workspace or project, combining assertion quality, test smell detection, mock usage analysis, test gap analysis, coverage risk, and test tagging into unified reports. Polyglot: .NET (MSTest/xUnit/NUnit/ TUnit), Python

• testability-migration

  Orchestrates end-to-end testability migration for .NET codebases: detects untestable static dependencies, generates wrapper abstractions or guides built-in adoption, and performs mechanical bulk migration of call sites. Use when asked to make code testable, remove static coupling, migrate to TimePro