nautobot 2.4.13__py3-none-any.whl → 2.4.15__py3-none-any.whl

nautobot/ipam/tables.py

@@ -1,8 +1,6 @@
-from django.db.models import Prefetch, QuerySet
+from django.db.models import Prefetch
 from django.utils.safestring import mark_safe
 import django_tables2 as tables
-from django_tables2.data import TableData
-from django_tables2.rows import BoundRows
 from django_tables2.utils import Accessor
 
 from nautobot.core.tables import (
@@ -38,7 +36,7 @@ from .models import (
     VRFPrefixAssignment,
 )
 
-AVAILABLE_LABEL = mark_safe('<span class="label label-success">Available</span>')  # noqa: S308  # suspicious-mark-safe-usage -- known safe string here
+AVAILABLE_LABEL = mark_safe('<span class="label label-success">Available</span>')
 
 UTILIZATION_GRAPH = """
 {% load helpers %}
@@ -425,17 +423,12 @@ class PrefixDetailTable(PrefixTable):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        # Conditionally prefetch children for the utilization calculation if that column is visible.
-        if self.columns["utilization"].visible and isinstance(self.data.data, QuerySet):
-            self.data = TableData.from_data(
-                self.data.data.prefetch_related(
-                    Prefetch(
-                        "children", queryset=Prefix.objects.only("network", "prefix_length", "parent_id").order_by()
-                    )
-                )
-            )
-            self.data.set_table(self)
-            self.rows = BoundRows(data=self.data, table=self, pinned_data=self.pinned_data)
+        self.add_conditional_prefetch(
+            "utilization",
+            prefetch=Prefetch(
+                "children", queryset=Prefix.objects.only("network", "prefix_length", "parent_id").order_by()
+            ),
+        )
 
     class Meta(PrefixTable.Meta):
         fields = (

nautobot/ipam/tests/migration/test_migrations.py

@@ -93,9 +93,9 @@ class AggregateToPrefixMigrationTestCase(MigratorTestCase):
         # self.prefix12(10.12.0.0)
         for i in range(8):
             prefix = Prefix.objects.create(
-                network=f"10.{i+5}.0.0", broadcast=f"10.{i+5}.0.15", prefix_length=28, status=self.prefix_status
+                network=f"10.{i + 5}.0.0", broadcast=f"10.{i + 5}.0.15", prefix_length=28, status=self.prefix_status
             )
-            setattr(self, f"prefix{i+5}", prefix)
+            setattr(self, f"prefix{i + 5}", prefix)
 
         # Create 16 aggregates that will be migrated to new Prefixes
         # self.aggregate5(8.5.0.0)
@@ -103,13 +103,13 @@ class AggregateToPrefixMigrationTestCase(MigratorTestCase):
         # self.aggregate20(8.20.0.0)
         for i in range(16):
             aggregate = Aggregate.objects.create(
-                network=f"8.{i+5}.0.0",
-                broadcast=f"8.{i+5}.0.7",
+                network=f"8.{i + 5}.0.0",
+                broadcast=f"8.{i + 5}.0.7",
                 rir=self.rir2,
                 prefix_length=29,
                 description="AggregateDesc",
             )
-            setattr(self, f"aggregate{i+5}", aggregate)
+            setattr(self, f"aggregate{i + 5}", aggregate)
 
         # tags
         self.prefix_tag_a = Tag.objects.create(name="PrefixTagA", slug="prefixtaga")
@@ -255,7 +255,7 @@ class AggregateToPrefixMigrationTestCase(MigratorTestCase):
         with self.subTest("network"):
             for i in range(16):
                 self.assertTrue(
-                    Prefix.objects.filter(network=f"8.{i+5}.0.0", prefix_length=29, rir_id=self.rir2.id).exists()
+                    Prefix.objects.filter(network=f"8.{i + 5}.0.0", prefix_length=29, rir_id=self.rir2.id).exists()
                 )
 
         with self.subTest("rir"):
@@ -266,11 +266,11 @@ class AggregateToPrefixMigrationTestCase(MigratorTestCase):
                 self.assertEqual(Prefix.objects.get(network="10.4.0.0").rir_id, self.rir1.id)
             with self.subTest(f"prefix.rir = {self.rir2.name}"):
                 for i in range(16):
-                    prefix = Prefix.objects.get(network=f"8.{i+5}.0.0")
+                    prefix = Prefix.objects.get(network=f"8.{i + 5}.0.0")
                     self.assertEqual(prefix.rir_id, self.rir2.id)
             with self.subTest("prefix.rir is None"):
                 for i in range(8):
-                    prefix = Prefix.objects.get(network=f"10.{i+5}.0.0")
+                    prefix = Prefix.objects.get(network=f"10.{i + 5}.0.0")
                     self.assertIsNone(prefix.rir_id)
 
         with self.subTest("description"):

nautobot/ipam/tests/test_api.py

@@ -508,7 +508,7 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
 
         response = self.client.get(f"{url}?depth=1", **self.header)
         for p in response.data["results"]:
-            self.assertEqual(p["display"], f'{p["prefix"]}: {p["namespace"]["name"]}')
+            self.assertEqual(p["display"], f"{p['prefix']}: {p['namespace']['name']}")
 
     def test_create_single_available_prefix(self):
         """
@@ -532,7 +532,7 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
                 "prefix_length": child_prefix_length,
                 "status": self.status.pk,
                 "description": f"Test Prefix {i + 1}",
-                "custom_fields": {"prefixcf": f"value {i+1}"},
+                "custom_fields": {"prefixcf": f"value {i + 1}"},
             }
             response = self.client.post(url, data, format="json", **self.header)
             self.assertHttpStatus(response, status.HTTP_201_CREATED)
