nautobot 2.3.4__py3-none-any.whl → 2.3.6__py3-none-any.whl

nautobot/ipam/migrations/0050_vlangroup_range.py

@@ -0,0 +1,24 @@
+# Generated by Django 4.2.16 on 2024-10-02 17:14
+
+from django.db import migrations
+
+import nautobot.core.models.fields
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ipam", "0049_vrf_data_migration"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="vlangroup",
+            name="range",
+            field=nautobot.core.models.fields.PositiveRangeNumberTextField(default="1-4094"),
+        ),
+        migrations.AddField(
+            model_name="vlangroup",
+            name="tags",
+            field=nautobot.core.models.fields.TagsField(through="extras.TaggedItem", to="extras.Tag"),
+        ),
+    ]

nautobot/ipam/models.py

@@ -10,8 +10,9 @@ from django.utils.functional import cached_property
 import netaddr
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
+from nautobot.core.forms.utils import parse_numeric_range
 from nautobot.core.models import BaseManager, BaseModel
-from nautobot.core.models.fields import JSONArrayField
+from nautobot.core.models.fields import JSONArrayField, PositiveRangeNumberTextField
 from nautobot.core.models.generics import OrganizationalModel, PrimaryModel
 from nautobot.core.models.utils import array_to_string
 from nautobot.core.utils.data import UtilizationData
@@ -889,22 +890,16 @@ class Prefix(PrimaryModel):
         )
         return available_ips
 
-    def get_child_ips(self):
+    def get_all_ips(self):
         """
-        Return IP addresses with this prefix as parent.
-
-        In a future release, if this prefix is a pool, it will return IP addresses within the pool's address space.
+        Return all IP addresses contained within this prefix, including child prefixes' IP addresses.
 
         Returns:
             IPAddress QuerySet
         """
-        # 3.0 TODO: uncomment this to enable this logic
-        # if self.type == choices.PrefixTypeChoices.TYPE_POOL:
-        #     return IPAddress.objects.filter(
-        #         parent__namespace=self.namespace, host__gte=self.network, host__lte=self.broadcast
-        #     )
-        # else:
-        return self.ip_addresses.all()
+        return IPAddress.objects.filter(
+            parent__namespace=self.namespace, host__gte=self.network, host__lte=self.broadcast
+        )
 
     def get_first_available_prefix(self):
         """
@@ -1280,11 +1275,14 @@ class IPAddressToInterface(BaseModel):
 
 
 @extras_features(
+    "custom_links",
     "custom_validators",
+    "export_templates",
     "graphql",
     "locations",
+    "webhooks",
 )
-class VLANGroup(OrganizationalModel):
+class VLANGroup(PrimaryModel):
     """
     A VLAN group is an arbitrary collection of VLANs within which VLAN IDs and names must be unique.
     """
@@ -1299,11 +1297,36 @@ class VLANGroup(OrganizationalModel):
     )
     description = models.CharField(max_length=CHARFIELD_MAX_LENGTH, blank=True)
 
+    range = PositiveRangeNumberTextField(
+        blank=False,
+        default="1-4094",
+        help_text="Permitted VID range(s) as comma-separated list, default '1-4094' if left blank.",
+        min_boundary=constants.VLAN_VID_MIN,
+        max_boundary=constants.VLAN_VID_MAX,
+    )
+
     class Meta:
         ordering = ("name",)
         verbose_name = "VLAN group"
         verbose_name_plural = "VLAN groups"
 
+    @property
+    def expanded_range(self):
+        """
+        Expand VLAN's range into a list of integers (VLAN IDs).
+        """
+        return parse_numeric_range(self.range)
+
+    @property
+    def available_vids(self):
+        """
+        Return all available VLAN IDs within this VLANGroup as a list.
+        """
+        used_ids = self.vlans.all().values_list("vid", flat=True)
+        available = sorted([vid for vid in self.expanded_range if vid not in used_ids])
+
+        return available
+
     def clean(self):
         super().clean()
 
@@ -1314,18 +1337,25 @@ class VLANGroup(OrganizationalModel):
                     {"location": f'VLAN groups may not associate to locations of type "{self.location.location_type}".'}
                 )
 
+        # Validate ranges for related VLANs.
+        _expanded_range = self.expanded_range
+        out_of_range_vids = [_vlan.vid for _vlan in self.vlans.all() if _vlan.vid not in _expanded_range]
+        if out_of_range_vids:
+            raise ValidationError(
+                {
+                    "range": f"VLAN group range may not be re-sized due to existing VLANs (IDs: {','.join(map(str, out_of_range_vids))})."
+                }
+            )
+
     def __str__(self):
         return self.name
 
     def get_next_available_vid(self):
         """
