public void Tree_PrettyPrint_TwoChildren_OneHasTwoChildren_WithOneGrandChildEach()
{
var tree = PrtgNode.Group(Group("PRTG Network Monitor", 0),
PrtgNode.Probe(Probe("Probe 1"),
PrtgNode.Group(Group(),
PrtgNode.Device(Device())
),
PrtgNode.Group(Group("Linux"),
PrtgNode.Device(Device("arch-1"))
)
),
PrtgNode.Probe(Probe("Probe 2"))
);
var expected = new[]
{
"PRTG Network Monitor",
"├──Probe 1",
"│ ├──Servers",
"│ │ └──dc-1",
"│ └──Linux",
"│ └──arch-1",
"└──Probe 2"
};
Validate(tree, expected);
}
public void Tree_Builds_OrdersChildPositions()
{
var tree = PrtgNode.Probe(Probe(),
PrtgNode.TriggerCollection(
PrtgNode.Trigger(Trigger("Trigger1")),
PrtgNode.Trigger(Trigger("Trigger2"))
),
PrtgNode.Group(Group("Servers", position: 3)),
PrtgNode.Device(Device("dc-1", position: 1),
PrtgNode.Sensor(Sensor("Sensor2", position: 2)),
PrtgNode.Sensor(Sensor("Sensor1", position: 1))
),
PrtgNode.Trigger(Trigger("Trigger3")),
PrtgNode.Device(Device("dc-2", position: 2))
);
TreePrettyPrintTests.Validate(tree, new[]
{
"Local Probe",
"├──dc-1",
"│ ├──Sensor1",
"│ └──Sensor2",
"├──dc-2",
"├──Servers",
"├──Trigger1",
"├──Trigger2",
"└──Trigger3"
});
}
public void Tree_Compare_Reduce_TreeDifference()
{
//We wanna make sure we're reducing on the TreeDifference, not the regular Difference.
//If we're reducing on the regular Difference, dc-1/2 gets reduced to have no children, but
//Servers doesn't have a difference so doesn't get replaced under Local Probe
var first = PrtgNode.Probe(Probe("Local Probe"),
PrtgNode.Group(Group("Servers"),
PrtgNode.Device(Device("dc-1", 3001),
PrtgNode.Sensor(Sensor("Sensor1", 4001),
DefaultProperty
),
PrtgNode.Sensor(Sensor("Sensor2", 4002))
)
)
);
var second = PrtgNode.Probe(Probe("Local Probe"),
PrtgNode.Group(Group("Servers"),
PrtgNode.Device(Device("dc-2", 3001),
PrtgNode.Sensor(Sensor("Sensor1", 4001),
DefaultProperty
),
PrtgNode.Sensor(Sensor("Sensor2", 4002))
)
)
);
var comparison = first.CompareTo(second);
var reduced = comparison.Reduce();
var list = reduced.DescendantNodesAndSelf().ToList();
Assert.AreEqual(3, list.Count);
}
public void Tree_Compare_Reduce_GrandParentParentTwoChildren_OneChildRemoved()
{
var first = PrtgNode.Probe(Probe("GrandParent"),
PrtgNode.Group(Group("Parent"),
PrtgNode.Device(Device("Child1", 3001)),
PrtgNode.Device(Device("Child2", 3002))
)
);
var second = PrtgNode.Probe(Probe("GrandParent"),
PrtgNode.Group(Group("Parent"),
PrtgNode.Device(Device("Child1", 3001))
)
);
ValidateReduce(
first, second,
new[] { new Validation(TreeNodeDifference.None, c => c.Difference) },
new[]
{
"GrandParent",
"└──<Yellow>Parent</Yellow>",
" └──<Red>Child2</Red>"
},
null,
new[]
{
"GrandParent",
"└──<Yellow>Parent</Yellow>",
" └──<Green>Child2</Green>"
}
);
}
public void Tree_Compare_Reduce_GrandParentTwoParentsOneChildEach_OneParentAndChildRemoved()
{
var first = PrtgNode.Probe(Probe("GrandParent"),
PrtgNode.Group(Group("Parent1"),
PrtgNode.Device(Device("Child1"))
),
PrtgNode.Group(Group("Parent2"),
PrtgNode.Device(Device("Child2"))
)
);
var second = PrtgNode.Probe(Probe("GrandParent"),
PrtgNode.Group(Group("Parent1"),
PrtgNode.Device(Device("Child1"))
)
);
ValidateReduce(
first, second,
new[] { new Validation(TreeNodeDifference.NumberOfChildren, c => c.Difference) },
new[]
{
"<Yellow>GrandParent</Yellow>",
"└──<Red>Parent2</Red>",
" └──<Red>Child2</Red>"
},
null,
new[]
{
"<Yellow>GrandParent</Yellow>",
"└──<Green>Parent2</Green>",
" └──<Green>Child2</Green>"
}
);
}
public void Tree_Compare_SecondLastNodeRemoved_LastNodePropertyCollection()
{
var first = PrtgNode.Device(Device(),
PrtgNode.Sensor(Sensor("First Sensor")),
PrtgNode.PropertyCollection(PrtgNode.Property(3001, "name_", "test"))
);
var second = PrtgNode.Device(Device(),
PrtgNode.PropertyCollection(PrtgNode.Property(3001, "name_", "test"))
);
ValidatePretty(first, second, new[]
{
"<Yellow>dc-1</Yellow>",
"├──<Red>First Sensor</Red>",
"└──Properties",
" └──name_"
}, new[]
{
"<Yellow>dc-1</Yellow>",
"├──Properties",
"│ └──name_",
"└──<Green>First Sensor</Green>",
});
}
public void Tree_Compare_SecondLastNodeRemoved_LastNodeTriggerCollection()
{
var first = PrtgNode.Device(Device(),
PrtgNode.Sensor(Sensor("First Sensor")),
PrtgNode.TriggerCollection(DefaultTrigger)
);
var second = PrtgNode.Device(Device(),
PrtgNode.TriggerCollection(DefaultTrigger)
);
ValidatePretty(first, second, new[]
{
"<Yellow>dc-1</Yellow>",
"├──<Red>First Sensor</Red>",
"└──Triggers",
" └──Email to Admin"
}, new[]
{
"<Yellow>dc-1</Yellow>",
"├──Triggers",
"│ └──Email to Admin",
"└──<Green>First Sensor</Green>"
});
}
public void Tree_NodeList_Item_InBounds()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
var device = probe.Children[0];
Assert.IsNotNull(device);
}
public void Tree_NodeList_ReplaceRange_NewNodes_Null_Throws()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
AssertEx.Throws <ArgumentNullException>(
() => probe.Children.ReplaceRange(probe["dc-1"], null),
"Value cannot be null"
);
}
public void Tree_Compare_Reduce_Root_NoDifference()
{
var node = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device()),
PrtgNode.Device(Device("exch-1")
));
var comparison = node.CompareTo(node).Reduce();
Assert.IsNull(comparison);
}
public void Tree_NodeList_ReplaceRange_OldNode_Null_Throws()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
AssertEx.Throws <ArgumentNullException>(
() => probe.Children.ReplaceRange(null, Enumerable.Empty <PrtgNode>()),
"Value cannot be null"
);
}
public void Tree_NodeList_Remove_Null_Throws()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
AssertEx.Throws <ArgumentNullException>(
() => probe.Children.Remove(null),
"Value cannot be null"
);
}
public void Tree_NodeList_RemoveAt()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device()),
PrtgNode.Group(Group())
);
var newList = probe.Children.RemoveAt(0);
Assert.AreEqual(1, newList.Count);
Assert.AreEqual(newList[0].Name, "Servers");
}
public void Tree_NodeList_Replace()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
var newChild = PrtgNode.Group(Group());
var newList = probe.Children.Replace(probe["dc-1"], newChild);
Assert.AreNotEqual(probe.Children, newList);
Assert.AreEqual(1, newList.Count);
Assert.AreEqual("Servers", newList[0].Name);
}
public void Tree_NodeList_InsertRange_InvalidIndex_Throws()
{
var probe = PrtgNode.Probe(Probe());
AssertEx.Throws <ArgumentOutOfRangeException>(
() => probe.Children.InsertRange(-1, new[] { PrtgNode.Device(Device()) }),
"Specified argument was out of the range of valid values"
);
AssertEx.Throws <ArgumentOutOfRangeException>(
() => probe.Children.InsertRange(1, new[] { PrtgNode.Device(Device()) }),
"Specified argument was out of the range of valid values"
);
}
public void Tree_NodeList_Add_NoExistingChildren()
{
var probe = PrtgNode.Probe(Probe());
var newList = probe.Children.Add(PrtgNode.Device(Device()));
Assert.AreNotEqual(probe.Children, newList);
//The list is standalone until it's added as the child
Assert.IsNull(newList[0].Parent);
var newProbe = probe.WithChildren(newList);
Assert.IsNotNull(newProbe.Children[0].Parent);
}
public void Tree_Compare_ReplaceChildWithGrandChild_With_ChildWithGrandChild()
{
var first = PrtgNode.Probe(Probe(),
PrtgNode.Group(Group()),
PrtgNode.Group(Group("Windows"),
PrtgNode.Device(Device())
)
);
var second = PrtgNode.Probe(Probe(),
PrtgNode.Group(Group()),
PrtgNode.Group(Group("Linux", 2002),
PrtgNode.Device(Device("arch-1"))
)
);
Validate(first, second, new[]
{
new Validation(TreeNodeDifference.None, c => c.Difference),
new Validation(TreeNodeDifference.Removed, c => c["Windows"].Difference),
new Validation(TreeNodeDifference.Added, c => c["Linux"].Difference),
new Validation(TreeNodeDifference.Added, c => c["Linux"]["arch-1"].Difference)
}, new[]
{
new Validation(TreeNodeDifference.None, c => c.Difference),
new Validation(TreeNodeDifference.Added, c => c["Windows"].Difference),
new Validation(TreeNodeDifference.Removed, c => c["Linux"].Difference),
new Validation(TreeNodeDifference.Removed, c => c["Linux"]["arch-1"].Difference)
});
ValidatePretty(first, second, new[]
{
"Local Probe",
"├──Servers",
"├──<Red>Windows</Red>",
"│ └──<Red>dc-1</Red>",
"└──<Green>Linux</Green>",
" └──<Green>arch-1</Green>"
}, new[]
{
"Local Probe",
"├──Servers",
"├──<Red>Linux</Red>",
"│ └──<Red>arch-1</Red>",
"└──<Green>Windows</Green>",
" └──<Green>dc-1</Green>",
});
}
public void Tree_Compare_Include_None()
{
var first = PrtgNode.Device(Device(),
PrtgNode.Sensor(Sensor("Sensor 1", 4001))
);
var second = PrtgNode.Device(Device(),
PrtgNode.Sensor(Sensor("Sensor 2", 4001))
);
CompareCompared(first, second,
new[] { TreeNodeDifference.None },
new[] { TreeNodeDifference.None, TreeNodeDifference.Name },
new[] { TreeNodeDifference.None, TreeNodeDifference.Name }
);
}
public void Tree_NodeList_Add_ExistingChildren()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
var newList = probe.Children.Add(PrtgNode.Group(Group()));
Assert.AreNotEqual(probe.Children, newList);
Assert.IsTrue(newList.All(i => i.Parent == null));
var newProbe = probe.WithChildren(newList);
Assert.IsTrue(newProbe.Children.All(c => c != null));
}
public void Tree_NodeList_Item_OutOfBounds()
{
var probe = PrtgNode.Probe(Probe(),
PrtgNode.Device(Device())
);
AssertEx.Throws <ArgumentOutOfRangeException>(
() => Console.WriteLine(probe.Children[-1]),
"Specified argument was out of the range of valid values"
);
AssertEx.Throws <ArgumentOutOfRangeException>(
() => Console.WriteLine(probe.Children[1]),
"Specified argument was out of the range of valid values"
);
}
public void Tree_PrettyPrint_SingleGrandChild()
{
var tree = PrtgNode.Probe(Probe(),
PrtgNode.Group(Group(),
PrtgNode.Device(Device())
)
);
var expected = new[]
{
"Local Probe",
"└──Servers",
" └──dc-1"
};
Validate(tree, expected);
}
public void Tree_Compare_Grouping_Throws()
{
var first = DefaultProbe;
var second = PrtgNode.Device(Device(),
DefaultSensor,
DefaultSensor
);
var grouping = second["VMware Datastore"];
Assert.AreEqual(PrtgNodeType.Grouping, grouping.Type);
AssertEx.Throws <ArgumentException>(
() => first.CompareTo(grouping),
"Cannot create a comparison containing a node of type Grouping."
);
}
public void Tree_Compare_Exclude_Single()
{
var first = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 1", 4001)),
PrtgNode.Device(Device("Device 3", 4003))
);
var second = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 2", 4001)),
PrtgNode.Device(Device("Device 3", 4003, parentId: 2))
);
CompareCompared(first, second,
new[] { ~TreeNodeDifference.Name },
new[] { TreeNodeDifference.None, TreeNodeDifference.Name, TreeNodeDifference.ParentId },
new[] { TreeNodeDifference.None, TreeNodeDifference.None, TreeNodeDifference.ParentId }
);
}
public void Tree_Compare_Include_Type()
{
var first = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 1", 4001)),
PrtgNode.Device(Device("Device 3", 4003))
);
var second = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 2", 4001)),
PrtgNode.Group(Group("Device 3", 4003, parentId: 3))
);
CompareCompared(first, second,
new[] { TreeNodeDifference.Type },
new[] { TreeNodeDifference.None, TreeNodeDifference.Name, TreeNodeDifference.Type },
new[] { TreeNodeDifference.None, TreeNodeDifference.None, TreeNodeDifference.Type }
);
}
public void Tree_Compare_Include_Value()
{
var first = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 1", 4001)),
PrtgNode.Property(Property("host", "dc-1"))
);
var second = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 2", 4001)),
PrtgNode.Property(Property("host", "dc-2"))
);
CompareCompared(first, second,
new[] { TreeNodeDifference.Value },
new[] { TreeNodeDifference.None, TreeNodeDifference.Name, TreeNodeDifference.Value },
new[] { TreeNodeDifference.None, TreeNodeDifference.None, TreeNodeDifference.Value }
);
}
public void Tree_Compare_Include_Position()
{
var first = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 1", 4001)),
PrtgNode.Device(Device("Device 3", 4003, position: 1))
);
var second = PrtgNode.Group(Group(),
PrtgNode.Device(Device("Device 2", 4001)),
PrtgNode.Device(Device("Device 3", 4003, position: 2))
);
CompareCompared(first, second,
new[] { TreeNodeDifference.Position },
new[] { TreeNodeDifference.None, TreeNodeDifference.Name, TreeNodeDifference.Position },
new[] { TreeNodeDifference.None, TreeNodeDifference.None, TreeNodeDifference.Position }
);
}
public void Tree_PrettyPrint_TwoGrandChildren()
{
var tree = PrtgNode.Probe(Probe(),
PrtgNode.Group(Group(),
PrtgNode.Device(Device()),
PrtgNode.Device(Device("dc-2", 3002))
)
);
var expected = new[]
{
"Local Probe",
"└──Servers",
" ├──dc-1",
" └──dc-2"
};
Validate(tree, expected);
}
public void Tree_NodeList_AddRange_NoExistingChildren()
{
var probe = PrtgNode.Probe(Probe());
var newList = probe.Children.AddRange(new PrtgNode[]
{
PrtgNode.Device(Device()),
PrtgNode.Group(Group())
});
Assert.AreNotEqual(probe.Children, newList);
Assert.AreEqual(2, newList.Count);
Assert.IsTrue(newList.All(v => v.Parent == null));
var newProbe = probe.WithChildren(newList);
Assert.IsTrue(newProbe.Children.All(v => v.Parent != null));
}
public void Tree_PrettyPrint_Grouping()
{
var tree = PrtgNode.Device(Device(),
PrtgNode.Sensor(Sensor(),
PrtgNode.Trigger(Trigger())
),
PrtgNode.Sensor(Sensor())
);
var grouping = tree["VMware Datastore"];
var expected = new[]
{
"VMware Datastore",
"└──Email to Admin",
"VMware Datastore"
};
Validate(grouping, expected);
}
public void Tree_PrettyPrint_NodeAndTwoTriggers()
{
var tree = PrtgNode.Group(Group(),
PrtgNode.Device(Device()),
PrtgNode.TriggerCollection(
PrtgNode.Trigger(Trigger()),
PrtgNode.Trigger(Trigger("Ticket Notification"))
)
);
var expected = new[]
{
"Servers",
"├──dc-1",
"├──Email to Admin",
"└──Ticket Notification",
};
Validate(tree, expected);
}
