IMessengerExtensions.Send blocks unit testing

[mikeKuester]

Hello,
I'm migrating a legacy app from MvvmLight to CommunityToolkit. Most parts are easy to handle, but now all unit tests which check the IMessenger calls fail, because of the IMessengerExtensions which use the internal Unit type.

I use .NET Framework 4.8.x and Moq for unit testing.

There is a messenger send in a method:

Messenger.Send(new NotificationMessage(Notifications.MyNotification));

And the unit tests for the method contains something like this:

msgrMock.Verify(
    p => p.Send(It.IsAny<NotificationMessage>()),
    Times.Once
);

The extension method Send<TMessage>(this IMessenger messenger, TMessage message) uses the internal type Unit, which I can't use in my units tests to see if a mock has the right invocations.

dotnet/src/CommunityToolkit.Mvvm/Messaging/IMessengerExtensions.cs

Line 422 in 657c697

public static TMessage Send<TMessage>(this IMessenger messenger, TMessage message)

    public static TMessage Send<TMessage>(this IMessenger messenger, TMessage message)
        where TMessage : class
    {
        ArgumentNullException.ThrowIfNull(messenger);
        ArgumentNullException.ThrowIfNull(message);

        return messenger.Send(message, default(Unit));
    }

I can't write a working unit test:

msgrMock.Verify(
    // But the type Unit is not accessible
    p => p.Send(It.IsAny<NotificationMessage>(), It.IsAny<CommunityToolkit.Mvvm.Messaging.Internals.Unit>()),
    Times.Once
);

Why is it not possible to use a public type in the extension method for the TToken?

The extension method should make it easy to use the Send method if you don't need different channels. However, the current implementation prevents this when I want to test my code. Or did I miss here something?

Thanks,
Mike

Update: It's not only the send method, all methods have the same problem.

[MakoPhil]

I found an elegant working answer on Stack Overflow and I want to share it here for posterity's sake. Not gonna lie, my jaw dropped when I saw it work!

Moq is incredibly extensible, and provides an extension point for exactly this purpose. You can provide custom type matching logic by creating a type that implements ITypeMatcher. To match the IMessenger.Send signature, for instance:

[TypeMatcher]
public sealed class IsAnyToken : ITypeMatcher, IEquatable<IsAnyToken>
{
    public bool Matches(Type typeArgument) => true;
    public bool Equals(IsAnyToken? other) => throw new NotImplementedException();
}

You can use this to write Setup and Verify code exactly like It.IsAnyType:

mockMessenger.Setup(x => x.Send(It.IsAny<MyMessage>(), It.IsAny<IsAnyToken>());
...
mockMessenger.Verify(x => x.Send(It.IsAny<MyMessage>(), It.IsAny<IsAnyToken>(), Times.Once);

[MassoudKargar]

Hi Mike,

The issue is caused by how Moq handles extension methods.

IMessengerExtensions.Send<TMessage>(...) is a static extension method, so Moq cannot intercept or verify it directly. The extension forwards the call to the underlying generic IMessenger.Send<TMessage, TToken>(...) implementation using the internal Unit token type.

This creates a limitation when trying to express the verification using the public API.

For a practical workaround, I would recommend testing the observable behavior rather than verifying the extension method itself.

For example, use a real WeakReferenceMessenger instance and register a recipient before invoking the code under test:

var messenger = new WeakReferenceMessenger();
var received = false;
var recipient = new object();

messenger.Register<NotificationMessage>(
    recipient,
    (r, message) => received = true);

// Execute the code under test using messenger.

Assert.True(received);

This example assumes the code under test receives the IMessenger instance through dependency injection and sends a NotificationMessage.

Alternatively, if verifying interactions is a strict requirement, introduce an application-level messaging abstraction with a public, mockable method and verify that abstraction instead.

This keeps the tests independent of CommunityToolkit's internal implementation details.

The core distinction is that extension methods are static, while Moq verifies calls to interceptable interface or virtual members.

Hope this helps!