问题 如何在MVVM中对异步ICommand进行单元测试？


我一直在谷歌搜索，甚至Binging，我还没有想出任何令人满意的东西。

我有一个ViewModel，它有一些命令，例如： SaveCommand， NewCommand 和 DeleteCommand。我的 SaveCommand 执行保存到文件操作，我想成为 async 操作，以便UI不等待它。

我的 SaveCommand 是一个实例 AsyncCommand，实现 ICommand。

 SaveCommand = new AsyncCommand(
  async param =>
        {
            Connection con = await Connection.GetInstanceAsync(m_configurationPath);
            con.Shoppe.Configurations = new List<CouchDbConfig>(m_configurations);
            await con.SaveConfigurationAsync(m_configurationPath);
            //now that its saved, we reload the Data.
            await LoadDataAsync(m_configurationPath);
        }, 
 ...etc

现在我正在为我的ViewModel构建一个测试。在其中，我创造了一个新的东西 NewCommand，我修改它，然后使用 SaveCommand。 

vm.SaveCommand.Execute(null);
Assert.IsFalse(vm.SaveCommand.CanExecute(null));

我的 CanExecute 方法（未示出） SaveCommand 应该回来 False 在项目保存之后（保存未更改的项目没有意义）。但是，上面显示的Assert总是失败，因为我不是在等待 SaveCommand 完成执行。

现在，我迫不及待地想要完成执行，因为我做不到。该 ICommand.Execute 没有返回 Task。如果我改变了 AsyncCommand 拥有它 Execute 回来一个 Task 那么它就不会实现了 ICommand 界面正常。

因此，出于测试目的，我认为我现在唯一可以做的就是 AsynCommand 有一个新功能：

public async Task ExecuteAsync(object param) { ... }

因此，我的测试将运行（和 await） ExecuteAsync 函数和XAML UI将运行 ICommand.Execute 它没有的方法 await。

我不像我想的那样对我提出的解决方案方法感到高兴，并希望并希望有更好的方法。

是我的建议，合理吗？有没有更好的办法？


9398
2018-04-28 12:35


起源
您的命令中是否有任何属性显示“正在运行”或“正在执行”？也许一种方法是在命令中添加执行标志。可能还会修复测试失败的原因，您可以使用CanExecute中的Executing标志来确保它们不会运行两次命令。 - Ron Beyer
我明白你的意思了。让我试一试。 *很快回来 - Peter pete
实际上，AsyncCommand已经有Executing标志。当我最初发现问题TBH时，我没有使用AsyncCommand，而是另一个没有使用AsyncCommand的东西。也许我现在实际上没有问题！ ..测试 - Peter pete
@RonBeyer：单元测试中的Assert现在通过，我的UI也可以工作，这要归功于Executing标志。但是，当单元测试结束时，我从SaveCommand得到一个ThreadAbortException，仍然将项目保存到文件中。虽然，“不是一个真正的问题”，但我想知道我是否能干净利落地完成它。 - Peter pete
我只是花一点时间（vm.SaveCommand.Executing）;在断言下验证操作是否完成。它会使测试运行时间更长，但可能会干净利落地执行。 - Ron Beyer

答案:

看起来答案是使用标志 AsyncCommand 目的。使用 Executing 的旗帜 AsyncCommand 在里面 CanExecute 方法将确保用户在另一个实例运行时无法执行该命令。

通过单元测试，您可以使用while循环使其在断言后等待：

while (vm.SaveCommand.Executing) ;

这样测试就会干净利落地进行。


2
2018-04-28 13:26


所以你的意思是这比添加另一个返回a的方法更清晰 Task？ - Sriram Sakthivel
是的，如果它意味着 Task 仅用于测试目的。我会避免编写额外的代码来通过测试，因为它会破坏测试的目的。 - Ron Beyer
我认为它更清洁。由于没有两个令人困惑的Execute方法。 - Peter pete
@RonBeyer你的方法并不好。您还将介绍一个仅用于测试的属性。这对你有好处吗？检查 本文 stephen建议添加另一个返回Task的方法，该方法很好地封装在另一个接口中。 - Sriram Sakthivel
@SriramSakthivel我没有创建属性，它已经存在于AsyncCommand对象上，请查看问题的注释。 - Ron Beyer

你的建议是合理的，而且正是如此 AsyncCommand 由Stephen Cleary创建的实现 （他是最重要的人之一） 关于异步主题的专家 代码恕我直言）

这是文章中代码的完整实现（加上我为我使用的用例做的一些调整。）

AsyncCommand.cs

/*
 * Based on the article: Patterns for Asynchronous MVVM Applications: Commands
 * http://msdn.microsoft.com/en-us/magazine/dn630647.aspx
 * 
 * Modified by Scott Chamberlain 11-19-2014
 * - Added parameter support 
 * - Added the ability to shut off the single invocation restriction.
 * - Made a non-generic version of the class that called the generic version with a <object> return type.
 */
using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;

namespace Infrastructure
{
    public class AsyncCommand : AsyncCommand<object>
    {
        public AsyncCommand(Func<object, Task> command) 
            : base(async (parmater, token) => { await command(parmater); return null; }, null)
        {
        }

        public AsyncCommand(Func<object, Task> command, Func<object, bool> canExecute)
            : base(async (parmater, token) => { await command(parmater); return null; }, canExecute)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task> command)
            : base(async (parmater, token) => { await command(parmater, token); return null; }, null)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task> command, Func<object, bool> canExecute)
            : base(async (parmater, token) => { await command(parmater, token); return null; }, canExecute)
        {
        }
    }

    public class AsyncCommand<TResult> : AsyncCommandBase, INotifyPropertyChanged
    {
        private readonly Func<object, CancellationToken, Task<TResult>> _command;
        private readonly CancelAsyncCommand _cancelCommand;
        private readonly Func<object, bool> _canExecute;
        private NotifyTaskCompletion<TResult> _execution;
        private bool _allowMultipleInvocations;

        public AsyncCommand(Func<object, Task<TResult>> command)
            : this((parmater, token) => command(parmater), null)
        {
        }

        public AsyncCommand(Func<object, Task<TResult>> command, Func<object, bool> canExecute)
            : this((parmater, token) => command(parmater), canExecute)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task<TResult>> command)
            : this(command, null)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task<TResult>> command, Func<object, bool> canExecute)
        {
            _command = command;
            _canExecute = canExecute;
            _cancelCommand = new CancelAsyncCommand();
        }


        public override bool CanExecute(object parameter)
        {
            var canExecute = _canExecute == null || _canExecute(parameter);
            var executionComplete = (Execution == null || Execution.IsCompleted);

            return canExecute && (AllowMultipleInvocations || executionComplete);
        }

        public override async Task ExecuteAsync(object parameter)
        {
            _cancelCommand.NotifyCommandStarting();
            Execution = new NotifyTaskCompletion<TResult>(_command(parameter, _cancelCommand.Token));
            RaiseCanExecuteChanged();
            await Execution.TaskCompletion;
            _cancelCommand.NotifyCommandFinished();
            RaiseCanExecuteChanged();
        }

        public bool AllowMultipleInvocations
        {
            get { return _allowMultipleInvocations; }
            set
            {
                if (_allowMultipleInvocations == value)
                    return;

                _allowMultipleInvocations = value;
                OnPropertyChanged();
            }
        }

        public ICommand CancelCommand
        {
            get { return _cancelCommand; }
        }

        public NotifyTaskCompletion<TResult> Execution
        {
            get { return _execution; }
            private set
            {
                _execution = value;
                OnPropertyChanged();
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }

        private sealed class CancelAsyncCommand : ICommand
        {
            private CancellationTokenSource _cts = new CancellationTokenSource();
            private bool _commandExecuting;

            public CancellationToken Token { get { return _cts.Token; } }

            public void NotifyCommandStarting()
            {
                _commandExecuting = true;
                if (!_cts.IsCancellationRequested)
                    return;
                _cts = new CancellationTokenSource();
                RaiseCanExecuteChanged();
            }

            public void NotifyCommandFinished()
            {
                _commandExecuting = false;
                RaiseCanExecuteChanged();
            }

            bool ICommand.CanExecute(object parameter)
            {
                return _commandExecuting && !_cts.IsCancellationRequested;
            }

            void ICommand.Execute(object parameter)
            {
                _cts.Cancel();
                RaiseCanExecuteChanged();
            }

            public event EventHandler CanExecuteChanged
            {
                add { CommandManager.RequerySuggested += value; }
                remove { CommandManager.RequerySuggested -= value; }
            }

            private void RaiseCanExecuteChanged()
            {
                CommandManager.InvalidateRequerySuggested();
            }
        }
    }
}

