Test_IRecipientGenerator.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

usingSystem;
usingSystem.Linq;
usingSystem.Reflection;
usingCommunityToolkit.Mvvm.Messaging;
usingMicrosoft.VisualStudio.TestTools.UnitTesting;

#pragma warning disable CS0618

namespaceCommunityToolkit.Mvvm.UnitTests;

[TestClass]
publicpartialclassTest_IRecipientGenerator
{
[TestMethod]
publicvoidTest_IRecipientGenerator_GeneratedRegistration()
{
StrongReferenceMessengermessenger=new();
RecipientWithSomeMessagesrecipient=new();

MessageAmessageA=new();
MessageBmessageB=new();

Action<IMessenger,object,int>registrator=Messaging.__Internals.__IMessengerExtensions.CreateAllMessagesRegistratorWithToken<int>(recipient);

registrator(messenger,recipient,42);

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,42));
Assert.IsTrue(messenger.IsRegistered<MessageB,int>(recipient,42));

Assert.IsNull(recipient.A);
Assert.IsNull(recipient.B);

_=messenger.Send(messageA,42);

Assert.AreSame(recipient.A,messageA);
Assert.IsNull(recipient.B);

_=messenger.Send(messageB,42);

Assert.AreSame(recipient.A,messageA);
Assert.AreSame(recipient.B,messageB);
}

[TestMethod]
publicvoidTest_IRecipientGenerator_TypeWithMultipleClassDeclarations()
{
RecipientWithMultipleClassDeclarationsrecipient=new();

// This test really just needs to verify this compiles and executes normally
_=Messaging.__Internals.__IMessengerExtensions.CreateAllMessagesRegistratorWithToken<int>(recipient);
}

[TestMethod]
publicvoidTest_IRecipientGenerator_AbstractTypesDoNotTriggerCodeGeneration()
{
MethodInfo?createAllPropertiesValidatorMethod=typeof(Messaging.__Internals.__IMessengerExtensions)
.GetMethods(BindingFlags.Static|BindingFlags.Public)
.Where(static m =>m.Name=="CreateAllMessagesRegistratorWithToken")
.Where(static m =>m.GetParameters()is{Length:1}parameters&&parameters[0].ParameterType==typeof(AbstractModelWithValidatablePropertyIRecipientInterfaces))
.FirstOrDefault();

// We need to validate that no methods are generated for abstract types, so we just check this method doesn't exist
Assert.IsNull(createAllPropertiesValidatorMethod);
}

publicsealedclassRecipientWithSomeMessages:IRecipient<MessageA>,IRecipient<MessageB>
{
publicMessageA?A{get;privateset;}

publicMessageB?B{get;privateset;}

publicvoidReceive(MessageAmessage)
{
A=message;
}

publicvoidReceive(MessageBmessage)
{
B=message;
}
}

publicsealedclassMessageA
{
}

publicsealedclassMessageB
{
}

publicsealedpartialclassRecipientWithMultipleClassDeclarations:IRecipient<MessageA>
{
publicvoidReceive(MessageAmessage)
{
}
}

// This empty partial type declarations needs to be present to ensure the generator
// correctly handles cases where the source type has multiple class declarations.
partialclassRecipientWithMultipleClassDeclarations
{
}

publicabstractclassAbstractModelWithValidatablePropertyIRecipientInterfaces:IRecipient<MessageA>,IRecipient<MessageB>
{
publicabstractvoidReceive(MessageAmessage);

publicvoidReceive(MessageBmessage)
{

}
}
}