nautobot 2.3.7__py3-none-any.whl → 2.3.8__py3-none-any.whl

nautobot/core/templates/inc/paginator.html

@@ -29,6 +29,9 @@
             {% endif %}
         {% endfor %}
         <select name="per_page" id="per_page" class="form-control">
+            {% if page.paginator.per_page not in "PER_PAGE_DEFAULTS"|settings_or_config %}
+                <option value="{{ page.paginator.per_page }}" selected="selected">{{ page.paginator.per_page }}</option>
+            {% endif %}
             {% for n in "PER_PAGE_DEFAULTS"|settings_or_config %}
                 <option value="{{ n }}"{% if page.paginator.per_page == n %} selected="selected"{% endif %}>{{ n }}</option>
             {% endfor %}

nautobot/core/templates/utilities/obj_table.html

@@ -45,7 +45,7 @@
 {% else %}
     {% include table_template|default:'responsive_table.html' %}
 {% endif %}
-{% if not disable_pagination %}
+{% if table.paginator.num_pages > 1 and not disable_pagination %}
     {% include 'inc/paginator.html' with paginator=table.paginator page=table.page %}
 {% endif %}
 <div class="clearfix"></div>

nautobot/dcim/api/serializers.py

@@ -798,14 +798,19 @@ class InterfaceSerializer(
     def validate(self, data):
         # Validate many-to-many VLAN assignments
         device = self.instance.device if self.instance else data.get("device")
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to assign a VLAN belongs to
-        # the parent Location or the child location of `device.location`?
+        location = None
+        if device:
+            location = device.location
+        if location:
+            location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        else:
+            location_ids = []
         for vlan in data.get("tagged_vlans", []):
-            if vlan.locations.exists() and not vlan.locations.filter(pk=device.location.pk).exists():
+            if vlan.locations.exists() and not vlan.locations.filter(pk__in=location_ids).exists():
                 raise serializers.ValidationError(
                     {
-                        "tagged_vlans": f"VLAN {vlan} must have a common location as the interface's parent device, or "
-                        f"it must be global."
+                        "tagged_vlans": f"VLAN {vlan} must have the same location as the interface's parent device, "
+                        f"or is in one of the parents of the interface's parent device's location, or it must be global."
                     }
                 )
 

nautobot/dcim/forms.py

@@ -213,23 +213,27 @@ class InterfaceCommonForm(forms.Form):
         elif mode == InterfaceModeChoices.MODE_TAGGED_ALL:
             self.cleaned_data["tagged_vlans"] = []
 
-        # Validate tagged VLANs; must be a global VLAN or in the same location
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
-        # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
+        # Validate tagged VLANs; must be a global VLAN or in the same location as the
+        # parent device/VM or any of that location's parent locations
         elif mode == InterfaceModeChoices.MODE_TAGGED:
-            valid_location = self.cleaned_data[parent_field].location
+            location = self.cleaned_data[parent_field].location
+            if location:
+                location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+            else:
+                location_ids = []
             invalid_vlans = [
                 str(v)
                 for v in tagged_vlans
                 if v.locations.without_tree_fields().exists()
-                and not VLANLocationAssignment.objects.filter(location=valid_location, vlan=v).exists()
+                and not VLANLocationAssignment.objects.filter(location__in=location_ids, vlan=v).exists()
             ]
 
             if invalid_vlans:
                 raise forms.ValidationError(
                     {
-                        "tagged_vlans": f"The tagged VLANs ({', '.join(invalid_vlans)}) must belong to the same location as "
-                        f"the interface's parent device/VM, or they must be global"
+                        "tagged_vlans": f"The tagged VLANs ({', '.join(invalid_vlans)}) must have the same location as the "
+                        "interface's parent device, or is in one of the parents of the interface's parent device's location, "
+                        "or it must be global."
                     }
                 )
 

nautobot/dcim/models/device_components.py

@@ -727,19 +727,22 @@ class Interface(ModularComponentModel, CableTermination, PathEndpoint, BaseInter
                     )
 
         # Validate untagged VLAN
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to assign a VLAN belongs to
-        # the parent Locations or the child locations of `device.location`?
+        location = self.parent.location if self.parent is not None else None
+        if location:
+            location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        else:
+            location_ids = []
         if (
             self.untagged_vlan
             and self.untagged_vlan.locations.exists()
             and self.parent
-            and not self.untagged_vlan.locations.filter(id=self.parent.location_id).exists()
+            and not self.untagged_vlan.locations.filter(pk__in=location_ids).exists()
         ):
             raise ValidationError(
                 {
                     "untagged_vlan": (
                         f"The untagged VLAN ({self.untagged_vlan}) must have a common location as the interface's parent "
-                        f"device, or it must be global."
+                        f"device, or is in one of the parents of the interface's parent device's location, or it must be global."
                     )
                 }
             )

nautobot/dcim/tests/test_api.py

@@ -2198,6 +2198,34 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             self.client.post(url, self.untagged_vlan_data, format="json", **self.header), status.HTTP_201_CREATED
         )
 
