public void I_root_returns_grandchild_on_DescendantOrDefault()
{
// ARRANGE
MockableNodeType grandChildNode = new Mock <MockableNodeType>().Object;
var childNode = new Mock <MockableNodeType>();
childNode
.Setup(n => n.TryGetChildNode(2))
.Returns((true, grandChildNode));
var childNodeObject = childNode.Object;
this.startNode
.Setup(n => n.TryGetChildNode(1))
.Returns((true, childNodeObject));
// ACT
MockableNodeType result1 = this.startNode.Object.DescendantAtOrDefault(HierarchyPath.Create(1, 2));
HierarchyPath <int> foundNodePath;
MockableNodeType result2 = this.startNode.Object.DescendantAtOrDefault(HierarchyPath.Create(1, 2), out foundNodePath);
// ASSERT
Assert.NotNull(grandChildNode);
Assert.Same(grandChildNode, result1);
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Exactly(2));
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Exactly(2));
}
public void IHasParentNode_inner_node_returns_parent_on_Parent()
{
// ARRANGE
var rootNode = new Mock <MockableNodeType>();
rootNode // has no parent
.Setup(r => r.HasParentNode).Returns(false);
var parentOfStartNode = new Mock <MockableNodeType>();
parentOfStartNode // has root node as parent
.Setup(p => p.HasParentNode).Returns(true);
parentOfStartNode
.Setup(p => p.ParentNode).Returns(rootNode.Object);
this.startNode // has a parant
.Setup(m => m.HasParentNode).Returns(true);
this.startNode // returns parent node
.Setup(m => m.ParentNode).Returns(parentOfStartNode.Object);
// ACT
MockableNodeType result = this.startNode.Object.Parent();
// ASSERT
startNode.Verify(m => m.HasParentNode, Times.Once());
startNode.Verify(m => m.ParentNode, Times.Once());
Assert.Same(parentOfStartNode.Object, result);
}
public void I_root_returns_substitute_on_invalid_childId_on_DescendantOrDefault()
{
// ARRANGE
MockableNodeType childNode = new Mock <MockableNodeType>().Object;
this.startNode
.Setup(n => n.TryGetChildNode(1))
.Returns((false, childNode));
MockableNodeType substitute = new Mock <MockableNodeType>().Object;
// ACT
MockableNodeType result1 = this.startNode.Object.DescendantAtOrDefault(HierarchyPath.Create(1), createDefault: () => substitute);
HierarchyPath <int> foundNodePath;
MockableNodeType result2 = this.startNode.Object.DescendantAtOrDefault(HierarchyPath.Create(1), out foundNodePath, createDefault: () => substitute);
// ASSERT
Assert.Same(substitute, result1);
Assert.Same(substitute, result2);
Assert.Equal(HierarchyPath.Create <int>(), foundNodePath);
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Exactly(2));
}
public void I_root_returns_grandchild_on_DescendentAt()
{
// ARRANGE
var subChildNode = new Mock <MockableNodeType>().Object;
var childNodeMock = new Mock <MockableNodeType>();
childNodeMock
.Setup(n => n.TryGetChildNode(2))
.Returns((true, subChildNode));
var childNode = childNodeMock.Object;
this.startNode
.Setup(n => n.TryGetChildNode(1))
.Returns((true, childNode));
// ACT
MockableNodeType result = this.startNode.Object.DescendantAt(HierarchyPath.Create(1, 2));
// ASSERT
Assert.Same(subChildNode, result);
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Once());
childNodeMock.Verify(n => n.TryGetChildNode(2), Times.Once());
}
public void I_root_returns_itself_on_DescendantAt()
{
// ACT
MockableNodeType result = this.startNode.Object.DescendantAt(HierarchyPath.Create <int>());
// ASSERT
Assert.Same(startNode.Object, result);
}
public void I_root_returns_itself_on_DescendantAtOrDefault()
{
// ACT
MockableNodeType result1 = this.startNode.Object.DescendantAtOrDefault(HierarchyPath.Create <int>());
HierarchyPath <int> foundNodePath;
MockableNodeType result2 = this.startNode.Object.DescendantAtOrDefault(HierarchyPath.Create <int>(), out foundNodePath);
// ASSERT
Assert.Same(startNode.Object, result1);
Assert.Same(startNode.Object, result2);
Assert.Equal(HierarchyPath.Create <int>(), foundNodePath);
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Never());
}
public void I_root_returns_child_on_DescendantAt()
{
// ARRANGE
MockableNodeType childNode = new Mock <MockableNodeType>().Object;
this.startNode
.Setup(n => n.TryGetChildNode(1))
.Returns((true, childNode));
// ACT
MockableNodeType result = this.startNode.Object.DescendantAt(HierarchyPath.Create(1));
// ASSERT
Assert.NotNull(childNode);
Assert.Same(childNode, result);
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Once());
}
