public void Should_return_ancestors_calling_GetAncestors() { // arrange var testTarget = new TestTarget { Id = 345, Data = new TestTargetData { TestString = "Its a target!" } }; var node = new HierarchyNode { Id = 34, LeftId = 2, RightId = 3, TargetId = testTarget.Id }; var ancestor1 = new HierarchyNode { Id = 22, LeftId = 1, RightId = 6, TargetId = testTarget.Id }; var ancestor2 = new HierarchyNode { Id = 11, LeftId = 1, RightId = 13, TargetId = testTarget.Id }; var mockHierarchyDataProvider = new Mock<IHierarchyDataProvider>(); mockHierarchyDataProvider.Setup(p => p.GetAncestors(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>(), true, true)) .Returns(new List<HierarchyNode> { ancestor2, ancestor1, node }); 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.GetAncestors(hierarchyEntry, node, true, true); // assert Assert.That(resultNode, Is.Not.Null); Assert.That(resultNode.Count, Is.EqualTo(3)); Assert.That(resultNode[0].Id, Is.EqualTo(ancestor2.Id)); Assert.That(resultNode[0].LeftId, Is.EqualTo(ancestor2.LeftId)); Assert.That(resultNode[0].RightId, Is.EqualTo(ancestor2.RightId)); Assert.That(resultNode[0].TargetId, Is.EqualTo(ancestor2.TargetId)); Assert.That(resultNode[1].Id, Is.EqualTo(ancestor1.Id)); Assert.That(resultNode[1].LeftId, Is.EqualTo(ancestor1.LeftId)); Assert.That(resultNode[1].RightId, Is.EqualTo(ancestor1.RightId)); Assert.That(resultNode[1].TargetId, Is.EqualTo(ancestor1.TargetId)); Assert.That(resultNode[2].Id, Is.EqualTo(node.Id)); Assert.That(resultNode[2].LeftId, Is.EqualTo(node.LeftId)); Assert.That(resultNode[2].RightId, Is.EqualTo(node.RightId)); Assert.That(resultNode[2].TargetId, Is.EqualTo(node.TargetId)); mockHierarchyDataProvider.Verify(p => p.GetAncestors(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>(), true, true)); }
public bool Delete(HierarchyEntry hierarchy, HierarchyNode node) { // can only delete leaf nodes - let consumer handle errors. if (node.RightId != node.LeftId + 1) return false; var deleteSql = string.Format(@" DELETE FROM [{0}].[{1}] WHERE id = @NodeId ", hierarchy.SchemaName, hierarchy.TableName); using (var conn = new SqlConnection(_connectionString)) { using (var command = new SqlCommand(deleteSql, conn)) { conn.Open(); command.Parameters.AddWithValue("@NodeId", node.Id); command.ExecuteNonQuery(); if (conn.State == ConnectionState.Open) conn.Close(); } } HandleGap(hierarchy, node, false); return true; }
public int Add(HierarchyEntry hierarchyEntry, HierarchyNode node) { if (!HierarchyInitialized(hierarchyEntry)) return 0; var insertQuery = node.Id == 0 ? string.Format(@"INSERT INTO [{0}].[{1}] (target_id, left_id, right_id) OUTPUT inserted.id VALUES (@TargetId, @LeftId, @RightId)", hierarchyEntry.SchemaName, hierarchyEntry.TableName) : string.Format(@"UPDATE [{0}].[{1}] SET target_id=@TargetId, left_id=@LeftId, right_id=@RightId WHERE id=@Id", hierarchyEntry.SchemaName, hierarchyEntry.TableName); int result = 0; using (SqlConnection conn = new SqlConnection(_connectionString)) { using (SqlCommand command = new SqlCommand(insertQuery, conn)) { conn.Open(); command.Parameters.AddWithValue("@LeftId", node.LeftId); command.Parameters.AddWithValue("@RightId", node.RightId); command.Parameters.AddWithValue("@TargetId", node.TargetId); if (node.Id == 0) { var rawResult = command.ExecuteScalar(); if (rawResult != null) { result = rawResult.CastTo<int>(); } } else { command.Parameters.AddWithValue("@Id", node.Id); var rowsAffected = command.ExecuteNonQuery(); result = rowsAffected == 0 ? 0 : node.Id; } if (conn.State == ConnectionState.Open) conn.Close(); } } return result; }
public static void BuildTestHierarchy(HierarchyEntry hierarchyEntry, IHierarchyDataProvider provider) { // initialize the hierarchy var originalRootNode = new HierarchyNode { LeftId = 1, RightId = 2 }; var rootId = provider.Add(hierarchyEntry, originalRootNode); // test get root node var persistedRootNode = provider.GetRootNode(hierarchyEntry); // then insert first primary child var firstChild = new HierarchyNode(); firstChild.LeftId = persistedRootNode.RightId; provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode); firstChild.RightId = firstChild.LeftId + 1; provider.Add(hierarchyEntry, firstChild); persistedRootNode = provider.GetRootNode(hierarchyEntry); // insert second primary child var secondChild = new HierarchyNode(); secondChild.LeftId = persistedRootNode.RightId; provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode); secondChild.RightId = secondChild.LeftId + 1; provider.Add(hierarchyEntry, secondChild); // reset root node and get children persistedRootNode = provider.GetRootNode(hierarchyEntry); var secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode); // insert first secondary child var primaryChildAsParent = secondChildren[0]; var secondaryChild1 = new HierarchyNode(); secondaryChild1.LeftId = primaryChildAsParent.RightId; provider.PrepareForInsertNode(hierarchyEntry, primaryChildAsParent); secondaryChild1.RightId = secondaryChild1.LeftId + 1; provider.Add(hierarchyEntry, secondaryChild1); // reset root node and get children persistedRootNode = provider.GetRootNode(hierarchyEntry); secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode); // insert second secondary child primaryChildAsParent = secondChildren[0]; var secondaryChild2 = new HierarchyNode(); secondaryChild2.LeftId = primaryChildAsParent.RightId; provider.PrepareForInsertNode(hierarchyEntry, primaryChildAsParent); secondaryChild2.RightId = secondaryChild2.LeftId + 1; provider.Add(hierarchyEntry, secondaryChild2); // reset root node and get children of primary2 persistedRootNode = provider.GetRootNode(hierarchyEntry); secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode); // insert first secondary child var primaryChild2AsParent = secondChildren[1]; var secondaryChild3 = new HierarchyNode(); secondaryChild3.LeftId = primaryChild2AsParent.RightId; provider.PrepareForInsertNode(hierarchyEntry, primaryChild2AsParent); secondaryChild3.RightId = secondaryChild3.LeftId + 1; provider.Add(hierarchyEntry, secondaryChild3); // reset root node and get children persistedRootNode = provider.GetRootNode(hierarchyEntry); secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode); // insert second secondary child primaryChild2AsParent = secondChildren[1]; var secondaryChild4 = new HierarchyNode(); secondaryChild4.LeftId = primaryChild2AsParent.RightId; provider.PrepareForInsertNode(hierarchyEntry, primaryChild2AsParent); secondaryChild4.RightId = secondaryChild4.LeftId + 1; provider.Add(hierarchyEntry, secondaryChild4); }
/// <summary> /// Handle the opening (insert) or closing (delete) of a gap /// </summary> /// <param name="hierarchyEntry"></param> /// <param name="node"></param> /// <param name="isInsert"></param> private void HandleGap(HierarchyEntry hierarchyEntry, HierarchyNode node, bool isInsert) { var offset = (isInsert) ? 2 : -2; var queryString = string.Format(@" UPDATE [{0}].[{1}] SET left_id = CASE WHEN left_id > @LeftId THEN left_id + @Offset ELSE left_id END, right_id = CASE WHEN right_id >= @RightId THEN right_id + @Offset ELSE right_id END WHERE right_id >= @RightId", hierarchyEntry.SchemaName, hierarchyEntry.TableName); using (var conn = new SqlConnection(_connectionString)) { using (var command = new SqlCommand(queryString, conn)) { conn.Open(); command.Parameters.AddWithValue("@LeftId", node.LeftId); command.Parameters.AddWithValue("@RightId", node.RightId); command.Parameters.AddWithValue("@Offset", offset); command.ExecuteNonQuery(); if (conn.State == ConnectionState.Open) conn.Close(); } } }
private void ReloadLeftRight(HierarchyEntry hierarchyEntry, HierarchyNode node) { var reloadedNode = GetNode(hierarchyEntry, node.Id); node.LeftId = reloadedNode.LeftId; node.RightId = reloadedNode.RightId; }
public void Should_verify_calling_DeleteNode() { // arrange var deleteNode = new HierarchyNode { Id = 1, LeftId = 2, RightId = 3 }; var mockHierarchyDataProvider = new Mock<IHierarchyDataProvider>(); mockHierarchyDataProvider.Setup(p => p.Delete(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())); 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 service.DeleteNode(hierarchyEntry, deleteNode); // assert mockHierarchyDataProvider.Verify(p => p.Delete(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())); }
public HierarchyNode PrepareForInsertNode(HierarchyEntry hierarchyEntry, HierarchyNode parentNode, HierarchyNode childNode) { childNode.LeftId = parentNode.RightId; hierarchyEntryDataProvider.PrepareForInsertNode(hierarchyEntry, parentNode); childNode.RightId = childNode.LeftId + 1; return childNode; }
public void Should_return_parent_calling_GetParent() { // arrange var testTarget = new TestTarget { Id = 345, Data = new TestTargetData { TestString = "Its a target!" } }; var childNode = new HierarchyNode { Id = 34, LeftId = 2, RightId = 3, TargetId = testTarget.Id }; var parentNode = new HierarchyNode { Id = 22, LeftId = 1, RightId = 6, TargetId = testTarget.Id }; var mockHierarchyDataProvider = new Mock<IHierarchyDataProvider>(); mockHierarchyDataProvider.Setup(p => p.GetParent(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())) .Returns(parentNode); 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.GetParent(hierarchyEntry, childNode); // assert Assert.That(resultNode, Is.Not.Null); Assert.That(resultNode.Id, Is.EqualTo(parentNode.Id)); Assert.That(resultNode.LeftId, Is.EqualTo(parentNode.LeftId)); Assert.That(resultNode.RightId, Is.EqualTo(parentNode.RightId)); Assert.That(resultNode.TargetId, Is.EqualTo(parentNode.TargetId)); mockHierarchyDataProvider.Verify(p => p.GetParent(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())); }
public void Should_return_valid_node_calling_GetRootNode() { // arrange var rootNodeTarget = new HierarchyNode { Id = 0, LeftId = 1, RightId = 2 }; var mockHierarchyDataProvider = new Mock<IHierarchyDataProvider>(); mockHierarchyDataProvider .Setup(p => p.GetRootNode(It.IsAny<HierarchyEntry>())) .Returns(rootNodeTarget); 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 rootHierarchyNode = service.GetRootNode(hierarchyEntry); // assert Assert.That(rootHierarchyNode, Is.Not.Null); Assert.That(rootHierarchyNode.LeftId, Is.EqualTo(1)); Assert.That(rootHierarchyNode.RightId, Is.EqualTo(2)); Assert.That(rootHierarchyNode.Id, Is.EqualTo(0)); mockHierarchyDataProvider.Verify(p => p.GetRootNode(It.IsAny<HierarchyEntry>())); }
public HierarchyNode InitializeHierarchy(HierarchyEntry hierarchyEntry, ITarget rootTarget = null) { var rootNode = new HierarchyNode { LeftId = 1, RightId = 2, TargetId = rootTarget == null ? 0 : rootTarget.Id }; // initialize the target table for the node hierarchyEntryDataProvider.Add(hierarchyEntry, rootNode); return rootNode; }
public List<HierarchyNode> GetAncestors(HierarchyEntry hierarchyEntry, HierarchyNode child, bool orderTopDown, bool includeChild) { var ancestors = new List<HierarchyNode>(); var orderString = (orderTopDown) ? "ASC" : "DESC"; var includeChildString = (includeChild) ? "=" : ""; var sql = string.Format(@" SELECT id, left_id, right_id, target_id FROM [{0}].[{1}] n WHERE n.left_id <{3} @ChildLeft AND n.right_id >{3} @ChildRight ORDER BY n.left_id {2}", hierarchyEntry.SchemaName, hierarchyEntry.TableName, orderString, includeChildString); using (var conn = new SqlConnection(_connectionString)) { using (var command = new SqlCommand(sql, conn)) { command.Parameters.AddWithValue("@ChildLeft", child.LeftId); command.Parameters.AddWithValue("@ChildRight", child.RightId); conn.Open(); var reader = command.ExecuteReader(); if (reader.HasRows) { while (reader.Read()) { ancestors.Add(PopulateHierarchyNode(reader)); } } if (conn.State == ConnectionState.Open) conn.Close(); } } return ancestors; }
public HierarchyNode GetParent(HierarchyEntry hierarchyEntry, HierarchyNode node) { return hierarchyEntryDataProvider.GetParent(hierarchyEntry, node); }
public IList<HierarchyNode> GetDescendants(HierarchyEntry hierarchyEntry, HierarchyNode parentNode, bool orderTopDown, bool includeParent) { return hierarchyEntryDataProvider.GetDescendants(hierarchyEntry, parentNode, orderTopDown, includeParent); }
public IList<HierarchyNode> GetChildren(HierarchyEntry hierarchyEntry, HierarchyNode parentNode) { return hierarchyEntryDataProvider.GetChildren(hierarchyEntry, parentNode); }
public IList<HierarchyNode> GetAncestors(HierarchyEntry hierarchyEntry, HierarchyNode node, bool orderTopDown, bool includeChild) { return hierarchyEntryDataProvider.GetAncestors(hierarchyEntry, node, orderTopDown, includeChild); }
public void DeleteNode(HierarchyEntry hierarchyEntry, HierarchyNode node) { hierarchyEntryDataProvider.Delete(hierarchyEntry, node); }
public void Should_properly_create_and_handle_simple_hierarchy_with_basic_operations() { // build a sample hierarchy var hierarchyEntry = new HierarchyEntry { Name = "Test Hierarchy", SchemaName = "dbo", TableName = "test" }; // initialize the provider var dataProvider = new MssqlDataProvider(); var provider = new MssqlHierarchyDataProvider(dataProvider); // initialize the hierarchy var originalRootNode = new HierarchyNode { LeftId = 1, RightId = 2 }; var rootId = provider.Add(hierarchyEntry, originalRootNode); // test get root node var persistedRootNode = provider.GetRootNode(hierarchyEntry); Assert.That(persistedRootNode.Id, Is.EqualTo(rootId)); Assert.That(persistedRootNode.LeftId, Is.EqualTo(1)); Assert.That(persistedRootNode.RightId, Is.EqualTo(2)); // then insert first primary child var firstChild = new HierarchyNode(); firstChild.LeftId = persistedRootNode.RightId; provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode); firstChild.RightId = firstChild.LeftId + 1; provider.Add(hierarchyEntry, firstChild); // verify new hierarchy persistedRootNode = provider.GetRootNode(hierarchyEntry); var firstChildren = provider.GetChildren(hierarchyEntry, persistedRootNode); Assert.That(firstChildren.Count, Is.EqualTo(1)); Assert.That(firstChildren[0].Id, Is.Not.EqualTo(0)); Assert.That(firstChildren[0].LeftId, Is.EqualTo(2)); Assert.That(firstChildren[0].RightId, Is.EqualTo(3)); Assert.That(persistedRootNode.LeftId, Is.EqualTo(1)); Assert.That(persistedRootNode.RightId, Is.EqualTo(4)); // insert second primary child var secondChild = new HierarchyNode(); secondChild.LeftId = persistedRootNode.RightId; provider.PrepareForInsertNode(hierarchyEntry, persistedRootNode); secondChild.RightId = secondChild.LeftId + 1; provider.Add(hierarchyEntry, secondChild); // verify new hierarchy persistedRootNode = provider.GetRootNode(hierarchyEntry); var secondChildren = provider.GetChildren(hierarchyEntry, persistedRootNode); Assert.That(secondChildren.Count, Is.EqualTo(2)); Assert.That(secondChildren[1].Id, Is.Not.EqualTo(0)); Assert.That(secondChildren[1].LeftId, Is.EqualTo(4)); Assert.That(secondChildren[1].RightId, Is.EqualTo(5)); Assert.That(secondChildren[0].LeftId, Is.EqualTo(2)); Assert.That(secondChildren[0].RightId, Is.EqualTo(3)); Assert.That(persistedRootNode.LeftId, Is.EqualTo(1)); Assert.That(persistedRootNode.RightId, Is.EqualTo(6)); // delete a node var deleteNode = secondChildren[1]; provider.Delete(hierarchyEntry, deleteNode); // verify revised hierarchy persistedRootNode = provider.GetRootNode(hierarchyEntry); var children = provider.GetChildren(hierarchyEntry, persistedRootNode); Assert.That(children.Count, Is.EqualTo(1)); Assert.That(children[0].Id, Is.Not.EqualTo(0)); Assert.That(children[0].LeftId, Is.EqualTo(2)); Assert.That(children[0].RightId, Is.EqualTo(3)); Assert.That(persistedRootNode.LeftId, Is.EqualTo(1)); Assert.That(persistedRootNode.RightId, Is.EqualTo(4)); // clean up dataProvider.DropTable(hierarchyEntry.SchemaName, hierarchyEntry.TableName); }
public List<HierarchyNode> GetChildren(HierarchyEntry hierarchy, HierarchyNode parent) { var children = new List<HierarchyNode>(); var sql = string.Format( @"SELECT id, left_id, right_id, target_id FROM [{0}].[{1}] n WHERE n.left_id > @ParentLeft AND n.right_id < @ParentRight AND NOT EXISTS ( SELECT * FROM [{0}].[{1}] mid WHERE mid.left_id BETWEEN @ParentLeft AND @ParentRight AND n.left_id BETWEEN mid.left_id AND mid.right_id AND mid.id != n.id AND mid.id != @ParentId) ORDER BY n.left_id", hierarchy.SchemaName, hierarchy.TableName); using (var conn = new SqlConnection(_connectionString)) { using (var command = new SqlCommand(sql, conn)) { command.Parameters.AddWithValue("@ParentId", parent.Id); command.Parameters.AddWithValue("@ParentLeft", parent.LeftId); command.Parameters.AddWithValue("@ParentRight", parent.RightId); conn.Open(); var reader = command.ExecuteReader(); if (reader.HasRows) { while(reader.Read()) { children.Add(PopulateHierarchyNode(reader)); } } if (conn.State == ConnectionState.Open) conn.Close(); } } return children; }
public HierarchyNode GetParent(HierarchyEntry hierarchy, HierarchyNode child) { var nodeList = GetAncestors(hierarchy, child, false, false); if (nodeList != null && nodeList.Count > 0) return nodeList[0]; return null; }
public void PrepareForInsertNode(HierarchyEntry hierarchy, HierarchyNode parent) { HandleGap(hierarchy, parent, true); // update parent with newly generated right_id. Could just get a new object from the repo, but don't want to kill the object itself. ReloadLeftRight(hierarchy, parent); }
public void Should_return_valid_node_calling_PrepareForInsertNode() { // arrange var parentNode = new HierarchyNode { Id = 0, LeftId = 1, RightId = 2 }; var childNode = new HierarchyNode { Id = 0, LeftId = 0, RightId = 0, TargetId = 345 }; var mockHierarchyDataProvider = new Mock<IHierarchyDataProvider>(); mockHierarchyDataProvider.Setup(p => p.PrepareForInsertNode(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())); 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 newHierarchyNode = service.PrepareForInsertNode(hierarchyEntry, parentNode, childNode); // assert Assert.That(newHierarchyNode, Is.Not.Null); Assert.That(newHierarchyNode.LeftId, Is.EqualTo(parentNode.RightId)); Assert.That(newHierarchyNode.RightId, Is.EqualTo(parentNode.RightId + 1)); Assert.That(newHierarchyNode.Id, Is.EqualTo(0)); mockHierarchyDataProvider.Verify(p => p.PrepareForInsertNode(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())); }
private static HierarchyNode PopulateHierarchyNode(IDataRecord reader) { var node = new HierarchyNode { Id = reader.GetInt32(reader.GetOrdinal("id")), LeftId = reader.GetInt32(reader.GetOrdinal("left_id")), RightId = reader.GetInt32(reader.GetOrdinal("right_id")), TargetId = reader.GetInt32(reader.GetOrdinal("target_id")) }; return node; }
public void Should_return_children_calling_GetChildren() { // 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.GetChildren(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())) .Returns(new List<HierarchyNode> { 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.GetChildren(hierarchyEntry, parentNode); // assert Assert.That(resultNode, Is.Not.Null); Assert.That(resultNode.Count, Is.EqualTo(2)); Assert.That(resultNode[0].Id, Is.EqualTo(child1.Id)); Assert.That(resultNode[0].LeftId, Is.EqualTo(child1.LeftId)); Assert.That(resultNode[0].RightId, Is.EqualTo(child1.RightId)); Assert.That(resultNode[0].TargetId, Is.EqualTo(child1.TargetId)); mockHierarchyDataProvider.Verify(p => p.GetChildren(It.IsAny<HierarchyEntry>(), It.IsAny<HierarchyNode>())); }
public HierarchyNode InsertNode(HierarchyEntry hierarchyEntry, HierarchyNode parentNode, ITarget childTarget) { var childNode = new HierarchyNode { TargetId = childTarget.Id }; childNode = PrepareForInsertNode(hierarchyEntry, parentNode, childNode); hierarchyEntryDataProvider.Add(hierarchyEntry, childNode); return childNode; }