Generic setup fails with unexpected error message about nsubstitute

[Ergamon]

Sadly it seems still something must be different. I tried to run it with some self imagined IEvent and INotification interfaces. Now even with exactly the ones you posted, I dont get any error.

Basically I did create a new .NET 7 console app, added NSubstitute NuGet package and pasted in basically your code:

using NSubstitute;

internal class Program
{
  private static INotificationRecipientsProvider<CreatedEvent, Source> _recipientProviderMock;

  static void Main(string[] args)
  {
    WithRecipients(Enumerable.Empty<string>());
  }

  private static void WithRecipients(IEnumerable<string> recipients)
  {
    _recipientProviderMock = Substitute.For<INotificationRecipientsProvider<CreatedEvent, Source>>();
    _recipientProviderMock
        .NotificationRecipients(Arg.Any<CreatedEvent>())
        .Returns(x => recipients?.ToList());
  }
}

public interface IEvent<T>
{
  string Description { get; }

  T Payload { get; }
}

public interface INotification
{
  string NotificationType { get; }

  long Key { get; }

  string Operation { get; }

  IDictionary<string, object> Properties { get; }

  INotification CreateSnapshot();
}

public interface INotificationRecipientsProvider<T, E>
    where T : EventBase<E>
    where E : class
{
  IList<string> NotificationRecipients(T notificastionEvent);
}

public abstract class EventBase<T> : IEvent<T>, INotification
{
  protected EventBase(T payload)
  {
    Payload = payload;
  }

  public abstract string Description { get; }

  public T Payload { get; }

  public abstract string NotificationType { get; }
  
  public abstract long Key { get; }

  public abstract string Operation { get; }

  public abstract IDictionary<string, object> Properties { get; }

  public abstract INotification CreateSnapshot();
}

public class Source
{

}

public class CreatedEvent : EventBase<Source>
{
  public CreatedEvent(Source source)
    : base(source)
  {
  }

  public override string Description => throw new NotImplementedException();

  public override string NotificationType => throw new NotImplementedException();

  public override long Key => throw new NotImplementedException();

  public override string Operation => throw new NotImplementedException();

  public override IDictionary<string, object> Properties => throw new NotImplementedException();

  public override INotification CreateSnapshot()
  {
    throw new NotImplementedException();
  }
}

And I dont get any excpetion. So it is hard to help, if you cannot reproduce the error.

[Ergamon]

I am lacking the definitions for IEvent and INotification.
Can you provide a working sample to reproduce or at least tell what other sources are needed?

[kchristo71]

@Ergamon although I am not sure these interfaces are in any way interesting (meaning you could remove the inheritance) this is IEvent definition
public interface IEvent<T> { string Description { get; } T Payload { get; } }
And this is INotification:
public interface INotification { string NotificationType { get; } long Key { get; } string Operation { get; } IDictionary<string, object> Properties { get; } INotification CreateSnapshot(); }
I hope this helps, if not please let me know what else is missing

[kchristo71]

@hi Ergamon. Thank you for your time. I have done a similar setup, extracting all the classes to a simple test project and the setup does not fail. I even you the same events and entities as payload for the event. This is a concern as this means that there is some reference or project configuration in the real life scenario that causes this weird behaviour.

[kchristo71]

Hi @Ergamon I finally managed to sort this out. I had to download NSubstitute latest code and debug.
It was a very tricky one. With Moq it is a common practice to use statements like:

T x = It.IsAny<T>(); which results in setting the default value of T.

This is used to "declare" that we do not care for the value x and can be any value.
Doing the equivalent (T x = Arg.Any<T>();) SHOULD NEVER be used with NSubstitute because it adds T as argument definition in the thread context and will be added to the potential argument matches for the next setup.

This is where Int32 was coming from

[kchristo71]

Thank you for looking into this @Ergamon and I have to apologise for not providing all the test setup code, but it seemed really irrelevant and "innocent".