AsyncCommandBase.cs

/*
 * Based on the article: Patterns for Asynchronous MVVM Applications: Commands
 * http://msdn.microsoft.com/en-us/magazine/dn630647.aspx
 */
using System;
using System.Threading.Tasks;
using System.Windows.Input;

namespace Infrastructure
{
    public abstract class AsyncCommandBase : IAsyncCommand
    {
        public abstract bool CanExecute(object parameter);

        public abstract Task ExecuteAsync(object parameter);

        public async void Execute(object parameter)
        {
            await ExecuteAsync(parameter);
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }

        protected void RaiseCanExecuteChanged()
        {
            CommandManager.InvalidateRequerySuggested();
        }
    }
}

NotifyTaskCompletion.cs

/*
 * Based on the article: Patterns for Asynchronous MVVM Applications: Commands
 * http://msdn.microsoft.com/en-us/magazine/dn630647.aspx
 * 
 * Modifed by Scott Chamberlain on 12/03/2014
 * Split in to two classes, one that does not return a result and a 
 * derived class that does.
 */

using System;
using System.ComponentModel;
using System.Threading.Tasks;

namespace Infrastructure
{
    public sealed class NotifyTaskCompletion<TResult> : NotifyTaskCompletion
    {
        public NotifyTaskCompletion(Task<TResult> task)
            : base(task)
        {
        }

