.NET Agent Skills

The dotnet-test plugin provides skills and agents for running, generating, analyzing, and improving tests. While originally built for .NET (MSTest, xUnit, NUnit, TUnit), many of its core features are polyglot and support multiple languages including Python, TypeScript/JavaScript, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, and C++.

Key Capabilities:

• Test Execution: Run .NET tests with automatic detection.
• Test Generation: Scaffold unit tests for any language via a multi-agent pipeline.
• Test Quality Audit: Detect anti-patterns, smells, and assertion gaps (polyglot).
• Coverage & Risk: Collect code coverage and compute CRAP scores (.NET only).
• Testability Improvement: Identify and fix hard-to-test static dependencies (.NET only).

Note: Test framework/platform migration (e.g., xUnit to MSTest) is handled by the separate dotnet-test-migration plugin.

The technology-selection skill provides guidance for selecting and implementing AI and Machine Learning features in .NET 8+ applications. It covers a spectrum ranging from classic ML (classification, regression, clustering) to modern LLM orchestration (RAG pipelines, agentic workflows, tool calling) and local inference.

Supported Technologies

• ML.NET: Classic machine learning tasks.
• Microsoft.Extensions.AI (MEAI): Standardized AI abstractions.
• Microsoft Agent Framework (MAF): Agentic workflows.
• GitHub Copilot SDK: Building Copilot extensions.
• ONNX Runtime: Custom model inference.
• OllamaSharp: Local LLM integration.

Requirements and Constraints

• Target Framework: Requires .NET 8+. This skill is not for .NET Framework projects.
• Scope: Use this for AI/ML features. Do not use it for pure data engineering/ETL tasks without an ML component.
• Deep Learning Training: If you need to train custom deep learning models from scratch, use Python (PyTorch/TensorFlow) and export to ONNX for .NET inference; this skill is for selection and implementation, not training loops.

The .NET test generation pipeline is a multi-stage process designed to automate the creation of unit tests for C# projects. It consists of several specialized agents that move from research to implementation:

1. code-testing-researcher: Analyzes the codebase to produce a research report (.testagent/research.md). It identifies the project structure, language version (.NET 9), test framework (e.g., MSTest), build/test commands, and prioritizes files for testing based on business logic density.
2. code-testing-planner: Consumes the research output to create a structured implementation plan (.testagent/plan.md). This plan breaks down testing into phases, specifies which methods to cover (happy paths, edge cases, error scenarios), and defines success criteria.
3. code-testing-implementer: Generates the actual test code (e.g., .cs files) based on the plan. It uses patterns like AAA (Arrange, Act, Assert) and mocking libraries (like Moq) to handle dependencies.
4. code-testing-fixer: Automatically diagnoses and resolves build errors or test failures encountered during the implementation phase (e.g., missing NuGet packages or incorrect constructor arguments).
5. code-testing-generator: Finalizes the process by producing a comprehensive Test Generation Report summarizing metrics, coverage, and build validation results.

The test-gap-analysis skill performs static pseudo-mutation analysis on production code in any supported language to identify gaps in existing tests. Unlike standard code coverage, which only tracks if a line was executed, this skill reasons about hypothetical mutations (e.g., boolean flips, boundary changes, null returns) to determine if existing tests would actually fail if the code were broken.

Use Cases

• Evaluating if tests are strong enough to catch subtle bugs or logic changes.
• Finding "blind spots" where tests pass even if the code is incorrect.
• Identifying weak or shallow tests.
• Prioritizing which tests need to be strengthened.
• Serving as a self-review step for test-generation agents to verify the effectiveness of newly generated tests.

Supported Languages

Polyglot support includes: .NET, Python, TS/JS, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, and C++.

Inputs

• Production code (Required): The source files to analyze for mutation points.
• Test code (Required): The test files that cover the production code.
• Focus area (Optional): A specific mutation category or code region to focus on.

The writing-mstest-tests skill is designed to help you write, create, modernize, or fix comprehensive MSTest unit tests using MSTest 3.x/4.x APIs.

Use this skill when you want to:

• Write new MSTest unit tests from scratch.
• Modernize existing MSTest tests (e.g., replacing Assert.IsTrue with specific assertions like Contains, IsInstanceOfType, or MatchesRegex).
• Fix swapped Assert.AreEqual arguments (ensure Expected is first and Actual is second).
• Replace ExpectedException with Assert.Throws.
• Implement data-driven tests using DataRow, DynamicData, or ValueTuples.
• Manage test lifecycles using TestInitialize, TestCleanup, or TestContext.
• Implement async/cancellation patterns or conditional execution/retry logic.
• Fix MSTest analyzer diagnostics (MSTESTxxxx).

Do NOT use this skill for:

• Test quality audits or anti-pattern detection (use test-anti-patterns).
• Running or executing tests (use run-tests).
• Migrating MSTest versions (use migrate-mstest-v1v2-to-v3 or migrate-mstest-v3-to-v4).
• Testing with xUnit, NUnit, or TUnit.