Exp Test Maintainability

Test Maintainability Assessment

Analyze .NET test code for maintainability issues: duplicated boilerplate, copy-paste test methods, and structural repetition across test methods and classes. Produce a report of refactoring opportunities with concrete before/after suggestions. The goal is analysis only — do not modify any files.

When to Use

• User asks to find duplicated code or boilerplate in tests
• User wants to know where test code can be DRY-ed up
• User asks to reduce test duplication, improve test readability, or clean up test boilerplate
• User asks for refactoring opportunities in a test suite
• User wants to identify shared setup or teardown candidates
• User asks "what patterns repeat across my tests?"
• User wants to centralize test data, introduce builders or helpers

When Not to Use

• User wants to write new tests from scratch (use writing-mstest-tests)
• User wants to detect anti-patterns or code smells (use test-anti-patterns)
• User wants to actually perform the refactoring (help them directly, this skill only analyzes)

Inputs

Workflow

Step 1: Gather the test code

Read all test files the user provides or references. If the user points to a directory or project, scan for all test files using these framework markers:

Step 2: Identify maintainability issues

Scan for these categories:

Category 1: Repeated object construction

Look for the same object being constructed in 3+ test methods with identical or near-identical parameters.

Indicators:

• new ClassName(...) appearing with identical arguments in multiple tests
• Multiple tests creating the same "system under test" with similar configuration
• Repeated mock/fake/stub creation with the same setup

Potential refactorings:

• Extract a factory method or test helper (e.g., CreateSut(), CreateDefaultOrder())
• Use [TestInitialize]/constructor/[SetUp] for shared construction
• Introduce a builder pattern for complex objects with many variations

Example — before:

[TestMethod]
public void Process_ValidOrder_Succeeds()
{
    var logger = new FakeLogger();
    var email = new FakeEmailService();
    var inventory = new FakeInventory(stock: 100);
    var processor = new OrderProcessor(logger, email, inventory);
    // ...
}

[TestMethod]
public void Process_EmptyItems_Fails()
{
    var logger = new FakeLogger();
    var email = new FakeEmailService();
    var inventory = new FakeInventory(stock: 100);
    var processor = new OrderProcessor(logger, email, inventory);
    // ...
}

After — extract factory:

private static OrderProcessor CreateProcessor(int stock = 100)
{
    return new OrderProcessor(new FakeLogger(), new FakeEmailService(), new FakeInventory(stock));
}

Category 2: Repeated assertion patterns

Look for the same sequence of assertions appearing in 3+ test methods.

Indicators:

• Multiple tests asserting the same set of properties on a result object
• Repeated null-check-then-value-check sequences
• Same collection of Assert.AreEqual calls across methods

Potential refactorings:

• Extract a custom assertion helper (e.g., AssertValidOrder(order, expectedTotal, expectedStatus))
• Use framework-specific assertion extensions
• Introduce a Verify method that checks a standard set of properties

Category 3: Copy-paste test methods

Look for test methods with near-identical bodies differing only in input values or a single parameter.

Indicators:

• 3+ methods with the same structure but different literal values
• Methods that could be collapsed into [DataRow]/[Theory]/[TestCase]
• Test names that follow a pattern like Method_Input1_Result, Method_Input2_Result

Potential refactorings:

• Convert to parameterized tests with [DataRow]/[InlineData]/[TestCase]
• Use [DynamicData]/[MemberData]/[TestCaseSource] for complex inputs
• Prefer [DataRow] with DisplayName over [DynamicData] when all values are compile-time constants. Reserve [DynamicData] for computed or complex values.
• Add DisplayName for non-obvious parameter values. [DataRow("Gold", 100.0, 90.0)] is self-explanatory; [DataRow(3, 7, 42)] is not.

Category 4: Duplicated setup/teardown logic

Look for initialization or cleanup code repeated across test classes.

Indicators:

• Multiple [TestInitialize]/[SetUp] methods with similar bodies
• Repeated database seeding, file creation, or HTTP client configuration
• Same using/IDisposable cleanup pattern across classes

Potential refactorings:

• Extract a shared test base class or fixture
• Use composition with a shared helper class
• Create a test context factory

Category 5: Repeated test infrastructure

Look for structural patterns shared across test classes.

Indicators:

• Same mock interfaces configured identically in multiple classes
• Repeated HttpClient setup with similar DelegatingHandler patterns
• Same logging/configuration scaffolding across test classes

Potential refactorings:

• Extract a shared test fixture or helper library
• Create reusable fake implementations
• Introduce a test harness class