[Bug] AsyncCommand is not testable

[WebDucer]

Description

Priviously we used DelegateCommand from Prism library but want to switch to AsyncCommands now. One of the reasons was, to be able to test easier commands with async actions behind them (most of them).

If we try to unit test our view models with AsyncCommand, the executeion fails due to hard dependecy on Device.BeginInvokeOnMainThread method.

Steps to Reproduce

1. Create a view model with an AsyncCommand
2. Create unit test, to test the execution of this command
3. Test fails with exception

Expected Behavior

It should be possible to test view models, without initializing Xamarin.Forms

Actual Behavior

Basic Information

• Version with issue: 1.0.2
• Last known good version: unknown
• IDE: VS 2019 16.8.4
• Platform Target Frameworks: NUinit with on .Net Core 3.1 project

Workaround

Not using AsyncCommand!

Reproduction imagery

[Test]
public async Task ResultCommand_Returns()
{
    // Arrange
    var expected = "returned result";
    var nav = Mock.Of<ICommonNavigationService>();
    var result = new Result(expected, new byte[0], new ResultPoint[0], BarcodeFormat.QR_CODE);

    var sut = CreateViewModel(nav);

    // Act
    await sut.ResultCommand.ExecuteAsync(result);

    // Assert
    Mock.Get(nav).Verify(v => v.ToPreviousWithDataAsync(CommonConstants.NavigationKeys.QR_CODE_CONTENT, expected), Times.Once);
}

Example

Log output

