public void ActionTestWithStartTimeDeadlineTest(bool useStartTime, bool useDeadLine)
{
//Arrange
Quest quest = new FakeQuest();
Quest parent = new FakeQuest();
IQuestViewModel questViewModel = MockRepository.GenerateStrictMock <IQuestViewModel>();
questViewModel.Expect(qvm => qvm.Model).
Repeat.Once().
Return(quest);
ICommand addCommand = MockRepository.GenerateStrictMock <ICommand>();
addCommand.Expect(ac => ac.Execute()).
Return(true).
Repeat.Once();
addCommand.Expect(ac => ac.Commit()).
Return(true).
Repeat.Once();
IQuestTree questRepository = MockRepository.GenerateStrictMock <IQuestTree>();
questRepository.Expect(qt => qt.Get(Arg <Predicate <Quest> > .Is.NotNull)).
Repeat.Once().
Return(parent);
ITreeCommandsFactory factory = MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
factory.Expect(f => f.AddQuest(Arg <Quest> .Is.Equal(parent), Arg <Quest> .Is.Equal(quest)))
.Return(addCommand)
.Repeat.Once();
IQuestValidator <ClarifiedResponse <int> > questValidator =
MockRepository.GenerateStrictMock <IQuestValidator <ClarifiedResponse <int> > >();
IQuestViewModelFactory questViewModelFactory = MockRepository.GenerateStrictMock <IQuestViewModelFactory>();
questViewModelFactory.Expect(qc => qc.CreateQuestViewModel()).
Repeat.Once().
Return(questViewModel);
QuestCreateViewModel viewModel = new QuestCreateViewModel(
questViewModelFactory,
questValidator,
questRepository,
factory);
//Act
viewModel.Initialize();
viewModel.Action();
//Assert
questViewModel.VerifyAllExpectations();
addCommand.VerifyAllExpectations();
questRepository.VerifyAllExpectations();
factory.VerifyAllExpectations();
questValidator.VerifyAllExpectations();
questViewModelFactory.VerifyAllExpectations();
}
public void RestartQuestValidPositionTest()
{
//Arrange
int position = 0;
Quest toRestart = new FakeQuest();
List <Quest> leaves = new List <Quest> {
toRestart
};
ICommand startCommand = MockRepository.GenerateStrictMock <ICommand>();
startCommand.Expect(dc => dc.Execute()).
Repeat.Once().
Return(true);
startCommand.Expect(dc => dc.Commit()).
Repeat.Once().
Return(true);
ICommand cancelCommand = MockRepository.GenerateStrictMock <ICommand>();
cancelCommand.Expect(dc => dc.Execute()).
Repeat.Once().
Return(true);
cancelCommand.Expect(dc => dc.Commit()).
Repeat.Once().
Return(true);
IQuestListModel model = MockRepository.GenerateStrictMock <IQuestListModel>();
model.Expect(rep => rep.Leaves).
Repeat.Once().
Return(leaves);
IStateCommandsFactory stateCommands = MockRepository.GenerateStrictMock <IStateCommandsFactory>();
stateCommands.Expect(sc => sc.CancelQuest(Arg <Quest> .Is.Equal(toRestart))).
Repeat.Once().
Return(cancelCommand);
stateCommands.Expect(sc => sc.StartQuest(Arg <Quest> .Is.Equal(toRestart))).
Repeat.Once().
Return(startCommand);
ITreeCommandsFactory repoCommands = MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
ResultsQuestListViewModel viewModel = new ResultsQuestListViewModel(model, stateCommands, repoCommands);
//Act
Task startTask = viewModel.RestartQuest(position);
//Assert
Assert.IsNotNull(startTask);
startTask.Wait();
cancelCommand.VerifyAllExpectations();
startCommand.VerifyAllExpectations();
model.VerifyAllExpectations();
stateCommands.VerifyAllExpectations();
repoCommands.VerifyAllExpectations();
}
public void UndoAfterExecuteCommitTest()
{
//Arrange
ICommand innerCommand = MockRepository.GenerateStrictMock <ICommand>();
innerCommand.Expect(ic => ic.Execute()).
Repeat.Once().
Return(true);
innerCommand.Expect(ic => ic.Commit()).
Repeat.Once().
Return(true);
innerCommand.Expect(ic => ic.Undo()).
Repeat.Never();
SwitchCommand command = new SwitchCommand(innerCommand);
//Act
bool execteResult = command.Execute();
bool commitResult = command.Commit();
bool undoResult = command.Undo();
//Assert
Assert.IsTrue(execteResult);
Assert.IsTrue(commitResult);
Assert.IsFalse(undoResult);
innerCommand.VerifyAllExpectations();
}
public void DeleteQuestValidPositionTest()
{
//Arrange
int position = 0;
Quest parent = new FakeQuest();
Quest toDelete = new FakeQuest();
List <Quest> leaves = new List <Quest> {
toDelete
};
ICommand deleteCommand = MockRepository.GenerateStrictMock <ICommand>();
deleteCommand.Expect(dc => dc.Execute()).
Repeat.Once().
Return(true);
deleteCommand.Expect(dc => dc.Commit()).
Repeat.Once().
Return(true);
IQuestListModel model = MockRepository.GenerateStrictMock <IQuestListModel>();
model.Expect(rep => rep.Leaves).
Repeat.Once().
Return(leaves);
model.Expect(m => m.Parent).
Repeat.Once().
Return(parent);
IStateCommandsFactory stateCommands = MockRepository.GenerateStrictMock <IStateCommandsFactory>();
ITreeCommandsFactory repoCommands = MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
repoCommands.Expect(rc => rc.DeleteQuest(Arg <Quest> .Is.Equal(parent), Arg <Quest> .Is.Equal(toDelete))).
Repeat.Once().
Return(deleteCommand);
QuestListViewModel viewModel = new QuestListViewModel(model, stateCommands, repoCommands);
//Act
Task deleteTask = viewModel.DeleteQuest(position);
//Assert
Assert.IsNotNull(deleteTask);
deleteTask.Wait();
model.VerifyAllExpectations();
deleteCommand.VerifyAllExpectations();
repoCommands.VerifyAllExpectations();
}
public void CancelQuestTest()
{
//Arrange
int position = 0;
Quest toFail = new FakeQuest();
List <Quest> leaves = new List <Quest> {
toFail
};
ICommand returnedCommand = MockRepository.GenerateStrictMock <ICommand>();
returnedCommand.Expect(rc => rc.Execute()).
Repeat.Once().
Return(true);
returnedCommand.Expect(rc => rc.Commit()).
Repeat.Once().
Return(true);
IQuestListModel model = MockRepository.GenerateStrictMock <IQuestListModel>();
model.Expect(m => m.Leaves).
Repeat.Once().
Return(leaves);
IStateCommandsFactory stateCommands = MockRepository.GenerateStrictMock <IStateCommandsFactory>();
stateCommands.Expect(sc => sc.CancelQuest(Arg <Quest> .Is.Equal(toFail))).
Repeat.Once().
Return(returnedCommand);
ITreeCommandsFactory repoCommands = MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
ActiveQuestListViewModel viewModel = new ActiveQuestListViewModel(model, stateCommands, repoCommands);
//Act
Task cancelTask = viewModel.CancelQuest(position);
//Assert
Assert.IsNotNull(cancelTask);
cancelTask.Wait();
returnedCommand.VerifyAllExpectations();
stateCommands.VerifyAllExpectations();
repoCommands.VerifyAllExpectations();
model.VerifyAllExpectations();
}
public void UndoOrderTest()
{
//Arrange
Stack <int> stack = new Stack <int>();
ICommand firstOne = MockRepository.GenerateStrictMock <ICommand>();
firstOne.Expect(c => c.Undo()).Repeat.Once().Return(true).Do(new Func <bool>((() =>
{
stack.Push(1);
return(true);
})));
ICommand secondOne = MockRepository.GenerateStrictMock <ICommand>();
secondOne.Expect(c => c.Undo()).Repeat.Once().Return(true).Do(new Func <bool>((() =>
{
stack.Push(2);
return(true);
})));
ICommand composite = new CompositeCommand(new[] { firstOne, secondOne });
//Act
composite.Undo();
//Assert
Assert.AreEqual(1, stack.Pop());
Assert.AreEqual(2, stack.Pop());
firstOne.VerifyAllExpectations();
secondOne.VerifyAllExpectations();
}
public void SetUp()
{
command = MockRepository.GenerateMock<ICommand>();
command.Expect(x => x.CanExecute(null)).Return(true).IgnoreArguments();
screenAction = new ScreenAction
{
Binding = new InputBinding(command, new KeyGesture(Key.F3)),
Name = "some text"
};
item = new CommandMenuItem(screenAction);
}
public void UndoWithoutExecuteTest()
{
//Arrange
ICommand innerCommand = MockRepository.GenerateStrictMock <ICommand>();
innerCommand.Expect(ic => ic.Undo()).
Repeat.Never();
SwitchCommand command = new SwitchCommand(innerCommand);
//Act
bool undoResult = command.Undo();
//Assert
Assert.IsFalse(undoResult);
innerCommand.VerifyAllExpectations();
}
public void CommitTest()
{
//Arrange
ICommand innerCommand = MockRepository.GenerateStrictMock <ICommand>();
innerCommand.Expect(ic => ic.Commit()).
Repeat.Once().
Return(true);
SwitchCommand command = new SwitchCommand(innerCommand);
//Act
bool commitResult = command.Commit();
//Assert
Assert.IsTrue(commitResult);
innerCommand.VerifyAllExpectations();
}
public void ValidFalseTest()
{
//Arrange
ICommand firstOne = MockRepository.GenerateStrictMock <ICommand>();
firstOne.Expect(c => c.IsValid()).Repeat.Once().Return(true);
ICommand secondOne = MockRepository.GenerateStrictMock <ICommand>();
secondOne.Expect(c => c.IsValid()).Repeat.Once().Return(false);
ICommand composite = new CompositeCommand(new[] { firstOne, secondOne });
//Act
bool isValid = composite.IsValid();
//Assert
Assert.IsFalse(isValid);
firstOne.VerifyAllExpectations();
secondOne.VerifyAllExpectations();
}
public void ActionTest(bool isCommandExecuted)
{
int questId = 42;
Quest model = new FakeQuest()
{
StartTime = DateTime.Now,
Deadline = DateTime.Now
};
IQuestViewModel questViewModel = MockRepository.GenerateStrictMock <IQuestViewModel>();
questViewModel.Expect(qvm => qvm.Model).
SetPropertyWithArgument(model).
Repeat.Once();
questViewModel.Expect(qvm => qvm.Model).
Repeat.Once().
Return(model);
questViewModel.Expect(qvm => qvm.UseStartTime).
SetPropertyWithArgument(true).
Repeat.Once();
questViewModel.Expect(qvm => qvm.UseDeadline).
SetPropertyWithArgument(true).
Repeat.Once();
IQuestTree questTree = MockRepository.GenerateStrictMock <IQuestTree>();
questTree.Expect(qt => qt.Get(Arg <Predicate <Quest> > .Is.NotNull)).
Repeat.Once().
Return(model);
IQuestViewModelFactory questFactory = MockRepository.GenerateStrictMock <IQuestViewModelFactory>();
questFactory.Expect(qf => qf.CreateQuestViewModel()).
Repeat.Once().
Return(questViewModel);
IQuestValidator <ClarifiedResponse <int> > questValidator =
MockRepository.GenerateStrictMock <IQuestValidator <ClarifiedResponse <int> > >();
ICommand updateCommand = MockRepository.GenerateStrictMock <ICommand>();
updateCommand.Expect(uc => uc.Execute()).
Repeat.Once().
Return(isCommandExecuted);
if (isCommandExecuted)
{
updateCommand.Expect(uc => uc.Commit()).
Repeat.Once().
Return(true);
}
ITreeCommandsFactory treeCommands =
MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
treeCommands.Expect(tc => tc.UpdateQuest(Arg <Quest> .Is.Equal(model))).
Repeat.Once().
Return(updateCommand);
QuestEditViewModel vm = new QuestEditViewModel(questFactory, questValidator, questTree, treeCommands)
{
QuestId = questId
};
//Act
vm.Initialize();
vm.Action();
//Assert
questViewModel.VerifyAllExpectations();
questTree.VerifyAllExpectations();
questFactory.VerifyAllExpectations();
questValidator.VerifyAllExpectations();
updateCommand.VerifyAllExpectations();
treeCommands.VerifyAllExpectations();
}
public void SetUp()
{
_mocks = new MockRepository();
_outputWriter = _mocks.DynamicMock<ICommandAccess>();
_executor = _mocks.DynamicMock<ICommand>();
_commandManager = new CommandManager(_outputWriter);
_executor.Expect(x => x.Identifier).Return("test");
}
