def test_unified_diff(options_ios):
host = Host(hostname="test_host", os="ios", hconfig_options=options_ios)
config_a = HConfig(host=host)
config_b = HConfig(host=host)
# deep differences
config_a.add_children_deep(["a", "aa", "aaa", "aaaa"])
config_b.add_children_deep(["a", "aa", "aab", "aaba"])
# these children will be the same and should not appear in the diff
config_a.add_children_deep(["b", "ba", "baa"])
config_b.add_children_deep(["b", "ba", "baa"])
# root level differences
config_a.add_children_deep(["c", "ca"])
config_b.add_child("d")
diff = list(config_a.unified_diff(config_b))
assert diff == [
"a",
" aa",
" - aaa",
" - aaaa",
" + aab",
" + aaba",
"- c",
" - ca",
"+ d",
]
def test_get_children(self):
hier = HConfig(host=self.host_a)
hier.add_child("interface Vlan2")
hier.add_child("interface Vlan3")
children = list(hier.get_children("startswith", "interface"))
assert len(children) == 2
for child in children:
assert child.text.startswith("interface Vlan")
def test_config_to_get_to(self):
running_config_hier = HConfig(self.host_a, self.os, self.options)
running_config_hier.add_child('interface Vlan2')
compiled_config_hier = HConfig(self.host_a, self.os, self.options)
compiled_config_hier.add_child('interface Vlan3')
remediation_config_hier = running_config_hier.config_to_get_to(
compiled_config_hier)
self.assertEqual(2, len(list(remediation_config_hier.all_children())))
def test_del_child(self):
hier1 = HConfig(host=self.host_a)
hier1.add_child("interface Vlan2")
assert len(list(hier1.all_children())) == 1
hier1.del_child(hier1.get_child("startswith", "interface"))
assert len(list(hier1.all_children())) == 0
def test_del_child(self):
hier1 = HConfig(host=self.host_a)
hier1.add_child('interface Vlan2')
self.assertEqual(1, len(list(hier1.all_children())))
hier1.del_child(hier1.get_child('startswith', 'interface'))
self.assertEqual(0, len(list(hier1.all_children())))
def test_config_to_get_to(self):
running_config_hier = HConfig(host=self.host_a)
interface = running_config_hier.add_child('interface Vlan2')
interface.add_child('ip address 192.168.1.1/24')
compiled_config_hier = HConfig(host=self.host_a)
compiled_config_hier.add_child('interface Vlan3')
remediation_config_hier = running_config_hier.config_to_get_to(
compiled_config_hier)
self.assertEqual(2, len(list(remediation_config_hier.all_children())))
def test_config_to_get_to(self):
running_config_hier = HConfig(host=self.host_a)
interface = running_config_hier.add_child("interface Vlan2")
interface.add_child("ip address 192.168.1.1/24")
generated_config_hier = HConfig(host=self.host_a)
generated_config_hier.add_child("interface Vlan3")
remediation_config_hier = running_config_hier.config_to_get_to(
generated_config_hier
)
assert len(list(remediation_config_hier.all_children())) == 2
def test_merge(self):
hier1 = HConfig(host=self.host_a)
hier1.add_child('interface Vlan2')
hier2 = HConfig(host=self.host_b)
hier2.add_child('interface Vlan3')
self.assertEqual(1, len(list(hier1.all_children())))
self.assertEqual(1, len(list(hier2.all_children())))
hier1.merge(hier2)
self.assertEqual(2, len(list(hier1.all_children())))
def test_merge(self):
hier1 = HConfig(host=self.host_a)
hier1.add_child("interface Vlan2")
hier2 = HConfig(host=self.host_b)
hier2.add_child("interface Vlan3")
assert len(list(hier1.all_children())) == 1
assert len(list(hier2.all_children())) == 1
hier1.merge(hier2)
assert len(list(hier1.all_children())) == 2
def test_add_sectional_exiting(self):
hier = HConfig(host=self.host_a)
bgp = hier.add_child("router bgp 64500")
template = bgp.add_child("template peer-policy")
hier.add_sectional_exiting()
sectional_exit = template.get_child("equals", "exit-peer-policy")
assert sectional_exit is not None
def test_add_sectional_exiting(self):
hier = HConfig(host=self.host_a)
bgp = hier.add_child('router bgp 64500')
template = bgp.add_child('template peer-policy')
hier.add_sectional_exiting()
sectional_exit = template.get_child('equals', 'exit-peer-policy')
self.assertIsNotNone(sectional_exit)
def test_cisco_style_text(self):
hier = HConfig(host=self.host_a)
interface = hier.add_child("interface Vlan2")
ip_address = interface.add_child("ip address 192.168.1.1 255.255.255.0")
assert ip_address.cisco_style_text() == " ip address 192.168.1.1 255.255.255.0"
assert isinstance(ip_address.cisco_style_text(), str)
assert not isinstance(ip_address.cisco_style_text(), list)
def difference(self, target, delta=None):
"""
Creates a new HConfig object with the config from self that is not in target
Example usage:
whats in the config.lines v.s. in running config
i.e. did all my configuration changes get written to the running config
:param target: HConfig - The configuration to check against
:param delta: HConfig - The elements from self that are not in target
:return: HConfig - missing config additions
"""
if delta is None:
from hier_config import HConfig
delta = HConfig(host=self.host)
for self_child in self.children:
# Not dealing with negations and defaults for now
if self_child.text.startswith(('no ', 'default ')):
continue
target_child = target.get_child('equals', self_child.text)
if target_child:
delta_child = delta.add_child(self_child.text)
self_child.difference(target_child, delta_child)
if not delta_child.children:
delta_child.delete()
else:
delta.add_deep_copy_of(self_child)
return delta
def test_append_tags(self):
config = HConfig(host=self.host_a)
interface = config.add_child("interface Vlan2")
ip_address = interface.add_child("ip address 192.168.1.1/24")
ip_address.append_tags("test_tag")
assert "test_tag" in config.tags
assert "test_tag" in interface.tags
assert "test_tag" in ip_address.tags
def test_all_children_sorted_by_lineage_rules(self, tags_ios):
hier = HConfig(host=self.host_a)
svi = hier.add_child("interface Vlan2")
svi.add_child("description switch-mgmt-10.0.2.0/24")
mgmt = hier.add_child("interface FastEthernet0")
mgmt.add_child("description mgmt-192.168.0.0/24")
assert len(list(hier.all_children())) == 4
assert isinstance(hier.all_children(), types.GeneratorType)
assert len(list(hier.all_children_sorted_with_lineage_rules(tags_ios))) == 2
assert isinstance(
hier.all_children_sorted_with_lineage_rules(tags_ios),
types.GeneratorType,
)
def test_add_children(self):
interface_items1 = [
"description switch-mgmt 192.168.1.0/24",
"ip address 192.168.1.1/24",
]
hier1 = HConfig(host=self.host_a)
interface1 = hier1.add_child("interface Vlan2")
interface1.add_children(interface_items1)
assert len(list(hier1.all_children())) == 3
interface_items2 = ["description switch-mgmt 192.168.1.0/24"]
hier2 = HConfig(host=self.host_a)
interface2 = hier2.add_child("interface Vlan2")
interface2.add_children(interface_items2)
assert len(list(hier2.all_children())) == 2
def test_add_children(self):
interface_items1 = [
'description switch-mgmt 192.168.1.0/24',
'ip address 192.168.1.1/24'
]
hier1 = HConfig(host=self.host_a)
interface1 = hier1.add_child('interface Vlan2')
interface1.add_children(interface_items1)
self.assertEqual(3, len(list(hier1.all_children())))
interface_items2 = "description switch-mgmt 192.168.1.0/24"
hier2 = HConfig(host=self.host_a)
interface2 = hier2.add_child('interface Vlan2')
interface2.add_children(interface_items2)
self.assertEqual(2, len(list(hier2.all_children())))
def test_append_tags(self):
config = HConfig(host=self.host_a)
interface = config.add_child('interface Vlan2')
ip_address = interface.add_child('ip address 192.168.1.1/24')
ip_address.append_tags('test_tag')
self.assertIn('test_tag', config.tags)
self.assertIn('test_tag', interface.tags)
self.assertIn('test_tag', ip_address.tags)
def test_get_child_deep(self):
hier = HConfig(host=self.host_a)
interface = hier.add_child('interface Vlan2')
interface.add_child('ip address 192.168.1.1 255.255.255.0')
child = hier.get_child_deep([('equals', 'interface Vlan2'),
('equals',
'ip address 192.168.1.1 255.255.255.0')])
self.assertIsNotNone(child)
def test_all_children_sorted_by_lineage_rules(self):
hier = HConfig(host=self.host_a)
svi = hier.add_child('interface Vlan2')
svi.add_child('description switch-mgmt-10.0.2.0/24')
mgmt = hier.add_child('interface FastEthernet0')
mgmt.add_child('description mgmt-192.168.0.0/24')
self.assertEqual(4, len(list(hier.all_children())))
self.assertTrue(isinstance(hier.all_children(), types.GeneratorType))
self.assertEqual(
2,
len(list(hier.all_children_sorted_with_lineage_rules(self.tags))))
self.assertTrue(
isinstance(hier.all_children_sorted_with_lineage_rules(self.tags),
types.GeneratorType))
def test_add_tags(self):
hier = HConfig(host=self.host_a)
tag_rules = [{"lineage": [{"equals": "interface Vlan2"}], "add_tags": "test"}]
child = hier.add_child("interface Vlan2")
hier.add_tags(tag_rules)
assert {"test"} == child.tags
def test_add_shallow_copy_of(self):
base_config = HConfig(host=self.host_a)
config_a = HConfig(host=self.host_a)
interface_a = config_a.add_child("interface Vlan2")
interface_a.append_tags({"ta", "tb"})
interface_a.comments.add("ca")
interface_a.order_weight = 200
config_b = HConfig(host=self.host_b)
interface_b = config_b.add_child("interface Vlan2")
interface_b.append_tags({"tc"})
interface_b.comments.add("cc")
interface_b.order_weight = 201
copied_interface = base_config.add_shallow_copy_of(interface_a, merged=True)
assert copied_interface.tags == {"ta", "tb"}
assert copied_interface.comments == {"ca"}
assert copied_interface.order_weight == 200
assert copied_interface.instances == [
{
"hostname": interface_a.host.hostname,
"comments": interface_a.comments,
"tags": interface_a.tags,
}
]
copied_interface = base_config.add_shallow_copy_of(interface_b, merged=True)
assert copied_interface.tags == {"ta", "tb", "tc"}
assert copied_interface.comments == {"ca", "cc"}
assert copied_interface.order_weight == 201
assert copied_interface.instances == [
{
"hostname": interface_a.host.hostname,
"comments": interface_a.comments,
"tags": interface_a.tags,
},
{
"hostname": interface_b.host.hostname,
"comments": interface_b.comments,
"tags": interface_b.tags,
},
]
def test_all_children_sorted_untagged(self):
config = HConfig(host=self.host_a)
interface = config.add_child("interface Vlan2")
ip_address_a = interface.add_child("ip address 192.168.1.1/24")
ip_address_a.append_tags("a")
ip_address_none = interface.add_child("ip address 192.168.2.1/24")
assert ip_address_none is list(config.all_children_sorted_untagged())[1]
assert len(list(config.all_children_sorted_untagged())) == 2
assert ip_address_none is list(config.all_children_sorted_untagged())[1]
def test_line_inclusion_test(self):
config = HConfig(host=self.host_a)
interface = config.add_child('interface Vlan2')
ip_address_ab = interface.add_child('ip address 192.168.2.1/24')
ip_address_ab.append_tags(['a', 'b'])
self.assertFalse(ip_address_ab.line_inclusion_test('a', 'b'))
self.assertFalse(ip_address_ab.line_inclusion_test('', 'a'))
self.assertTrue(ip_address_ab.line_inclusion_test('a', ''))
self.assertFalse(ip_address_ab.line_inclusion_test('', ''))
def test_add_ancestor_copy_of(self):
hier1 = HConfig(host=self.host_a)
interface = hier1.add_child("interface Vlan2")
interface.add_children(
["description switch-mgmt-192.168.1.0/24", "ip address 192.168.1.0/24"]
)
hier1.add_ancestor_copy_of(interface)
assert len(list(hier1.all_children())) == 3
assert isinstance(hier1.all_children(), types.GeneratorType)
def test_line_inclusion_test(self):
config = HConfig(host=self.host_a)
interface = config.add_child("interface Vlan2")
ip_address_ab = interface.add_child("ip address 192.168.2.1/24")
ip_address_ab.append_tags(["a", "b"])
assert not ip_address_ab.line_inclusion_test({"a"}, {"b"})
assert not ip_address_ab.line_inclusion_test(set(), {"a"})
assert ip_address_ab.line_inclusion_test({"a"}, set())
assert not ip_address_ab.line_inclusion_test(set(), set())
def test_cisco_style_text(self):
hier = HConfig(host=self.host_a)
interface = hier.add_child('interface Vlan2')
ip_address = interface.add_child(
'ip address 192.168.1.1 255.255.255.0')
self.assertEqual(' ip address 192.168.1.1 255.255.255.0',
ip_address.cisco_style_text())
self.assertNotEqual(' ip address 192.168.1.1 255.255.255.0',
ip_address.cisco_style_text())
self.assertTrue(isinstance(ip_address.cisco_style_text(), str))
self.assertFalse(isinstance(ip_address.cisco_style_text(), list))
def test_add_ancestor_copy_of(self):
hier1 = HConfig(host=self.host_a)
interface = hier1.add_child('interface Vlan2')
interface.add_children([
'description switch-mgmt-192.168.1.0/24',
'ip address 192.168.1.0/24'
])
hier1.add_ancestor_copy_of(interface)
self.assertEqual(3, len(list(hier1.all_children())))
self.assertTrue(isinstance(hier1.all_children(), types.GeneratorType))
def test_rebuild_children_dict(self):
hier1 = HConfig(host=self.host_a)
interface = hier1.add_child("interface Vlan2")
interface.add_children(
["description switch-mgmt-192.168.1.0/24", "ip address 192.168.1.0/24"]
)
delta_a = hier1
hier1.rebuild_children_dict()
delta_b = hier1
assert list(delta_a.all_children()) == list(delta_b.all_children())
def test_get_child_deep(self):
hier = HConfig(host=self.host_a)
interface = hier.add_child("interface Vlan2")
interface.add_child("ip address 192.168.1.1 255.255.255.0")
child = hier.get_child_deep(
[
("equals", "interface Vlan2"),
("equals", "ip address 192.168.1.1 255.255.255.0"),
]
)
assert child is not None
