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

Download the skill as a ZIP:
https://autogineer.com/agent-skills/dotnet/test-analysis-extensions/download

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

File	Languages / Frameworks	Contents
extensions/dotnet.md	.NET (C#/F#/VB) — MSTest, xUnit, NUnit, TUnit	Test markers, assertion APIs, sleep/delay patterns, skip annotations, mystery guest, integration markers, setup/teardown, tag support
extensions/python.md	Python — pytest, unittest	Same categories, with pytest fixtures/markers and unittest TestCase
extensions/typescript.md	TypeScript / JavaScript — Jest, Vitest, Mocha, Jasmine, node:test	Same categories, with async/await pitfalls
extensions/java.md	Java — JUnit 4, JUnit 5 (Jupiter), TestNG	Same categories, with `@Tag` / `@Category` / groups
extensions/go.md	Go — `testing` package, testify	Same categories, with table-driven idiom and build tags
extensions/ruby.md	Ruby — RSpec, Minitest	Same categories, with RSpec metadata and Minitest tags
extensions/rust.md	Rust — built-in `#[test]`, `cargo test`	Same categories, with `#[ignore]`, `#[should_panic]`, feature flags
extensions/swift.md	Swift — XCTest, Swift Testing	Same categories, with `@Test`, `@Tag`, `@Suite`
extensions/kotlin.md	Kotlin — JUnit 5, Kotest, MockK	Same categories, with `@Tag` and Kotest tags
extensions/powershell.md	PowerShell — Pester v5	Same categories, with `-Tag` and `Skip`
extensions/cpp.md	C++ — GoogleTest, Catch2, doctest	Same categories, with `[tags]` and `*` filters

Usage

Detect the target codebase's primary language and test framework.
Read the matching extension file before performing analysis.
If multiple test frameworks are present (e.g., a project mixing Jest and Mocha), read all relevant extensions.
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

ATTRIBUTION.mdAdded by AutoGineer859 B
LICENSELicence file added by AutoGineer1.1 KiB
SKILL.md4.6 KiB
extensions/cpp.md8.4 KiB
extensions/dotnet.md6.7 KiB
extensions/go.md7.4 KiB
extensions/java.md7.5 KiB
extensions/kotlin.md7.2 KiB
extensions/powershell.md6.3 KiB
extensions/python.md6.8 KiB
extensions/ruby.md6.6 KiB
extensions/rust.md7.2 KiB
extensions/swift.md6.8 KiB
extensions/typescript.md7.4 KiB

extensions/python.md

Python Test Frameworks Reference (pytest, unittest)

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

Capability tags

Capability	Support
Test discovery	Strong — convention-driven (`test_.py`, `_test.py`, `Test*` classes)
Assertion detection	Strong — bare `assert`, `unittest` methods, `pytest.raises`
Sleep/delay detection	Strong — `time.sleep`, `asyncio.sleep`
Skip/ignore detection	Strong — `@pytest.mark.skip`, `unittest.skip`
Setup/teardown detection	Strong — fixtures and methods
Tag support	auto-edit — `@pytest.mark.<tag>` (pytest), no canonical syntax in unittest

Test File Identification

Framework	Test file convention	Test method markers
pytest	`test_.py` or `_test.py`	functions starting with `test_`; classes starting with `Test` (no `__init__`) and methods starting with `test_`
unittest	any module (often `test_*.py`)	classes inheriting `unittest.TestCase` with methods starting with `test`

Assertion APIs

Category	pytest	unittest
Equality	`assert x == y`	`self.assertEqual(x, y)`
Inequality	`assert x != y`	`self.assertNotEqual(x, y)`
Boolean	`assert flag` / `assert not flag`	`self.assertTrue(flag)` / `self.assertFalse(flag)`
None	`assert x is None`	`self.assertIsNone(x)` / `self.assertIsNotNone(x)`
Exception	`with pytest.raises(SomeError) as exc_info: ...`	`with self.assertRaises(SomeError): ...`
Type	`assert isinstance(x, T)`	`self.assertIsInstance(x, T)`
Identity	`assert x is y`	`self.assertIs(x, y)`
Membership	`assert item in collection`	`self.assertIn(item, collection)`
Approximate	`assert x == pytest.approx(y, rel=0.01)`	`self.assertAlmostEqual(x, y, places=2)`
String	`assert sub in s` / `assert s.startswith(...)`	`self.assertIn(sub, s)`
Skip	`pytest.skip("reason")`	`self.skipTest("reason")`
Fail	`pytest.fail("reason")`	`self.fail("reason")`

Important: Bare assert is the canonical pytest assertion and produces rich failure diffs via pytest's assertion rewriting. Do NOT flag bare assert as a missing-framework-API smell.

Third-party assertion libraries: assertpy, hamcrest (assert_that), expects.

Sleep/Delay Patterns

Pattern	Example
Sync sleep	`time.sleep(2)`
Async sleep	`await asyncio.sleep(1)`
Loop wait	`while not condition: time.sleep(0.1)`
Trio/anyio	`await trio.sleep(...)`, `await anyio.sleep(...)`

Skip/Ignore Annotations

Framework	Annotation
pytest	`@pytest.mark.skip(reason="...")`, `@pytest.mark.skipif(cond, reason="...")`, `@pytest.mark.xfail(reason="...")`, `pytest.skip("...")` inline
unittest	`@unittest.skip("reason")`, `@unittest.skipIf(cond, "reason")`, `@unittest.skipUnless(cond, "reason")`, `@unittest.expectedFailure`

Exception Handling — Idiomatic Alternatives

# pytest (preferred):
with pytest.raises(ValueError, match=r"must be positive"):
    parse_amount(-5)

# unittest:
with self.assertRaises(ValueError):
    parse_amount(-5)

# To inspect the exception:
with pytest.raises(ValueError) as exc_info:
    parse_amount(-5)
assert "must be positive" in str(exc_info.value)

Flag bare try/except in tests as Exception Handling smell only when no assertion follows or the exception is silently swallowed.

Mystery Guest — Common Python Patterns

Indicator	What to look for
File system	`open()`, `pathlib.Path(...).read_text()`, `os.path.exists`, hard-coded absolute paths
Database	direct `psycopg2`/`mysql.connector`/`sqlite3.connect` to a file path, `SQLAlchemy` engine pointing at a real DB URL
Network	`requests.get/post`, `httpx.get/post`, `urllib.request.urlopen`, raw `socket`
Environment	`os.getenv("X")` (especially without default), `os.environ["X"]`
Acceptable	`io.StringIO` / `io.BytesIO`, `tmp_path` / `tmp_path_factory` pytest fixtures, `monkeypatch.setenv`, `responses` / `httpx.MockTransport`, `pytest-mock`, sqlite `:memory:`

Integration Test Markers

Folder names: tests/integration/, tests/e2e/, tests/acceptance/
Module/class/function names containing Integration, E2E, EndToEnd, Acceptance
@pytest.mark.integration / @pytest.mark.e2e (project-specific markers registered in pytest.ini / pyproject.toml)
Conftest fixtures that spin up containers / databases (testcontainers, docker-compose fixtures)

Setup/Teardown

Framework	Setup	Teardown
pytest	`@pytest.fixture` (any scope), `autouse=True` fixtures	yield-based teardown inside fixture or `request.addfinalizer`
pytest (class)	`setup_method` / `setup_class`	`teardown_method` / `teardown_class`
unittest	`setUp` / `setUpClass` / `setUpModule`	`tearDown` / `tearDownClass` / `tearDownModule`

Tag/Trait Attributes (for `test-tagging`)

Framework	Tag mechanism	Example
pytest	`@pytest.mark.<name>` (project-registered)	`@pytest.mark.positive`, `@pytest.mark.boundary`
unittest	none built-in — use class organization, attributes, or `unittest.skipIf` toggles	(report-only; recommend pytest markers or a project convention)

For pytest, ensure the markers are registered in pyproject.toml / pytest.ini to avoid PytestUnknownMarkWarning:

[tool.pytest.ini_options]
markers = [
    "positive: verifies expected behavior under normal conditions",
    "negative: verifies handling of invalid input or error paths",
    "boundary: tests limits, thresholds, empty/null inputs",
]

Language-specific calibration notes

Bare assert is the pytest idiom — do not flag it as assertion-free.
Snapshot tests (syrupy, pytest-snapshot) replace the assert call with an implicit snapshot compare; treat as a legitimate assertion.
Property-based tests (hypothesis): a @given(...)-decorated function is a real test even if it appears to have no body — the assertions live in the generated input cycles.
Async tests (pytest-asyncio, anyio): missing await on a coroutine call inside the test produces a RuntimeWarning and an effectively assertion-free test. Flag as a critical anti-pattern.
Doctests invoked via --doctest-modules are tests too; treat >>> blocks as test methods if the user includes them in scope.
Parametrized tests (@pytest.mark.parametrize) are not duplicates of the underlying function — treat them as the consolidated form.
Fixtures used by only one test are not General Fixture smells; pytest fixtures are pay-as-you-go (a fixture only runs when a test requests it).

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

2026-11-09

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

Download ZIP

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

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by .NET (Microsoft)

Test Analysis Extensions

Available Extension Files

Usage

Capability tags

Notes for skill authors

Files

extensions/python.md

Python Test Frameworks Reference (pytest, unittest)

Capability tags

Test File Identification

Assertion APIs

Sleep/Delay Patterns

Skip/Ignore Annotations

Exception Handling — Idiomatic Alternatives

Mystery Guest — Common Python Patterns

Integration Test Markers

Setup/Teardown

Tag/Trait Attributes (for test-tagging)

Language-specific calibration notes

Requirements and compatibility

Security

Attribution and licence

Related skills

Setup Matt Pocock Skills

Writing For Agents

Loop Me

Writing Skills

Diagnosing Superpowers

Skill Creator

Download ZIP

Tag/Trait Attributes (for `test-tagging`)