nautobot 2.4.16__py3-none-any.whl → 2.4.17__py3-none-any.whl

nautobot/ipam/templates/ipam/inc/ipadress_edit_header.html

@@ -2,15 +2,15 @@
 
 <ul class="nav nav-tabs" style="margin-bottom: 20px">
     <li role="presentation"{% if active_tab == 'add' %} class="active"{% endif %}>
-        <a href="{% url 'ipam:ipaddress_add' %}{% querystring request %}">New IP</a>
+        <a href="{% url 'ipam:ipaddress_add' %}{% legacy_querystring request %}">New IP</a>
     </li>
     {% if 'interface' in request.GET or 'vminterface' in request.GET %}
         <li role="presentation"{% if active_tab == 'assign' %} class="active"{% endif %}>
-            <a href="{% url 'ipam:ipaddress_assign' %}{% querystring request %}">Assign IP</a>
+            <a href="{% url 'ipam:ipaddress_assign' %}{% legacy_querystring request %}">Assign IP</a>
         </li>
     {% else %}
         <li role="presentation"{% if active_tab == 'bulk_add' %} class="active"{% endif %}>
-            <a href="{% url 'ipam:ipaddress_bulk_add' %}{% querystring request %}">Bulk Create</a>
+            <a href="{% url 'ipam:ipaddress_bulk_add' %}{% legacy_querystring request %}">Bulk Create</a>
         </li>
     {% endif %}
 </ul>

nautobot/ipam/templates/ipam/inc/toggle_available.html

@@ -1,10 +1,10 @@
 {% load helpers %}
 {% if show_available is not None %}
         <div class="btn-group" role="group">
-            <a href="{{ request.path }}{% querystring request show_available='true' %}" class="btn btn-default{% if show_available %} active disabled{% endif %}">
+            <a href="{{ request.path }}{% legacy_querystring request show_available='true' %}" class="btn btn-default{% if show_available %} active disabled{% endif %}">
               <i class="mdi mdi-eye-outline"></i> Show available
             </a>
-            <a href="{{ request.path }}{% querystring request show_available='false' %}" class="btn btn-default{% if not show_available %} active disabled{% endif %}">
+            <a href="{{ request.path }}{% legacy_querystring request show_available='false' %}" class="btn btn-default{% if not show_available %} active disabled{% endif %}">
               <i class="mdi mdi-eye-off-outline"></i> Hide available
             </a>
         </div>

nautobot/ipam/templates/ipam/ipaddress_assign.html

@@ -46,7 +46,7 @@
     </form>
     {% if table %}
         <div class="row">
-            <form action="{% querystring request %}" method="post" class="form form-horizontal">
+            <form action="{% legacy_querystring request %}" method="post" class="form form-horizontal">
                 {% csrf_token %}
                 <div class="col-md-12" style="margin-top: 20px">
                     <h3>Search Results</h3>

nautobot/ipam/templates/ipam/prefix_list.html

@@ -10,7 +10,7 @@
             </button>
             <ul class="dropdown-menu" aria-labelledby="max_length">
                 {% for i in "4,8,12,16,20,24,28,32,40,48,56,64"|split %}
-                    <li><a href="{% url 'ipam:prefix_list' %}{% querystring request prefix_length__lte=i page=1 %}">
+                    <li><a href="{% url 'ipam:prefix_list' %}{% legacy_querystring request prefix_length__lte=i page=1 %}">
                         {{ i }} {% if request.GET.prefix_length__lte == i %}<i class="mdi mdi-check-bold"></i>{% endif %}
                     </a></li>
                 {% endfor %}

nautobot/ipam/templates/ipam/vlan_retrieve.html

@@ -5,80 +5,4 @@
     {% if object.vlan_group %}
         <li><a href="{% url 'ipam:vlan_list' %}?vlan_group={{ object.vlan_group.name }}">{{ object.vlan_group }}</a></li>
     {% endif %}
