public void CancellationFiresCanceled()
{
var runner = new CommandRunner();
var cancelException = new CommandCanceledException();
CommandCanceledException firedReason = null;
int fireCount = 0;
runner.TaskCanceled += (sender, e) => {
++fireCount;
firedReason = e.CancelReason;
};
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null)
.Callback(() => {
throw cancelException;
});
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
Assert.AreEqual(1, fireCount);
AssertCanceledExceptionsSame(cancelException, firedReason);
}
public void CancellationSetsCancelled()
{
var runner = new CommandRunner();
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null)
.Callback(() => {
throw new CommandCanceledException();
});
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
Assert.AreEqual(TaskState.Canceled, task.State);
}
public void TaskNameIsCommandName()
{
var runner = new CommandRunner();
const string commandName = "Command name";
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null);
mockCommand.Setup((command) => command.Name)
.Returns(commandName);
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
Assert.AreEqual(commandName, task.Name);
}
public void RunThrowsOnNull()
{
var runner = new CommandRunner();
Assert.Throws<ArgumentNullException>(() => runner.Run(null));
}
public void RunSetsIsRunning()
{
var runner = new CommandRunner();
ICommandTask task = null;
TaskState? taskStateInCommand = null;
var taskReadySync = new AutoResetEvent(false);
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null)
.Callback(() => {
taskReadySync.WaitOne();
taskStateInCommand = task.State;
});
task = runner.Run(mockCommand.Object);
taskReadySync.Set();
task.WaitHandle.WaitOne();
Assert.IsNotNull(taskStateInCommand);
Assert.AreEqual(TaskState.Running, (TaskState) taskStateInCommand);
}
public void RunFiresStartOnce()
{
var runner = new CommandRunner();
int fireCount = 0;
runner.TaskStarted += (sender, e) => {
++fireCount;
};
var task = runner.Run(new CommandChain());
task.WaitHandle.WaitOne();
Assert.AreEqual(1, fireCount);
}
public void RunExecutesCommandInSeparateThread()
{
var runner = new CommandRunner();
Thread commandThread = null;
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null)
.Callback(() => {
commandThread = Thread.CurrentThread;
});
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
Assert.AreNotEqual(Thread.CurrentThread, commandThread);
}
public void RunExecutesCommand()
{
var runner = new CommandRunner();
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null);
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
mockCommand.Verify((command) => command.Process(null, It.IsAny<IMutableProgressTracker>(), It.IsAny<CancellationToken>()), Times.Once());
}
public void RunEndResetsIsRunning()
{
var runner = new CommandRunner();
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null);
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
Assert.AreNotEqual(TaskState.Running, task.State);
}
public void RunDisposesReturnedData()
{
var mockDisposable = new Mock<IDisposable>(MockBehavior.Strict);
mockDisposable.Setup((typedData) => typedData.Dispose());
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns(new TypedData(TypedDataType.User, mockDisposable.Object, "my data"));
var runner = new CommandRunner();
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
mockDisposable.Verify((typedData) => typedData.Dispose(), Times.Once());
}
public void ProgressUpdatesFire()
{
var runner = new CommandRunner();
var progressUpdates = new List<double>();
runner.ProgressUpdated += (sender, e) => progressUpdates.Add(e.Progress);
var mockCommand = GetCommandMock();
mockCommand.Setup((command) => command.Process(null, It.Is<IMutableProgressTracker>((mpt) => mpt != null), It.IsAny<CancellationToken>()))
.Returns((TypedData) null)
.Callback((TypedData data, IMutableProgressTracker progress, CancellationToken cancelToken) => {
progress.Progress = 0.5;
progress.Progress = 0.6;
progress.Progress = 1;
});
var task = runner.Run(mockCommand.Object);
task.WaitHandle.WaitOne();
CollectionAssert.AreEqual(new[] { 0.5, 0.6, 1 }, progressUpdates);
}