xUnit Migration: Exception property access (.Message, .ParamName) not properly converted

[thomhurst]

Description

When using the TUnit xUnit migration code fixer (TUXU0001), the fixer incorrectly attempts to access exception properties like .Message, .ParamName, .InnerException on ThrowsAssertion<T> objects rather than on the captured exception instance itself, resulting in CS1061 compilation errors.

Steps to Reproduce

1. Create an xUnit test that captures and inspects an exception:

using Xunit;

[Fact]
public void Test_Exception_Message()
{
    var ex = Assert.Throws<ArgumentException>(() => ThrowException());
    Assert.Equal("param", ex.ParamName);
    Assert.Contains("error occurred", ex.Message);
}

2. Install TUnit package and run dotnet format analyzers --severity info --diagnostics TUXU0001

Expected Behavior

The code should be converted to properly capture the exception and access its properties:

[Test]
public async Task Test_Exception_Message()
{
    var ex = await Assert.That(() => ThrowException()).Throws<ArgumentException>();
    await Assert.That(ex.ParamName).IsEqualTo("param");
    await Assert.That(ex.Message).Contains("error occurred");
}

Or use a different pattern that allows property access on the captured exception.

Actual Behavior

The code is converted to:

[Test]
public async Task Test_Exception_Message()
{
    var ex = awaitAssert.ThrowsAsync<ArgumentException>(() => ThrowException());
    await Assert.That(ex.ParamName).IsEqualTo("param");  // ex is ThrowsAssertion, not ArgumentException
    await Assert.That(ex.Message).Contains("error occurred");
}

This causes multiple errors:

error CS1061: 'ThrowsAssertion<ArgumentException>' does not contain a definition for 'ParamName'
error CS1061: 'ThrowsAssertion<ArgumentException>' does not contain a definition for 'Message'

Properties Affected

The following exception properties commonly accessed after Assert.Throws<T>() are not properly handled:

• .Message
• .ParamName (for ArgumentException)
• .InnerException
• .StackTrace
• Custom exception properties (like .IsVerificationError in Moq's MockException)
• .Reasons (custom properties)

Impact

This is a compound issue with the awaitAssert problem, but even if awaitAssert were defined correctly, the pattern of capturing an exception and accessing its properties would need different handling.

In the Moq test suite, this resulted in 200+ compilation errors for various exception property accesses.

Environment

• TUnit Version: 1.9.91
• .NET SDK: 10.0.101
• OS: Windows

[claude]

Analysis

Type: Bug Report
Priority: High
Duplicate: No (distinct from #4331)

This issue reports that the TUXU0001 code fixer incorrectly handles exception property access after Assert.Throws calls. The fixer generates code that attempts to access exception properties (like .Message, .ParamName, .InnerException) on ThrowsAssertion objects instead of on the captured exception itself.

Related Issues

• xUnit Migration: Assert.Throws converted to undefined 'awaitAssert.ThrowsAsync' #4331 - Undefined 'awaitAssert' variable (closely related, same code pattern)
• xUnit Migration: Summary of code fixer issues found during Moq migration #4336 - Summary issue tracking all migration problems
• Part of a series: xUnit Migration: Code fixer does not add 'using System.Threading.Tasks;' directive #4330, xUnit Migration: Assert.Throws converted to undefined 'awaitAssert.ThrowsAsync' #4331, xUnit Migration: Record.Exception() pattern not converted #4332, xUnit Migration: Assert.Same converted to non-existent IsSameReference method #4333, xUnit Migration: Exception property access (.Message, .ParamName) not properly converted #4334, xUnit Migration: Assert.All converted to non-existent AllSatisfy method #4335

Impact

• 200+ compilation errors in Moq test suite migration
• Blocks proper exception testing pattern migration
• Affects common exception properties: .Message, .ParamName, .InnerException, .StackTrace, and custom properties

Technical Root Cause

The code fixer needs to:

1. Generate correct syntax (await Assert.That(...).Throws not awaitAssert.ThrowsAsync)
2. Ensure the return type is the exception type T, not ThrowsAssertion
3. Properly handle the async/await pattern for TUnit assertions

Label applied: bug

[thomhurst]

Fixed in PR #4367. The xUnit migration code fixer now properly handles exception property access by converting Assert.Throws<T>() to the correct pattern that returns the exception instance.