-{% endblock extra_breadcrumbs %}
-
-{% block extra_nav_tabs %}
-        <li role="presentation"{% if active_tab == 'interfaces' %} class="active"{% endif %}>
-            <a href="{% url 'ipam:vlan_interfaces' pk=object.pk %}">Device Interfaces <span class="badge">{{ object.get_interfaces.count }}</span></a>
-        </li>
-        <li role="presentation"{% if active_tab == 'vminterfaces' %} class="active"{% endif %}>
-            <a href="{% url 'ipam:vlan_vminterfaces' pk=object.pk %}">VM Interfaces <span class="badge">{{ object.get_vminterfaces.count }}</span></a>
-        </li>
-{% endblock extra_nav_tabs %}
-
-{% block content_left_page %}
-            <div class="panel panel-default">
-                <div class="panel-heading">
-                    <strong>VLAN</strong>
-                </div>
-                <table class="table table-hover panel-body attr-table">
-                    <tr>
-                        <td>Locations</td>
-                        <td>
-                            {% for location in object.locations.all %}
-                                {{ location|hyperlinked_object }}<br>
-                            {% empty %}
-                                <span class="text-muted">None</span>
-                            {% endfor %}
-                        </td>
-                    </tr>
-                    <tr>
-                        <td>VLAN Group</td>
-                        <td>{{ object.vlan_group|hyperlinked_object }}</td>
-                    </tr>
-                    <tr>
-                        <td>VLAN ID</td>
-                        <td>{{ object.vid }}</td>
-                    </tr>
-                    <tr>
-                        <td>Name</td>
-                        <td>{{ object.name }}</td>
-                    </tr>
-                    {% include 'inc/tenant_table_row.html' %}
-                    <tr>
-                        <td>Status</td>
-                        <td>
-                            {{ object.status| hyperlinked_object_with_color }}
-                        </td>
-                    </tr>
-                    <tr>
-                        <td>Role</td>
-                        <td>{{ object.role | hyperlinked_object_with_color }}</td>
-                    </tr>
-                    <tr>
-                        <td>Description</td>
-                        <td>{{ object.description|placeholder }}</td>
-                    </tr>
-                </table>
-            </div>
-{% endblock content_left_page %}
-
-{% block content_full_width_page %}
-            <div class="panel panel-default">
-                <div class="panel-heading">
-                    <strong>Prefixes</strong>
-                </div>
-                {% include 'responsive_table.html' with table=prefix_table %}
-                {% if perms.ipam.add_prefix %}
-                    <div class="panel-footer text-right noprint">
-                        <a href="{% url 'ipam:prefix_add' %}?{% if object.tenant %}tenant={{ object.tenant.pk }}{% endif %}&vlan={{ object.pk }}{% for loc in object.locations.all %}&locations={{ loc.pk }}{% endfor %}" class="btn btn-primary btn-xs">
-                            <span class="mdi mdi-plus-thick" aria-hidden="true"></span>
-                            Add a prefix
-                        </a>
-                    </div>
-                {% endif %}
-            </div>
-            {% if prefix_table.paginator.num_pages > 1 %}
-                {% include "inc/paginator.html" with paginator=prefix_table.paginator page=prefix_table.page %}
-            {% endif %}
-{% endblock content_full_width_page %}
+{% endblock extra_breadcrumbs %}

nautobot/ipam/tests/test_jobs.py

