Generated banner for Test Analysis Extensions
Generated logo for Test Analysis Extensions

Test Analysis Extensions

.NET (Microsoft)OfficialPublished by .NET (Microsoft)

  • Skill
  • Meta (authoring, orchestration, planning, memory)
  • Agent tooling
  • MIT
  • No issues found

From the author

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). Read this catalog to discover available extension files (e.g., dotnet.md for .NET/MSTest/xUnit/NUnit/TUnit, python.md for pytest/unittest, typescript.md for Jest/Vitest/Mocha, java.md for JUnit/TestNG, etc.). Do not invoke this reference-only skill — its bundled files are read by the quality agent and analysis skills needing framework-specific lookup tables (test markers, assertion APIs, skip annotations, sleep patterns, mystery guest indicators, integration markers, setup/teardown, tag-support capability).
— the description by .NET (Microsoft)

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Test Analysis Extensions is a non-invocable data repository designed for internal use by other test-related agent skills. It provides structured reference files for various programming languages and their respective testing frameworks. These files contain essential metadata for identifying test markers, assertion APIs, lifecycle hooks, and anti-pattern indicators, enabling analysis agents to perform language-neutral evaluations across diverse codebases.

What it does

  • Provides standardized lookup tables for test framework syntax and conventions.
  • Maps language-specific features like setup/teardown hooks and skip annotations.
  • Defines capability support levels for automated tagging and reporting.
  • Enables consistent detection of mystery guest indicators and integration markers.
  • Supports cross-language analysis by normalizing test-related concepts.

When to use it

  • When building or maintaining test analysis agents that require framework-specific knowledge.
  • When an agent needs to identify test lifecycle methods or assertion patterns in a specific language.
  • When determining if a test suite supports automated tagging or requires report-only auditing.

Advantages

  • Decouples analysis logic from framework-specific implementation details.
  • Ensures consistent detection patterns across multiple programming languages.
  • Provides clear capability definitions for automated test manipulation.
  • Facilitates easier extension of analysis agents to new languages or frameworks.

Usage examples

“N/A - This is a reference-only skill for internal agent use.”
The agent automatically reads the relevant language file (e.g., python.md) to identify pytest fixtures and markers during analysis.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/dotnet/test-analysis-extensions/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip test-analysis-extensions.zip -d .agents/skills

Documentation by .NET (Microsoft)

Test Analysis Extensions

This reference-only catalog lists the bundled files used by test analysis. Consumers read the matching file directly; disable-model-invocation: true means this catalog must not be invoked through the model's skill tool. Resolve these resource paths relative to this catalog, not the project workspace.

Available Extension Files