@@ -768,6 +768,299 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         response = self.client.get(url, **self.header)
         self.assertEqual(len(response.data), 6)  # 8 - 2 because prefix.type = network
 
+    def test_ipv4_prefix_list_available_ips_with_limit(self):
+        """
+        Test retrieval with a limit of all available IP addresses within a parent IPv4 prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        limit = 2
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"limit": limit},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), limit)
+
+    def test_ipv6_prefix_list_available_ips_with_limit(self):
+        """
+        Test retrieval with a limit of all available IP addresses within a parent IPv6 prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        limit = 100
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"limit": limit},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), limit)
+
+    def test_range_parameters_validation(self):
+        """
+        Test detection of incorrect range_start or range_end parameters.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+
+        range_start = "fdffZabcdZfffZfc01"  #  purposefully incorrect parameter
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("detail", response.data)
+
+        range_end = "fdffZabcdZfffZfcff"  #  purposefully incorrect parameter
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_end": range_end},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("detail", response.data)
+
+    def test_list_available_ips_with_range_start(self):
+        """
+        Test retrieval with range_start parameter of all available IP addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "192.0.3.2"
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 6)  # because prefix type = pool
+        self.assertIn("address", response.data[0])
+        self.assertIn("192.0.3.2/29", response.data[0]["address"])
+
+    def test_list_available_ips_with_range_start_ipv6(self):
+        """
+        Test retrieval with range_start parameter of all available IPv6 addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "fdff:abcd:ffff:ffff:ffff:ffff:ffff:fff0"
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 16)
+        self.assertIn("address", response.data[0])
+        self.assertIn("fdff:abcd:ffff:ffff:ffff:ffff:ffff:fff0/54", response.data[0]["address"])
+
+    def test_list_available_ips_with_range_end(self):
+        """
+        Test retrieval with range_end parameter of all available IP addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_end = "192.0.3.5"
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_end": range_end},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 6)  # because prefix type = pool
+        self.assertIn("address", response.data[-1])
+        self.assertIn("192.0.3.5/29", response.data[-1]["address"])
+
+    def test_list_available_ips_with_range_end_ipv6(self):
+        """
+        Test retrieval with range_end parameter of all available IPv6 addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_end = "fdff:abcd:ffff:fc00::000f"
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_end": range_end},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 16)  # because prefix type = pool
+        self.assertIn("address", response.data[-1])
+        self.assertIn("fdff:abcd:ffff:fc00::f/54", response.data[-1]["address"])
+
+    def test_list_available_ips_with_range_start_and_end(self):
+        """
+        Test retrieval with range_end parameter of all available IP addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "192.0.3.2"
+        range_end = "192.0.3.5"
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start, "range_end": range_end},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 4)
+        self.assertIn("address", response.data[0])
+        self.assertIn("address", response.data[-1])
+        self.assertIn("192.0.3.2/29", response.data[0]["address"])
+        self.assertIn("192.0.3.5/29", response.data[-1]["address"])
+
+    def test_list_available_ips_with_range_start_and_end_ipv6(self):
+        """
+        Test retrieval with range_end parameter of all available IPv6 addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "fdff:abcd:ffff:fcff::"
+        range_end = "fdff:abcd:ffff:fcff::f"
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start, "range_end": range_end},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 16)
+        self.assertIn("address", response.data[0])
+        self.assertIn("address", response.data[-1])
+        self.assertIn("fdff:abcd:ffff:fcff::/54", response.data[0]["address"])
+        self.assertIn("fdff:abcd:ffff:fcff::f/54", response.data[-1]["address"])
+
+    def test_list_available_ips_with_range_start_and_limit(self):
+        """
+        Test retrieval with range_start and limit of all available IP addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "192.0.3.2"
+        limit = 2
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start, "limit": limit},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), limit)
+        self.assertIn("address", response.data[0])
+        self.assertIn("192.0.3.2/29", response.data[0]["address"])
+
+    def test_list_available_ips_with_range_start_and_limit_ipv6(self):
+        """
+        Test retrieval with range_start and limit of all available IPv6 addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "fdff:abcd:ffff:ffff:ffff:ffff:ffff:fff0"
+        limit = 2
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start, "limit": limit},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), limit)
+        self.assertIn("fdff:abcd:ffff:ffff:ffff:ffff:ffff:fff0/54", response.data[0]["address"])
+
+    def test_list_available_ips_with_range_start_range_end_and_limit(self):
+        """
+        Test retrieval with range_start, range_end and limit of all available IP addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "192.0.3.2"
+        range_end = "192.0.3.5"
+        limit = 2
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start, "range_end": range_end, "limit": limit},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), limit)
+        self.assertIn("address", response.data[0])
+        self.assertIn("address", response.data[-1])
+        self.assertIn("192.0.3.2/29", response.data[0]["address"])
+        self.assertIn("192.0.3.3/29", response.data[-1]["address"])  # .3 is the next one
+
+    def test_list_available_ips_with_range_start_range_end_and_limit_ipv6(self):
+        """
+        Test retrieval with range_start, range_end and limit of all available IPv6 addresses within a parent prefix.
+        """
+        prefix = Prefix.objects.create(
+            prefix="fdff:abcd:ffff:fc00::/54",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        range_start = "fdff:abcd:ffff:fcff::"
+        range_end = "fdff:abcd:ffff:fcff::f"
+        limit = 2
+        url = self.add_query_params_to_url(
+            url=reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            query_dict={"range_start": range_start, "range_end": range_end, "limit": limit},
+        )
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), limit)
+        self.assertIn("address", response.data[0])
+        self.assertIn("address", response.data[-1])
+        self.assertIn("fdff:abcd:ffff:fcff::/54", response.data[0]["address"])
+        self.assertIn("fdff:abcd:ffff:fcff::1/54", response.data[-1]["address"])
+
     def test_list_available_ips_calculate_child_ips(self):
         """
         Test retrieval of all available IP addresses when child IP's exists.
@@ -871,6 +1164,36 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
         self.assertIn("detail", response.data)
 
+    def test_create_single_available_ip_with_range_start(self):
+        prefix = Prefix.objects.create(
+            prefix="192.0.2.0/29",
+            namespace=self.namespace,
+            type=choices.PrefixTypeChoices.TYPE_NETWORK,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.view_namespace", "ipam.add_ipaddress", "extras.view_status")
+
+        range_start = "192.0.2.3"
+        url = self.add_query_params_to_url(
+            reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            {"range_start": range_start},
+        )
+        # Create available IPs with range start
+        for i in range(1, 5):
+            data = {
+                "description": f"Test IP {i}",
+                "status": self.status.pk,
+            }
+            response = self.client.post(url, data, format="json", **self.header)
+            self.assertHttpStatus(response, status.HTTP_201_CREATED)
+            self.assertEqual(str(response.data["parent"]["url"]), self.absolute_api_url(prefix))
+            self.assertEqual(response.data["description"], data["description"])
+
+        # Next creation request with range start should be denied
+        response = self.client.post(url, {"status": self.status.pk}, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+
     def test_create_multiple_available_ips(self):
         """
         Test the creation of available IP addresses within a parent prefix.
