Fix dependency injection scope sharing between test executions

[Copilot]

When using DependencyInjectionDataSourceAttribute<TScope> with multiple test arguments, the same dependency injection scope was incorrectly shared across all test invocations, causing scoped services to be reused when they should be isolated per test.

Problem

Consider this test class using dependency injection:

public sealed class Dependency
{
    private static int _value = 0;
    public int Value { get; } = Interlocked.Increment(ref _value);
}

public sealed class DependencyInjectionClassConstructor : DependencyInjectionDataSourceAttribute<IServiceScope>
{
    private readonly IServiceProvider _serviceProvider = BuildServiceProvider();

    private static IServiceProvider BuildServiceProvider()
    {
        var services = new ServiceCollection();
        services.AddScoped<Dependency>();
        return services.BuildServiceProvider();
    }

    public override object? Create(IServiceScope scope, Type type) =>
        ActivatorUtilities.GetServiceOrCreateInstance(scope.ServiceProvider, type);

    public override IServiceScope CreateScope(DataGeneratorMetadata dataGeneratorMetadata) =>
        _serviceProvider.CreateAsyncScope();
}

[DependencyInjectionClassConstructor]
public sealed class ActualTestClass(Dependency dependency)
{
    [Test]
    [Arguments(1)]
    [Arguments(2)]
    public void Test1(int testNumber)
    {
        Console.WriteLine(dependency.Value);
    }
}

Before this fix: Both test executions would output 1 because they shared the same DI scope and got the same Dependency instance.

After this fix: The test executions output different values (1 and 2 or 2 and 1) because each gets its own DI scope with a fresh Dependency instance.

Solution

The issue was in DependencyInjectionDataSourceAttribute<TScope>.GenerateDataSources() where the scope was created once during data generation and reused across all test executions:

// Before: Scope created once and shared
var scope = CreateScope(dataGeneratorMetadata);
yield return () => { /* all tests use same scope */ };

Changed to create a new scope for each test execution:

// After: Scope created per test execution
yield return () => {
    var scope = CreateScope(dataGeneratorMetadata); // Fresh scope per test
    // ... proper disposal setup for this specific scope
    // ... return test instance data
};

This ensures proper test isolation while maintaining backward compatibility. Each scope is properly disposed after its corresponding test execution through the test context's disposal events.

Fixes #2930.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[thomhurst]

@copilot Add a test for this, and decorate it with [EngineTest(ExpectedResult.Pass)] so it is run as part of the regression

[Copilot]

@copilot Add a test for this, and decorate it with [EngineTest(ExpectedResult.Pass)] so it is run as part of the regression

Added regression test DependencyInjectionScopeIsolationTest decorated with [EngineTest(ExpectedResult.Pass)]. The test verifies that each test execution with multiple arguments gets its own DI scope and scoped services are not shared between invocations. It uses a ScopedTestService with unique instance numbers to verify isolation and includes validation that all instances are unique. Commit bb48bfc.