+    def test_tagged_vlan_must_be_in_the_location_or_parent_locations_of_the_parent_device(self):
+        self.add_permissions("dcim.add_interface")
+
+        interface_status = Status.objects.get_for_model(Interface).first()
+        location = self.devices[0].location
+        location_ids = [ancestor.id for ancestor in location.ancestors()]
+        non_valid_locations = Location.objects.exclude(pk__in=location_ids)
+        faulty_vlan = self.vlans[0]
+        faulty_vlan.locations.set([non_valid_locations.first().pk])
+        faulty_vlan.validated_save()
+        faulty_data = {
+            "device": self.devices[0].pk,
+            "name": "Test Vlans Interface",
+            "type": "virtual",
+            "status": interface_status.pk,
+            "mode": InterfaceModeChoices.MODE_TAGGED,
+            "parent_interface": self.interfaces[1].pk,
+            "tagged_vlans": [faulty_vlan.pk, self.vlans[1].pk],
+            "untagged_vlan": self.vlans[2].pk,
+        }
+        response = self.client.post(self._get_list_url(), data=faulty_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            b"must have the same location as the interface's parent device, or is in one of the parents of the interface's parent device's location, or "
+            b"it must be global.",
+            response.content,
+        )
+
     def test_interface_belonging_to_common_device_or_vc_allowed(self):
         """Test parent, bridge, and LAG interfaces belonging to common device or VC is valid"""
         self.add_permissions("dcim.add_interface")

nautobot/dcim/tests/test_forms.py

@@ -341,9 +341,25 @@ class InterfaceTestCase(TestCase):
             "tagged_vlans": [cls.vlan.pk],
         }
 
+    def test_interface_form_clean_vlan_location_success(self):
+        """Assert that form validation succeeds when matching locations/parent locations are associated to tagged VLAN"""
+        location = self.device.location
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        self.vlan.locations.set([location.id])
+        self.data["tagged_vlans"] = [self.vlan]
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+        self.vlan.locations.set(location_ids[:2])
+        self.data["tagged_vlans"] = [self.vlan]
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
     def test_interface_form_clean_vlan_location_fail(self):
         """Assert that form validation fails when no matching locations are associated to tagged VLAN"""
-        self.vlan.locations.set(list(Location.objects.exclude(pk=self.device.location.pk))[:2])
+        location = self.device.location
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        self.vlan.locations.set(list(Location.objects.exclude(pk__in=location_ids))[:2])
+        self.data["tagged_vlans"] = [self.vlan]
         form = InterfaceForm(data=self.data, instance=self.interface)
         self.assertFalse(form.is_valid())
 

nautobot/dcim/tests/test_models.py

@@ -2376,19 +2376,57 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         )
 
     def test_error_raised_when_adding_tagged_vlan_with_different_location_from_interface_parent_location(self):
+        intf_status = Status.objects.get_for_model(Interface).first()
+        intf_role = Role.objects.get_for_model(Interface).first()
+        location_type = LocationType.objects.get(name="Campus")
+        child_location = Location.objects.filter(parent__isnull=False, location_type=location_type).first()
+        self.device.location = child_location
+        self.device.validated_save()
+        # Same location as the device
+        interface = Interface.objects.create(
+            name="Test Interface 2",
+            mode=InterfaceModeChoices.MODE_TAGGED,
+            device=self.device,
+            status=intf_status,
+            role=intf_role,
+        )
+        self.other_location_vlan.locations.set([self.device.location.pk])
+        interface.tagged_vlans.set([self.other_location_vlan.pk])
+
+        # One of the parent locations of the device's location
+        interface = Interface.objects.create(
+            name="Test Interface 3",
+            mode=InterfaceModeChoices.MODE_TAGGED,
+            device=self.device,
+            status=intf_status,
+            role=intf_role,
+        )
+        self.other_location_vlan.locations.set([self.device.location.ancestors().first().pk])
+        interface.tagged_vlans.set([self.other_location_vlan.pk])
+
         with self.assertRaises(ValidationError) as err:
             interface = Interface.objects.create(
-                name="Test Interface",
+                name="Test Interface 1",
                 mode=InterfaceModeChoices.MODE_TAGGED,
                 device=self.device,
-                status=Status.objects.get_for_model(Interface).first(),
-                role=Role.objects.get_for_model(Interface).first(),
+                status=intf_status,
+                role=intf_role,
+            )
+            location_3 = Location.objects.create(
+                name="Invalid VLAN Location",
+                location_type=LocationType.objects.get(name="Campus"),
+                status=Status.objects.get_for_model(Location).first(),
             )