-        Return the first available VLAN ID (1-4094) in the group.
+        Return the first available VLAN ID in the group's range.
         """
-        vlan_ids = VLAN.objects.filter(vlan_group=self).values_list("vid", flat=True)
-        for i in range(1, 4095):
-            if i not in vlan_ids:
-                return i
-        return None
+        _available_vids = self.available_vids
+        return _available_vids[0] if _available_vids else None
 
 
 @extras_features(
@@ -1444,6 +1474,13 @@ class VLAN(PrimaryModel):
         # Return all VM interfaces assigned to this VLAN
         return VMInterface.objects.filter(Q(untagged_vlan_id=self.pk) | Q(tagged_vlans=self.pk)).distinct()
 
+    def clean(self):
+        super().clean()
+
+        # Validate Vlan Group Range
+        if self.vlan_group and self.vid not in self.vlan_group.expanded_range:
+            raise ValidationError({"vid": f"VLAN ID is not contained in VLAN Group range ({self.vlan_group.range})"})
+
 
 @extras_features("graphql")
 class VLANLocationAssignment(BaseModel):

nautobot/ipam/navigation.py

@@ -191,7 +191,14 @@ menu_items = (
                         permissions=[
                             "ipam.view_service",
                         ],
-                        buttons=(),
+                        buttons=(
+                            NavMenuAddButton(
+                                link="ipam:service_add",
+                                permissions=[
+                                    "ipam.add_service",
+                                ],
+                            ),
+                        ),
                     ),
                 ),
             ),

nautobot/ipam/tables.py

@@ -161,9 +161,9 @@ VLAN_LINK = """
 {% url 'ipam:vlan_add' %}\
 ?vid={{ record.vid }}&vlan_group={{ vlan_group.pk }}\
 {% if vlan_group.location %}&location={{ vlan_group.location.pk }}{% endif %}\
-" class="btn btn-xs btn-success">{{ record.available }} VLAN{{ record.available|pluralize }} available</a>\
+" class="btn btn-xs btn-success">{{ record.available }} VLAN{{ record.available|pluralize }} available ({{ record.range }})</a>\
 {% else %}