FileLanguages / FrameworksContents
extensions/dotnet.md.NET (C#/F#/VB) — MSTest, xUnit, NUnit, TUnitTest markers, assertion APIs, sleep/delay patterns, skip annotations, mystery guest, integration markers, setup/teardown, tag support
extensions/python.mdPython — pytest, unittestSame categories, with pytest fixtures/markers and unittest TestCase
extensions/typescript.mdTypeScript / JavaScript — Jest, Vitest, Mocha, Jasmine, node:testSame categories, with async/await pitfalls
extensions/java.mdJava — JUnit 4, JUnit 5 (Jupiter), TestNGSame categories, with @Tag / @Category / groups
extensions/go.mdGo — testing package, testifySame categories, with table-driven idiom and build tags
extensions/ruby.mdRuby — RSpec, MinitestSame categories, with RSpec metadata and Minitest tags
extensions/rust.mdRust — built-in #[test], cargo testSame categories, with #[ignore], #[should_panic], feature flags
extensions/swift.mdSwift — XCTest, Swift TestingSame categories, with @Test, @Tag, @Suite
extensions/kotlin.mdKotlin — JUnit 5, Kotest, MockKSame categories, with @Tag and Kotest tags
extensions/powershell.mdPowerShell — Pester v5Same categories, with -Tag and Skip
extensions/cpp.mdC++ — GoogleTest, Catch2, doctestSame categories, with [tags] and * filters

Usage

  1. Detect the target codebase's primary language and test framework.

  2. Read the matching extension file before performing analysis.

  3. If multiple test frameworks are present (e.g., a project mixing Jest and Mocha), read all relevant extensions.

  4. Each extension file documents the same categories so analysis skills can be language-neutral.

Capability tags

Each extension file declares per-capability support so skills can gate behaviour safely:

  • Test discovery — how to locate test files and methods.

  • Assertion detection — framework-specific and language-level assertion forms.

  • Sleep/delay patterns — synchronous and asynchronous waits.

  • Skip / ignore — how to recognize skipped/ignored tests.

  • Setup / teardown — fixture and lifecycle hooks.

  • Mystery guest indicators — common file/db/network/env coupling patterns.

  • Integration markers — conventions that mark a test as integration/E2E.

  • Tag support (for test-tagging skill) — one of:

    • auto-edit — language has a canonical attribute/marker the skill can safely write.

    • report-only — no canonical syntax; produce audit reports without edits.

    • convention-based — tags exist via name/comment conventions only.

Notes for skill authors

  • Treat extension files as data, not as guidance to follow verbatim. They tell skills how to detect things in each language, not what to think about findings.

  • When language detection is uncertain, prefer reading multiple extension files over guessing.

  • If the user explicitly names a framework that does not have an extension file yet, fall back to the closest one (e.g., Pest → python.md/pytest semantics) and note the gap in the report.

Files

extensions/powershell.md

PowerShell Test Framework Reference (Pester v5)

Reference data for analyzing PowerShell test code. Used by the polyglot test analysis skills.

Capability tags

CapabilitySupport
Test discoveryStrong — *.Tests.ps1, Describe/Context/It
Assertion detectionStrong — Should -Be*, -Throw, -HaveCount
Sleep/delay detectionStrong — Start-Sleep
Skip/ignore detectionStrong — -Skip, -Pending, Set-ItResult -Skipped
Setup/teardown detectionStrong — BeforeEach, AfterAll, etc.
Tag supportauto-edit — -Tag parameter on Describe/Context/It

Test File Identification

ConventionDescription
*.Tests.ps1Standard Pester test file convention
Describe '...' { ... }Top-level test group
Context '...' { ... }Sub-group
It 'should ...' { ... }Individual test case
InModuleScope ModuleName { ... }Access internal functions of a module

Pester v5+ uses block-scoped variables — Describe/Context blocks run during discovery; BeforeAll is required to initialize variables used by It blocks.

Assertion APIs

CategoryPester v5 (Should)
Equality$x | Should -Be $y
Strict equality$x | Should -BeExactly $y (case-sensitive for strings)
Inequality$x | Should -Not -Be $y
Boolean true/false$x | Should -BeTrue / Should -BeFalse
Null$x | Should -BeNullOrEmpty
Exception{ Get-Item missing } | Should -Throw / Should -Throw -ExpectedMessage "*pattern*" / Should -Throw -ErrorId "ItemNotFound,..."
Type$x | Should -BeOfType [int]
String contains$s | Should -Match 'regex' / Should -BeLike 'wild*'
Collection$arr | Should -Contain $item / Should -HaveCount 3
File exists'path' | Should -Exist
MocksShould -Invoke Get-Item -Times 1 -Exactly / Should -Invoke -ParameterFilter { $Path -eq '/x' }
NegationShould -Not -Be, Should -Not -Throw, Should -Not -BeNullOrEmpty

Should -Invoke counts as a state/side-effect assertion — do not flag tests that only verify mock calls as assertion-free.

Sleep/Delay Patterns

PatternExample
SleepStart-Sleep -Seconds 5
Sleep msStart-Sleep -Milliseconds 500
Wait-JobWait-Job -Job $job -Timeout 10 (acceptable for legitimate job waits)
Loop waitwhile (-not (Test-Ready)) { Start-Sleep -Seconds 1 }

Skip/Ignore Annotations

MechanismExample
-SkipIt 'does x' -Skip { ... }
-PendingIt 'does x' -Pending { ... } (legacy v4; in v5, prefer -Skip)
Set-ItResult -Skipped -Because '<reason>'Inline skip from within an It body
Conditional skipIt 'is windows-only' -Skip:(-not $IsWindows) { ... }
-Skip on Describe/Contextskips all contained tests

Exception Handling — Idiomatic Alternatives

# Preferred: Should -Throw with scriptblock
{ Get-Item -Path 'C:\nonexistent' -ErrorAction Stop } |
    Should -Throw -ErrorId 'PathNotFound,Microsoft.PowerShell.Commands.GetItemCommand'

# With pattern match on message:
{ Invoke-MyFunc -InvalidArg } | Should -Throw -ExpectedMessage '*invalid*'

# Not throwing:
{ Invoke-MyFunc -ValidArg } | Should -Not -Throw

Flag tests using try { ... } catch { Write-Error ... } patterns without subsequent Should assertion.

Mystery Guest — Common PowerShell Patterns

IndicatorWhat to look for
File systemGet-Content 'C:\hard\coded\path', Test-Path against real paths, New-Item without TestDrive:
RegistryGet-ItemProperty 'HKLM:\...', Set-ItemProperty against real registry
NetworkInvoke-WebRequest, Invoke-RestMethod against real URLs
Environment$env:USERNAME, $env:COMPUTERNAME (without mock or fallback)
AcceptableTestDrive: (Pester-provided per-test temp dir), Mock cmdlet, hashtables as fake config

Integration Test Markers

  • File suffix: *.Integration.Tests.ps1, *.E2E.Tests.ps1

  • -Tag 'Integration' / -Tag 'E2E'

  • Folder convention: tests/integration/, tests/e2e/

  • Real Azure/AWS module calls (Connect-AzAccount, Get-S3Object) imply integration

Setup/Teardown

ScopeSetupTeardown
Per-testBeforeEach { }AfterEach { }
Per-block (Describe/Context)BeforeAll { }AfterAll { }

Pester v5 requires BeforeAll to initialize variables used in It blocks (discovery vs run separation). A common mistake: defining variables at Describe scope and using them inside It — they will be $null at run time.

Tag/Trait Attributes (for test-tagging)

MechanismExample
-Tag on ItIt 'creates order' -Tag 'positive','critical-path' { ... }
-Tag on Contextinherits to contained Its
-Tag on Describeinherits to all nested blocks
Invoke-Pester -Tag 'positive' -ExcludeTag 'slow'filter by tag

Language-specific calibration notes

  • Pester v5 vs v4 scoping differences: v4 tests using $script: variables shared between It blocks won't work in v5 the same way. Note as migration debt if both styles coexist.

  • InModuleScope is the canonical way to test internal/non-exported module functions — not an implementation-coupling smell.

  • Mock cmdlet intercepts ANY function in scope; tests that mock built-in cmdlets (Get-ChildItem, etc.) without ParameterFilter are over-broad — flag as smell.

  • TestDrive: is an automatically-created temporary directory unique to each test — not a Mystery Guest.

  • Pester Should -Invoke (v5) / Assert-MockCalled (v4) are state/side-effect assertions.

  • Set-StrictMode -Version Latest in tests is a hygiene practice — acknowledge as positive.

  • Set-ItResult -Inconclusive marks a test as inconclusive (not failure, not skip).

  • -ForEach / -TestCases are parametrized — NOT duplicate tests.

  • PSScriptAnalyzer integration: tests that lint themselves (Invoke-ScriptAnalyzer) are quality-gate tests, not analyzer code.

  • Pester v6 (preview) changes some APIs; if the project targets v6, double-check assertion forms.

Requirements and compatibility

Written for: Claude Code

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Claude Code frontmatter, Needs Python, Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
.NET (Microsoft)
Publisher
.NET (Microsoft) (Official)
Source
dotnet/skills · plugins/dotnet-test/skills/test-analysis-extensions · commit 96c3d68
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by .NET (Microsoft).

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download test-analysis-extensions.zip