Fix IAsyncEnumerable detection in MethodDataSource source generator (#2991)

* Initial plan

* Initial investigation of IAsyncEnumerable issue

Co-authored-by: thomhurst <30480171+thomhurst@users.noreply.github.com>

* Fix IAsyncEnumerable detection in source generator

Co-authored-by: thomhurst <30480171+thomhurst@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: thomhurst <30480171+thomhurst@users.noreply.github.com>

Author: Copilot

TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs

@@ -978,6 +978,14 @@ private static void GenerateMethodDataSourceFactory(CodeWriter writer, IMethodSy
 
     private static bool IsAsyncEnumerable(ITypeSymbol type)
     {
+        // Check if the type itself is an IAsyncEnumerable<T>
+        if (type is INamedTypeSymbol namedType && namedType.IsGenericType && 
+            namedType.OriginalDefinition.ToDisplayString() == "System.Collections.Generic.IAsyncEnumerable<T>")
+        {
+            return true;
+        }
+
+        // Check if the type implements IAsyncEnumerable<T>
         return type.AllInterfaces.Any(i =>
             i.IsGenericType &&
             i.OriginalDefinition.ToDisplayString() == "System.Collections.Generic.IAsyncEnumerable<T>");

TUnit.UnitTests/AsyncDataSourceTests.cs

@@ -74,6 +74,15 @@ public async Task TestWithAsyncValueTaskDataSource(int value, string text)
         await Assert.That(text).Contains("hundred");
     }
 
+    [Test]
+    [MethodDataSource(nameof(AsyncEnumerableDataSource))]
+    public async Task TestWithAsyncEnumerableDataSource(int value, string text)
+    {
+        await Assert.That(value).IsGreaterThan(0);
+        await Assert.That(text).IsNotNull();
+        await Assert.That(text).IsNotEmpty();
+    }
+
 
 }
 

TUnit.UnitTests/IAsyncEnumerableDocumentationExample.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using TUnit.Core;
+
+namespace TUnit.UnitTests;
+
+public record AsyncTestData(int Id, string Name, DateTime CreatedAt);
+
+public static class AsyncTestDataSources
+{
+    // AOT-compatible async data source with cancellation support - matching documentation
+    public static async IAsyncEnumerable<Func<AsyncTestData>> GetAsyncTestData(
+        [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        for (int i = 1; i <= 3; i++)
+        {
+            ct.ThrowIfCancellationRequested();
+            
+            // Simulate async data loading (database, API, etc.)
+            await Task.Delay(10, ct);
+            
+            yield return () => new AsyncTestData(
+                Id: i, 
+                Name: $"Item_{i}", 
+                CreatedAt: DateTime.UtcNow.AddDays(-i)
+            );
+        }
+    }
+
+    // Simple async enumerable returning tuples - matching documentation
+    public static async IAsyncEnumerable<(int, string)> GetSimpleAsyncData(
+        [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        await Task.Delay(1, ct); // Simulate async work
+        yield return (1, "first");
+        yield return (2, "second");
+        yield return (3, "third");
+    }
+}
+
+public class IAsyncEnumerableDocumentationExample
+{
+    [Test]
+    [MethodDataSource(typeof(AsyncTestDataSources), nameof(AsyncTestDataSources.GetAsyncTestData))]
+    public async Task TestWithAsyncComplexData(AsyncTestData testData)
+    {
+        await Assert.That(testData.Id).IsGreaterThan(0);
+        await Assert.That(testData.Name).StartsWith("Item_");
+        await Assert.That(testData.CreatedAt).IsLessThan(DateTime.UtcNow);
+    }
+
+    [Test]
+    [MethodDataSource(typeof(AsyncTestDataSources), nameof(AsyncTestDataSources.GetSimpleAsyncData))]
+    public async Task TestWithAsyncSimpleData(int id, string name)
+    {
+        await Assert.That(id).IsGreaterThan(0).And.IsLessThanOrEqualTo(3);
+        await Assert.That(name).IsNotEmpty();
+    }
+}