Test_ObservableObject.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.ComponentModel;
usingSystem.Threading.Tasks;
usingCommunityToolkit.Mvvm.ComponentModel;
usingCommunityToolkit.Mvvm.UnitTests.Helpers;
usingMicrosoft.VisualStudio.TestTools.UnitTesting;

namespaceCommunityToolkit.Mvvm.UnitTests;

[TestClass]
publicclassTest_ObservableObject
{
[TestMethod]
publicvoidTest_ObservableObject_Events()
{
SampleModel<int>?model=new();

(PropertyChangingEventArgs,int)changing=default;
(PropertyChangedEventArgs,int)changed=default;

model.PropertyChanging+=(s,e)=>
{
Assert.IsNull(changing.Item1);
Assert.IsNull(changed.Item1);
Assert.AreSame(model,s);
Assert.IsNotNull(s);
Assert.IsNotNull(e);

changing=(e,model.Data);
};

model.PropertyChanged+=(s,e)=>
{
Assert.IsNotNull(changing.Item1);
Assert.IsNull(changed.Item1);
Assert.AreSame(model,s);
Assert.IsNotNull(s);
Assert.IsNotNull(e);

changed=(e,model.Data);
};

model.Data=42;

Assert.AreEqual(changing.Item1?.PropertyName,nameof(SampleModel<int>.Data));
Assert.AreEqual(changing.Item2,0);
Assert.AreEqual(changed.Item1?.PropertyName,nameof(SampleModel<int>.Data));
Assert.AreEqual(changed.Item2,42);
}

publicclassSampleModel<T>:ObservableObject
{
privateT?data;

publicT?Data
{
get=>this.data;
set=>SetProperty(refthis.data,value);
}
}

[TestMethod]
publicvoidTest_ObservableObject_ProxyCrudWithProperty()
{
WrappingModelWithProperty?model=new(newPerson{Name="Alice"});

(PropertyChangingEventArgs?,string?)changing=default;
(PropertyChangedEventArgs?,string?)changed=default;

model.PropertyChanging+=(s,e)=>
{
Assert.AreSame(model,s);

changing=(e,model.Name);
};

model.PropertyChanged+=(s,e)=>
{
Assert.AreSame(model,s);

changed=(e,model.Name);
};

model.Name="Bob";

Assert.AreEqual(changing.Item1?.PropertyName,nameof(WrappingModelWithProperty.Name));
Assert.AreEqual(changing.Item2,"Alice");
Assert.AreEqual(changed.Item1?.PropertyName,nameof(WrappingModelWithProperty.Name));
Assert.AreEqual(changed.Item2,"Bob");
Assert.AreEqual(model.PersonProxy.Name,"Bob");
}

publicclassPerson
{
publicstring?Name{get;set;}
}

publicclassWrappingModelWithProperty:ObservableObject
{
privatePersonPerson{get;}

publicWrappingModelWithProperty(Personperson)
{
Person=person;
}

publicPersonPersonProxy=>Person;

publicstring?Name
{
get=>Person.Name;
set=>SetProperty(Person.Name,value,Person,(person,name)=>person.Name=name);
}
}

[TestMethod]
publicvoidTest_ObservableObject_ProxyCrudWithField()
{
WrappingModelWithField?model=new(newPerson{Name="Alice"});

(PropertyChangingEventArgs?,string?)changing=default;
(PropertyChangedEventArgs?,string?)changed=default;

model.PropertyChanging+=(s,e)=>
{
Assert.AreSame(model,s);

changing=(e,model.Name);
};

model.PropertyChanged+=(s,e)=>
{
Assert.AreSame(model,s);

changed=(e,model.Name);
};

model.Name="Bob";

Assert.AreEqual(changing.Item1?.PropertyName,nameof(WrappingModelWithField.Name));
Assert.AreEqual(changing.Item2,"Alice");
Assert.AreEqual(changed.Item1?.PropertyName,nameof(WrappingModelWithField.Name));
Assert.AreEqual(changed.Item2,"Bob");
Assert.AreEqual(model.PersonProxy.Name,"Bob");
}

publicclassWrappingModelWithField:ObservableObject
{
privatereadonlyPersonperson;

publicWrappingModelWithField(Personperson)
{
this.person=person;
}

publicPersonPersonProxy=>this.person;

publicstring?Name
{
get=>this.person.Name;
set=>SetProperty(this.person.Name,value,this.person,(person,name)=>person.Name=name);
}
}

[TestMethod]
publicasyncTaskTest_ObservableObject_NotifyTask()
{
staticasyncTaskTestAsync(Action<TaskCompletionSource<int>>callback)
{
SampleModelWithTask<int>?model=new();
TaskCompletionSource<int>?tcs=new();
Task<int>?task=tcs.Task;

(PropertyChangingEventArgs?,Task<int>?)changing=default;
(PropertyChangedEventArgs?,Task<int>?)changed=default;

model.PropertyChanging+=(s,e)=>
{
Assert.AreSame(model,s);

changing=(e,model.Data);
};

model.PropertyChanged+=(s,e)=>
{
Assert.AreSame(model,s);

changed=(e,model.Data);
};

model.Data=task;

Assert.IsFalse(task.IsCompleted);
Assert.AreEqual(changing.Item1?.PropertyName,nameof(SampleModelWithTask<int>.Data));
Assert.IsNull(changing.Item2);
Assert.AreEqual(changed.Item1?.PropertyName,nameof(SampleModelWithTask<int>.Data));
Assert.AreSame(changed.Item2,task);

changed=default;

callback(tcs);

awaitTask.Delay(100);// Time for the notification to dispatch

Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(changed.Item1?.PropertyName,nameof(SampleModel<int>.Data));
Assert.AreSame(changed.Item2,task);
}

awaitTestAsync(tcs =>tcs.SetResult(42));
awaitTestAsync(tcs =>tcs.SetException(newArgumentException("Something went wrong")));
awaitTestAsync(tcs =>tcs.SetCanceled());
}

publicclassSampleModelWithTask<T>:ObservableObject
{
privateTaskNotifier<T>?data;

publicTask<T>?Data
{
get=>this.data;
set=>SetPropertyAndNotifyOnCompletion(refthis.data,value);
}
}

[TestMethod]
publicasyncTaskTest_ObservableObject_ThrowingTaskBubblesToUnobservedTaskException()
{
SampleModelWithTaskmodel=new();

staticasyncTaskTestMethodAsync(Actionaction)
{
awaitTask.Delay(100);

action();
}

asyncvoidTestCallback(ActionthrowAction,ActioncompleteAction)
{
model.Data=TestMethodAsync(throwAction);
model.Data=null;

awaitTask.Delay(200);

completeAction();
}

boolsuccess=awaitTaskSchedulerTestHelper.IsExceptionBubbledUpToUnobservedTaskExceptionAsync(TestCallback);

Assert.IsTrue(success);
}

[TestMethod]
publicasyncTaskTest_ObservableObject_ThrowingTaskOfTBubblesToUnobservedTaskException()
{
SampleModelWithTask<int>model=new();

staticasyncTask<int>TestMethodAsync(Actionaction)
{
awaitTask.Delay(100);

action();

return42;
}

asyncvoidTestCallback(ActionthrowAction,ActioncompleteAction)
{
model.Data=TestMethodAsync(throwAction);
model.Data=null;

awaitTask.Delay(200);

completeAction();
}

boolsuccess=awaitTaskSchedulerTestHelper.IsExceptionBubbledUpToUnobservedTaskExceptionAsync(TestCallback);

Assert.IsTrue(success);
}

publicclassSampleModelWithTask:ObservableObject
{
privateTaskNotifier?taskNotifier;

publicTask?Data
{
get=>this.taskNotifier;
set=>SetPropertyAndNotifyOnCompletion(refthis.taskNotifier,value);
}
}
}