+            # clear the valid locations
+            self.other_location_vlan.locations.set([])
+            # assign the invalid location
+            self.other_location_vlan.location = location_3
+            self.other_location_vlan.validated_save()
             interface.tagged_vlans.add(self.other_location_vlan)
         self.assertEqual(
             err.exception.message_dict["tagged_vlans"][0],
             f"Tagged VLAN with names {[self.other_location_vlan.name]} must all belong to the "
-            f"same location as the interface's parent device, or it must be global.",
+            f"same location as the interface's parent device, one of the parent locations of the interface's parent device's location, or it must be global.",
         )
 
     def test_add_ip_addresses(self):

nautobot/dcim/utils.py

@@ -139,12 +139,14 @@ def validate_interface_tagged_vlans(instance, model, pk_set):
         )
 
     # Filter the model objects based on the primary keys passed in kwargs and exclude the ones that have
-    # a location that is not the parent's location or None
-    # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
-    # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
-    device_location = getattr(instance.parent, "location", None)
+    # a location that is not the parent's location, or parent's location's ancestors, or None
+    location = getattr(instance.parent, "location", None)
+    if location:
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+    else:
+        location_ids = []
     tagged_vlans = (
-        model.objects.filter(pk__in=pk_set).exclude(locations__isnull=True).exclude(locations__in=[device_location])
+        model.objects.filter(pk__in=pk_set).exclude(locations__isnull=True).exclude(locations__in=location_ids)
     )
 
     if tagged_vlans.count():
@@ -152,7 +154,8 @@ def validate_interface_tagged_vlans(instance, model, pk_set):
             {
                 "tagged_vlans": (
                     f"Tagged VLAN with names {list(tagged_vlans.values_list('name', flat=True))} must all belong to the "
-                    f"same location as the interface's parent device, or it must be global."
+                    "same location as the interface's parent device, "
+                    "one of the parent locations of the interface's parent device's location, or it must be global."
                 )
             }
         )

nautobot/extras/plugins/views.py

@@ -30,6 +30,21 @@ class InstalledAppsView(GenericView):
         data = []
         for app in apps.get_app_configs():
             if app.name in settings.PLUGINS:
+                try:
+                    reverse(app.home_view_name)
+                    home_url = app.home_view_name
+                except NoReverseMatch:
+                    home_url = None
+                try:
+                    reverse(app.config_view_name)
+                    config_url = app.config_view_name
+                except NoReverseMatch:
+                    config_url = None
+                try:
+                    reverse(app.docs_view_name)
+                    docs_url = app.docs_view_name
+                except NoReverseMatch:
+                    docs_url = None
                 data.append(
                     {
                         "name": app.verbose_name,
@@ -40,9 +55,9 @@ class InstalledAppsView(GenericView):
                         "description": app.description,
                         "version": app.version,
                         "actions": {
-                            "home": app.home_view_name,
-                            "configure": app.config_view_name,
-                            "docs": app.docs_view_name,
+                            "home": home_url,
+                            "configure": config_url,
+                            "docs": docs_url,
                         },
                     }
                 )

nautobot/ipam/filters.py

@@ -586,13 +586,13 @@ class VLANFilterSet(
         fields = ["id", "name", "tags", "vid"]
 
     def get_for_device(self, queryset, name, value):
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we consider to include
-        # VLANs that belong to the parent/child locations of the `device.location`?
         """Return all VLANs available to the specified Device(value)."""
         devices = Device.objects.select_related("location").filter(**{f"{name}__in": value})
         if not devices.exists():
             return queryset.none()
         location_ids = list(devices.values_list("location__id", flat=True))
+        for location in Location.objects.filter(pk__in=location_ids):
+            location_ids.extend([ancestor.id for ancestor in location.ancestors()])
         return queryset.filter(Q(locations__isnull=True) | Q(locations__in=location_ids))
 
 

nautobot/ipam/models.py

@@ -890,12 +890,39 @@ class Prefix(PrimaryModel):
         )
         return available_ips
 
