Dependent data sources

[mike-bagheri]

I am trying to inject three classes into my test as a data source.
[ClassDataSource<SomeClass1, SomeClass2, SomeClass3>(Shared = [SharedType.PerTestSession, SharedType.PerTestSession, SharedType.PerTestSession]

All classes implementing IAsyncInitializer.
All good. However, SomeClass1 depends on the other two classes, meaning that in the InitializeAsync of SomeClass1, I need to access the SomeClass2 and SomeClass3 and I also need it to be already initialized.

Is this possible?

[thomhurst]

This isn't supported currently with ClassDataSource. You're best off creating a factory class that does this for you and injecting that in.

Alternatively, if you inject them in via the class constructor, you can use a [ClassConstruct<T>] attribute with some custom DI logic in it.

[mike-bagheri]

Here is the solution I came up with: (in my case, I only need to have my classes initialize per test session)

public class FixtureProvider : IClassConstructor, IFirstTestInTestSessionEventReceiver, ILastTestInTestSessionEventReceiver
{
	private readonly AsyncServiceScope _scope = ServiceProvider.CreateAsyncScope();

	private static readonly Type[] ServiceTypes = [typeof(SomeClass2), typeof(SomeClass3), typeof(SomeClass1)];

	private static readonly IServiceProvider ServiceProvider = CreateProvider();

	public T Create<T>(ClassConstructorMetadata classConstructorMetadata) where T : class
	{
		return ActivatorUtilities.GetServiceOrCreateInstance<T>(_scope.ServiceProvider);
	}

	public async ValueTask OnFirstTestInTestSession(TestSessionContext current, TestContext testContext)
	{
		foreach (var type in ServiceTypes)
		{
			if (_scope.ServiceProvider.GetRequiredService(type) is IAsyncInitializer initializer)
			{
				await initializer.InitializeAsync();
			}
		}
	}

	public async ValueTask OnLastTestInTestSession(TestSessionContext current, TestContext testContext)
	{
		foreach (var type in ServiceTypes)
		{
			if (_scope.ServiceProvider.GetRequiredService(type) is IAsyncDisposable disposer)
			{
				await disposer.DisposeAsync();
			}
		}

		await _scope.DisposeAsync();
	}

	private static IServiceProvider CreateProvider()
	{
		var services = new ServiceCollection();

		foreach (var type in ServiceTypes)
		{
			services.AddSingleton(type);
		}

		return services.BuildServiceProvider();
	}
}

public class SomeClass1 : IAsyncInitializer
{
	private readonly SomeClass2 _class2;

	private readonly SomeClass3 _class3;

	public SomeClass1(SomeClass2 class2, SomeClass3 class3)
	{
		_class2 = class2;
		_class3 = class3;
	}

	public Task InitializeAsync()
	{
                // Now here I can access _class2 and _class3 and their respective InitializeAsync already called and they are ready
		return Task.CompletedTask;
	}

[ClassConstructor<FixtureProvider>]
public class MyTest(SomeClass1 class1)
{
   [Test]
   public async Task Test1()
   {
        // I can use resources on SomeClass1
   }
}