Visual Studio + Code both Execute DI Injection for Every Test even when a single test is selected to run/debug

[JohnGalt1717]

I have a Attribute for provide injection following the setup in the documentation.

When I right click on a test and choose run or debug from the Test Explorer, the DI Attribute is executed for every single test in the class, not just the one that was run.

[thomhurst]

Yeah objects are created at startup. Any expensive operations should be in IAsyncInitializer.InitializeAsync which is run at test execution.

[JohnGalt1717]

I think it's more than that.

I have a bunch of projects. But I'm trying to run a single test from a single test class. The project in question has 3 test classes.

Every project for tests inherits from Shared.Tests which has some convenience stuff in it.

When I run any of the tests singly in the single test class in the single project, it's showing me in the logs that it's running all tests in the entire solution. It does this in vs code, VS.net 2022, VS.net 2026, and Rider 2025.2.3 and 2025.3.0 EAP.

And if I look in task manager, there's a running IdentityTests (the test project) running just hung there, but in the debug run in terminal in vs code it shows the logs from all other tests running.

My Directory.Build.props looks like this:

<Project>
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
    <WarningsAsErrors>Nullable</WarningsAsErrors>
    <InvariantGlobalization>true</InvariantGlobalization>
    <NoWarn>IDE0053;IDE0055;IDE0021</NoWarn>
    <LangVersion>14</LangVersion>
    <TieredPGO>true</TieredPGO>
    <AnalysisLevel>latest</AnalysisLevel>
    <BlazorDisableThrowNavigationException>true</BlazorDisableThrowNavigationException>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Update="CSharpier.MsBuild">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="MassTransit.Analyzers">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
  </ItemGroup>
</Project>

The test project in question looks like this:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <EnableStaticNativeInstrumentation>False</EnableStaticNativeInstrumentation>
    <EnableDynamicNativeInstrumentation>False</EnableDynamicNativeInstrumentation>
    <VSTestUseMSBuildOutput>false</VSTestUseMSBuildOutput>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="TUnit.Engine" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Shared.Tests.RavenDb\Shared.Tests.RavenDb.csproj" />
  </ItemGroup>
</Project>

RavenDb.csproj: (just has the test server etc)

<Project Sdk="Microsoft.NET.Sdk">
  <ItemGroup>
    <PackageReference Include="RavenDB.TestDriver" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Shared.Tests\Shared.Tests.csproj" />
  </ItemGroup>
</Project>

And Shared.Test.csproj:

<Project Sdk="Microsoft.NET.Sdk">
  <ItemGroup>
    <PackageReference Include="DistributedLock.FileSystem" />
    <PackageReference Include="FakeItEasy" />
    <PackageReference Include="FakeItEasy.Analyzer.CSharp">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
    <PackageReference Include="Microsoft.Garnet" />
    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" />
    <PackageReference Include="Microsoft.Testing.Extensions.Telemetry" />
    <PackageReference Include="Microsoft.Testing.Extensions.TrxReport" />
    <PackageReference Include="TUnit.Assertions" />
    <PackageReference Include="TUnit.Core" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\ServiceDefaults\ServiceDefaults.csproj" />
  </ItemGroup>
</Project>

The class looks like this:

[EndorsementProviderInjection]
public sealed class EndorsementProviderTests(
    EndorsementProvider endorsementProvider,
    IIdentityProvider identityProvider,
    IDataSession dbSession
)
{
...
}

and the injector looks like this:

public sealed class EndorsementProviderInjection
    : DependencyInjectionDataSourceAttribute<IServiceScope>,
        IAsyncDisposable,
        IAsyncInitializer
{
    private IHost _host = null!;
    private static readonly RavenDbTestDriver SERVER;

    static EndorsementProviderInjection()
    {
        SERVER = new RavenDbTestDriver();
    }

    public override IServiceScope CreateScope(DataGeneratorMetadata dataGeneratorMetadata) =>
        _host.Services.CreateAsyncScope();

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

    public ValueTask DisposeAsync()
    {
        _host.Dispose();

        return new();
    }

    public async Task InitializeAsync()
    {
        var builder = new HostApplicationBuilder();

        builder.CreateConfiguration([]);
        builder.AddConfigurationOptions();
        builder.Logging.AddConsole().SetMinimumLevel(LogLevel.Debug);

        builder.Services.AddSingleton<IPasswordHasher<Contact>, CustomPasswordHasher>();

        builder.AddTestRavenDbServer(SERVER, Guid.NewGuid().ToString());

        builder.Services.AddScoped<IEndorsementProvider, EndorsementProvider>();
        builder.Services.AddScoped<IIdentityProvider, IdentityProvider>();

        builder.Services.AddSingleton(UserIdentity.Empty);
        builder.Services.AddSingleton(IdentityOrigin.Empty);

        builder.Services.AddOpenIddict(config =>
        {
            config.AddCore(options =>
            {
                options.UseRavenDb();
            });
        });

        builder.Services.AddDistributedMemoryCache();

        builder.Services.AddSingleton(TimeProvider.System);

        _host = builder.Build();

        var store = _host.Services.GetRequiredService<IDocumentStore>();
        store.EnsureDatabaseExists();
        await builder!.Services.MigrateDatabaseAsync<IDataSession>(store);
    }
}

All of my injectors anywhere on all tests even outside the class library for which this test resides gets run and if I do a debug I can break into those tests all running.

[JohnGalt1717]

Even this:

dotnet test --no-build --list-tests

In the project's folder ends up executing the DI stuff at least but it looks like it's walking backwards and listing all tests in the entire solution and takes forever.

(And if I comment out the DI, then it goes back to normal and works correctly)

[thomhurst]

Ah - I need to update the documentation, but IAsyncInitializer if placed on a DataSource attribute (which the DI one is) will run before it generates data (which happens during discovery/startup), because it assumes it needs to be initialised before getting the data.

You could switch to ITestStartEventReceiver instead so that it only runs on a test start.

[JohnGalt1717]

Ok, but the constructor is executed immediately for all tests even out of project... this seems ... odd.