+    def get_child_ips(self):
+        """
+        Return IP addresses with this prefix as their *direct* parent.
+
+        Does *not* include IPs that descend from a descendant prefix; if those are desired, use get_all_ips() instead.
+
+        ```
+        Prefix 10.0.0.0/16
+            IPAddress 10.0.0.1/24
+            Prefix 10.0.1.0/24
+                IPAddress 10.0.1.1/24
+        ```
+
+        In the above example, `<Prefix 10.0.0.0/16>.get_child_ips()` will *only* return 10.0.0.1/24,
+        while `<Prefix 10.0.0.0/16>.get_all_ips()` will return *both* 10.0.0.1.24 and 10.0.1.1/24.
+        """
+        return self.ip_addresses.all()
+
     def get_all_ips(self):
         """
         Return all IP addresses contained within this prefix, including child prefixes' IP addresses.
 
-        Returns:
-            IPAddress QuerySet
+        This is distinct from the behavior of `get_child_ips()` and in *most* cases is probably preferred.
+
+        ```
+        Prefix 10.0.0.0/16
+            IPAddress 10.0.0.1/24
+            Prefix 10.0.1.0/24
+                IPAddress 10.0.1.1/24
+        ```
+
+        In the above example, `<Prefix 10.0.0.0/16>.get_child_ips()` will *only* return 10.0.0.1/24,
+        while `<Prefix 10.0.0.0/16>.get_all_ips()` will return *both* 10.0.0.1.24 and 10.0.1.1/24.
         """
         return IPAddress.objects.filter(
             parent__namespace=self.namespace, host__gte=self.network, host__lte=self.broadcast

nautobot/ipam/templates/ipam/ipaddress.html

@@ -150,9 +150,9 @@
                 </tr>
             </table>
         </div>
-        {% include 'panel_table.html' with table=parent_prefixes_table heading='Parent Prefixes' %}
 {% endblock content_right_page %}
 
 {% block content_full_width_page %}
-        {% include 'utilities/obj_table.html' with table=related_ips_table table_template='panel_table.html' heading='Related IP Addresses' panel_class='default' %}
+    {% include 'utilities/obj_table.html' with table=parent_prefixes_table table_template='panel_table.html' heading='Parent Prefixes' %}
+    {% include 'utilities/obj_table.html' with table=related_ips_table table_template='panel_table.html' heading='Related IP Addresses' %}
 {% endblock content_full_width_page %}

nautobot/ipam/templates/ipam/ipaddress_interfaces.html

@@ -21,6 +21,9 @@
             {% render_table interface_table 'inc/table.html' %}
         </div>
     </form>
+    {% if interface_table.paginator.num_pages > 1 %}
+        {% include "inc/paginator.html" with paginator=interface_table.paginator page=interface_table.page %}
+    {% endif %}
     {% table_config_form interface_table %}
 {% endblock content %}
 

nautobot/ipam/templates/ipam/ipaddress_vm_interfaces.html

@@ -21,6 +21,9 @@
             {% render_table vm_interface_table 'inc/table.html' %}
         </div>
     </form>
+    {% if vm_interface_table.paginator.num_pages > 1 %}
+        {% include "inc/paginator.html" with paginator=vm_interface_table.paginator page=vm_interface_table.page %}
+    {% endif %}
     {% table_config_form vm_interface_table %}
 {% endblock content %}
 

nautobot/ipam/templates/ipam/prefix.html

@@ -117,7 +117,7 @@
 {% endblock content_left_page %}
 
 {% block content_right_page %}
-            {% include 'panel_table.html' with table=parent_prefix_table heading='Parent Prefixes' panel_class='default' %}
-            {% include "utilities/obj_table.html" with table=vrf_table table_template="panel_table.html" heading="Assigned VRFs" disable_pagination=False %}
-            {% include "utilities/obj_table.html" with table=cloud_network_table table_template="panel_table.html" heading="Assigned Cloud Networks" disable_pagination=False %}
+    {% include "utilities/obj_table.html" with table=parent_prefix_table table_template="panel_table.html" heading="Parent Prefixes" %}
+    {% include "utilities/obj_table.html" with table=vrf_table table_template="panel_table.html" heading="Assigned VRFs" %}
+    {% include "utilities/obj_table.html" with table=cloud_network_table table_template="panel_table.html" heading="Assigned Cloud Networks" %}
 {% endblock content_right_page %}

nautobot/ipam/templates/ipam/routetarget.html

@@ -24,6 +24,6 @@
 {% endblock content_left_page %}
 
 {% block content_right_page %}
-        {% include 'panel_table.html' with table=importing_vrfs_table heading="Importing VRFs" %}
-        {% include 'panel_table.html' with table=exporting_vrfs_table heading="Exporting VRFs" %}
+    {% include 'utilities/obj_table.html' with table=importing_vrfs_table table_template='panel_table.html' heading="Importing VRFs" %}
+    {% include 'utilities/obj_table.html' with table=exporting_vrfs_table table_template='panel_table.html' heading="Exporting VRFs" %}
 {% endblock content_right_page %}

nautobot/ipam/templates/ipam/vlan.html

@@ -86,4 +86,7 @@
                     </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 %}