System.InvalidOperationException : You must call Xamarin.Forms.Forms.Init(); prior to using this property.
   at Xamarin.Forms.Device.get_PlatformServices()
   at Xamarin.Forms.Device.BeginInvokeOnMainThread(Action action)
   at Xamarin.CommunityToolkit.ObjectModel.Internals.BaseCommand`1.RaiseCanExecuteChanged()
   at Xamarin.CommunityToolkit.ObjectModel.Internals.BaseCommand`1.set_ExecutionCount(Int32 value)
   at Xamarin.CommunityToolkit.ObjectModel.Internals.BaseAsyncCommand`2.ExecuteAsync(TExecute parameter)
   at Xamarin.Common.Tests.ViewModels.QrScanViewModelTests.ResultCommand_Returns() in C:\src\XF Libs\Xamarin.Common-69-xamarin_forms_5\tests\Xamarin.Common.Tests\ViewModels\QrScanViewModelTests.cs:line 60
   at NUnit.Framework.Internal.TaskAwaitAdapter.GenericAdapter`1.GetResult()
   at NUnit.Framework.Internal.AsyncToSyncAdapter.Await(Func`1 invoke)
   at NUnit.Framework.Internal.Commands.TestMethodCommand.RunTestMethod(TestExecutionContext context)
   at NUnit.Framework.Internal.Commands.TestMethodCommand.Execute(TestExecutionContext context)
   at NUnit.Framework.Internal.Execution.SimpleWorkItem.<>c__DisplayClass4_0.<PerformWork>b__0()
   at NUnit.Framework.Internal.ContextUtils.<>c__DisplayClass1_0`1.<DoIsolated>b__0(Object _)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
--- End of stack trace from previous location where exception was thrown ---
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at NUnit.Framework.Internal.ContextUtils.DoIsolated(ContextCallback callback, Object state)
   at NUnit.Framework.Internal.ContextUtils.DoIsolated[T](Func`1 func)
   at NUnit.Framework.Internal.Execution.SimpleWorkItem.PerformWork()

I suppose, the following line produce the problem:

XamarinCommunityToolkit/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseCommand.shared.cs

Lines 80 to 87 in 04c3cd5

	/// <summary>
	/// Raises the `ICommand.CanExecuteChanged` event.
	/// </summary>
	public void RaiseCanExecuteChanged()
	{
	// Automatically marshall to the Main Thread to adhere to the way that Xamarin.Forms automatically marshalls binding events to Main Thread
	Device.BeginInvokeOnMainThread(() => weakEventManager.RaiseEvent(this, EventArgs.Empty, nameof(CanExecuteChanged)));
	}

Reproduction Link

[roubachof]

Maybe it's the answer you're looking for:

https://brianlagunas.com/mocking-and-unit-testing-the-xamarin-forms-application-class/

"If you follow that up the chain, you’ll see that for each platform in the Forms.Init() call, these values are being set based on the platform. So this means we need to create our own Init() call for our unit tests!"

We should maybe add a "using XCT in test projects" to the docs...

[WebDucer]

@roubachof This could be a workaround, but not my prefered solution. A view model has only two parts visible and testable. This are properties (backed with INotifyPropertyChanged and Commands. I expect to be able to test a view model, without framework initialization.

If I want to test controls, this is other playground. There I would expect prlatform initialization.

[roubachof]

I understand your separation of concerns :)
However if RaiseCanExecuteChanged does not raise the events on the main thread, it means that the async code passed as argument must be ran on the main thread. With this line, it's up to the user to decide whether or not he wants its async code to be on a different thread. So yeah it's not perfect but I guess it's an acceptable tradeoff.

[WebDucer]

Brian Lagunas in Prism.Core library uses own synchronization context in commands, so there is no dependency on Device-Singleton.

Singletons is something that I don't like in tests 😉 .

https://github.com/PrismLibrary/Prism/blob/0fc56abbea733a319c9734c65d1110db07f7ebd4/src/Prism.Core/Commands/DelegateCommandBase.cs#L37-L47

protected virtual void OnCanExecuteChanged()
{
	var handler = CanExecuteChanged;
	if (handler != null)
	{
		if (_synchronizationContext != null && _synchronizationContext != SynchronizationContext.Current)
			_synchronizationContext.Post((o) => handler.Invoke(this, EventArgs.Empty), null);
		else
			handler.Invoke(this, EventArgs.Empty);
	}
}

[roubachof]

I was afraid that using SynchronizationContext.Current would be different from using Device.BeginInvokeOnMainThread cause it won't use native Android looper:

https://github.com/xamarin/Xamarin.Forms/blob/80a4dbfb1cd897f478c38d0aafa6a5d67940d2f3/Xamarin.Forms.Platform.Android/Forms.cs#L637-L651

But I did some digging and found out that SynchronizationContext.Current use looper on mono android:

https://github.com/xamarin/xamarin-android/blob/aad2c29e30e362b19bf526eb14075d8325a1f2d8/src/Mono.Android/Android.App/SyncContext.cs

So I guess the solution implemented by prism should be considered :)

[WebDucer]

@roubachof Should I make a PR for this? As I can see, the change would only happen in the base class BaseCommand.

[roubachof]

I would personally be ok with a PR, but since it is mostly @brminnick code, it's a gentleman agreement to have his opinion on the subject first.

[TheCodeTraveler]

Workaround

The workaround is to create MockDeviceInfo.cs, and MockPlatformServices.cs, and initialize both in [Setup].

[Setup]

We can use the [Setup] attribute to run code before each test.

Here is the code for [Setup] that I use to Unit Test my GitTrends app: https://github.com/brminnick/GitTrends/blob/dea981a9a0fe2319cac1c70cd85757e68331df98/GitTrends.UnitTests/Tests/Base/BaseTest.cs#L24-L35

[SetUp]
public virtual async Task Setup()
{
    Xamarin.Forms.Device.Info = new MockDeviceInfo();
    Xamarin.Forms.Device.PlatformServices = new MockPlatformServices();
}

MockDeviceInfo

Here is the code for MockDeviceInfo that I use to Unit Test my GitTrends app:
https://github.com/brminnick/GitTrends/blob/dea981a9a0fe2319cac1c70cd85757e68331df98/GitTrends.UnitTests/MockServices/MockDeviceInfo.cs#L6

class MockDeviceInfo : DeviceInfo
{
    public override Size PixelScreenSize { get; } = new Size(0, 0);

    public override Size ScaledScreenSize { get; } = new Size(0, 0);

    public override double ScalingFactor { get; } =  1;
}

MockPlatformServices

Here is the code for MockPlatformServices that I use to Unit Test my GitTrends app:
https://github.com/brminnick/GitTrends/blob/dea981a9a0fe2319cac1c70cd85757e68331df98/GitTrends.UnitTests/MockServices/MockPlatformServices.cs

using System;
using System.Collections.Generic;
using System.IO.IsolatedStorage;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using GitTrends.UnitTests;
using Xamarin.Forms;
using Xamarin.Forms.Internals;
using FileAccess = System.IO.FileAccess;
using FileMode = System.IO.FileMode;
using FileShare = System.IO.FileShare;
using Stream = System.IO.Stream;

[assembly: Dependency(typeof(MockDeserializer))]
[assembly: Dependency(typeof(MockResourcesProvider))]
namespace GitTrends.UnitTests
{
    class MockPlatformServices : IPlatformServices
    {
        readonly Action<Action>? _invokeOnMainThread;
        readonly Action<Uri>? _openUriAction;
        readonly Func<Uri, CancellationToken, Task<Stream>>? _getStreamAsync;
        readonly Func<VisualElement, double, double, SizeRequest>? _getNativeSizeFunc;
        readonly bool _useRealisticLabelMeasure;

        public MockPlatformServices(Action<Action>? invokeOnMainThread = null,
                                    Action<Uri>? openUriAction = null,
                                    Func<Uri, CancellationToken, Task<Stream>>? getStreamAsync = null,
                                    Func<VisualElement, double, double, SizeRequest>? getNativeSizeFunc = null,
                                    bool useRealisticLabelMeasure = false)
        {
            _invokeOnMainThread = invokeOnMainThread;
            _openUriAction = openUriAction;
            _getStreamAsync = getStreamAsync;
            _getNativeSizeFunc = getNativeSizeFunc;
            _useRealisticLabelMeasure = useRealisticLabelMeasure;
        }

        public OSAppTheme RequestedTheme { get; } = OSAppTheme.Unspecified;

        public bool IsInvokeRequired { get; } = false;

        public string RuntimePlatform { get; } = "Other";

        public string GetMD5Hash(string input) => throw new NotImplementedException();

        public string GetHash(string input) => throw new NotImplementedException();

        public double GetNamedSize(NamedSize size, Type targetElement, bool useOldSizes) => size switch
        {
            NamedSize.Default => 10,
            NamedSize.Micro => 4,
            NamedSize.Small => 8,
            NamedSize.Medium => 12,
            NamedSize.Large => 16,
            _ => throw new ArgumentOutOfRangeException(nameof(size)),
        };

        public Color GetNamedColor(string name) => name switch
        {
            "SystemBlue" => Color.FromRgb(0, 122, 255),
            "SystemChromeHighColor" => Color.FromHex("#FF767676"),
            "HoloBlueBright" => Color.FromHex("#ff00ddff"),
            _ => Color.Default,
        };

        public void OpenUriAction(Uri uri)
        {
            if (_openUriAction != null)
                _openUriAction(uri);
            else
                throw new NotImplementedException();
        }

        public void BeginInvokeOnMainThread(Action action)
        {
            if (_invokeOnMainThread is null)
                action();
            else
                _invokeOnMainThread(action);
        }

        public Ticker CreateTicker() => new MockTicker();

        public void StartTimer(TimeSpan interval, Func<bool> callback)
        {
            Timer? timer = null;
            timer = new Timer(onTimeout, null, interval, interval);

            void onTimeout(object? o) => BeginInvokeOnMainThread(() =>
            {
                if (callback())
                    return;

                timer?.Dispose();
            });
        }

        public Task<Stream> GetStreamAsync(Uri uri, CancellationToken cancellationToken)
        {
            if (_getStreamAsync is null)
                throw new NotImplementedException();

            return _getStreamAsync(uri, cancellationToken);
        }

        public Assembly[] GetAssemblies() => AppDomain.CurrentDomain.GetAssemblies();

        public IIsolatedStorageFile GetUserStoreForApplication() => new MockIsolatedStorageFile(IsolatedStorageFile.GetUserStoreForAssembly());

        public class MockIsolatedStorageFile : IIsolatedStorageFile
        {
            readonly IsolatedStorageFile _isolatedStorageFile;

            public MockIsolatedStorageFile(IsolatedStorageFile isolatedStorageFile) =>
                _isolatedStorageFile = isolatedStorageFile;

            public Task<bool> GetDirectoryExistsAsync(string path) => Task.FromResult(_isolatedStorageFile.DirectoryExists(path));

            public Task CreateDirectoryAsync(string path)
            {
                _isolatedStorageFile.CreateDirectory(path);
                return Task.FromResult(true);
            }

            public Task<Stream> OpenFileAsync(string path, FileMode mode, FileAccess access)
            {
                Stream stream = _isolatedStorageFile.OpenFile(path, mode, access);
                return Task.FromResult(stream);
            }

            public Task<Stream> OpenFileAsync(string path, FileMode mode, FileAccess access, FileShare share)
            {
                Stream stream = _isolatedStorageFile.OpenFile(path, mode, access, share);
                return Task.FromResult(stream);
            }

            public Task<bool> GetFileExistsAsync(string path) => Task.FromResult(_isolatedStorageFile.FileExists(path));

            public Task<DateTimeOffset> GetLastWriteTimeAsync(string path) => Task.FromResult(_isolatedStorageFile.GetLastWriteTime(path));
        }

        public void QuitApplication()
        {

        }

        public SizeRequest GetNativeSize(VisualElement view, double widthConstraint, double heightConstraint)
        {
            if (_getNativeSizeFunc != null)
                return _getNativeSizeFunc(view, widthConstraint, heightConstraint);

            if (view is Label label && _useRealisticLabelMeasure)
            {
                var letterSize = new Size(5, 10);
                var w = label.Text.Length * letterSize.Width;
                var h = letterSize.Height;
                if (!double.IsPositiveInfinity(widthConstraint) && w > widthConstraint)
                {
                    h = ((int)w / (int)widthConstraint) * letterSize.Height;
                    w = widthConstraint - (widthConstraint % letterSize.Width);

                }
                return new SizeRequest(new Size(w, h), new Size(Math.Min(10, w), h));
            }

            return new SizeRequest(new Size(100, 20));
        }
    }

    class MockDeserializer : IDeserializer
    {
        public Task<IDictionary<string, object>> DeserializePropertiesAsync() =>
            Task.FromResult<IDictionary<string, object>>(new Dictionary<string, object>());

        public Task SerializePropertiesAsync(IDictionary<string, object> properties) => Task.FromResult(false);
    }

    class MockResourcesProvider : ISystemResourcesProvider
    {
        public IResourceDictionary GetSystemResources()
        {
            var dictionary = new ResourceDictionary();

            Style style;
            style = new Style(typeof(Label));
            dictionary[Device.Styles.BodyStyleKey] = style;

            style = new Style(typeof(Label));
            style.Setters.Add(Label.FontSizeProperty, 50);
            dictionary[Device.Styles.TitleStyleKey] = style;

            style = new Style(typeof(Label));
            style.Setters.Add(Label.FontSizeProperty, 40);
            dictionary[Device.Styles.SubtitleStyleKey] = style;

            style = new Style(typeof(Label));
            style.Setters.Add(Label.FontSizeProperty, 30);
            dictionary[Device.Styles.CaptionStyleKey] = style;

            style = new Style(typeof(Label));
            style.Setters.Add(Label.FontSizeProperty, 20);
            dictionary[Device.Styles.ListItemTextStyleKey] = style;

            style = new Style(typeof(Label));
            style.Setters.Add(Label.FontSizeProperty, 10);
            dictionary[Device.Styles.ListItemDetailTextStyleKey] = style;

            return dictionary;
        }
    }

    public class MockApplication : Application
    {
        public MockApplication()
        {
        }
    }

    class MockTicker : Ticker
    {
        bool _enabled;

        protected override void EnableTimer()
        {
            _enabled = true;

            while (_enabled)
            {
                SendSignals(16);
            }
        }

        protected override void DisableTimer() => _enabled = false;
    }
}

[TheCodeTraveler]

Now that we have the workaround out of the way (hopefully it helps fellow devs who may experience the same problem!), @WebDucer yes a PR to replace Device.BeginInvokeOnMainThread with SynchronizationContext.Post is a great idea!

Feel free to assign me as the reviewer to your PR once it's open!

[WebDucer]

@roubachof @brminnick OK. Then I will take this and make a PR in the next days.