public void RootIdTest()
{
//Arrange
int questId = 42;
Quest parent = new FakeQuest()
{
Id = questId
};
IQuestListModel model = MockRepository.GenerateStrictMock <IQuestListModel>();
model.Expect(mo => mo.Parent).
Repeat.Once().
Return(parent);
IStateCommandsFactory stateCommands = MockRepository.GenerateStrictMock <IStateCommandsFactory>();
ITreeCommandsFactory repoCommands = MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
QuestListViewModel viewModel = new QuestListViewModel(model, stateCommands, repoCommands);
//Act
int id = viewModel.RootId;
//Assert
Assert.AreEqual(questId, id);
model.VerifyAllExpectations();
}
public void NullOrWhiteSpaceDescriptionTest(string description)
{
//Arrange
Quest quest = new FakeQuest()
{
Description = description
};
int nullOrWhitespace = 0;
int nullOtWhitespaceClar = 1;
DescriptionQuestValidator <int> validator = new DescriptionQuestValidator <int>(nullOrWhitespace,
nullOtWhitespaceClar);
//Act
ClarifiedResponse <int> response = validator.Validate(quest);
//Assert
Assert.IsNotNull(response);
Assert.IsFalse(response.IsSuccessful);
Assert.AreEqual(1, response.Errors.Count);
ClarifiedError <int> error = response.Errors[0];
Assert.AreEqual(nullOrWhitespace, error.Error);
Assert.AreEqual(nullOtWhitespaceClar, error.Clarification);
}
public void OnlyStartTimeDefaultDeadlineBeforeNowTest()
{
//Arrange
int startTimeMoreThanDeadline = 0;
int startTimeMoreThanDeadlineClar = 1;
int deadlineLessThanNow = 2;
int deadlineLessThanNowClar = 3;
StartTimeDeadlineQuestValidator <int> validator = new StartTimeDeadlineQuestValidator <int>(
startTimeMoreThanDeadline,
startTimeMoreThanDeadlineClar,
deadlineLessThanNow,
deadlineLessThanNowClar);
Quest quest = new FakeQuest()
{
StartTime = null,
Deadline = DateTime.Now - new TimeSpan(1, 1, 1)
};
//Act
ClarifiedResponse <int> response = validator.Validate(quest);
//Assert
Assert.IsNotNull(response);
Assert.IsFalse(response.IsSuccessful);
Assert.AreEqual(1, response.Errors.Count);
ClarifiedError <int> error = response.Errors[0];
Assert.AreEqual(deadlineLessThanNow, error.Error);
Assert.AreEqual(deadlineLessThanNowClar, error.Clarification);
}
public void OrderQuestsDescendingTest()
{
//Arrange
DateTime current = DateTime.Now;
Quest q1 = new FakeQuest()
{
Deadline = current + new TimeSpan(1, 0, 0)
};
Quest q2 = new FakeQuest()
{
Deadline = current + new TimeSpan(3, 10, 0)
};
List <Quest> quests = new List <Quest> {
q2, q1
};
TimeLeftOrderStrategy strategy = new TimeLeftOrderStrategy()
{
Descending = true
};
//Act
IList <Quest> orderedList = strategy.Order(quests).ToList();
//Assert
Assert.IsNotNull(orderedList);
Assert.AreEqual(2, orderedList.Count);
Assert.AreEqual(q2, orderedList[0]);
Assert.AreEqual(q1, orderedList[1]);
}
public void DeadlineMoreThanStartTimeTest()
{
//Arrange
int startTimeMoreThanDeadline = 0;
int startTimeMoreThanDeadlineClar = 1;
int deadlineLessThanNow = 2;
int deadlineLessThanNowClar = 3;
StartTimeDeadlineQuestValidator <int> validator = new StartTimeDeadlineQuestValidator <int>(
startTimeMoreThanDeadline,
startTimeMoreThanDeadlineClar,
deadlineLessThanNow,
deadlineLessThanNowClar);
DateTime current = DateTime.Now;
Quest quest = new FakeQuest()
{
StartTime = current,
Deadline = current + new TimeSpan(1, 1, 1)
};
//Act
ClarifiedResponse <int> response = validator.Validate(quest);
//Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.IsSuccessful);
Assert.IsEmpty(response.Errors);
}
public void OnlyDeadlineDefaultTest()
{
//Arrange
int startTimeMoreThanDeadline = 0;
int startTimeMoreThanDeadlineClar = 1;
int deadlineLessThanNow = 2;
int deadlineLessThanNowClar = 3;
StartTimeDeadlineQuestValidator <int> validator = new StartTimeDeadlineQuestValidator <int>(
startTimeMoreThanDeadline,
startTimeMoreThanDeadlineClar,
deadlineLessThanNow,
deadlineLessThanNowClar);
Quest quest = new FakeQuest()
{
StartTime = DateTime.Now,
Deadline = null
};
//Act
ClarifiedResponse <int> response = validator.Validate(quest);
//Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.IsSuccessful);
Assert.IsEmpty(response.Errors);
}
public void UseStartTimeChangingTest()
{
//Arrange
DateTime?expectedStartTime = DateTime.Now;
Quest model = new FakeQuest
{
StartTime = expectedStartTime
};
QuestViewModel viewModel = new QuestViewModel
{
Model = model
};
//Act
DateTime?startBeforeAnyChanges = viewModel.StartTime;
viewModel.UseStartTime = false;
DateTime?startAfterUseFalse = viewModel.StartTime;
DateTime?modelStartAfterUseFalse = viewModel.Model.StartTime;
viewModel.UseStartTime = true;
DateTime?startAfterUseTrue = viewModel.StartTime;
DateTime?modelStartAfterUseTrue = viewModel.Model.StartTime;
//Assert
Assert.AreEqual(expectedStartTime, startBeforeAnyChanges);
Assert.AreEqual(expectedStartTime, startAfterUseFalse);
Assert.AreEqual(null, modelStartAfterUseFalse);
Assert.AreEqual(expectedStartTime, startAfterUseTrue);
Assert.AreEqual(expectedStartTime, modelStartAfterUseTrue);
}
public void ModelNotNullSettersTest()
{
//Arrange
string title = "title";
string description = "description";
bool isImportant = true;
DateTime startTime = DateTime.Now;
DateTime deadline = DateTime.Now;
Quest model = new FakeQuest()
{
};
QuestViewModel viewModel = new QuestViewModel
{
Model = model,
Title = title,
Description = description,
IsImportant = isImportant,
StartTime = startTime,
Deadline = deadline
};
//Act
Quest innerModel = viewModel.Model;
//Assert
Assert.AreEqual(title, innerModel.Title);
Assert.AreEqual(description, innerModel.Description);
Assert.AreEqual(isImportant, innerModel.IsImportant);
Assert.AreEqual(startTime, innerModel.StartTime);
Assert.AreEqual(deadline, innerModel.Deadline);
}
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 ValidateTest()
{
//Act
Quest quest = new FakeQuest();
StubResponse response = new StubResponse();
IQuestValidator <StubResponse> firstValidator = MockRepository.GenerateStrictMock <IQuestValidator <StubResponse> >();
firstValidator.
Expect(v => v.Validate(Arg <Quest> .Is.Equal(quest))).
Repeat.Once().
Return(response);
IQuestValidator <StubResponse> secondValidator = MockRepository.GenerateStrictMock <IQuestValidator <StubResponse> >();
secondValidator.
Expect(v => v.Validate(Arg <Quest> .Is.Equal(quest))).
Repeat.Once().
Return(response);
CompositeQuestValidator <StubResponse> validator = new CompositeQuestValidator <StubResponse>(new [] { firstValidator, secondValidator });
//Arrange
StubResponse returnedResponse = validator.Validate(quest);
//Assert
Assert.IsNotNull(returnedResponse);
firstValidator.VerifyAllExpectations();
secondValidator.VerifyAllExpectations();
}
public void UseStartTimeDeadlineNotNullModelSetterTest()
{
//Arrange
DateTime expectedStartTime = DateTime.Now;
DateTime expectedDeadline = DateTime.Now + new TimeSpan(1);
Quest model = new FakeQuest()
{
StartTime = expectedStartTime,
Deadline = expectedDeadline
};
QuestViewModel viewModel = new QuestViewModel
{
Model = model
};
//Act
bool useStartTime = viewModel.UseStartTime;
bool useDeadline = viewModel.UseDeadline;
//Assert
Assert.IsTrue(useStartTime);
Assert.IsTrue(useDeadline);
}
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 UndoWithParentsTest()
{
//Arrange
Quest root = new FakeQuest();
Quest parent0 = new FakeQuest();
Quest parent1 = new FakeQuest();
Quest parent2 = new FakeQuest();
root.Parent = null;
parent0.Parent = root;
parent1.Parent = parent0;
parent2.Parent = parent1;
IQuestTree tree = MockRepository.GenerateStrictMock <IQuestTree>();
tree.Expect(tr => tr.Root).Return(root).Repeat.Times(4);
IQuestCommand innerCommand = MockRepository.GenerateStrictMock <IQuestCommand>();
innerCommand.Expect(ic => ic.Undo(Arg <Quest> .Is.Equal(parent2))).Repeat.Once().Return(true);
innerCommand.Expect(ic => ic.Undo(Arg <Quest> .Is.Equal(parent1))).Repeat.Once().Return(true);
innerCommand.Expect(ic => ic.Undo(Arg <Quest> .Is.Equal(parent0))).Repeat.Once().Return(true);
innerCommand.Expect(ic => ic.Undo(Arg <Quest> .Is.Equal(root))).Repeat.Never();
UpToRootQuestCommand command = new UpToRootQuestCommand(parent2, tree, innerCommand);
//Act
bool result = command.Undo();
//Assert
Assert.IsTrue(result);
innerCommand.VerifyAllExpectations();
}
public void ExecuteWithParentsOneReturnsFalseTest()
{
//Arrange
Quest root = new FakeQuest();
Quest parent0 = new FakeQuest();
Quest parent1 = new FakeQuest();
Quest parent2 = new FakeQuest();
root.Parent = null;
parent0.Parent = root;
parent1.Parent = parent0;
parent2.Parent = parent1;
IQuestCommand innerCommand = MockRepository.GenerateStrictMock <IQuestCommand>();
innerCommand.Expect(ic => ic.Execute(Arg <Quest> .Is.Equal(parent2))).Repeat.Once().Return(true);
innerCommand.Expect(ic => ic.Execute(Arg <Quest> .Is.Equal(parent1))).Repeat.Once().Return(false);
innerCommand.Expect(ic => ic.Execute(Arg <Quest> .Is.Equal(parent0))).Repeat.Once().Return(true);
innerCommand.Expect(ic => ic.Execute(Arg <Quest> .Is.Equal(root))).Repeat.Once().Return(true);
UpHierarchyQuestCommandMock command = new UpHierarchyQuestCommandMock(parent2, innerCommand);
//Act
bool result = command.Execute();
//Assert
Assert.IsTrue(result);
innerCommand.VerifyAllExpectations();
}
public void TitleTooLongTest()
{
//Arrange
string title = new string('h', 26);
Quest quest = new FakeQuest()
{
Title = title
};
int nullOrWhitespace = 0;
int nullOtWhitespaceClar = 1;
int tooLong = 2;
int tooLongClar = 3;
TitleQuestValidator <int> validator = new TitleQuestValidator <int>(nullOrWhitespace, nullOtWhitespaceClar, tooLong, tooLongClar);
//Act
ClarifiedResponse <int> response = validator.Validate(quest);
//Assert
Assert.IsNotNull(response);
Assert.IsFalse(response.IsSuccessful);
Assert.AreEqual(1, response.Errors.Count);
ClarifiedError <int> error = response.Errors[0];
Assert.AreEqual(tooLong, error.Error);
Assert.AreEqual(tooLongClar, error.Clarification);
}
public void InitializeRetrieveQuestWithoutStartDeadlineFromTreeByIdTest()
{
int questId = 42;
Quest model = new FakeQuest()
{
StartTime = null,
Deadline = null
};
IQuestViewModel questViewModel = MockRepository.GenerateStrictMock <IQuestViewModel>();
questViewModel.Expect(qvm => qvm.Model).
SetPropertyWithArgument(model).
Repeat.Once();
questViewModel.Expect(qvm => qvm.UseStartTime).
SetPropertyWithArgument(false).
Repeat.Once();
questViewModel.Expect(qvm => qvm.UseDeadline).
SetPropertyWithArgument(false).
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> > >();
ITreeCommandsFactory treeCommands =
MockRepository.GenerateStrictMock <ITreeCommandsFactory>();
QuestEditViewModel vm = new QuestEditViewModel(questFactory, questValidator, questTree, treeCommands)
{
QuestId = questId
};
//Act
vm.Initialize();
//Assert
questViewModel.VerifyAllExpectations();
questTree.VerifyAllExpectations();
questFactory.VerifyAllExpectations();
questValidator.VerifyAllExpectations();
treeCommands.VerifyAllExpectations();
}
public void UndoOnQuestWithChildrenTest()
{
//Arrange
Quest child = new FakeQuest();
Quest quest = new FakeQuest()
{
Children = new List <Quest>()
{
child, null
}
};
int undoOnParentCount = 0;
int undoOnChildCount = 0;
int undoAfterTraverseParentCount = 0;
int undoAfterTraverseChildCount = 0;
MockDownHierarchyQuestCommand command = new MockDownHierarchyQuestCommand(quest);
command.OnUndoOnQuest += (q) =>
{
if (q == quest)
{
undoOnParentCount++;
}
if (q == child)
{
undoOnChildCount++;
}
};
command.OnUndoOnQuestAfterTraverse += (q) =>
{
if (q == quest)
{
undoAfterTraverseParentCount++;
}
if (q == child)
{
undoAfterTraverseChildCount++;
}
};
//Act
command.Execute();
command.Undo();
//Assert
Assert.AreEqual(1, undoOnParentCount);
Assert.AreEqual(1, undoOnChildCount);
Assert.AreEqual(1, undoAfterTraverseParentCount);
Assert.AreEqual(0, undoAfterTraverseChildCount);
}
public void UpdateRevertUpdateQuestAndSaveTest()
{
//Arrange
int updatedId = 42;
Quest savedRoot = new FakeQuest()
{
Id = TopRootId
};
List <Quest> rootChildren = new List <Quest>()
{
new FakeQuest()
{
Id = updatedId
}
};
Quest toUpdate = rootChildren[0];
IQuestFactory factory = MockRepository.GenerateStrictMock <IQuestFactory>();
IQuestDataLayer dataLayer = MockRepository.GenerateStrictMock <IQuestDataLayer>();
dataLayer.Expect(dl => dl.Open()).
Repeat.Once();
dataLayer.Expect(dl => dl.Get(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(savedRoot);
dataLayer.Expect(dl => dl.IsClosed()).
Repeat.Once().
Return(false);
dataLayer.Expect(dl => dl.GetAll(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(rootChildren);
dataLayer.Expect(dl => dl.Dispose()).
Repeat.Once();
dataLayer.Expect(dl => dl.UpdateAll(Arg <IEnumerable <Quest> > .Is.Anything)).
IgnoreArguments().
Repeat.Never();
QuestTreeInMemory tree = new QuestTreeInMemory(dataLayer, factory);
//Act
tree.Initialize();
tree.Update(toUpdate);
tree.RevertUpdate(toUpdate);
tree.Save();
//Assert
dataLayer.VerifyAllExpectations();
factory.VerifyAllExpectations();
}
public void TraverseToRoot()
{
//Arrange
int position = 0;
List <Quest> children = new List <Quest>()
{
new FakeQuest(),
};
Quest parent = new FakeQuest {
Children = children
};
Quest childToTraverse = children[position];
childToTraverse.Parent = parent;
IQuestTree tree = MockRepository.GenerateStrictMock <IQuestTree>();
tree.Expect(tr => tr.IsInitialized()).
Repeat.Once().
Return(true);
tree.Expect(tr => tr.Initialize()).
Repeat.Never();
tree.Expect(tr => tr.Root).
Repeat.Times(7).
Return(parent);
tree.Expect(tr => tr.LoadChildren(Arg <Quest> .Is.Equal(childToTraverse))).
Repeat.Once();
tree.Expect(tr => tr.UnloadChildren(Arg <Quest> .Is.Equal(childToTraverse))).
Repeat.Once();
QuestListModelTopChildrenPredicate list = new QuestListModelTopChildrenPredicate(tree, q => true);
//Act
list.Initialize();
bool traverseResult = list.TraverseToLeaf(position);
bool traverseToRootResult = list.TraverseToRoot();
Quest listParent = list.Parent;
List <Quest> listChildren = list.Leaves;
//Assert
Assert.AreEqual(parent, listParent);
Assert.AreEqual(children, listChildren);
Assert.IsTrue(traverseResult);
Assert.IsTrue(traverseToRootResult);
tree.VerifyAllExpectations();
}
public void CtorTest()
{
//Arrange
Quest quest = new FakeQuest();
MockAbstractQuestCommand command = null;
//Act
Assert.DoesNotThrow(() => command = new MockAbstractQuestCommand(quest));
//Assert
Assert.AreEqual(quest, command.GetQuestRef);
}
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 ExecuteWithParentsTest()
{
//Arrange
Quest root = new FakeQuest();
Quest parent0 = new FakeQuest();
Quest parent1 = new FakeQuest();
Quest parent2 = new FakeQuest();
root.Parent = null;
parent0.Parent = root;
parent1.Parent = parent0;
parent2.Parent = parent1;
bool hasExecutedOnRoot = false;
bool hasExecutedOnParent0 = false;
bool hasExecutedOnParent1 = false;
bool hasExecutedOnParent2 = false;
MockUpHierarchyQuestCommand command = new MockUpHierarchyQuestCommand(parent2);
command.OnExecuteOnQuest += (q) =>
{
if (q == root)
{
hasExecutedOnRoot = true;
}
else if (q == parent0)
{
hasExecutedOnParent0 = true;
}
else if (q == parent1)
{
hasExecutedOnParent1 = true;
}
else if (q == parent2)
{
hasExecutedOnParent2 = true;
}
};
//Act
command.Execute();
//Assert
Assert.IsFalse(hasExecutedOnRoot);
Assert.IsTrue(hasExecutedOnParent0);
Assert.IsTrue(hasExecutedOnParent1);
Assert.IsTrue(hasExecutedOnParent2);
}
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 InitializeBindRootAndChildren()
{
//Arrange
Quest savedRoot = new FakeQuest()
{
Id = TopRootId
};
List <Quest> children = new List <Quest>()
{
new FakeQuest()
};
IQuestFactory factory = MockRepository.GenerateStrictMock <IQuestFactory>();
IQuestDataLayer dataLayer = MockRepository.GenerateStrictMock <IQuestDataLayer>();
dataLayer.Expect(dl => dl.Get(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(savedRoot);
dataLayer.Expect(dl => dl.Open()).
Repeat.Once();
dataLayer.Expect(dl => dl.IsClosed()).
Repeat.Once().
Return(false);
dataLayer.Expect(dl => dl.Dispose()).
Repeat.Once();
dataLayer.Expect(dl => dl.GetAll(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(children);
QuestTreeInMemory tree = new QuestTreeInMemory(dataLayer, factory);
//Act
tree.Initialize();
Quest root = tree.Root;
//Assert
Assert.AreEqual(1, root.Children.Count);
Quest child = root.Children[0];
Assert.IsTrue(root.Children.Any(q => q == child));
Assert.AreEqual(root, child.Parent);
Assert.AreEqual(root.Id, child.ParentId);
dataLayer.VerifyAllExpectations();
factory.VerifyAllExpectations();
}
public void UpdateCommandTest()
{
//Arrange
ITreeCommandsFactory factory = new DefaultTreeCommandsFactory(
MockRepository.GenerateStrictMock <IQuestTree>());
Quest quest = new FakeQuest();
//Act
ICommand addCommand = factory.UpdateQuest(quest);
//Assert
Assert.IsNotNull(addCommand);
Assert.IsTrue(addCommand is CurrentQuestCommand);
}
public void InitializeWithSavedRootWithChildrenTest()
{
//Arrange
Quest savedRoot = new FakeQuest()
{
Id = TopRootId
};
List <Quest> children = new List <Quest>()
{
new FakeQuest()
};
IQuestFactory factory = MockRepository.GenerateStrictMock <IQuestFactory>();
IQuestDataLayer dataLayer = MockRepository.GenerateStrictMock <IQuestDataLayer>();
dataLayer.Expect(dl => dl.Get(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(savedRoot);
dataLayer.Expect(dl => dl.Open()).
Repeat.Once();
dataLayer.Expect(dl => dl.IsClosed()).
Repeat.Once().
Return(false);
dataLayer.Expect(dl => dl.Dispose()).
Repeat.Once();
dataLayer.Expect(dl => dl.GetAll(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(children);
QuestTreeInMemory tree = new QuestTreeInMemory(dataLayer, factory);
//Act
tree.Initialize();
Quest root = tree.Root;
//Assert
Assert.IsNotNull(root);
Assert.AreEqual(savedRoot, root);
Assert.IsNotEmpty(root.Children);
Assert.AreEqual(children, root.Children);
dataLayer.VerifyAllExpectations();
factory.VerifyAllExpectations();
}
public void InitializeNoSavedRootTest()
{
//Arrange
Quest createdRoot = new FakeQuest();
IQuestFactory factory = MockRepository.GenerateStrictMock <IQuestFactory>();
factory.Expect(cr => cr.CreateQuest()).
Repeat.Once().
Return(createdRoot);
IQuestDataLayer dataLayer = MockRepository.GenerateStrictMock <IQuestDataLayer>();
dataLayer.Expect(dl => dl.Get(Arg <int> .Is.Equal(TopRootId))).
Repeat.Once().
Return(null);
dataLayer.Expect(dl => dl.Open()).
Repeat.Once();
dataLayer.Expect(dl => dl.Dispose()).
Repeat.Once();
dataLayer.Expect(dl => dl.Insert(Arg <Quest> .Is.Anything)).
Repeat.Once();
QuestTreeInMemory tree = new QuestTreeInMemory(dataLayer, factory);
//Act
tree.Initialize();
bool isInitialized = tree.IsInitialized();
Quest root = tree.Root;
//Assert
Assert.IsTrue(isInitialized);
Assert.IsNotNull(root);
Assert.AreEqual(createdRoot, root);
Assert.AreEqual(null, root.ParentId);
Quest savedRoot =
dataLayer.GetArgumentsForCallsMadeOn(dl => dl.Insert(Arg <Quest> .Is.Anything))[0][0] as Quest;
Assert.IsNotNull(savedRoot);
Assert.AreEqual(root, savedRoot);
Assert.AreEqual(TopRootId, savedRoot.Id);
dataLayer.VerifyAllExpectations();
factory.VerifyAllExpectations();
}
public void ExecuteUndoTest()
{
//Arrange
Quest quest = new FakeQuest();
MockThisQuestCommand command = new MockThisQuestCommand(quest);
command.OnExecuteOnQuest += (q) => { Assert.AreEqual(quest, q); };
command.OnUndoOnQuest += (q) => { Assert.AreEqual(quest, q); };
//Act
command.Execute();
command.Undo();
//Assert
}
public void DeleteCommandTest()
{
//Arrange
Quest quest = new FakeQuest();
Quest parent = new FakeQuest();
ITreeCommandsFactory factory = new DefaultTreeCommandsFactory(
MockRepository.GenerateStrictMock <IQuestTree>());
//Act
ICommand addCommand = factory.DeleteQuest(parent, quest);
//Assert
Assert.IsNotNull(addCommand);
Assert.IsTrue(addCommand is CompositeCommand);
}
public void ExecuteOnQuestWithoutChildrenTest()
{
//Arrange
Quest quest = new FakeQuest();
MockDownHierarchyQuestCommand command = new MockDownHierarchyQuestCommand(quest);
command.OnExecuteOnQuest += (q) =>
{
Assert.AreEqual(quest, q);
};
//Act
command.Execute();
//Assert
}