nautobot/ipam/templates/ipam/vrf.html

@@ -38,8 +38,11 @@
 {% endblock content_left_page %}
 
 {% block content_right_page %}
-        {% include 'panel_table.html' with table=import_targets_table heading="Import Route Targets" %}
-        {% include 'panel_table.html' with table=export_targets_table heading="Export Route Targets" %}
-	{% include 'panel_table.html' with table=prefix_table heading="Assigned Prefixes" %}
-	{% include 'panel_table.html' with table=device_table heading="Assigned Devices" %}
+    {% include 'utilities/obj_table.html' with table=import_targets_table table_template='panel_table.html' heading="Import Route Targets" %}
+    {% include 'utilities/obj_table.html' with table=export_targets_table table_template='panel_table.html' heading="Export Route Targets" %}
 {% endblock content_right_page %}
+
+{% block content_full_width_page %}
+	{% include 'utilities/obj_table.html' with table=prefix_table table_template='panel_table.html' heading="Assigned Prefixes" %}
+	{% include 'utilities/obj_table.html' with table=device_table table_template='panel_table.html' heading="Assigned Devices" %}
+{% endblock content_full_width_page %}

nautobot/ipam/tests/test_models.py

@@ -555,8 +555,9 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
             IPAddress.objects.create(address="10.0.2.1/24", status=self.status, namespace=self.namespace),
             IPAddress.objects.create(address="10.0.3.1/24", status=self.status, namespace=self.namespace),
         )
+        self.assertQuerysetEqualAndNotEmpty(parent_prefix.ip_addresses.all(), parent_prefix.get_child_ips())
+        self.assertQuerysetEqualAndNotEmpty(parent_prefix.ip_addresses.all(), parent_prefix.get_all_ips())
         child_ip_pks = {p.pk for p in parent_prefix.ip_addresses.all()}
-
         # Global container should return all children
         self.assertSetEqual(child_ip_pks, {ips[0].pk, ips[1].pk, ips[2].pk, ips[3].pk})
 
@@ -566,6 +567,8 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
             IPAddress.objects.create(address="20.0.4.0/31", status=self.status, namespace=self.namespace),
             IPAddress.objects.create(address="20.0.4.1/31", status=self.status, namespace=self.namespace),
         )
+        self.assertQuerysetEqualAndNotEmpty(parent_prefix_31.ip_addresses.all(), parent_prefix_31.get_child_ips())
+        self.assertQuerysetEqualAndNotEmpty(parent_prefix_31.ip_addresses.all(), parent_prefix_31.get_all_ips())
         child_ip_pks = {p.pk for p in parent_prefix_31.ip_addresses.all()}
         self.assertSetEqual(child_ip_pks, {ips_31[0].pk, ips_31[1].pk})
 
@@ -660,10 +663,22 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         slash25 = Prefix.objects.create(prefix="10.0.0.128/25", status=self.status, namespace=self.namespace)
         self.assertEqual(prefix.get_utilization(), (192, 256))
 
-        # Create 32 IPAddresses within the Prefix
+        # Create 32 IPAddresses within the /26 Prefix
         for i in range(1, 33):
             IPAddress.objects.create(address=f"10.0.0.{i}/32", status=self.status, namespace=self.namespace)
 