        public TResult Result
        {
            get
            {
                return (Task.Status == TaskStatus.RanToCompletion) ?
                    ((Task<TResult>)Task).Result : default(TResult);
            }
        }
    }

    public class NotifyTaskCompletion : INotifyPropertyChanged
    {
        public NotifyTaskCompletion(Task task)
        {
            Task = task;
            if (!task.IsCompleted)
                TaskCompletion = WatchTaskAsync(task);
            else
                TaskCompletion = Task;
        }

        private async Task WatchTaskAsync(Task task)
        {
            try
            {
                await task;
            }
            catch
            {
                //This catch is intentionally empty, the errors will be handled lower on the "task.IsFaulted" branch.
            }
            var propertyChanged = PropertyChanged;
            if (propertyChanged == null)
                return;
            propertyChanged(this, new PropertyChangedEventArgs("Status"));
            propertyChanged(this, new PropertyChangedEventArgs("IsCompleted"));
            propertyChanged(this, new PropertyChangedEventArgs("IsNotCompleted"));
            if (task.IsCanceled)
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsCanceled"));
            }
            else if (task.IsFaulted)
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsFaulted"));
                propertyChanged(this, new PropertyChangedEventArgs("Exception"));
                propertyChanged(this, new PropertyChangedEventArgs("InnerException"));
                propertyChanged(this, new PropertyChangedEventArgs("ErrorMessage"));
            }
            else
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsSuccessfullyCompleted"));
                propertyChanged(this, new PropertyChangedEventArgs("Result"));
            }
        }

        public Task Task { get; private set; }
        public Task TaskCompletion { get; private set; }
        public TaskStatus Status { get { return Task.Status; } }
        public bool IsCompleted { get { return Task.IsCompleted; } }
        public bool IsNotCompleted { get { return !Task.IsCompleted; } }
        public bool IsSuccessfullyCompleted
        {
            get
            {
                return Task.Status ==
                    TaskStatus.RanToCompletion;
            }
        }
        public bool IsCanceled { get { return Task.IsCanceled; } }
        public bool IsFaulted { get { return Task.IsFaulted; } }
        public AggregateException Exception { get { return Task.Exception; } }
        public Exception InnerException
        {
            get
            {
                return (Exception == null) ?
                    null : Exception.InnerException;
            }
        }
        public string ErrorMessage
        {
            get
            {
                return (InnerException == null) ?
                    null : InnerException.Message;
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
    }
}