@@ -0,0 +1,454 @@
+from django.contrib.contenttypes.models import ContentType
+import netaddr
+
+from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.models import JobLogEntry, Status
+from nautobot.ipam.models import get_default_namespace, IPAddress, Namespace, Prefix
+from nautobot.users.models import ObjectPermission
+
+
+class FixIPAMParentsTestCase(TransactionTestCase):
+    """Tests for the FixIPAMParents system Job."""
+
+    databases = ("default", "job_logs")
+
+    def setUp(self):
+        super().setUp()
+
+        self.status, _ = Status.objects.get_or_create(name="Active")
+        self.status.content_types.add(ContentType.objects.get_for_model(IPAddress))
+        self.status.content_types.add(ContentType.objects.get_for_model(Prefix))
+
+        # Create the "intended" hierarchy of records to test
+        self.root = Prefix.objects.create(prefix="10.0.0.0/8", status=self.status)
+        self.branch1 = Prefix.objects.create(prefix="10.1.0.0/16", status=self.status)
+        self.leaf11 = Prefix.objects.create(prefix="10.1.1.0/24", status=self.status)
+        self.leaf12 = Prefix.objects.create(prefix="10.1.2.0/24", status=self.status)
+        self.leaf13 = Prefix.objects.create(prefix="10.1.3.0/24", status=self.status)
+        self.leaf14 = Prefix.objects.create(prefix="10.1.4.0/24", status=self.status)
+        self.branch2 = Prefix.objects.create(prefix="10.2.0.0/16", status=self.status)
+        self.leaf21 = Prefix.objects.create(prefix="10.2.1.0/24", status=self.status)
+
+        self.ip111 = IPAddress.objects.create(address="10.1.1.1/24", status=self.status)
+        self.ip112 = IPAddress.objects.create(address="10.1.1.2/24", status=self.status)
+        self.ip121 = IPAddress.objects.create(address="10.1.2.1/24", status=self.status)
+        self.ip122 = IPAddress.objects.create(address="10.1.2.2/24", status=self.status)
+        self.ip201 = IPAddress.objects.create(address="10.2.0.1/16", status=self.status)
+        self.ip211 = IPAddress.objects.create(address="10.2.1.1/24", status=self.status)
+        self.ip212 = IPAddress.objects.create(address="10.2.1.2/24", status=self.status)
+        self.ip213 = IPAddress.objects.create(address="10.2.1.3/24", status=self.status)
+        self.ip214 = IPAddress.objects.create(address="10.2.1.4/24", status=self.status)
+
+        self.other_namespace = Namespace.objects.create(name="Some other namespace")
+        self.other_branch3 = Prefix.objects.create(
+            prefix="10.3.0.0/16", status=self.status, namespace=self.other_namespace
+        )
+        self.other_leaf31 = Prefix.objects.create(
+            prefix="10.3.1.0/24", status=self.status, namespace=self.other_namespace
+        )
+        self.other_ip = IPAddress.objects.create(address="10.3.1.1/24", status=self.status, parent=self.other_leaf31)
+
+        self.all_pfxs = {
+            self.root,
+            self.branch1,
+            self.leaf11,
+            self.leaf12,
+            self.leaf13,
+            self.leaf14,
+            self.branch2,
+            self.leaf21,
+            self.other_branch3,
+            self.other_leaf31,
+        }
+        self.all_ips = {
+            self.ip111,
+            self.ip112,
+            self.ip121,
+            self.ip122,
+            self.ip201,
+            self.ip211,
+            self.ip212,
+            self.ip213,
+            self.ip214,
+            self.other_ip,
+        }
+
+    def assert_ip_parents(self, expected_parentage: dict):
+        self.assertEqual(set(expected_parentage.keys()), self.all_ips)
+        for ip, expected_parent in expected_parentage.items():
+            ip.refresh_from_db()
+            self.assertEqual(
+                ip.parent,
+                expected_parent,
+                f"parent of IP {ip.host} is expected to be {expected_parent.prefix if expected_parent else None} but "
+                f"is instead {ip.parent.prefix if ip.parent else None}",
+            )
+
+    def assert_prefix_parents(self, expected_parentage: dict):
+        self.assertEqual(set(expected_parentage.keys()), self.all_pfxs)
+        for pfx, expected_parent in expected_parentage.items():
+            pfx.refresh_from_db()
+            self.assertEqual(
+                pfx.parent,
+                expected_parent,
+                f"parent of prefix {pfx.prefix} should be {expected_parent.prefix if expected_parent else None} but "
+                f"is {pfx.parent.prefix if pfx.parent else None}",
+            )
+
+    def test_initial_parentage_correct(self):
+        self.assert_prefix_parents(
+            {
+                self.root: None,
+                self.branch1: self.root,
+                self.leaf11: self.branch1,
+                self.leaf12: self.branch1,
+                self.leaf13: self.branch1,
+                self.leaf14: self.branch1,
+                self.branch2: self.root,
+                self.leaf21: self.branch2,
+                self.other_branch3: None,
+                self.other_leaf31: self.other_branch3,
+            }
+        )
+
+        self.assert_ip_parents(
+            {
+                self.ip111: self.leaf11,
+                self.ip112: self.leaf11,
+                self.ip121: self.leaf12,
+                self.ip122: self.leaf12,
+                self.ip201: self.branch2,
+                self.ip211: self.leaf21,
+                self.ip212: self.leaf21,
+                self.ip213: self.leaf21,
+                self.ip214: self.leaf21,
+                self.other_ip: self.other_leaf31,
+            }
+        )
+
+    def corrupt_the_hierarchy(self):
+        """
+        Make 'bad' data for testing purposes.
+
+        Uses QuerySet.update() because that bypasses clean/save validation.
+        """
+        # Change leaf11 to a different subnet, but don't update the parent of ip111 and ip112 accordingly
+        Prefix.objects.filter(id=self.leaf11.id).update(network="10.2.0.0", broadcast="10.2.0.255")
+        self.leaf11.refresh_from_db()
+        # Change leaf13 to have an incorrect null parent
+        Prefix.objects.filter(id=self.leaf13.id).update(parent=None)
+        self.leaf13.refresh_from_db()
+        # Change ip213 to have an incorrect/invalid null parent
+        IPAddress.objects.filter(id=self.ip213.id).update(parent=None)
+        self.ip213.refresh_from_db()
+        # Change other_branch3 to have cross-namespace parentage
+        Prefix.objects.filter(id=self.other_branch3.id).update(parent=self.root)
+        self.other_branch3.refresh_from_db()
+        # Change leaf14 to have a valid but not most-specific parent
+        Prefix.objects.filter(id=self.leaf14.id).update(parent=self.root)
+        self.leaf14.refresh_from_db()
+        # Change ip214 and other_ip to have a valid but not most-specific parent
+        IPAddress.objects.filter(id=self.ip214.id).update(parent=self.root)
+        self.ip214.refresh_from_db()
+        IPAddress.objects.filter(id=self.other_ip.id).update(parent=self.other_branch3)
+        self.other_ip.refresh_from_db()
+
+        self.corrupted_ip_parents = {
+            self.ip111: self.leaf11,  # wrong
+            self.ip112: self.leaf11,  # wrong
+            self.ip121: self.leaf12,
+            self.ip122: self.leaf12,
+            self.ip201: self.branch2,  # wrong
+            self.ip211: self.leaf21,
+            self.ip212: self.leaf21,
+            self.ip213: None,  # wrong
+            self.ip214: self.root,  # wrong
+            self.other_ip: self.other_branch3,  # wrong
+        }
+
+        self.corrupted_pfx_parents = {
+            self.root: None,
+            self.branch1: self.root,
+            self.leaf11: self.branch1,  # wrong
+            self.leaf12: self.branch1,
+            self.leaf13: None,  # wrong
+            self.leaf14: self.root,  # wrong
+            self.branch2: self.root,
+            self.leaf21: self.branch2,
+            self.other_branch3: self.root,  # wrong
+            self.other_leaf31: self.other_branch3,
+        }
+
+        self.repaired_ip_parents = {
+            self.ip111: self.branch1,  # corrected after change of leaf11
+            self.ip112: self.branch1,  # corrected after change of leaf11
+            self.ip121: self.leaf12,
+            self.ip122: self.leaf12,
+            self.ip201: self.leaf11,  # corrected after change of leaf11
+            self.ip211: self.leaf21,
+            self.ip212: self.leaf21,
+            self.ip213: self.leaf21,  # corrected from null
+            self.ip214: self.leaf21,  # corrected from root
+            self.other_ip: self.other_leaf31,  # corrected from other_branch3
+        }
+
+        self.repaired_pfx_parents = {
+            self.root: None,
+            self.branch1: self.root,
+            self.leaf11: self.branch2,  # corrected after network change
+            self.leaf12: self.branch1,
+            self.leaf13: self.branch1,  # corrected from null
+            self.leaf14: self.branch1,  # corrected from root
+            self.branch2: self.root,
+            self.leaf21: self.branch2,
+            self.other_branch3: None,  # corrected from cross-namespace linkage
+            self.other_leaf31: self.other_branch3,
+        }
+
+    def test_fixup_all(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            cleanup_types=("ipam.IPAddress", "ipam.Prefix"),
+            restrict_to_namespace=None,
+            restrict_to_network=None,
+            dryrun=False,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_prefix_parents(self.repaired_pfx_parents)
+        self.assert_ip_parents(self.repaired_ip_parents)
+
+    def test_dryrun(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            cleanup_types=("ipam.IPAddress", "ipam.Prefix"),
+            restrict_to_namespace=None,
+            restrict_to_network=None,
+            dryrun=True,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_prefix_parents(self.corrupted_pfx_parents)  # no change
+        self.assert_ip_parents(self.corrupted_ip_parents)  # no change
+
+    def test_fixup_without_permissions(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        for cleanup_type, modelname in (
+            ("ipam.IPAddress", "IP Address"),
+            ("ipam.Prefix", "Prefix"),
+        ):
+            job_result = create_job_result_and_run_job(
+                "nautobot.ipam.jobs.cleanup",
+                "FixIPAMParents",
+                username=self.user.username,  # otherwise this API defaults to using a superuser account
+                cleanup_types=[cleanup_type],
+                restrict_to_namespace=None,
+                restrict_to_network=None,
+                dryrun=False,
+            )
+            self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+            log_failure = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_FAILURE)
+            self.assertEqual(
+                log_failure.message,
+                f'User "{self.user.username}" does not have permission to update {modelname} records',
+            )
+
+            self.assert_prefix_parents(self.corrupted_pfx_parents)  # no change
+            self.assert_ip_parents(self.corrupted_ip_parents)  # no change
+
+    def test_fixup_with_constrained_permissions(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        prefix_perm = ObjectPermission.objects.create(
+            name="Prefix permission",
+            actions=["view", "change"],
+            constraints={"network__net_contained_or_equal": str(self.branch2.prefix)},
+        )
+        prefix_perm.users.add(self.user)
+        prefix_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
+
+        ip_perm = ObjectPermission.objects.create(
+            name="IPAddress permission",
+            actions=["view", "change"],
+            constraints={"host__net_host_contained": str(self.branch2.prefix)},
+        )
+        ip_perm.users.add(self.user)
+        ip_perm.object_types.add(ContentType.objects.get_for_model(IPAddress))
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            username=self.user.username,
+            cleanup_types=("ipam.IPAddress", "ipam.Prefix"),
+            restrict_to_namespace=None,
+            restrict_to_network=None,
+            dryrun=False,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_prefix_parents(
+            {
+                **{
+                    pfx: parent
+                    for pfx, parent in self.repaired_pfx_parents.items()
+                    if pfx.prefix >= self.branch2.prefix
+                    and netaddr.IPAddress(pfx.broadcast) <= netaddr.IPAddress(self.branch2.broadcast)
+                },
+                **{
+                    pfx: parent
+                    for pfx, parent in self.corrupted_pfx_parents.items()
+                    if pfx.prefix < self.branch2.prefix
+                    or netaddr.IPAddress(pfx.broadcast) > netaddr.IPAddress(self.branch2.broadcast)
+                },
+            }
+        )
+
+        self.assert_ip_parents(
+            {
+                **{
+                    ip: parent
+                    for ip, parent in self.repaired_ip_parents.items()
+                    if ip.address >= self.branch2.prefix and ip.address <= netaddr.IPAddress(self.branch2.broadcast)
+                },
+                **{
+                    ip: parent
+                    for ip, parent in self.corrupted_ip_parents.items()
+                    if ip.address < self.branch2.prefix or ip.address > netaddr.IPAddress(self.branch2.broadcast)
+                },
+            }
+        )
+
+    def test_cleanup_ips_only(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        ip_perm = ObjectPermission.objects.create(
+            name="IPAddress permission",
+            actions=["view", "change"],
+        )
+        ip_perm.users.add(self.user)
+        ip_perm.object_types.add(ContentType.objects.get_for_model(IPAddress))
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            username=self.user.username,
+            cleanup_types=("ipam.IPAddress"),
+            restrict_to_namespace=None,
+            restrict_to_network=None,
+            dryrun=False,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_ip_parents(self.repaired_ip_parents)  # repaired
+        self.assert_prefix_parents(self.corrupted_pfx_parents)  # no change
+
+    def test_cleanup_prefixes_only(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        prefix_perm = ObjectPermission.objects.create(
+            name="Prefix permission",
+            actions=["view", "change"],
+        )
+        prefix_perm.users.add(self.user)
+        prefix_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            username=self.user.username,
+            cleanup_types=("ipam.Prefix"),
+            restrict_to_namespace=None,
+            restrict_to_network=None,
+            dryrun=False,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_ip_parents(self.corrupted_ip_parents)  # no change
+        self.assert_prefix_parents(self.repaired_pfx_parents)  # repaired
+
+    def test_cleanup_restrict_to_namespace(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        default_ns = get_default_namespace()
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            cleanup_types=("ipam.IPAddress", "ipam.Prefix"),
+            restrict_to_namespace=default_ns.pk,
+            restrict_to_network=None,
+            dryrun=False,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_prefix_parents(
+            {
+                **{pfx: parent for pfx, parent in self.repaired_pfx_parents.items() if pfx.namespace == default_ns},
+                **{pfx: parent for pfx, parent in self.corrupted_pfx_parents.items() if pfx.namespace != default_ns},
+            }
+        )
+        self.assert_ip_parents(
+            {
+                **{
+                    ip: parent
+                    for ip, parent in self.repaired_ip_parents.items()
+                    if ip.parent and ip.parent.namespace == default_ns
+                },
+                **{
+                    ip: parent
+                    for ip, parent in self.corrupted_ip_parents.items()
+                    if not ip.parent or ip.parent.namespace != default_ns
+                },
+            }
+        )
+
+    def test_cleanup_restrict_to_network(self):
+        self.corrupt_the_hierarchy()  # 🤘
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.ipam.jobs.cleanup",
+            "FixIPAMParents",
+            cleanup_types=("ipam.IPAddress", "ipam.Prefix"),
+            restrict_to_namespace=None,
+            restrict_to_network=str(self.branch1.prefix),
+            dryrun=False,
+        )
+        self.assertJobResultStatus(job_result)
+
+        self.assert_prefix_parents(
+            {
+                **{
+                    pfx: parent
+                    for pfx, parent in self.repaired_pfx_parents.items()
+                    if pfx.prefix >= self.branch1.prefix
+                    and netaddr.IPAddress(pfx.broadcast) <= netaddr.IPAddress(self.branch1.broadcast)
+                },
+                **{
+                    pfx: parent
+                    for pfx, parent in self.corrupted_pfx_parents.items()
+                    if pfx.prefix < self.branch1.prefix
+                    or netaddr.IPAddress(pfx.broadcast) > netaddr.IPAddress(self.branch1.broadcast)
+                },
+            }
+        )
+        self.assert_ip_parents(
+            {
+                **{
+                    ip: parent
+                    for ip, parent in self.repaired_ip_parents.items()
+                    if ip.address >= self.branch1.prefix and ip.address <= netaddr.IPAddress(self.branch1.broadcast)
+                },
+                **{
+                    ip: parent
+                    for ip, parent in self.corrupted_ip_parents.items()
+                    if ip.address < self.branch1.prefix or ip.address > netaddr.IPAddress(self.branch1.broadcast)
+                },
+            }
+        )