+        # Assert differing behavior of get_all_ips() versus get_child_ips() for the /24 and /26 prefixes
+        self.assertQuerysetEqual(prefix.get_child_ips(), IPAddress.objects.none())
+        self.assertQuerysetEqualAndNotEmpty(
+            prefix.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash26.get_child_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash26.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+
         # The parent prefix utilization does not change because the ip addresses are parented to the child /26 prefix.
         self.assertEqual(prefix.get_utilization(), (192, 256))
 
@@ -674,6 +689,17 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         IPAddress.objects.create(address="10.0.0.0/32", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="10.0.0.63/32", status=self.status, namespace=self.namespace)
 
+        self.assertQuerysetEqual(prefix.get_child_ips(), IPAddress.objects.none())
+        self.assertQuerysetEqualAndNotEmpty(
+            prefix.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash26.get_child_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash26.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+
         # The /26 denominator will change to 64
         self.assertEqual(slash26.get_utilization(), (34, 64))
 
@@ -688,30 +714,60 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         pool.save()
         self.assertEqual(slash25.get_utilization(), (4, 126))
 
+        # Further distinguishing between get_child_ips() and get_all_ips():
+        IPAddress.objects.create(address="10.0.0.64/32", status=self.status, namespace=self.namespace)
+        self.assertQuerysetEqualAndNotEmpty(
+            prefix.get_child_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.64/26")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            prefix.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+
+        slash27 = Prefix.objects.create(prefix="10.0.0.0/27", status=self.status, namespace=self.namespace)
+        self.assertEqual(slash27.get_utilization(), (32, 32))
+        self.assertQuerysetEqualAndNotEmpty(
+            prefix.get_child_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.64/26")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            prefix.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/24")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash26.get_child_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.32/27")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash26.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/26")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash27.get_child_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/27")
+        )
+        self.assertQuerysetEqualAndNotEmpty(
+            slash27.get_all_ips(), IPAddress.objects.filter(host__net_host_contained="10.0.0.0/27")
+        )
+
         # IPv4 Non-container Prefix /31, network and broadcast addresses count toward utilization
-        prefix = Prefix.objects.create(prefix="10.0.1.0/31", status=self.status, namespace=self.namespace)
+        slash31 = Prefix.objects.create(prefix="10.0.1.0/31", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="10.0.1.0/32", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="10.0.1.1/32", status=self.status, namespace=self.namespace)
-        self.assertEqual(prefix.get_utilization(), (2, 2))
+        self.assertEqual(slash31.get_utilization(), (2, 2))
 
         # IPv6 Non-container Prefix, first and last addresses count toward utilization
-        prefix = Prefix.objects.create(prefix="aaab::/124", status=self.status, namespace=self.namespace)
+        slash124_1 = Prefix.objects.create(prefix="aaab::/124", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="aaab::1/128", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="aaab::2/128", status=self.status, namespace=self.namespace)
-        self.assertEqual(prefix.get_utilization(), (2, 16))
+        self.assertEqual(slash124_1.get_utilization(), (2, 16))
 
-        prefix = Prefix.objects.create(prefix="aaaa::/124", status=self.status, namespace=self.namespace)
+        slash124_2 = Prefix.objects.create(prefix="aaaa::/124", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="aaaa::0/128", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="aaaa::f/128", status=self.status, namespace=self.namespace)
-        self.assertEqual(prefix.get_utilization(), (2, 16))
+        self.assertEqual(slash124_2.get_utilization(), (2, 16))
 
         # single address prefixes
-        prefix = Prefix.objects.create(prefix="cccc::1/128", status=self.status, namespace=self.namespace)
+        slash128 = Prefix.objects.create(prefix="cccc::1/128", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="cccc::1/128", status=self.status, namespace=self.namespace)
-        self.assertEqual(prefix.get_utilization(), (1, 1))
-        prefix = Prefix.objects.create(prefix="1.1.1.1/32", status=self.status, namespace=self.namespace)
+        self.assertEqual(slash128.get_utilization(), (1, 1))
+        slash32 = Prefix.objects.create(prefix="1.1.1.1/32", status=self.status, namespace=self.namespace)
         IPAddress.objects.create(address="1.1.1.1/32", status=self.status, namespace=self.namespace)
-        self.assertEqual(prefix.get_utilization(), (1, 1))
+        self.assertEqual(slash32.get_utilization(), (1, 1))
 
         # Large Prefix
         large_prefix = Prefix.objects.create(