public void RemoveNodeHierachyWriter_doesnt_removes_child_node_if_it_has_children()
{
// ARRANGE
var grandChildMock = new Mock <NodeType>();
var grandChild = grandChildMock.Object;
var childNodeMock = new Mock <NodeType>();
childNodeMock
.Setup(n => n.HasChildNodes)
.Returns(true);
var startNodeMock = new Mock <NodeType>();
startNodeMock
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNodeMock.Object));
var writer = new RemoveNodeHierarchyWriter <string, NodeType>();
// ACT
var result = writer.RemoveNode(startNodeMock.Object, HierarchyPath.Create("a"), false, out var nodeRemoved);
// ASSERT
Assert.Same(result, startNodeMock.Object);
Assert.False(nodeRemoved);
startNodeMock.Verify(n => n.RemoveChild(childNodeMock.Object), Times.Never());
startNodeMock.VerifyAll();
childNodeMock.Verify(n => n.RemoveChild(grandChild), Times.Never());
childNodeMock.VerifyAll();
}
public void RemoveNodeHierachyWriter_removes_child_node()
{
// ARRANGE
var childNodeMock = new Mock <NodeType>();
var childNode = childNodeMock.Object;
var startNodeMock = new Mock <NodeType>();
startNodeMock
.Setup(n => n.RemoveChild(childNode))
.Returns(startNodeMock.Object);
startNodeMock
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNode));
var writer = new RemoveNodeHierarchyWriter <string, NodeType>();
// ACT
var result = writer.RemoveNode(startNodeMock.Object, HierarchyPath.Create("a"), false, out var nodeRemoved);
// ASSERT
Assert.Same(result, startNodeMock.Object);
Assert.True(nodeRemoved);
startNodeMock.Verify(n => n.RemoveChild(childNode), Times.Once());
startNodeMock.VerifyAll();
}
public void RemoveValueHierarchyWriter_doesnt_remove_value_from_startNode_child_if_no_value_was_set()
{
// ARRANGE
var childNodeMock = new Mock <NodeType>();
int value = 0;
childNodeMock
.Setup(n => n.TryGetValue(out value))
.Returns(false);
childNodeMock
.Setup(n => n.RemoveValue())
.Returns(false);
var childNode = childNodeMock.Object;
var startNode = new Mock <NodeType>();
startNode
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNode));
var writer = new RemoveValueHierarchyWriter <string, int, NodeType>();
// ACT
writer.ClearValue(startNode.Object, HierarchyPath.Create <string>("a"));
// ASSERT
Assert.False(writer.ValueWasCleared);
startNode.Verify(n => n.TryGetChildNode("a"), Times.Once());
childNodeMock.Verify(n => n.RemoveValue());
}
public void RemoveValueHierarchyWriter_removes_value_from_childNode()
{
// ARRANGE
var childNodeMock = new Mock <NodeType>();
childNodeMock
.Setup(n => n.RemoveValue())
.Returns(true);
var childNode = childNodeMock.Object;
var startNodeMock = new Mock <NodeType>();
startNodeMock
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNode));
var writer = new RemoveValueHierarchyWriter <string, int, NodeType>();
// ACT
writer.ClearValue(startNodeMock.Object, HierarchyPath.Create("a"));
// ASSERT
Assert.True(writer.ValueWasCleared);
startNodeMock.Verify(n => n.RemoveValue(), Times.Never());
startNodeMock.VerifyAll();
childNodeMock.Verify(n => n.RemoveValue(), Times.Once());
childNodeMock.VerifyAll();
}
public void IHierarchy_RemoveNode_non_recursive_fails_if_childnode_is_present(string nodePath, string subNodePath, IHierarchy <string, string> hierarchy)
{
// ARRANGE
string test = "test";
string test1 = "test1";
hierarchy.Add(HierarchyPath.Parse(nodePath, "/"), test);
hierarchy.Add(HierarchyPath.Parse(subNodePath, "/"), test1);
// ACT
var result = hierarchy.RemoveNode(HierarchyPath.Parse(nodePath, "/"), recurse: false);
// ASSERT
Assert.False(result);
string value;
// node has no value
Assert.True(hierarchy.TryGetValue(HierarchyPath.Parse(nodePath, "/"), out value));
Assert.Equal(test, value);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Parse(subNodePath, "/"), out value));
Assert.Equal(test1, value);
}
/// <summary>
/// Set the value of the specified node of the hierarchy.
/// if the node doesn't exist, it is created.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public TValue this[HierarchyPath <TKey> path]
{
get
{
if (this.TryGetValue(path, out var value))
{
return(value);
}
throw new KeyNotFoundException($"path '{path}' doesn't exist or has no value");
}
set
{
bool isLocked = false;
try
{
this.writeLock.Enter(ref isLocked);
var writer = new SetOrAddNodeValueWriter <TKey, TValue, ImmutableNode <TKey, TValue> >(createNode: key => new ImmutableNode <TKey, TValue>(key));
// if the root node has changed, it substitutes the existing root node.
this.rootNode = writer.SetValue(this.rootNode, path, value);
}
finally
{
if (isLocked)
{
this.writeLock.Exit();
}
}
}
}
public void RemoveValueAndPruneHierarchyWriter_prunes_hierarchy_if_no_descendant_has_value_and_no_value_was_removed()
{
// ARRANGE
var childNodeMock = new Mock <NodeType>();
childNodeMock
.Setup(n => n.RemoveValue())
.Returns(false);
var childNode = childNodeMock.Object;
var startNode = new Mock <NodeType>();
startNode
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNode));
startNode
.Setup(n => n.RemoveChild(childNode))
.Returns(startNode.Object); // node is changed in place
var writer = new RemoveValueAndPruneHierarchyWriter <string, int, NodeType>();
// ACT
writer.ClearValue(startNode.Object, HierarchyPath.Create <string>("a"));
// ASSERT
Assert.False(writer.ValueWasCleared);
startNode.Verify(n => n.TryGetChildNode("a"), Times.Once());
startNode.Verify(n => n.RemoveChild(childNode), Times.Once());
childNodeMock.Verify(n => n.RemoveValue());
}
public void IHierarchy_adds_grandchild_under_existing_nodes_returns_hierachy_with_same_values(IHierarchy <string, string> hierarchy)
{
// ARRANGE
string test = "test";
string test1 = "test1";
string test2 = "test2";
string test3 = "test3";
hierarchy.Add(HierarchyPath.Create <string>(), test);
hierarchy.Add(HierarchyPath.Create("a"), test1);
hierarchy.Add(HierarchyPath.Create("b"), test2);
// ACT
hierarchy.Add(HierarchyPath.Create("a", "c"), test3);
// ASSERT
// new hierarchy contains the root date and the new node.
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create <string>(), out var value1));
Assert.Same(test, value1);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("a"), out var value2));
Assert.Equal(test1, value2);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("b"), out var value3));
Assert.Equal(test2, value3);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("a", "c"), out var value4));
Assert.Equal(test3, value4);
}
public void LiteDbHierarchy_removing_root_non_recursive_fails_if_child_node_is_present()
{
// ARRANGE
var setValue_root = Guid.NewGuid();
hierarchy.Add(HierarchyPath.Create <string>(), setValue_root);
hierarchy.Add(HierarchyPath.Create("a"), Guid.NewGuid());
var originalRootDoc = this.nodes.FindOne(Query.EQ("key", null));
originalRootDoc.TryGetValue("_id", out var originalRootDocId);
// ACT
// remove value from root
var result = hierarchy.RemoveNode(HierarchyPath.Create <string>(), recurse: false);
// ASSERT
// root has no value, /a still has a value
Assert.False(result);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create <string>(), out var value_root));
Assert.Equal(setValue_root, value_root);
// check db
var rootDoc = this.nodes.FindOne(Query.EQ("key", null));
Assert.True(rootDoc.TryGetValue("_id", out var rootDocId));
Assert.Equal(originalRootDocId, rootDocId);
Assert.True(rootDoc.TryGetValue("value", out var rootDocValue));
Assert.Equal(setValue_root, rootDocValue.RawValue);
}
public void LiteDbHierarchy_removing_root_recursive_removes_childnode()
{
// ARRANGE
hierarchy.Add(HierarchyPath.Create <string>(), Guid.NewGuid());
hierarchy.Add(HierarchyPath.Create("a"), Guid.NewGuid());
var arrangeRootDoc = this.nodes.FindOne(Query.EQ("key", null));
arrangeRootDoc.TryGetValue("_id", out var arrangeRootDocId);
var arrangeChildDocId = arrangeRootDoc.Get("cn").AsDocument.Get("a").AsObjectId;
var arrangeChildDoc = this.nodes.FindById(arrangeChildDocId);
// ACT
// remove value from root
var result = hierarchy.RemoveNode(HierarchyPath.Create <string>(), recurse: true);
// ASSERT
// root has no value, /a has no value
Assert.True(result);
Assert.False(hierarchy.TryGetValue(HierarchyPath.Create <string>(), out var value));
Assert.False(hierarchy.TryGetValue(HierarchyPath.Create <string>("a"), out value));
// check db
var rootDoc = this.nodes.FindOne(Query.EQ("key", null));
Assert.True(rootDoc.TryGetValue("_id", out var rootDocId));
Assert.NotEqual(arrangeRootDocId, rootDocId);
Assert.False(rootDoc.TryGetValue("value", out var rootDocValue));
Assert.Equal(BsonValue.Null, rootDoc.Get("cn"));
Assert.Null(this.nodes.FindById(arrangeChildDocId));
}
public void LiteDbHierarchy_removes_root_node(bool recurse)
{
// ARRANGE
hierarchy.Add(HierarchyPath.Create <string>(), Guid.NewGuid());
var arrangeRootDoc = this.nodes.FindOne(Query.EQ("key", null));
arrangeRootDoc.TryGetValue("_id", out var originalRootDocId);
// ACT
// remove root node 'physically'
var result = hierarchy.RemoveNode(HierarchyPath.Create <string>(), recurse: recurse);
// ASSERT
// root has no value, /a has no value
Assert.True(result);
Assert.False(hierarchy.TryGetValue(HierarchyPath.Create <string>(), out var value_root));
// check db
var rootDoc = this.nodes.FindOne(Query.EQ("key", null));
Assert.True(rootDoc.TryGetValue("_id", out var rootDocId));
Assert.NotEqual(originalRootDocId, rootDocId);
Assert.False(rootDoc.TryGetValue("value", out var rootDocValue));
}
public ModelModel(string basePath, string[] filePartPaths)
: base(basePath, filePartPaths.First(f => f.EndsWith(".obj", StringComparison.OrdinalIgnoreCase)))
{
ResourceType = ResourceType.Model;
Name = Path.GetFileNameWithoutExtension(FilePath);
HierarchyPath = HierarchyPath.Take(HierarchyPath.Length - 1).ToArray();
}
public void IHierarchy_remove_value_from_child_returns_true(IHierarchy <string, string> hierarchy)
{
// ARRANGE
string test = "test";
string test1 = "test1";
string test2 = "test2";
hierarchy.Add(HierarchyPath.Create <string>(), test);
hierarchy.Add(HierarchyPath.Create("a"), test1);
hierarchy.Add(HierarchyPath.Create("a", "b"), test2);
// ACT
var result = hierarchy.Remove(HierarchyPath.Create("a"));
// ASSERT
Assert.True(result);
string value;
// new node has no value
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create <string>(), out value));
Assert.Equal(test, value);
Assert.False(hierarchy.TryGetValue(HierarchyPath.Create("a"), out value));
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("a", "b"), out value));
Assert.Equal(test2, value);
}
public void I_root_returns_child_and_grandchild_on_DescendAlongPath()
{
// 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.DescendAlongPath(HierarchyPath.Create(1, 2)).ToArray();
// ASSERT
Assert.Equal(new[] { this.startNode.Object, childNode, subChildNode }, result);
this.startNode.Verify(n => n.TryGetChildNode(1), Times.Once());
childNodeMock.Verify(n => n.TryGetChildNode(2), Times.Once());
}
/// <summary>
/// Sets the value at the specfied node.
/// </summary>
/// <param name="startNode">node to start to descend along the path</param>
/// <param name="path">path to follow from start node</param>
/// <param name="value">vaue to add</param>
/// <returns><paramref name="startNode"/>or its susbtitute</returns>
public TNode SetValue(TNode startNode, HierarchyPath <TKey> path, TValue value)
{
var thisNode = base.GetOrCreate(startNode, path, out var descendantAt);
descendantAt.SetValue(value);
return(thisNode);
}
public void IHierarchy_adds_child_sibling_value_twice_throws_ArgumentException(IHierarchy <string, string> hierarchy)
{
// ARRANGE
string test = "test";
string test1 = "test1";
string test2 = "test2";
string test3 = "test3";
hierarchy.Add(HierarchyPath.Create <string>(), test);
hierarchy.Add(HierarchyPath.Create("a"), test1);
hierarchy.Add(HierarchyPath.Create("b"), test2);
// ACT & ASSERT
var result = Assert.Throws <ArgumentException>(() => hierarchy.Add(HierarchyPath.Create("b"), test3));
// ASSERT
Assert.True(result.Message.Contains("already has a value"));
Assert.True(result.Message.Contains("'b'"));
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("b"), out var value));
Assert.Equal(test2, value);
Assert.Equal("path", result.ParamName);
}
public void RemoveNodeHierachyWriter_does_nothing_for_wrong_path()
{
// ARRANGE
var childNodeMock = new Mock <NodeType>();
var childNode = childNodeMock.Object;
var startNodeMock = new Mock <NodeType>();
startNodeMock
.Setup(n => n.TryGetChildNode("a"))
.Returns((false, null));
var writer = new RemoveNodeHierarchyWriter <string, NodeType>();
// ACT
var result = writer.RemoveNode(startNodeMock.Object, HierarchyPath.Create("a"), false, out var nodeRemoved);
// ASSERT
Assert.Same(result, startNodeMock.Object);
Assert.False(nodeRemoved);
startNodeMock.Verify(n => n.RemoveChild(childNode), Times.Never());
startNodeMock.VerifyAll();
}
public void IHierarchy_set_value_at_grandchild(IHierarchy <string, string> hierarchy)
{
// ARRANGE
string test = "test";
string test1 = "test1";
string test2 = "test2";
string test3 = "test3";
hierarchy[HierarchyPath.Create <string>()] = test;
hierarchy[HierarchyPath.Create("a")] = test1;
hierarchy[HierarchyPath.Create("b")] = test2;
// ACT
hierarchy[HierarchyPath.Create("a", "c")] = test3;
// ASSERT
// hierarchy contains the root date and the new node.
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create <string>(), out var value1));
Assert.Equal(test, value1);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("a"), out var value2));
Assert.Equal(test1, value2);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("b"), out var value3));
Assert.Equal(test2, value3);
Assert.True(hierarchy.TryGetValue(HierarchyPath.Create("a", "c"), out var value4));
Assert.Equal(test3, value4);
}
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_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 SetOrAddValue_Adds_value_to_created_inner_node()
{
// ARRANGE
var childNode = new Mock <NodeType>();
var startNode = new Mock <NodeType>();
startNode
.Setup(n => n.TryGetChildNode("a"))
.Returns((false, null));
startNode
.Setup(n => n.AddChild(childNode.Object))
.Returns(startNode.Object);
var writer = new SetOrAddNodeValueWriter <string, int, NodeType>(id => childNode.Object);
// ACT
var result = writer.AddValue(startNode.Object, HierarchyPath.Create("a"), 1);
// ASSERT
startNode.Verify(n => n.AddChild(childNode.Object), Times.Once());
startNode.VerifyAll();
childNode.Verify(n => n.SetValue(1), Times.Once());
childNode.VerifyAll();
Assert.Same(startNode.Object, result);
}
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 D_returns_child_and_grandchild_on_DescendAlongPath()
{
// ARRANGE
var nodeHierarchy = (Func <string, string, (bool, string)>)(delegate(string node, string key)
{
if (node == "startNode" && key == "childNode")
{
return(true, "childNode");
}
else if (node == "childNode" && key == "grandChildNode")
{
return(true, "grandChildNode");
}
throw new InvalidOperationException("unknown node");
});
// ACT
string[] result = "startNode".DescendAlongPath(nodeHierarchy, HierarchyPath.Create("childNode", "grandChildNode")).ToArray();
// ASSERT
Assert.Equal(new[] { "startNode", "childNode", "grandChildNode" }, result);
}
public void SetOrAddValue_Set_value_overwrites_existing_value()
{
// ARRANGE
int value = 2;
var childNode = new Mock <NodeType>();
var childNodeObject = childNode.Object;
var startNode = new Mock <NodeType>();
startNode
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNodeObject));
startNode
.Setup(n => n.ReplaceChild(childNodeObject, childNodeObject))
.Returns(startNode.Object);
var writer = new SetOrAddNodeValueWriter <string, int, NodeType>(id => null);
// ACT
var result = writer.SetValue(startNode.Object, HierarchyPath.Create("a"), 1);
// ASSERT
startNode.Verify(n => n.TryGetChildNode("a"), Times.Once());
startNode.VerifyAll();
childNode.Verify(n => n.TryGetValue(out value), Times.Never());
childNode.Verify(n => n.SetValue(1), Times.Once());
childNode.VerifyAll();
Assert.Same(startNode.Object, result);
}
public void GetOrCreateNode_creates_child_of_startNode_as_destination()
{
// ARRANGE
var childNode = new Mock <NodeType>().Object;
var startNode = new Mock <NodeType>();
startNode
.Setup(n => n.TryGetChildNode("a"))
.Returns((false, null));
startNode
.Setup(n => n.AddChild(childNode))
.Returns(startNode.Object);
Func <string, NodeType> createChildCallback = id =>
{
Assert.Equal("a", id);
return(childNode);
};
var writer = new GetOrCreateNodeWriter <string, NodeType>(createChildCallback);
// ACT
var result = writer.GetOrCreate(startNode.Object, HierarchyPath.Create("a"), out var descendantAt);
// ASSERT
Assert.Same(result, startNode.Object);
Assert.Same(childNode, descendantAt);
startNode.Verify(n => n.AddChild(It.IsAny <NodeType>()), Times.Once());
}
public void GetOrCreateNode_returns_child_of_startNode_as_destination()
{
// ARRANGE
var childNode = new Mock <NodeType>().Object;
var startNode = new Mock <NodeType>();
startNode
.Setup(n => n.TryGetChildNode("a"))
.Returns((true, childNode));
startNode
.Setup(n => n.ReplaceChild(childNode, childNode))
.Returns(startNode.Object);
var writer = new GetOrCreateNodeWriter <string, NodeType>(id => null);
// ACT
var result = writer.GetOrCreate(startNode.Object, HierarchyPath.Create("a"), out var descendentAt);
// ASSERT
Assert.Same(result, startNode.Object);
Assert.Same(childNode, descendentAt);
startNode.Verify(n => n.TryGetChildNode("a"), Times.Once());
startNode.Verify(n => n.ReplaceChild(childNode, childNode), Times.Once());
startNode.VerifyAll();
}
public void Root_pathes_are_equal()
{
// ACT & ASSERT
Equal(HierarchyPath.Create <string>(), HierarchyPath.Parse("/", separator: "/"));
Equal(HierarchyPath.Parse("/", separator: "/"), HierarchyPath.Parse("", separator: "/"));
NotEqual(HierarchyPath.Create <string>(), HierarchyPath.Create <string>(""));
}
/// <summary>
/// Removes the value from the specified node in hierarchy.
/// </summary>
/// <param name="path"></param>
/// <returns>true if value was removed, false otherwise</returns>
public bool Remove(HierarchyPath <TKey> path)
{
var writer = new RemoveValueAndPruneHierarchyWriter <TKey, TValue, MutableNode <TKey, TValue> >();
writer.ClearValue(this.rootNode, path);
return(writer.ValueWasCleared);
}
public bool Remove(HierarchyPath <string> path)
{
var writer = new RemoveValueHierarchyWriter <string, TValue, LiteDbMutableNode <TValue> >();
writer.ClearValue(this.GetOrCreateRootNode(), path);
return(writer.ValueWasCleared);
}
public void I_root_returns_itself_on_DescendantAt()
{
// ACT
MockableNodeType result = this.startNode.Object.DescendantAt(HierarchyPath.Create <int>());
// ASSERT
Assert.Same(startNode.Object, result);
}