-    {{ record.available }} VLAN{{ record.available|pluralize }} available
+    {{ record.available }} VLAN{{ record.available|pluralize }} available ({{ record.range }})
 {% endif %}
 """
 
@@ -665,8 +665,8 @@ class VLANGroupTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = VLANGroup
-        fields = ("pk", "name", "location", "vlan_count", "description", "actions")
-        default_columns = ("pk", "name", "location", "vlan_count", "description", "actions")
+        fields = ("pk", "name", "location", "range", "vlan_count", "description", "actions")
+        default_columns = ("pk", "name", "range", "location", "vlan_count", "description", "actions")
 
 
 #

nautobot/ipam/templates/ipam/prefix.html

@@ -33,7 +33,7 @@
         </li>
         {% if perms.ipam.view_ipaddress %}
             <li role="presentation"{% if active_tab == 'ip-addresses' %} class="active"{% endif %}>
-                <a href="{% url 'ipam:prefix_ipaddresses' pk=object.pk %}">IP Addresses <span class="badge">{{ object.get_child_ips.count }}</span></a>
+                <a href="{% url 'ipam:prefix_ipaddresses' pk=object.pk %}">IP Addresses <span class="badge">{{ object.get_all_ips.count }}</span></a>
             </li>
         {% endif %}
 {% endblock extra_nav_tabs %}

nautobot/ipam/templates/ipam/vlangroup.html

@@ -17,6 +17,10 @@
                     <td>Location</td>
                     <td>{% include 'dcim/inc/location_hierarchy.html' with location=object.location %}</td>
                 </tr>
+                <tr>
+                    <td>Range</td>
+                    <td>{{ object.range }}</td>
+                </tr>
                 <tr>
                     <td>VLANs</td>
                     <td>

nautobot/ipam/tests/test_api.py

@@ -991,6 +991,15 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         "description": "New description",
     }
 
+    @classmethod
+    def setUpTestData(cls):
+        cls.vlan_group = VLANGroup.objects.create(name="Test", range="5-10,15-20")
+        cls.default_status = Status.objects.first()
+        VLAN.objects.create(name="vlan_5", vid=5, status=cls.default_status, vlan_group=cls.vlan_group)
+        VLAN.objects.create(name="vlan_10", vid=10, status=cls.default_status, vlan_group=cls.vlan_group)
+        VLAN.objects.create(name="vlan_17", vid=17, status=cls.default_status, vlan_group=cls.vlan_group)
+        cls.unused_vids = [6, 7, 8, 9, 15, 16, 18, 19, 20]
+
     def get_deletable_object(self):
         return VLANGroup.objects.create(name="DELETE ME")
 
@@ -1002,6 +1011,171 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         ]
         return [vg.pk for vg in vlangroups]
 
+    def test_list_available_vlans(self):
+        """
+        Test retrieval of all available VLAN IDs within a VLANGroup.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions("ipam.view_vlangroup")
+
+        # Retrieve all available VLAN IDs
+        response = self.client.get(url, **self.header)
+
+        self.assertEqual(response.data["results"], self.unused_vids)
+        self.assertEqual(response.data["count"], len(self.unused_vids))
+
+    def test_create_single_available_vlan(self):
+        """
+        Test creation of the first available VLAN within a VLANGroup.
+        """
+        cf = CustomField.objects.create(key="sor", label="Source of Record Field", type="text")
+        cf.content_types.add(ContentType.objects.get_for_model(VLAN))
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Create all nine available VLANs with individual requests
+        for unused_vid in self.unused_vids:
+            data = {
+                "name": f"VLAN_{unused_vid}",
+                "description": f"Test VLAN {unused_vid}",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+            response = self.client.post(url, data, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_201_CREATED)
+            self.assertEqual(response.data["results"]["name"], data["name"])
+            self.assertEqual(response.data["results"]["vid"], unused_vid)
+            self.assertEqual(response.data["results"]["description"], data["description"])
+            self.assertEqual(response.data["results"]["vlan_group"]["id"], self.vlan_group.pk)
+            self.assertIn("custom_fields", response.data["results"])
+            self.assertIn("sor", response.data["results"]["custom_fields"])
+            self.assertEqual("Nautobot", response.data["results"]["custom_fields"]["sor"])
+
+        # Try to create one more VLAN
+        response = self.client.post(
+            url, {"name": "UTILIZED_VLAN_GROUP", "status": self.default_status.pk}, format="json", **self.header
+        )
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertIn(
+            f"An insufficient number of VLANs are available within the VLANGroup {self.vlan_group}",
+            response.data["detail"],
+        )
+
+    def test_create_multiple_available_vlans(self):
+        """
+        Test the creation of available VLANS within a VLANGroup.
+        """
+        cf = CustomField.objects.create(key="sor", label="Source of Record Field", type="text")
+        cf.content_types.add(ContentType.objects.get_for_model(VLAN))
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create ten VLANs (only nine are available)
+        data = [  # First nine VLANs
+            {
+                "name": f"VLAN_{unused_vid}",
+                "description": f"Test VLAN {unused_vid}",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+            for unused_vid in self.unused_vids
+        ]
+        additional_vlan = [
+            {
+                "name": "VLAN_10",  # Out of range VLAN
+                "description": "Test VLAN 10",
+                "status": self.default_status.pk,
+                "custom_fields": {"sor": "Nautobot"},
+            }
+        ]
+        response = self.client.post(url, data + additional_vlan, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+
+        # Create all nine available VLANs in a single request
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 9)
+
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+            self.assertEqual(response.data["results"][i]["vid"], int(vlan_data["name"].replace("VLAN_", "")))
+            self.assertEqual(response.data["results"][i]["description"], vlan_data["description"])
+            self.assertEqual(response.data["results"][i]["vlan_group"]["id"], self.vlan_group.pk)
+            self.assertIn("custom_fields", response.data["results"][i])
+            self.assertIn("sor", response.data["results"][i]["custom_fields"])
+            self.assertEqual("Nautobot", response.data["results"][i]["custom_fields"]["sor"])
+
+    def test_create_multiple_explicit_vlans(self):
+        """
+        Test the creation of available VLANS within a VLANGroup requesting explicit VLAN IDs.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create VLANs with specified VLAN IDs. Also, explicitly (and redundantly) specify a VLAN Group.
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_7", "status": self.default_status.pk, "vid": 7},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+            {"name": "VLAN_9", "status": self.default_status.pk, "vid": 9, "vlan_group": self.vlan_group.pk},
+            {"name": "VLAN_15", "status": self.default_status.pk},
+            {"name": "VLAN_16", "status": self.default_status.pk, "vid": 16, "vlan_group": self.vlan_group.pk},
+        ]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 6)
+
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+            self.assertEqual(response.data["results"][i]["vid"], int(vlan_data["name"].replace("VLAN_", "")))
+            self.assertEqual(response.data["results"][i]["vlan_group"]["id"], self.vlan_group.pk)
+
+    def test_create_invalid_vlans(self):
+        """
+        Test the creation of VLANs using invalid requests.
+        """
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.add_vlan",
+        )
+
+        # Try to create VLANs using same vid
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_7", "status": self.default_status.pk, "vid": 6},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+        ]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertEqual("VLAN 6 is not available within the VLANGroup.", response.data["detail"])
+
+        # Try to create VLANs specifying other VLAN Group
+        some_other_vlan_group = VLANGroup.objects.create(name="VLAN Group 100-200", range="100-200")
+        data = [{"name": "VLAN_7", "status": self.default_status.pk, "vlan_group": some_other_vlan_group.pk}]
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+        self.assertEqual(
+            f"Invalid VLAN Group requested: {some_other_vlan_group}. Only VLAN Group {self.vlan_group} is permitted.",
+            response.data["detail"],
+        )
+
 
 class VLANTest(APIViewTestCases.APIViewTestCase):
     model = VLAN

nautobot/ipam/tests/test_filters.py

@@ -1256,7 +1256,7 @@ class VLANLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
         params = {"q": vlan_vid}
         queryset = VLANLocationAssignment.objects.exclude(location__name__icontains=vlan_vid)
         filterset = VLANLocationAssignmentFilterSet(params, queryset).qs
-        expected_queryset = VLANLocationAssignment.objects.filter(vlan__vid__exact=vlan_vid)
+        expected_queryset = queryset.filter(vlan__vid__exact=vlan_vid)
         self.assertQuerysetEqualAndNotEmpty(filterset, expected_queryset)
 
 

nautobot/ipam/tests/test_models.py

@@ -1302,7 +1302,7 @@ class TestVLANGroup(ModelTestCases.BaseModelTestCase):
         self.assertIn(f'VLAN groups may not associate to locations of type "{location_type.name}"', str(cm.exception))
 
     def test_get_next_available_vid(self):
-        vlangroup = VLANGroup.objects.create(name="VLAN Group 1")
+        vlangroup = VLANGroup.objects.create(name="VLAN Group 1", range="1-6")
         status = Status.objects.get_for_model(VLAN).first()
         VLAN.objects.bulk_create(
             (
@@ -1316,6 +1316,40 @@ class TestVLANGroup(ModelTestCases.BaseModelTestCase):
 
         VLAN.objects.bulk_create((VLAN(name="VLAN 4", vid=4, vlan_group=vlangroup, status=status),))
         self.assertEqual(vlangroup.get_next_available_vid(), 6)
+        # Next out of range.
+        VLAN.objects.bulk_create((VLAN(name="VLAN 6", vid=6, vlan_group=vlangroup, status=status),))
+        self.assertEqual(vlangroup.get_next_available_vid(), None)
+
+    def test_range_resize(self):
+        vlangroup = VLANGroup.objects.create(name="VLAN Group 1", range="1-3")
+        status = Status.objects.get_for_model(VLAN).first()
+        VLAN.objects.bulk_create(
+            (
+                VLAN(name="VLAN 1", vid=1, vlan_group=vlangroup, status=status),
+                VLAN(name="VLAN 2", vid=2, vlan_group=vlangroup, status=status),
+                VLAN(name="VLAN 3", vid=3, vlan_group=vlangroup, status=status),
+            )
+        )
+        with self.assertRaises(ValidationError) as exc:
+            vlangroup.range = "1-2"
+            vlangroup.validated_save()
+        self.assertEqual(
+            str(exc.exception), "{'range': ['VLAN group range may not be re-sized due to existing VLANs (IDs: 3).']}"
+        )
+
+    def test_assign_vlan_out_of_range(self):
+        vlangroup = VLANGroup.objects.create(name="VLAN Group 1", range="1-2")
+        status = Status.objects.get_for_model(VLAN).first()
+        VLAN.objects.bulk_create(
+            (
+                VLAN(name="VLAN 1", vid=1, vlan_group=vlangroup, status=status),
+                VLAN(name="VLAN 2", vid=2, vlan_group=vlangroup, status=status),
+            )
+        )
+        with self.assertRaises(ValidationError) as exc:
+            vlan = VLAN(name="VLAN 3", vid=3, vlan_group=vlangroup, status=status)
+            vlan.validated_save()
+        self.assertEqual(str(exc.exception), "{'vid': ['VLAN ID is not contained in VLAN Group range (1-2)']}")
 
 
 class TestVLAN(ModelTestCases.BaseModelTestCase):

nautobot/ipam/tests/test_utils.py

@@ -0,0 +1,61 @@
+from django.test import TestCase
+
+from nautobot.core.forms.utils import parse_numeric_range
+from nautobot.extras.models import Status
+from nautobot.ipam.models import VLAN, VLANGroup
+from nautobot.ipam.utils import add_available_vlans
+
+
+class AddAvailableVlansTest(TestCase):
+    """Tests for add_available_vlans()."""
+
+    def test_add_available_vlans(self):
+        vlan_group = VLANGroup.objects.create(name="VLAN Group 1", range="100-105,110-112,115")
+        status = Status.objects.get_for_model(VLAN).first()
+        vlan_100 = {"vid": 100, "available": 2, "range": "100-101"}
+        vlan_102 = VLAN.objects.create(name="VLAN 102", vid=102, vlan_group=vlan_group, status=status)
+        vlan_103 = VLAN.objects.create(name="VLAN 103", vid=103, vlan_group=vlan_group, status=status)
+        vlan_104 = {"vid": 104, "available": 2, "range": "104-105"}
+        vlan_110 = VLAN.objects.create(name="VLAN 110", vid=110, vlan_group=vlan_group, status=status)
+        vlan_111 = VLAN.objects.create(name="VLAN 111", vid=111, vlan_group=vlan_group, status=status)
+        vlan_112 = {"vid": 112, "available": 1, "range": "112"}
+        vlan_115 = VLAN.objects.create(name="VLAN 115", vid=115, vlan_group=vlan_group, status=status)
+
+        self.assertEqual(
+            list(add_available_vlans(vlan_group=vlan_group, vlans=vlan_group.vlans.all())),
+            [vlan_100, vlan_102, vlan_103, vlan_104, vlan_110, vlan_111, vlan_112, vlan_115],
+        )
+
+
+class ParseNumericRangeTest(TestCase):
+    """Tests for add_available_vlans()."""
+
+    def test_parse(self):
+        self.assertEqual(parse_numeric_range(input_string="5"), [5])
+        self.assertEqual(parse_numeric_range(input_string="5-5"), [5])
+        self.assertEqual(parse_numeric_range(input_string="5-5,5,5"), [5])
+        self.assertEqual(parse_numeric_range(input_string="1-5"), [1, 2, 3, 4, 5])
+        self.assertEqual(parse_numeric_range(input_string="1,2,3,4,5"), [1, 2, 3, 4, 5])
+        self.assertEqual(parse_numeric_range(input_string="5,4,3,1,2"), [1, 2, 3, 4, 5])
+        self.assertEqual(parse_numeric_range(input_string="1-5,10"), [1, 2, 3, 4, 5, 10])
+        self.assertEqual(parse_numeric_range(input_string="1,5,10-11"), [1, 5, 10, 11])
+        self.assertEqual(parse_numeric_range(input_string="10-11,1,5"), [1, 5, 10, 11])
+        self.assertEqual(parse_numeric_range(input_string="a", base=16), [10])
+        self.assertEqual(parse_numeric_range(input_string="a,b", base=16), [10, 11])
+        self.assertEqual(parse_numeric_range(input_string="9-c,f", base=16), [9, 10, 11, 12, 15])
+        self.assertEqual(parse_numeric_range(input_string="15-19", base=16), [21, 22, 23, 24, 25])
+        self.assertEqual(parse_numeric_range(input_string="fa-ff", base=16), [250, 251, 252, 253, 254, 255])
+
+    def test_invalid_input(self):
+        invalid_inputs = [
+            [1, 2, 3],
+            None,
+            1,
+            "",
+            "3-",
+        ]
+
+        for x in invalid_inputs:
+            with self.assertRaises(TypeError) as exc:
+                parse_numeric_range(input_string=x)
+            self.assertEqual(str(exc.exception), "Input value must be a string using a range format.")

nautobot/ipam/tests/test_views.py

@@ -328,6 +328,44 @@ class PrefixTestCase(ViewTestCases.PrimaryObjectViewTestCase, ViewTestCases.List
                 strip_tags(content),
             )
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_prefix_ipaddresses_table_list_includes_child_ips(self):
+        ip_status = Status.objects.get_for_model(IPAddress).first()
+        instance = Prefix.objects.create(
+            prefix="5.5.10.0/23",
+            namespace=self.namespace,
+            type=PrefixTypeChoices.TYPE_NETWORK,
+            status=self.statuses[1],
+        )
+        Prefix.objects.create(
+            prefix="5.5.10.0/30",
+            namespace=self.namespace,
+            type=PrefixTypeChoices.TYPE_POOL,
+            status=self.statuses[1],
+        )
+        IPAddress.objects.create(
+            address="5.5.10.1/23",
+            status=ip_status,
+            namespace=self.namespace,
+        )
+        IPAddress.objects.create(
+            address="5.5.10.4/23",
+            status=ip_status,
+            namespace=self.namespace,
+        )
+        url = reverse("ipam:prefix_ipaddresses", args=(instance.pk,))
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        content = response.content.decode(response.charset)
+        # This validates that both parent prefix and child prefix IPAddresses are present in parent prefix IPAddresses list
+        self.assertIn("5.5.10.1/23", strip_tags(content))
+        self.assertIn("5.5.10.4/23", strip_tags(content))
+        print(response.content.decode(response.charset))
+        ip_address_tab = (
+            f'<li role="presentation" class="active"><a href="{url}">IP Addresses <span class="badge">2</span></a></li>'
+        )
+        self.assertInHTML(ip_address_tab, content)
+
 
 class IPAddressTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = IPAddress
@@ -993,6 +1031,8 @@ class VLANGroupTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
             "name": "VLAN Group X",
             "location": location.pk,
             "description": "A new VLAN group",
+            "range": "1-4094",
+            "tags": [t.pk for t in Tag.objects.get_for_model(VLANGroup)],
         }
 
     def get_deletable_object(self):
@@ -1005,7 +1045,6 @@ class VLANTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     @classmethod
     def setUpTestData(cls):
         cls.locations = Location.objects.filter(location_type=LocationType.objects.get(name="Campus"))
-        location_1 = cls.locations.first()
 
         vlangroups = (
             VLANGroup.objects.create(name="VLAN Group 1", location=cls.locations.first()),
@@ -1014,51 +1053,14 @@ class VLANTestCase(ViewTestCases.PrimaryObjectViewTestCase):
 
         roles = Role.objects.get_for_model(VLAN)[:2]
 
-        statuses = Status.objects.get_for_model(VLAN)
-        status_1 = statuses[0]
-        status_2 = statuses[1]
-
-        vlans = (
-            VLAN.objects.create(
-                vlan_group=vlangroups[0],
-                vid=101,
-                name="VLAN101",
-                role=roles[0],
-                status=status_1,
-                _custom_field_data={"custom_field": "Value"},
-            ),
-            VLAN.objects.create(
-                vlan_group=vlangroups[0],
-                vid=102,
-                name="VLAN102",
-                role=roles[0],
-                status=status_1,
-                _custom_field_data={"custom_field": "Value"},
-            ),
-            VLAN.objects.create(
-                vlan_group=vlangroups[0],
-                vid=103,
-                name="VLAN103",
-                role=roles[0],
-                status=status_1,
-                _custom_field_data={"custom_field": "Value"},
-            ),
-        )
-        vlans[0].locations.add(location_1)
-        vlans[1].locations.add(location_1)
-        vlans[2].locations.add(location_1)
-
-        custom_field = CustomField.objects.create(
-            type=CustomFieldTypeChoices.TYPE_TEXT, label="Custom Field", default=""
-        )
-        custom_field.content_types.set([ContentType.objects.get_for_model(VLAN)])
+        status = Status.objects.get_for_model(VLAN).first()
 
         cls.form_data = {
             "vlan_group": vlangroups[1].pk,
             "vid": 999,
             "name": "VLAN999 with an unwieldy long name since we increased the limit to more than 64 characters",
             "tenant": None,
-            "status": status_2.pk,
+            "status": status.pk,
             "role": roles[1].pk,
             "locations": list(cls.locations.values_list("pk", flat=True)[:2]),
             "description": "A new VLAN",
@@ -1068,7 +1070,7 @@ class VLANTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         cls.bulk_edit_data = {
             "vlan_group": vlangroups[0].pk,
             "tenant": Tenant.objects.first().pk,
-            "status": status_2.pk,
+            "status": status.pk,
             "role": roles[0].pk,
             "description": "New description",
         }