Why are these NSubstitute Argument Matchers not Matching?

 Issues with NSubstitute and AddTransient

NSubstitute’s Behavior with IServiceCollection:

NSubstitute’s IServiceCollection mock doesn't inherently support verifying the specifics of AddTransient calls, especially when the method signature involves Type parameters.

The AddTransient Method Signature:

The AddTransient method is an extension method on IServiceCollection that internally calls Add with a ServiceDescriptor. When using NSubstitute to verify calls to AddTransient, it's critical to ensure that the exact method signature and parameters are being used in the verification.

Solutions to Verify AddTransient Calls

1. Use a Mock of IServiceCollection with Custom Verification

You need to verify that AddTransient was called with the correct parameters. However, because IServiceCollection is an interface with extension methods, you might have to verify the underlying ServiceDescriptor being added:

csharp
Copy code
[Fact]
public void When__Given__Then()
{
    // Arrange
    var serviceCollection = Substitute.For<IServiceCollection>();
    var serviceDescriptors = new List<ServiceDescriptor>();

    // Use a callback to capture the ServiceDescriptors being added
    serviceCollection
        .When(x => x.Add(Arg.Any<ServiceDescriptor>()))
        .Do(x => serviceDescriptors.Add(x.Arg<ServiceDescriptor>()));

    // Act
    RequestDispatcherRegistrar.AddRequestDispatcher(serviceCollection);

    // Assert
    Assert.Contains(serviceDescriptors, sd =>
        sd.ServiceType == typeof(IRequestHandler<VoidDispatcherRequest>) &&
        sd.ImplementationType == typeof(VoidDispatcherRequestHandler) &&
        sd.Lifetime == ServiceLifetime.Transient);
}
Here, we capture ServiceDescriptor instances added to the IServiceCollection and then verify that the correct ServiceDescriptor was added.

2. Use a Real IServiceCollection Implementation

For testing purposes, using a real IServiceCollection implementation, like ServiceCollection, can be more straightforward:

csharp
Copy code
[Fact]
public void When__Given__Then()
{
    // Arrange
    var serviceCollection = new ServiceCollection();

    // Act
    RequestDispatcherRegistrar.AddRequestDispatcher(serviceCollection);

    // Assert
    var serviceProvider = serviceCollection.BuildServiceProvider();
    var serviceDescriptor = serviceCollection.FirstOrDefault(descriptor =>
        descriptor.ServiceType == typeof(IRequestHandler<VoidDispatcherRequest>) &&
        descriptor.ImplementationType == typeof(VoidDispatcherRequestHandler) &&
        descriptor.Lifetime == ServiceLifetime.Transient);

    Assert.NotNull(serviceDescriptor);
}
In this approach, you use the real ServiceCollection and verify the registrations after building the service provider.

3. Check for Incorrect Method Overloads

Make sure that the AddTransient method signature you're verifying matches the actual call in your implementation. NSubstitute may not match if there are discrepancies in method overloads.

4. Ensure Correct Use of Arg.Is<T>

If you’re using matchers, ensure that your matcher is properly constructed and matches the expected behavior.

Summary
The core problem is verifying AddTransient calls with specific types using NSubstitute. NSubstitute’s handling of extension methods can be tricky, and using real implementations or capturing parameters with callbacks can often lead to more reliable results. Try capturing ServiceDescriptor instances or using a real IServiceCollection implementation to assert that the correct registrations are being made.