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;
}
