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_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_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_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_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_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_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_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_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_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_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);
}
