Test_ObservableRecipientAttribute.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.Collections.Generic;
usingSystem.ComponentModel;
usingSystem.ComponentModel.DataAnnotations;
usingSystem.Linq;
usingSystem.Reflection;
usingCommunityToolkit.Mvvm.ComponentModel;
usingCommunityToolkit.Mvvm.Messaging;
usingMicrosoft.VisualStudio.TestTools.UnitTesting;

#pragma warning disable MVVMTK0033

namespaceCommunityToolkit.Mvvm.UnitTests;

[TestClass]
publicpartialclassTest_ObservableRecipientAttribute
{
[TestMethod]
publicvoidTest_ObservableRecipientAttribute_Events()
{
Person?model=new();
List<PropertyChangedEventArgs>?args=new();

model.PropertyChanged+=(s,e)=>args.Add(e);

Assert.IsFalse(model.HasErrors);

model.Name="No";

Assert.IsTrue(model.HasErrors);
Assert.AreEqual(args.Count,2);
Assert.AreEqual(args[0].PropertyName,nameof(Person.Name));
Assert.AreEqual(args[1].PropertyName,nameof(INotifyDataErrorInfo.HasErrors));

model.Name="Valid";

Assert.IsFalse(model.HasErrors);
Assert.AreEqual(args.Count,4);
Assert.AreEqual(args[2].PropertyName,nameof(Person.Name));
Assert.AreEqual(args[3].PropertyName,nameof(INotifyDataErrorInfo.HasErrors));

Assert.IsNotNull(typeof(Person).GetProperty("Messenger",BindingFlags.Instance|BindingFlags.NonPublic));
Assert.AreEqual(typeof(Person).GetConstructors(BindingFlags.Instance|BindingFlags.NonPublic).Length,0);
}

[ObservableRecipient]
publicpartialclassPerson:ObservableValidator
{
publicPerson()
{
Messenger=WeakReferenceMessenger.Default;
}

privatestring?name;

[MinLength(4)]
[MaxLength(20)]
[Required]
publicstring?Name
{
get=>this.name;
set=>SetProperty(refthis.name,value,true);
}

publicvoidTestCompile()
{
// Validates that the method Broadcast is correctly being generated
Broadcast(0,1,nameof(TestCompile));
}
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_AbstractConstructors()
{
ConstructorInfo[]?ctors=typeof(AbstractPerson).GetConstructors(BindingFlags.Instance|BindingFlags.NonPublic);

Assert.AreEqual(ctors.Length,2);
Assert.IsTrue(ctors.All(static ctor =>ctor.IsFamily));
}

[ObservableRecipient]
publicabstractpartialclassAbstractPerson:ObservableObject
{
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_NonAbstractConstructors()
{
ConstructorInfo[]?ctors=typeof(NonAbstractPerson).GetConstructors(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);

Assert.AreEqual(ctors.Length,2);
Assert.IsTrue(ctors.All(static ctor =>ctor.IsPublic));
}

[ObservableRecipient]
publicpartialclassNonAbstractPerson:ObservableObject
{
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_TrimmingAnnoations_IsActive()
{
boolshouldHaveTrimmingAnnotations=
#if NET6_0_OR_GREATER
true;
#else
false;
#endif

MethodInfoisActivePropertySetter=typeof(TestRecipient).GetProperty(nameof(TestRecipient.IsActive))!.SetMethod!;

if(shouldHaveTrimmingAnnotations)
{
Attribute[]attributes=isActivePropertySetter.GetCustomAttributes().ToArray();

Assert.AreEqual(1,attributes.Length);
Assert.AreEqual("System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute",attributes[0].GetType().ToString());
}
else
{
Attribute[]attributes=isActivePropertySetter.GetCustomAttributes().ToArray();

Assert.AreEqual(0,attributes.Length);
}
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_TrimmingAnnoations_OnActivated()
{
boolshouldHaveTrimmingAnnotations=
#if NET6_0_OR_GREATER
true;
#else
false;
#endif

MethodInfoonActivatedMethod=typeof(TestRecipient).GetMethod("OnActivated",BindingFlags.Instance|BindingFlags.NonPublic)!;
IEnumerable<Attribute>attributes=onActivatedMethod.GetCustomAttributes();

if(shouldHaveTrimmingAnnotations)
{
Assert.IsTrue(attributes.Any(static a =>a.GetType().ToString()=="System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute"));
}
else
{
Assert.IsFalse(attributes.Any(static a =>a.GetType().ToString()=="System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute"));
}
}

[ObservableRecipient]
publicabstractpartialclassTestRecipient:ObservableObject
{
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_PersonWithCustomOnActivated()
{
PersonWithCustomOnActivatedmodel=new();

model.IsActive=true;

Assert.IsTrue(model.Result);
}

[ObservableRecipient]
publicpartialclassPersonWithCustomOnActivated:ObservableObject
{
publicboolResult{get;privateset;}

protectedvirtualpartialvoidOnActivated()
{
Result=true;
}
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_PersonWithCustomOnDeactivated()
{
PersonWithCustomOnDeactivatedmodel=new();

model.IsActive=true;
model.IsActive=false;

Assert.IsTrue(model.Result);
}

[ObservableRecipient]
publicpartialclassPersonWithCustomOnDeactivated:ObservableObject
{
publicboolResult{get;privateset;}

protectedvirtualpartialvoidOnDeactivated()
{
Result=true;
}
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_PersonWithCustomOnActivatedAndOnDeactivated()
{
PersonWithCustomOnActivatedAndOnDeactivatedmodel=new();

model.IsActive=true;

Assert.IsTrue(model.OnActivatedResult);

model.IsActive=false;

Assert.IsTrue(model.OnDeactivatedResult);
}

[ObservableRecipient]
publicpartialclassPersonWithCustomOnActivatedAndOnDeactivated:ObservableObject
{
publicboolOnActivatedResult{get;privateset;}

publicboolOnDeactivatedResult{get;privateset;}

protectedvirtualpartialvoidOnActivated()
{
OnActivatedResult=true;
}

protectedvirtualpartialvoidOnDeactivated()
{
OnDeactivatedResult=true;
}
}

[TestMethod]
publicvoidTest_ObservableRecipientAttribute_SealedPersonWithCustomOnActivatedAndOnDeactivated()
{
SealedPersonWithCustomOnActivatedAndOnDeactivatedmodel=new();

model.IsActive=true;

Assert.IsTrue(model.OnActivatedResult);

model.IsActive=false;

Assert.IsTrue(model.OnDeactivatedResult);
}

[ObservableRecipient]
publicsealedpartialclassSealedPersonWithCustomOnActivatedAndOnDeactivated:ObservableObject
{
publicboolOnActivatedResult{get;privateset;}

publicboolOnDeactivatedResult{get;privateset;}

privatepartialvoidOnActivated()
{
OnActivatedResult=true;
}

privatepartialvoidOnDeactivated()
{
OnDeactivatedResult=true;
}
}

// See https://github.com/CommunityToolkit/dotnet/issues/109
[TestMethod]
publicvoidTest_ObservableRecipientAttribute_WorksWithBaseClassWithObservableObjectAttribute()
{
ViewModelWithOnlyObservableRecipientAttributemodel=new();

// This test method really only needs the two classes below to compile at all
Assert.IsTrue(modelisINotifyPropertyChanged);// From [ObservableObject]
Assert.IsFalse(model.IsActive);// From [ObservableRecipient]
}

[ObservableObject]
publicpartialclassBaseViewModelWithObservableObjectAttribute
{
}

[ObservableRecipient]
publicpartialclassViewModelWithOnlyObservableRecipientAttribute:BaseViewModelWithObservableObjectAttribute
{
}
}