@@ -911,6 +1234,33 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         self.assertIn("ipcf", response.data[0]["custom_fields"])
         self.assertEqual("1", response.data[0]["custom_fields"]["ipcf"])
 
+    def test_create_multiple_available_ips_with_range_start(self):
+        prefix = Prefix.objects.create(
+            prefix="192.0.2.0/29",
+            type=choices.PrefixTypeChoices.TYPE_NETWORK,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        self.add_permissions("ipam.view_prefix", "ipam.add_ipaddress", "ipam.view_namespace", "extras.view_status")
+
+        range_start = "192.0.2.3"
+        url = self.add_query_params_to_url(
+            reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk}),
+            {"range_start": range_start},
+        )
+        # create all 5 available IPs in a single request
+        data = [
+            {"description": f"Test IP {i}", "status": self.status.pk, "custom_fields": {"ipcf": str(i)}}
+            for i in range(1, 5)
+        ]
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data), 4)
+        # next attempt with only one IP requested should fail (prefix space exhausted)
+        data = data[0]
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+
     def test_create_available_ips_with_permissions_constraint(self):
         # Prepare prefix and permissions
         prefix = Prefix.objects.create(

nautobot/ipam/tests/test_models.py

@@ -455,7 +455,7 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         for location in locations:
             location.location_type.content_types.add(ContentType.objects.get_for_model(Prefix))
         for i in range(10):
-            pfx = Prefix.objects.create(prefix=f"1.1.1.{4*i}/30", status=self.status, namespace=self.namespace)
+            pfx = Prefix.objects.create(prefix=f"1.1.1.{4 * i}/30", status=self.status, namespace=self.namespace)
             if i > 4:
                 pfx.locations.set(locations)