public void Should_return_descendants_calling_GetDescendants()
        {
            // arrange
            var testTarget = new TestTarget
            {
                Id = 345,
                Data = new TestTargetData{ TestString = "Its a target!"}
            };
            var parentNode = new HierarchyNode
            {
                Id = 23,
                LeftId = 1,
                RightId = 6,
                TargetId = testTarget.Id
            };
            var child1 = new HierarchyNode
            {
                Id = 45,
                LeftId = 2,
                RightId = 3,
                TargetId = testTarget.Id
            };
            var child2 = new HierarchyNode
            {
                Id = 46,
                LeftId = 4,
                RightId = 5,
                TargetId = testTarget.Id
            };

            var mockHierarchyDataProvider = new Mock<IHierarchyDataProvider>();
            mockHierarchyDataProvider.Setup(p => p.GetDescendants(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>(), true, true))
                .Returns(new List<HierarchyNode> { parentNode, child1, child2 });
            var mockHierarchyEntryRepository = new Mock<IHierarchyEntryRepository>();
            var mockTargetEntryRepository = new Mock<ITargetEntryRepository>();
            var mockTargetRepository = new Mock<ITargetRepository>();
            var mockTargetTypes = new List<Type>();
            var service = new HierarchyService(mockHierarchyDataProvider.Object, mockHierarchyEntryRepository.Object, mockTargetEntryRepository.Object, mockTargetRepository.Object, mockTargetTypes);

            // act
            var resultNode = service.GetDescendants(hierarchyEntry, parentNode, true, true);

            // assert
            Assert.That(resultNode, Is.Not.Null);
            Assert.That(resultNode.Count, Is.EqualTo(3));
            Assert.That(resultNode[0].Id, Is.EqualTo(parentNode.Id));
            Assert.That(resultNode[0].LeftId, Is.EqualTo(parentNode.LeftId));
            Assert.That(resultNode[0].RightId, Is.EqualTo(parentNode.RightId));
            Assert.That(resultNode[0].TargetId, Is.EqualTo(parentNode.TargetId));
            Assert.That(resultNode[1].Id, Is.EqualTo(child1.Id));
            Assert.That(resultNode[1].LeftId, Is.EqualTo(child1.LeftId));
            Assert.That(resultNode[1].RightId, Is.EqualTo(child1.RightId));
            Assert.That(resultNode[1].TargetId, Is.EqualTo(child1.TargetId));
            Assert.That(resultNode[2].Id, Is.EqualTo(child2.Id));
            Assert.That(resultNode[2].LeftId, Is.EqualTo(child2.LeftId));
            Assert.That(resultNode[2].RightId, Is.EqualTo(child2.RightId));
            Assert.That(resultNode[2].TargetId, Is.EqualTo(child2.TargetId));

            mockHierarchyDataProvider.Verify(p => p.GetDescendants(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>(), true, true));
        }