public async Task TestCommand_With_Condition()
{
bool isCalled = false;
bool canExecute = false;
string parameter = null;
var command = new AsyncCommand <string>(async(p) =>
{
await Task.Delay(500);
isCalled = true;
parameter = p;
}, (p) => canExecute);
await command.ExecuteAsync("A");
Assert.AreEqual(false, command.CanExecute(null));
Assert.AreEqual(false, isCalled);
Assert.AreEqual(null, parameter);
canExecute = true;
await command.ExecuteAsync("A");
Assert.AreEqual(true, command.CanExecute(null));
Assert.AreEqual(true, isCalled);
Assert.AreEqual("A", parameter);
}
public async Task TestCommand_Chains_Cancel()
{
bool isCalled = false;
var command = new AsyncCommand(async() =>
{
await Task.Delay(2000);
isCalled = true;
});
command.CancellationTokenSource.CancelAfter(500);
await command.ExecuteAsync();
Assert.IsTrue(isCalled);
Assert.AreEqual(true, command.IsCancellationRequested);
command.CancellationTokenSource = new System.Threading.CancellationTokenSource();
Assert.AreEqual(false, command.IsCancellationRequested);
isCalled = false;
await command.ExecuteAsync();
Assert.IsTrue(isCalled);
Assert.AreEqual(false, command.IsCancellationRequested);
command.CancellationTokenSource.CancelAfter(500);
await command.ExecuteAsync();
Assert.IsTrue(isCalled);
Assert.AreEqual(true, command.IsCancellationRequested);
}
public async Task TestAsyncCommandCatchesException()
{
AsyncCommand <string> target = new AsyncCommand <string>(() => Task.Factory.StartNew(() =>
{
throw new Exception("an exception occured");
return("Failed");
}));
bool isFaultedEvent = false;
target.Execution.PropertyChanged += (s, e) =>
{
if (e.PropertyName.Equals("IsFaulted"))
{
isFaultedEvent = true;
}
};
target.ExecuteAsync(null);
while (target.Execution.IsNotCompleted)
{
}
Assert.IsTrue(target.Execution.IsFaulted, "task should be faulted");
Assert.IsFalse(target.Execution.IsSuccessfullyCompleted, "task should have failed");
Assert.AreEqual("an exception occured", target.Execution.ErrorMessage);
Assert.IsTrue(isFaultedEvent, "Faulted event should have been raised");
}
public async Task IAsyncCommand_CanExecuteChanged_AllowsMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
IAsyncCommand <int> command = new AsyncCommand <int>(IntParameterTask);
command.CanExecuteChanged += handleCanExecuteChanged;
Assert.IsTrue(command.AllowsMultipleExecutions);
// Act
var asyncCommandTask = command.ExecuteAsync(Delay);
// Assert
Assert.IsTrue(command.IsExecuting);
Assert.IsTrue(command.CanExecute(null));
// Act
await asyncCommandTask.ConfigureAwait(false);
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.AreEqual(0, canExecuteChangedCount);
command.CanExecuteChanged -= handleCanExecuteChanged;
void handleCanExecuteChanged(object?sender, EventArgs e) => canExecuteChangedCount++;
}
public async Task TimeoutSuccessCancelCommandTest()
{
var logs = new List <string>();
// Даем команде 5 секунд на выполнение
var command = new AsyncCommand(Execute).WithCancelledHandlerAsync(Cancelled).WithTimeout(5000);
// Команда выполняется 4 секунды и что-то асинхронно делает
// По окончании пишем в логгер об успехе
Task Execute(CancellationToken token)
=> Task.Run(async() =>
{
for (var i = 0; i < 40; i++)
{
await Task.Delay(100, token);
}
logs.Add("Command completed successfully");
}, token);
// Пишем в логгер, если команда отменилась
Task Cancelled(OperationCanceledException exception)
=> Task.Run(() => logs.Add("Command canceled"));
// Запускаем команду и ждем завершения
await command.ExecuteAsync();
Assert.AreEqual(1, logs.Count);
Assert.AreEqual("Command completed successfully", logs.Single());
Assert.False(command.IsExecuting);
}
public async Task ExecuteAsync_DoNotExecuteWhenCanExecuteReturnsFalse_Async()
{
// Arrange
var executed = false;
Task Execute()
{
executed = true;
return(Task.CompletedTask);
}
bool CanExecute() => false;
var errorHandler = new ErrorHandlerTestImplementation((cmd,
exception) =>
{
});
IAsyncCommand command = new AsyncCommand(Execute, CanExecute, errorHandler);
// Act
await command.ExecuteAsync();
// Assert
Assert.IsFalse(executed);
}
public async Task IAsyncCommand_CanExecuteChanged_DoesNotAllowMultipleExecutions_Test()
{
// Arrange
var canExecuteChangedCount = 0;
IAsyncCommand <int> command = new AsyncCommand <int>(IntParameterTask, allowsMultipleExecutions: false);
command.CanExecuteChanged += handleCanExecuteChanged;
Assert.False(command.AllowsMultipleExecutions);
// Act
var asyncCommandTask = command.ExecuteAsync(Delay);
// Assert
Assert.True(command.IsExecuting);
Assert.False(command.CanExecute(null));
// Act
await asyncCommandTask;
// Assert
Assert.True(command.CanExecute(null));
Assert.Equal(2, canExecuteChangedCount);
void handleCanExecuteChanged(object sender, EventArgs e) => canExecuteChangedCount++;
}
public async Task SuccessTaskTest()
{
var command = new AsyncCommand(SuccessFunc);
await command.ExecuteAsync(null);
Assert.AreEqual(TaskStatus.RanToCompletion, command.Execution.Status);
}
public async Task AsyncCommand_ExecuteAsync_IntParameter_Test(int parameter)
{
//Arrange
IAsyncCommand command = new AsyncCommand <int>(IntParameterTask);
//Act
await command.ExecuteAsync(parameter);
//Assert
}
public async Task AsyncCommand_ExecuteAsync_StringParameter_Test(string parameter)
{
//Arrange
IAsyncCommand command = new AsyncCommand <string>(StringParameterTask);
//Act
await command.ExecuteAsync(parameter);
//Assert
}
public async Task AsyncCommand_ExecuteAsync_NullableParameter_Test(int?parameter)
{
// Arrange
var command = new AsyncCommand <int?>(NullableParameterTask);
// Act
await command.ExecuteAsync(parameter).ConfigureAwait(false);
// Assert
}
public async Task AsyncCommand_ExecuteAsync_StringParameter_Test(string parameter)
{
// Arrange
var command = new AsyncCommand <string>(StringParameterTask);
// Act
await command.ExecuteAsync(parameter).ConfigureAwait(false);
// Assert
}
public async Task SettingIsExecutingFiresCanExecuteChangedEvent()
{
int changedCount = 0;
var command = new AsyncCommand(() => { return(Task.CompletedTask); });
command.CanExecuteChanged += delegate { changedCount += 1; };
await command.ExecuteAsync();
Assert.AreEqual(2, changedCount);
}
public async Task IsExecutingIsFalseAfterExecutingACommand()
{
Task action()
{
return(Task.CompletedTask);
};
var command = new AsyncCommand(action);
await command.ExecuteAsync();
Assert.IsFalse(command.IsExecuting);
}
public void ExecuteAsyncThrowsOnCancel()
{
var command = new AsyncCommand()
{
Action = (p, token) => Task.Delay(100, token)
};
var task = command.ExecuteAsync();
command.CancelCommand.Execute();
Assert.Throws <TaskCanceledException>(() => task.GetAwaiter().GetResult());
}
public async void ExecuteAsyncExecutesTheAction()
{
var run = false;
var command = new AsyncCommand <object>(async o =>
{
await AsyncMethod(() => run = true);
});
await command.ExecuteAsync(null);
run.Should().BeTrue();
}
public async void ExecuteAsyncDoesNotExecuteTheActionIfCanExecuteIsFalse()
{
var run = false;
var command = new AsyncCommand(async() =>
{
await AsyncMethod(() => run = true);
}, o => false);
await command.ExecuteAsync(null);
run.Should().BeFalse();
}
public async Task ExecuteAsync_CorrectExecutionWithCanExecuteChanged_Async()
{
// Arrange
var executed = false;
Task Execute()
{
executed = true;
return(Task.CompletedTask);
}
bool CanExecute() => true;
var errorHandler = new ErrorHandlerTestImplementation((cmd,
exception) =>
{
});
IAsyncCommand command = new AsyncCommand(Execute, CanExecute, errorHandler);
var invokedSenderList = new List <object>();
var invokedArgsList = new List <EventArgs>();
var invokedCanExecuteStateList = new List <bool>();
command.CanExecuteChanged += (sender,
args) =>
{
if (sender != null)
{
invokedSenderList.Add(sender);
}
if (args != null)
{
invokedArgsList.Add(args);
}
invokedCanExecuteStateList.Add(command.CanExecute());
};
// Act
await command.ExecuteAsync();
// Assert
Assert.IsTrue(executed);
Assert.AreEqual(2, invokedSenderList.Count);
Assert.AreSame(command, invokedSenderList[0]);
Assert.AreSame(command, invokedSenderList[1]);
Assert.AreEqual(2, invokedArgsList.Count);
Assert.AreSame(EventArgs.Empty, invokedArgsList[0]);
Assert.AreSame(EventArgs.Empty, invokedArgsList[1]);
Assert.AreEqual(2, invokedCanExecuteStateList.Count);
Assert.IsFalse(invokedCanExecuteStateList[0]); // Cannot execute during first execution, even when the CanExecute delegate returns true.
Assert.IsTrue(invokedCanExecuteStateList[1]); // Can execute after the execution has finished.
}
public async Task IAsyncCommand_ExecuteAsync_NoParameter_ContinueOnCapturedContext_Test(bool continueOnCapturedContext)
{
//Arrange
IAsyncCommand command = new AsyncCommand(NoParameterTask, continueOnCapturedContext);
var callingThreadId = Thread.CurrentThread.ManagedThreadId;
//Act
await command.ExecuteAsync(null);
var returningThreadId = Thread.CurrentThread.ManagedThreadId;
//Assert
Assert.AreNotEqual(callingThreadId, returningThreadId);
}
public async Task AsyncCommand_ExecuteAsync_Parameter_ContinueOnCapturedContext_Test(int parameter, bool continueOnCapturedContext)
{
//Arrange
AsyncCommand <int> command = new AsyncCommand <int>(IntParameterTask, continueOnCapturedContext);
var callingThreadId = Thread.CurrentThread.ManagedThreadId;
//Act
await command.ExecuteAsync(parameter);
var returningThreadId = Thread.CurrentThread.ManagedThreadId;
//Assert
Assert.AreNotEqual(callingThreadId, returningThreadId);
}
public async Task TestCommand()
{
bool isCalled = false;
var command = new AsyncCommand(async() =>
{
await Task.Delay(500);
isCalled = true;
});
await command.ExecuteAsync();
Assert.IsTrue(isCalled);
}
public async Task TestCommand_With_Condition()
{
bool isCalled = false;
bool canExecute = false;
var command = new AsyncCommand(async() =>
{
await Task.Delay(500);
isCalled = true;
}, () => canExecute);
await command.ExecuteAsync();
Assert.AreEqual(false, command.CanExecute(null));
Assert.AreEqual(false, isCalled);
canExecute = true;
await command.ExecuteAsync();
Assert.AreEqual(true, command.CanExecute(null));
Assert.AreEqual(true, isCalled);
}
public async Task IAsyncCommand_CanExecuteChanged_DoesNotAllowMultipleExecutions_Test()
{
// Arrange
var semaphoreSlim = new SemaphoreSlim(1, 1);
var canExecuteChangedCount = 0;
var handleCanExecuteChangedTCS = new TaskCompletionSource <int>();
IAsyncCommand <int> command = new AsyncCommand <int>(IntParameterTask, allowsMultipleExecutions: false);
command.CanExecuteChanged += handleCanExecuteChanged;
Assert.False(command.AllowsMultipleExecutions);
// Act
var asyncCommandTask = command.ExecuteAsync(Delay);
// Assert
Assert.IsTrue(command.IsExecuting);
Assert.False(command.CanExecute(null));
// Act
await asyncCommandTask.ConfigureAwait(false);
var handleCanExecuteChangedREsult = await handleCanExecuteChangedTCS.Task.ConfigureAwait(false);
// Assert
Assert.IsTrue(command.CanExecute(null));
Assert.AreEqual(2, canExecuteChangedCount);
Assert.AreEqual(canExecuteChangedCount, handleCanExecuteChangedREsult);
async void handleCanExecuteChanged(object?sender, EventArgs e)
{
await semaphoreSlim.WaitAsync().ConfigureAwait(false);
try
{
if (++canExecuteChangedCount is 2)
{
command.CanExecuteChanged -= handleCanExecuteChanged;
handleCanExecuteChangedTCS.SetResult(canExecuteChangedCount);
}
}
finally
{
semaphoreSlim.Release();
}
}
}
public async Task IsExecutingIsFalseAfterExecutingACommandAndCommandThrowsAnException()
{
Task action()
{
throw new Exception();
};
var command = new AsyncCommand(action);
try
{
await command.ExecuteAsync();
}
catch
{
Assert.IsFalse(command.IsExecuting);
}
}
public async Task FaultedTaskTest()
{
var command = new AsyncCommand(ExeptionFunc);
var task = command.ExecuteAsync(null);
// catch execption that the method will continue after fault
try
{
await task;
}
catch (Exception)
{
}
Assert.AreEqual(TaskStatus.Faulted, command.Execution.Status);
}
public async Task CanExecuteSimpleTest()
{
var command = new AsyncCommand(LongSuccessFunc);
var task = command.ExecuteAsync(null);
var execution = command.Execution;
ThreadPool.QueueUserWorkItem(delegate
{
Thread.Sleep(50);
Console.WriteLine("task ended");
Assert.True(execution.IsNotCompleted);
});
await task;
}
public async Task TestCommand()
{
bool isCalled = false;
string parameter = null;
var command = new AsyncCommand <string>(async(p) =>
{
await Task.Delay(500);
isCalled = true;
parameter = p;
});
await command.ExecuteAsync("A");
Assert.IsTrue(isCalled);
Assert.AreEqual("A", parameter);
}
public ExceptionViewModel(INavigationService navigationService)
{
NavigationService = navigationService;
// Устанавливаем команду для асинхронной инициализации с обработчиком ошибки
InitAsyncCommand = new AsyncCommand(InitAsync).WithFaultedHandlerAsync(FaultedHandlerAsync);
// Обратить внимание запуск в конструкторе и без await!
// Это норм - обработка исключения внутри команды
InitAsyncCommand.ExecuteAsync();
CloseCommand = new AsyncCommand(_ =>
{
// Не забываем отменить асинхронную инициализацию при закрытии страницы
// Вдруг она еще не отработала
InitAsyncCommand.Cancel();
return(navigationService.CloseAsync(this));
});
}
public async void ProgressAction(AsyncCommand command)
{
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
StackProgress.IsVisible = true;
GridContent.IsVisible = false;
});
if (command != null)
{
await command.ExecuteAsync(null);
}
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
StackProgress.IsVisible = false;
GridContent.IsVisible = true;
});
}
public void ExecuteAsyncTest()
{
asyncTestCommand = new AsyncCommand <int>((a) => AsyncExecuteMethod3(a));
int isExecutingChangedCount = 0;
((INotifyPropertyChanged)asyncTestCommand).PropertyChanged += (s, e) =>
e.If(x => x.PropertyName == "IsExecuting").Do(x => isExecutingChangedCount++);
bool completed = false;
asyncTestCommand.ExecuteAsync(100).ContinueWith(x => {
Assert.AreEqual(2, isExecutingChangedCount);
Assert.AreEqual(false, asyncTestCommand.IsExecuting);
completed = true;
});
Assert.Throws <NotSupportedException>(() => asyncTestCommand.Wait(),
"The Wait method is not supported when you use the ExecuteAsync method. Use async/await syntax instead.");
WaitCondition(() => completed);
Assert.AreEqual(true, completed);
}