12
2018-04-28 13:53


Wowsers。这似乎做了一切，包括厨房水槽！我同意这是一个看似非常完整的实现，包括取消等等。现在，我的问题是，我的答案是正确的？对于我的直接需求，我可能需要一段时间才能在我的测试用例中使用while循环。但我理解这个答案是最完整的，并最终解决了我的直接问题，也可能解决了我未来的所有问题。 - Peter pete

回顾其他答案

干 while (vm.SaveCommand.Executing) ; 似乎 忙着等待 而我更喜欢 避免这样做。

使用其他解决方案 AsyncCommand 斯蒂芬克利里似乎有点 这样一个简单的任务有点过分。

我提议的方法不会打破封装 - Save 方法不会暴露任何内部。它只是提供了另一种访问相同功能的方法。

我的解决方案似乎涵盖了所需的一切 简单明了的方式。

建议

我会建议 重构 这段代码：

SaveCommand = new AsyncCommand(
    async param =>
    {
        Connection con = await Connection.GetInstanceAsync(m_configurationPath);
        con.Shoppe.Configurations = new List<CouchDbConfig>(m_configurations);
        await con.SaveConfigurationAsync(m_configurationPath);
        //now that its saved, we reload the Data.
        await LoadDataAsync(m_configurationPath);
    });

至：

SaveCommand = new RelayCommand(async param => await Save(param));

public async Task Save(object param)
{
    Connection con = await Connection.GetInstanceAsync(m_configurationPath);
    con.Shoppe.Configurations = new List<CouchDbConfig>(m_configurations);
    await con.SaveConfigurationAsync(m_configurationPath);
    //now that its saved, we reload the Data.
    await LoadDataAsync(m_configurationPath);
}

请注意：我改变了 AsyncCommand至 RelayCommand 可以在任何MVVM框架中找到它。它只是接收一个动作作为参数并在运行时运行 ICommand.Execute 方法被调用。

单元测试

我使用支持的NUnit框架做了一个例子 async 测试：

[Test]
public async Task MyViewModelWithAsyncCommandsTest()
{
    // Arrange
    // do view model initialization here

    // Act
    await vm.Save(param);

    // Assert
    // verify that what what you expected actually happened
}

并在视图中绑定命令，就像你通常会做的那样：

Command="{Binding SaveCommand}"

0
2017-07-08 08:09



热门问题

不使用eval / new函数的JavaScript模板库 当涉及内部类时，Java继承如何工作 .NET Windows服务的奇怪问题 在.ipa或.app下查找App ID 快速入门XSLT参考[关闭] 如何找出Android应用程序中未使用的资源 Ruby中并发的同步方法[重复] 将std :: chrono :: system_clock :: time_point转换为struct timeval并返回 Google Drive API V3（javascript）更新文件内容 Bootstrap 3.0 - 将元素推到底部 受密码保护的.NET ClickOnce部署？ 如何用postgresql安装wordpress coq Set或Type如何成为命题 硒滚动元素进入（中心）视图 在Spring Transaction JUnit测试中自动装配Hibernate会话的正确方法 Git的Dockerfile策略 如何在FOS_PICKFOLDER中使用IFileDialog，同时仍在对话框中显示文件名 在Firefox扩展中复制Google Chrome浏览器操作弹出效果 CakePHP找到MAX 芹菜 - 完成任务的召唤功能 从使用fmemopen创建的流中读取宽字符 .NET是否为每个程序集创建一个字符串实习池？ DefaultModelBinder不绑定嵌套模型 Navigator.MediaDevices.getUserMedia（）使用了哪些相机通信标准？ 选择命名空间名称时应该知道什么？ cout Swagger Codegen CLI Java客户端 - 如何正确使用它 一个很好的哈希函数用于采访整数，字符串？ Maven 3 ciManagement配置的目的是什么？ 如何通过语言文化获取代码页？
licensed under cc by-sa 3.0 with attribution.
隐私政策 往来