[Copilot] Implement DI injection for testing

[manio143]

Conversation Summary

1. You asked whether it’s possible to inject dependencies directly into F# xUnit test method arguments, and if not, whether it could be implemented.
2. I explained why xUnit doesn’t natively support this, especially with F# static methods, but that it’s possible with custom DataAttributes.
3. You asked about the impact on performance and test discovery/naming in test runners when using a custom DataAttribute for DI.
4. I described the expected behavior, performance, and test runner appearance.
5. You requested example code for such a custom attribute in C# (adaptable to F#).
6. You asked for clarification on why F# attributes are considered more limited than C#’s.

---

Expanded Summary: Steps to Get to the Custom DataAttribute Code

• Understand the need:

  • In F#, xUnit static methods cannot use constructor injection for dependencies.
  • Method injection via parameters (from a DI container) is not natively supported by xUnit, but could be achieved with a custom DataAttribute.

• Constraints:

  • xUnit’s data attributes provide arguments to [Theory] test parameters.
  • F# tests often use static/module methods; DI works best with classes, but method injection can be simulated.

• Design a solution:

  • Write a custom DataAttribute that, for a [Theory] test, resolves parameters from a DI container (typically IServiceProvider).
  • Implement a mechanism to set a globally available ServiceProvider for test runs.
  • In the attribute, loop through method arguments and resolve each via GetService.
  • Make sure to provide a helpful GetDisplayName for the test method so it appears meaningfully in test runners.

• Performance/Usability considerations:

  • Test discovery and execution may be slightly slower, but impact is negligible if DI resolution is fast.
  • Test naming in IDEs may lack parameter value details unless you set display names carefully.
  • Errors in the service construction phase surface as initialization/test failures.

• Code outline and example usage:

  1. Define the custom DataAttribute (e.g., InjectFromServicesDataAttribute).
  2. Expose a static method to set the DI container globally during test setup.
  3. In your test, add [Theory, InjectFromServicesData] and provide DI-required parameters.
  4. Set up services before running tests (e.g., in a test assembly fixture or module init).
  5. Run tests – dependencies get injected from the container into the method.

• F# and C# differences:

  • The pattern is most easily implemented in C#, but can be used in F# by applying the attribute to functions that compile to proper .NET methods.
  • Defining custom attributes in F# has runtime restrictions (constructor arguments/types) and tooling limitations, so it’s common to write the attribute in C# and use it from F#.

---

using System;
using System.Collections.Generic;
using System.Reflection;
using Xunit.Sdk;

public class InjectFromServicesDataAttribute : DataAttribute
{
    private static IServiceProvider GlobalServiceProvider = null;

    // For demo only: Normally set this up via test class/fixture setup, not directly!
    public static void SetServiceProvider(IServiceProvider sp) => GlobalServiceProvider = sp;

    public override IEnumerable<object[]> GetData(MethodInfo testMethod)
    {
        if (GlobalServiceProvider == null)
            throw new InvalidOperationException("GlobalServiceProvider not set.");

        var parameters = testMethod.GetParameters();
        var values = new object[parameters.Length];
        for (int i = 0; i < parameters.Length; i++)
        {
            var dep = GlobalServiceProvider.GetService(parameters[i].ParameterType);
            if (dep == null)
                throw new InvalidOperationException($"Cannot resolve {parameters[i].ParameterType}");
            values[i] = dep;
        }
        yield return values;
    }

    public override string GetDisplayName(MethodInfo methodInfo, object[] data)
    {
        var paramNames = methodInfo.GetParameters();
        var dataTypes = string.Join(", ",
            data != null
                ? data.Select(d => d?.GetType().Name ?? "null")
                : paramNames.Select(p => p.ParameterType.Name)
        );
        return $"{methodInfo.Name}({dataTypes})";
    }
}

I want to expand on this in the following ways:

1. Enable passing primitive inline data into the attribute so that it can be set on primitive parameters (e.g. parents 1-3 are complex types, injected, parameters 4-5 are primitive and should be sourced from attribute)
2. For each test we should start a new Scope on the DI container
3. In the display name generation we should only set primitive data as arguments and skip any injected ones, unless they have an overloaded toString which will provide a sensible value.

I want this added into a new shared F# test project so it can be referenced by the F# tests.