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

Step 3: Apply calibration rules

Before reporting, filter findings through these rules:

• Only report at 3+ occurrences. Two similar setups are not boilerplate — they may be intentional clarity.

• Don't flag simple constructors. new Calculator() or new List<int>() is not meaningful boilerplate. Don't recommend builders for new User(1, "Alice") either.

• Respect intentional verbosity. If each test is self-contained and reads clearly on its own, explicit setup per test is a valid choice. Note it but don't flag it as a problem.

• Distinguish structural similarity from true duplication. Tests that follow AAA (Arrange-Act-Assert) will look similar by nature. Only flag when the actual code (not just the structure) is duplicated.

• Consider the blast radius of refactoring. A helper shared across 20 tests creates coupling. Note the trade-off.

• If tests are already well-maintained, say so. A report finding only minor opportunities is perfectly valid. Acknowledge what's already good.

Step 4: Report findings

Present findings in this structure:

1. Summary — How many patterns found, broken down by category. If the test suite is clean, lead with that.

2. Findings by category — For each pattern found:

   • Category name and description

   • Locations: list the specific test methods and files involved

   • The duplicated code pattern (show a representative sample)

   • Suggested refactoring with a concrete before/after example

   • Estimated impact: how many lines/methods would be simplified

3. Refactoring priority — Rank findings by:

   • Occurrence count (more occurrences = higher value)

   • Complexity of the duplicated code (complex setup > simple construction)

   • Risk (low-risk extractions first)

4. Trade-offs — For each suggestion, note:

   • What readability is gained

   • What locality/independence is lost

   • Whether it's worth it given the occurrence count

Validation

• [ ] Every finding includes specific file and method locations

• [ ] Every finding shows the actual duplicated code, not just a description

• [ ] Every suggestion includes a concrete before/after example

• [ ] Findings are filtered through the 3+ occurrence threshold

• [ ] Simple constructors are not flagged

• [ ] Trade-offs are acknowledged for each suggestion

• [ ] If tests are clean, the report says so upfront

Common Pitfalls