Fix ArgumentDisplayFormatter being ignored - invalidate cache after d…

…iscovery

Co-authored-by: thomhurst <[email protected]>

TUnit.Core/TestContext.cs

@@ -242,6 +242,15 @@ public string GetDisplayName()
         return _cachedDisplayName;
     }
 
+    /// <summary>
+    /// Clears the cached display name, forcing it to be recomputed on next access.
+    /// This is called after discovery event receivers run to ensure custom argument formatters are applied.
+    /// </summary>
+    internal void InvalidateDisplayNameCache()
+    {
+        _cachedDisplayName = null;
+    }
+
     public Dictionary<string, object?> ObjectBag => _testBuilderContext.ObjectBag;
 
     public bool ReportResult { get; set; } = true;

TUnit.Engine/Building/TestBuilder.cs

@@ -802,6 +802,11 @@ public async Task<AbstractExecutableTest> BuildTestAsync(TestMetadata metadata,
 
         await InvokeDiscoveryEventReceiversAsync(context);
 
+        // Clear the cached display name after discovery events
+        // This ensures that ArgumentDisplayFormatterAttribute and similar attributes
+        // have a chance to register their formatters before the display name is finalized
+        context.InvalidateDisplayNameCache();
+
         return test;
     }
 

TUnit.TestProject/ArgumentDisplayFormatterTests.cs

@@ -0,0 +1,72 @@
+using TUnit.TestProject.Attributes;
+
+namespace TUnit.TestProject;
+
+[EngineTest(ExpectedResult.Pass)]
+public class ArgumentDisplayFormatterTests
+{
+    [Test]
+    [MethodDataSource(nameof(Data1))]
+    [ArgumentDisplayFormatter<FooFormatter>]
+    public async Task FormatterShouldBeAppliedToMethodDataSource(Foo foo)
+    {
+        // Verify the formatter was applied by checking the display name
+        var displayName = TestContext.Current!.GetDisplayName();
+        await Assert.That(displayName).IsEqualTo("FormatterShouldBeAppliedToMethodDataSource(FooFormatterValue)");
+    }
+
+    [Test]
+    [Arguments(1, 2, 3)]
+    [ArgumentDisplayFormatter<IntFormatter>]
+    public async Task FormatterShouldBeAppliedToArguments(int a, int b, int c)
+    {
+        // Verify the formatter was applied by checking the display name
+        var displayName = TestContext.Current!.GetDisplayName();
+        await Assert.That(displayName).IsEqualTo("FormatterShouldBeAppliedToArguments(INT:1, INT:2, INT:3)");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(DataWithException))]
+    [ArgumentDisplayFormatter<BarFormatter>]
+    public async Task FormatterShouldPreventExceptionInToString(Bar bar)
+    {
+        // The Bar.ToString() throws, but the formatter should prevent that
+        var displayName = TestContext.Current!.GetDisplayName();
+        await Assert.That(displayName).IsEqualTo("FormatterShouldPreventExceptionInToString(BarFormatterValue)");
+    }
+
+    public static IEnumerable<Foo> Data1() => [new Foo()];
+
+    public static IEnumerable<Bar> DataWithException() => [new Bar()];
+}
+
+public class Foo
+{
+    public override string ToString() => throw new Exception("Foo.ToString should not be called");
+}
+
+public class Bar
+{
+    public override string ToString() => throw new Exception("Bar.ToString should not be called");
+}
+
+public class FooFormatter : ArgumentDisplayFormatter
+{
+    public override bool CanHandle(object? value) => value is Foo;
+
+    public override string FormatValue(object? value) => "FooFormatterValue";
+}
+
+public class BarFormatter : ArgumentDisplayFormatter
+{
+    public override bool CanHandle(object? value) => value is Bar;
+
+    public override string FormatValue(object? value) => "BarFormatterValue";
+}
+
+public class IntFormatter : ArgumentDisplayFormatter
+{
+    public override bool CanHandle(object? value) => value is int;
+
+    public override string FormatValue(object? value) => $"INT:{value}";
+}