public void Given_a_CommandManager_Before_Executing_CurrentTransaction_is_null()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
Assert.IsTrue(manager.CurrentTransaction == null);
}
public void Given_a_CommandManager_When_storing_different_Commands_Everything_is_initialized_without_sideeffects()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
Assert.IsTrue(cmd.Value == 1);
Assert.IsTrue(cmd5.Value == 0);
}
public void Given_a_CommandManager_When_Executing_Command_is_executed()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
manager.Do(Execute.The(cmd));
Assert.IsTrue(cmd.Value == 2);
}
public void Given_a_CommandManager_When_Once_Executed_Should_set_Undo_State_to_true()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
manager.Do(Execute.The(cmd));
Assert.IsTrue(manager.CanUndo);
Assert.IsFalse(manager.CanRedo);
}
public void Given_a_CommandManager_When_Executing_Should_only_call_Completed_once()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
var called = 0;
manager.Do(Execute.The(cmd).AndWhenCompletedCall(state => called++));
Assert.IsTrue(called == 1);
}
public void Given_a_CommandManager_When_Executed_Should_notify_Undo_State_changed()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
var called = false;
manager.CanUndoRedoChanged += (sender, args) => called = true;
manager.Do(Execute.The(cmd));
Assert.IsTrue(called);
}
public void Given_a_CommandManager_When_executing_an_unbounded_transaction_without_commiting_Should_throw_Exception()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd)));
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd5)));
manager.Do(Execute.The(cmd));
}
public void Given_a_CommandManager_When_executing_2_independend_StackTogetherTransactions_Should_be_put_in_one_TransactionalCommand()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd)));
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd5)));
Assert.IsTrue(manager.CurrentTransaction.Commands.Count == 2);
}
public void Given_a_CommandManager_After_Executing_multiple_times_CurrentTransaction_is_null()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd));
Assert.IsTrue(manager.CurrentTransaction == null);
}
public void Given_An_ICommand_When_Calling_Run_CommandInBackground_Should_alter_ExecutionConfiguration()
{
Mock <IEventAggregator> aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
var incrementCommand = new IncrementByOneCommand(1);
var configuration = Execute.The(incrementCommand).RunCommandInBackground();
manager.Do(configuration);
Assert.IsTrue(configuration.RunInBackground, "RunInBackground was not set to TRUE!");
}
public void Given_a_CommandManager_When_Undoing_And_Redoing_And_again_Undoing_Command_is_rolled_back()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
manager.Do(Execute.The(cmd));
manager.Undo();
manager.Redo();
manager.Undo();
Assert.IsTrue(cmd.Value == 1);
}
public void Given_a_CommandManager_When_storing_different_Commands_Undoing_is_in_order()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd5));
manager.Do(Execute.The(cmd));
Assert.IsTrue(cmd.Value == 3);
Assert.IsTrue(cmd5.Value == 5);
}
public void Given_a_CommandManager_When_Undoing_an_Open_Transaction_Should_Commit_and_Undo()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd)));
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd5)));
manager.Undo();
Assert.IsTrue(cmd.Value == 1);
Assert.IsTrue(cmd5.Value == 0);
}
public void Given_An_ICommand_When_Calling_Run_CommandInBackground_Should_execute_properly()
{
ManualResetEvent resetEvent = new ManualResetEvent(false);
Mock <IEventAggregator> aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
var incrementCommand = new IncrementByOneCommand(1);
manager.Do(
Execute.The(incrementCommand)
.RunCommandInBackground()
.AndWhenCompletedCall(state => resetEvent.Set()));
resetEvent.WaitOne(1000, false);
Assert.IsTrue(incrementCommand.Value == 2, "Command was not executed properly!");
}
public void Given_a_CommandManager_When_Executing_Within_Transaction_Then_CurrentTransaction_is_NOT_null_within_Transaction()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
manager.RunWithinTransactionAndCommit(
commandManager =>
{
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd));
Assert.IsTrue(manager.CurrentTransaction != null);
});
}
public void Given_a_CommandManager_When_executing_within_transaction_commits_with_RunWithinTransactionAndCommit()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd)));
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd5)));
manager.RunWithinTransactionAndCommit(commandManager => manager.Do(Execute.The(cmd)));
Assert.IsTrue(manager.CurrentTransaction == null);
Assert.IsTrue(manager.UndoStack.Count == 1);
Assert.IsTrue(manager.UndoStack.Peek().Commands.Count == 3);
}
public void Given_a_CommandManager_When_Undoing_and_executing_new_command_RedoStack_should_be_cleared()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd));
manager.Undo();
manager.Do(Execute.The(cmd5));
Assert.IsFalse(manager.CanRedo);
Assert.IsTrue(manager.CanUndo);
}
public void Given_a_CommandManager_When_one_of_multiple_Commands_Aborts_Should_only_Register_the_other_Commands_for_Undo()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand incCmd = new IncrementByOneCommand(1);
AbortingCommand cmd = new AbortingCommand();
IncrementBy5Command inc5Cmd = new IncrementBy5Command(1);
manager.Do(Execute.The(incCmd));
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(inc5Cmd));
Assert.IsTrue(manager.UndoStack.Count == 2);
Assert.IsTrue(manager.UndoStack.Pop().Commands[0] == inc5Cmd);
Assert.IsTrue(manager.UndoStack.Pop().Commands[0] == incCmd);
}
public void Given_a_CommandManager_When_executing_3_times_and_undoing_once_should_undo_last_command()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd5));
manager.Do(Execute.The(cmd));
manager.Undo();
Assert.IsTrue(cmd.Value == 2);
Assert.IsTrue(cmd5.Value == 5);
}
public void Given_a_CommandManager_When_Undoing_a_Transaction_Should_undo_grouped_commands_in_reversed_order()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
var calls = new List <ICommand>();
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd).AndWhenCompletedCall(state => calls.Add(cmd))));
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd5).AndWhenCompletedCall(state => calls.Add(cmd5))));
manager.CommitTransaction();
manager.Undo();
Assert.IsTrue(calls[2] == cmd5);
Assert.IsTrue(calls[3] == cmd);
}
public void Given_a_CommandManager_When_undoing_a_transaction_should_call_completed_for_each_command_within_transaction()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
var calls = new List <ICommand>();
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd).AndWhenCompletedCall(state => calls.Add(cmd))));
manager.RunWithinTransaction(commandManager => manager.Do(Execute.The(cmd5).AndWhenCompletedCall(state => calls.Add(cmd5))));
manager.CommitTransaction();
Assert.IsTrue(calls[0] == cmd);
Assert.IsTrue(calls[1] == cmd5);
Assert.IsTrue(calls.Count == 2);
}
public void Given_a_CommandManager_When_Tranactionally_executing_3_commands_and_doing_Rollback_Should_Undo_all_commands()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.RunWithinTransactionAndCommit(commandManager =>
{
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd5));
manager.Do(Execute.The(cmd));
manager.RollBackTransaction();
});
Assert.IsTrue(cmd.Value == 1);
Assert.IsTrue(cmd5.Value == 0);
}
public void Given_a_CommandManager_When_Transactionally_executing_3_times__and_undoing_and_Redoing_once_should_result_in_end_values()
{
var aggregator = new Mock <IEventAggregator>();
CommandManager manager = new CommandManager(aggregator.Object, SynchronizationContext.Current);
IncrementByOneCommand cmd = new IncrementByOneCommand(1);
IncrementBy5Command cmd5 = new IncrementBy5Command(0);
manager.RunWithinTransactionAndCommit(commandManager =>
{
manager.Do(Execute.The(cmd));
manager.Do(Execute.The(cmd5));
manager.Do(Execute.The(cmd));
});
manager.Undo();
manager.Redo();
Assert.IsTrue(cmd.Value == 3);
Assert.IsTrue(cmd5.Value == 5);
}
