nautobot 2.4.0b1__py3-none-any.whl → 2.4.1__py3-none-any.whl

nautobot/ipam/tests/test_api.py

@@ -2,6 +2,7 @@ from concurrent.futures.thread import ThreadPoolExecutor
 import json
 from random import shuffle
 from unittest import skip
+import uuid
 
 from django.contrib.contenttypes.models import ContentType
 from django.db import connection
@@ -348,6 +349,8 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         cls.create_data = [
             {
                 "prefix": "192.168.4.0/24",
+                "network": "192.168.4.0",  # not required, but possible to specify
+                "broadcast": "192.168.4.255",  # not required, but possible to specify
                 "status": cls.status.pk,
                 "rir": rir.pk,
                 "type": choices.PrefixTypeChoices.TYPE_POOL,
@@ -506,7 +509,8 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
             url, {"prefix_length": "hello", "status": self.status.pk}, format="json", **self.header
         )
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
-        self.assertIn("prefix_length", response.data[0])
+        self.assertIn("prefix_length", response.data)
+        self.assertEqual(response.data["prefix_length"], "This field must be an integer.")
 
     def test_create_multiple_available_prefixes(self):
         """
@@ -571,6 +575,126 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         self.assertIn("prefixcf", response.data[0]["custom_fields"])
         self.assertEqual("value 1", response.data[0]["custom_fields"]["prefixcf"])
 
+    def test_create_available_prefixes_with_permissions_constraint(self):
+        # Prepare prefix and permissions
+        prefix = Prefix.objects.create(
+            prefix="10.2.3.0/24",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+            description="This is the Prefix created for whole network.",
+        )
+        url = reverse("ipam-api:prefix-available-prefixes", kwargs={"pk": prefix.pk})
+        self.add_permissions("ipam.view_prefix")
+        self.add_permissions(
+            "ipam.add_prefix", constraints={"description__startswith": "This is the Prefix created for"}
+        )
+
+        # Test invalid request
+        data = {
+            "prefix_length": 26,
+            "status": self.status.pk,
+        }
+        invalid_data_list = [
+            data,
+            {**data, "description": ""},
+            {**data, "description": "Some description"},
+            {**data, "description": "Some description. This is the IP created for"},
+        ]
+
+        for invalid_data in invalid_data_list:
+            with self.subTest(case=invalid_data):
+                response = self.client.post(url, invalid_data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+                self.assertIn("detail", response.data)
+                self.assertEqual(response.data["detail"], "You do not have permission to perform this action.")
+
+                # Verify that no prefixes were created (the entire prefix is still available)
+                response = self.client.get(url, **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                self.assertEqual(len(response.data), 1)
+                self.assertEqual(response.data[0]["prefix"], prefix.cidr_str)
+
+        # Test valid request
+        valid_data = {
+            "prefix_length": 26,
+            "status": self.status.pk,
+            "description": "This is the Prefix created for my local network",
+        }
+        response = self.client.post(url, valid_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(response.data["prefix"], "10.2.3.0/26")
+
+        # Verify that prefix is created
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data), 2)
+        self.assertEqual(response.data[0]["prefix"], "10.2.3.64/26")
+        self.assertEqual(response.data[1]["prefix"], "10.2.3.128/25")
+
+    def test_create_multiple_available_prefixes_with_permissions_constraint(self):
+        # Prepare prefix and permissions
+        prefix = Prefix.objects.create(
+            prefix="10.2.3.0/24",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+            description="This is the Prefix created for whole network.",
+        )
+        url = reverse("ipam-api:prefix-available-prefixes", kwargs={"pk": prefix.pk})
+        self.add_permissions("ipam.view_prefix")
+        self.add_permissions(
+            "ipam.add_prefix", constraints={"description__startswith": "This is the Prefix created for"}
+        )
+
+        # Test invalid request
+        data = [
+            {
+                "prefix_length": 26,
+                "status": self.status.pk,
+                "description": "This is the Prefix created for my local network",
+            },
+            {
+                "prefix_length": 26,
+                "status": self.status.pk,
+            },
+        ]
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+        self.assertIn("detail", response.data)
+        self.assertEqual(response.data["detail"], "You do not have permission to perform this action.")
+
+        # Verify that no prefixes were created (the entire prefix is still available)
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data), 1)
+        self.assertEqual(response.data[0]["prefix"], prefix.cidr_str)
+
+        # Test valid request
+        data = [
+            {
+                "prefix_length": 26,
+                "status": self.status.pk,
+                "description": "This is the Prefix created for my local network",
+            },
+            {
+                "prefix_length": 26,
+                "status": self.status.pk,
+                "description": "This is the Prefix created for my guest house network",
+            },
+        ]
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data), 2)
+        self.assertEqual(response.data[0]["prefix"], "10.2.3.0/26")
+        self.assertEqual(response.data[1]["prefix"], "10.2.3.64/26")
+
+        # Verify that prefixes were created
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data), 1)
+        self.assertEqual(response.data[0]["prefix"], "10.2.3.128/25")
+
     def test_list_available_ips(self):
         """
         Test retrieval of all available IP addresses within a parent prefix.
@@ -594,9 +718,76 @@ 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_list_available_ips_calculate_child_ips(self):
+        """
+        Test retrieval of all available IP addresses when child IP's exists.
+        """
+        ip_status = Status.objects.get_for_model(IPAddress).first()
+        prefix = Prefix.objects.create(
+            prefix="192.0.3.0/29",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        Prefix.objects.create(
+            prefix="192.0.3.0/30",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        IPAddress.objects.create(
+            address="192.0.3.1/30",
+            status=ip_status,
+            namespace=self.namespace,
+        )
+
+        url = reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk})
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+
+        # Retrieve all available IPs
+        response = self.client.get(url, **self.header)
+        self.assertEqual(len(response.data), 7)  # 7 because prefix.type = pool got 8 IP's minus one children IP
+
+    def test_create_single_available_ip_calculate_child_ips(self):
+        """
+        Test creating a single IP when child IP's exists.
+        """
+        ip_status = Status.objects.get_for_model(IPAddress).first()
+        prefix = Prefix.objects.create(
+            prefix="192.0.4.0/31",
+            namespace=self.namespace,
+            type=choices.PrefixTypeChoices.TYPE_NETWORK,
+            status=self.status,
+        )
+        Prefix.objects.create(
+            prefix="192.0.4.0/32",
+            type=choices.PrefixTypeChoices.TYPE_POOL,
+            namespace=self.namespace,
+            status=self.status,
+        )
+        IPAddress.objects.create(
+            address="192.0.4.0/32",
+            status=ip_status,
+            namespace=self.namespace,
+        )
+        url = reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk})
+        self.add_permissions("ipam.view_prefix", "ipam.add_ipaddress", "extras.view_status")
+
+        data = {
+            "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))
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
+        self.assertIn("detail", response.data)
+
     def test_create_single_available_ip(self):
         """
-        Test retrieval of the first available IP address within a parent prefix.
+        Test creating single IP will return 204 No content when pool is fully filled.
         """
         prefix = Prefix.objects.create(
             prefix="192.0.2.0/29",
@@ -664,6 +855,136 @@ class PrefixTest(APIViewTestCases.APIViewTestCase):
         self.assertIn("ipcf", response.data[0]["custom_fields"])
         self.assertEqual("1", response.data[0]["custom_fields"]["ipcf"])
 
+    def test_create_available_ips_with_permissions_constraint(self):
+        # Prepare prefix and permissions
+        prefix = Prefix.objects.create(
+            prefix="192.168.0.0/30",
+            type=choices.PrefixTypeChoices.TYPE_NETWORK,
+            namespace=self.namespace,
+            status=self.status,
+            description="This is the Prefix created for whole network.",
+        )
+        url = reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk})
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        self.add_permissions(
+            "ipam.add_ipaddress", constraints={"description__startswith": "This is the IP created for"}
+        )
+
+        # Test invalid request
+        data = {
+            "status": self.status.pk,
+        }
+        invalid_data_list = [
+            data,
+            {**data, "description": ""},
+            {**data, "description": "Some description"},
+            {**data, "description": "Some description. This is the IP created for"},
+        ]
+
+        for invalid_data in invalid_data_list:
+            with self.subTest(case=invalid_data):
+                response = self.client.post(url, invalid_data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+                self.assertIn("detail", response.data)
+                self.assertEqual(response.data["detail"], "You do not have permission to perform this action.")
+
+                # Verify that no IPs were created (the entire prefix pool is still available)
+                response = self.client.get(url, **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                self.assertEqual(len(response.data), 2)
+
+        # Test valid request
+        valid_data = {
+            "status": self.status.pk,
+            "description": "This is the IP created for my private laptop",
+        }
+        response = self.client.post(url, valid_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(response.data["address"], "192.168.0.1/30")
+
+        # Verify that IP is created
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data), 1)
+        self.assertEqual(response.data[0]["address"], "192.168.0.2/30")
+
+    def test_create_multiple_available_ips_with_permissions_constraint(self):
+        # Prepare prefix and permissions
+        prefix = Prefix.objects.create(
+            prefix="192.168.0.0/30",
+            type=choices.PrefixTypeChoices.TYPE_NETWORK,
+            namespace=self.namespace,
+            status=self.status,
+            description="This is a Prefix created for whole network.",
+        )
+        url = reverse("ipam-api:prefix-available-ips", kwargs={"pk": prefix.pk})
+        self.add_permissions("ipam.view_prefix", "ipam.view_ipaddress")
+        self.add_permissions(
+            "ipam.add_ipaddress", constraints={"description__startswith": "This is the IP created for"}
+        )
+
+        # Test invalid request
+        data = [
+            {
+                "status": self.status.pk,
+            },
+            {
+                "status": self.status.pk,
+                "description": "This is an IP created for my private laptop",
+            },
+        ]
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+        self.assertIn("detail", response.data)
+        self.assertEqual(response.data["detail"], "You do not have permission to perform this action.")
+
+        # Verify that no IPs were created (the entire prefix pool is still available)
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data), 2)
+
+        # Test valid request
+        valid_data = [
+            {
+                "status": self.status.pk,
+                "description": "This is the IP created for my private laptop",
+            },
+            {
+                "status": self.status.pk,
+                "description": "This is the IP created for my gaming laptop",
+            },
+        ]
+        response = self.client.post(url, valid_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data), 2)
+        self.assertEqual(response.data[0]["address"], "192.168.0.1/30")
+        self.assertEqual(response.data[1]["address"], "192.168.0.2/30")
+
+        # Verify that IPs are created
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data), 0)
+
+    def test_prefix_type_filter(self):
+        url = reverse("ipam-api:prefix-list")
+        self.add_permissions("ipam.view_prefix")
+
+        test_cases = {
+            "ic": "WOR",
+            "isw": "NET",
+            "iew": "WORK",
+            "ie": "NETWORK",
+        }
+
+        for type_filter_lookup, type_filter_value in test_cases.items():
+            with self.subTest(render_as=type_filter_lookup):
+                response = self.client.get(f"{url}?type__{type_filter_lookup}={type_filter_value}", **self.header)
+
+                # Assert that the prefixes returned match the type filter
+                self.assertEqual(response.status_code, 200)
+                for result in response.data["results"]:
+                    self.assertEqual(result["type"]["value"], "network")
+
 
 class PrefixLocationAssignmentTest(APIViewTestCases.APIViewTestCase):
     model = PrefixLocationAssignment
@@ -1022,7 +1343,7 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         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")
+        self.add_permissions("ipam.view_vlangroup", "ipam.view_vlan")
 
         # Retrieve all available VLAN IDs
         response = self.client.get(url, **self.header)
@@ -1039,6 +1360,7 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
         self.add_permissions(
             "ipam.view_vlangroup",
+            "ipam.view_vlan",
             "ipam.add_vlan",
         )
 
@@ -1080,6 +1402,7 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
         self.add_permissions(
             "ipam.view_vlangroup",
+            "ipam.view_vlan",
             "ipam.add_vlan",
         )
 
@@ -1126,6 +1449,7 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
         self.add_permissions(
             "ipam.view_vlangroup",
+            "ipam.view_vlan",
             "ipam.add_vlan",
         )
 
@@ -1155,6 +1479,7 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
         url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
         self.add_permissions(
             "ipam.view_vlangroup",
+            "ipam.view_vlan",
             "ipam.add_vlan",
         )
 
@@ -1181,6 +1506,114 @@ class VLANGroupTest(APIViewTestCases.APIViewTestCase):
             f"Invalid VLAN Group requested: {some_other_vlan_group}. Only VLAN Group {self.vlan_group} is permitted.",
             response.data["detail"],
         )
+        invalid_id = uuid.uuid4()
+        data[0]["vlan_group"] = invalid_id  # Invalid UUID
+        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"VLAN Group with pk {invalid_id} does not exist.",
+            response.data["detail"],
+        )
+
+    def test_create_available_vlans_with_permissions_constraint(self):
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.view_vlan",
+        )
+        self.add_permissions("ipam.add_vlan", constraints={"description__startswith": "This is the VLAN created for"})
+
+        data = {"name": "VLAN_6", "status": self.default_status.pk, "vid": 6}
+        invalid_data_list = [
+            data,
+            {**data, "description": ""},
+            {**data, "description": "Some description"},
+            {**data, "description": "Some description. This is the VLAN created for"},
+        ]
+
+        # Test invalid request
+        for invalid_data in invalid_data_list:
+            with self.subTest(case=invalid_data):
+                response = self.client.post(url, data, format="json", **self.header)
+                self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+                self.assertIn("detail", response.data)
+                self.assertEqual(response.data["detail"], "You do not have permission to perform this action.")
+
+                # Verify that no VLANs were created (number of VLANs is the same as on the beginning of the test)
+                response = self.client.get(url, **self.header)
+                self.assertHttpStatus(response, status.HTTP_200_OK)
+                self.assertEqual(len(response.data["results"]), len(self.unused_vids))
+
+        # Test valid request
+        valid_data = {
+            "name": "VLAN_6",
+            "status": self.default_status.pk,
+            "vid": 6,
+            "description": "This is the VLAN created for home automation.",
+        }
+        response = self.client.post(url, valid_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(response.data["results"]["name"], valid_data["name"])
+
+        # Verify that VLAN is created
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(
+            len(response.data["results"]), len(self.unused_vids) - 1
+        )  # initial unsued vids minus one created
+
+    def test_create_multiple_available_vlans_with_permissions_constraint(self):
+        url = reverse("ipam-api:vlangroup-available-vlans", kwargs={"pk": self.vlan_group.pk})
+        self.add_permissions(
+            "ipam.view_vlangroup",
+            "ipam.view_vlan",
+        )
+        self.add_permissions("ipam.add_vlan", constraints={"description__startswith": "This is the VLAN created for"})
+
+        # Test invalid request
+        data = [
+            {"name": "VLAN_6", "status": self.default_status.pk},
+            {"name": "VLAN_7", "status": self.default_status.pk},
+            {"name": "VLAN_8", "status": self.default_status.pk},
+        ]
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+        self.assertIn("detail", response.data)
+        self.assertEqual(response.data["detail"], "You do not have permission to perform this action.")
+
+        # Verify that no VLANs were created (number of VLANs is the same as on the beginning of the test)
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(len(response.data["results"]), len(self.unused_vids))
+
+        # Test valid request
+        valid_data = [
+            {
+                "name": "VLAN_6",
+                "status": self.default_status.pk,
+                "description": "This is the VLAN created for home automation.",
+            },
+            {
+                "name": "VLAN_7",
+                "status": self.default_status.pk,
+                "description": "This is the VLAN created for IP cameras.",
+            },
+            {"name": "VLAN_8", "status": self.default_status.pk, "description": "This is the VLAN created for guests."},
+        ]
+        response = self.client.post(url, valid_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(len(response.data["results"]), 3)
+        for i, vlan_data in enumerate(data):
+            self.assertEqual(response.data["results"][i]["name"], vlan_data["name"])
+
+        # Verify that VLANs are created
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(
+            len(response.data["results"]), len(self.unused_vids) - 3
+        )  # initial unsued vids minus three created
 
 
 class VLANTest(APIViewTestCases.APIViewTestCase):

nautobot/ipam/tests/test_forms.py

@@ -1,5 +1,6 @@
 """Test IPAM forms."""
 
+from django.forms import Form
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
@@ -9,62 +10,63 @@ from nautobot.ipam.choices import IPAddressTypeChoices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
 
 
-class BaseNetworkFormTest:
-    form_class = None
-    field_name = None
-    object_name = None
-    extra_data = {}
-
-    def setUp(self):
-        super().setUp()
-        self.namespace = Namespace.objects.create(name="IPAM Form Test")
-        self.status = Status.objects.get(name="Active")
-        self.prefix_status = Status.objects.get_for_model(Prefix).first()
-        self.ip_status = Status.objects.get_for_model(IPAddress).first()
-        self.parent = Prefix.objects.create(
-            prefix="192.168.1.0/24", namespace=self.namespace, status=self.prefix_status
-        )
-        self.parent2 = Prefix.objects.create(
-            prefix="192.168.0.0/16", namespace=self.namespace, status=self.prefix_status
-        )
-        self.parent6 = Prefix.objects.create(
-            prefix="2001:0db8::/40", namespace=self.namespace, status=self.prefix_status
-        )
+class NetworkFormTestCases:
+    class BaseNetworkFormTest(TestCase):
+        form_class: type[Form]
+        field_name: str
+        object_name: str
+        extra_data = {}
+
+        def setUp(self):
+            super().setUp()
+            self.namespace = Namespace.objects.create(name="IPAM Form Test")
+            self.status = Status.objects.get(name="Active")
+            self.prefix_status = Status.objects.get_for_model(Prefix).first()
+            self.ip_status = Status.objects.get_for_model(IPAddress).first()
+            self.parent = Prefix.objects.create(
+                prefix="192.168.1.0/24", namespace=self.namespace, status=self.prefix_status
+            )
+            self.parent2 = Prefix.objects.create(
+                prefix="192.168.0.0/16", namespace=self.namespace, status=self.prefix_status
+            )
+            self.parent6 = Prefix.objects.create(
+                prefix="2001:0db8::/40", namespace=self.namespace, status=self.prefix_status
+            )
 
-    def test_valid_ip_address(self):
-        data = {self.field_name: "192.168.2.0/24", "namespace": self.namespace, "status": self.status}
-        data.update(self.extra_data)
-        form = self.form_class(data)
+        def test_valid_ip_address(self):
+            data = {self.field_name: "192.168.2.0/24", "namespace": self.namespace, "status": self.status}
+            data.update(self.extra_data)
+            form = self.form_class(data)
 
-        self.assertTrue(form.is_valid())
-        self.assertTrue(form.save())
+            self.assertTrue(form.is_valid())
+            self.assertTrue(form.save())
 
-    def test_address_invalid_ipv4(self):
-        data = {self.field_name: "192.168.0.1/64", "namespace": self.namespace, "status": self.status}
-        data.update(self.extra_data)
-        form = self.form_class(data)
+        def test_address_invalid_ipv4(self):
+            data = {self.field_name: "192.168.0.1/64", "namespace": self.namespace, "status": self.status}
+            data.update(self.extra_data)
+            form = self.form_class(data)
 
-        self.assertFalse(form.is_valid())
-        self.assertEqual("Please specify a valid IPv4 or IPv6 address.", form.errors[self.field_name][0])
+            self.assertFalse(form.is_valid())
+            self.assertEqual("Please specify a valid IPv4 or IPv6 address.", form.errors[self.field_name][0])
 
-    def test_address_zero_mask(self):
-        data = {self.field_name: "192.168.0.1/0", "namespace": self.namespace, "status": self.status}
-        data.update(self.extra_data)
-        form = self.form_class(data)
+        def test_address_zero_mask(self):
+            data = {self.field_name: "192.168.0.1/0", "namespace": self.namespace, "status": self.status}
+            data.update(self.extra_data)
+            form = self.form_class(data)
 
-        # With the advent of `Prefix.parent`, it's now possible to create a /0 .
-        self.assertTrue(form.is_valid())
+            # With the advent of `Prefix.parent`, it's now possible to create a /0 .
+            self.assertTrue(form.is_valid())
 
-    def test_address_missing_mask(self):
-        data = {self.field_name: "192.168.0.1", "namespace": self.namespace, "status": self.status}
-        data.update(self.extra_data)
-        form = self.form_class(data)
+        def test_address_missing_mask(self):
+            data = {self.field_name: "192.168.0.1", "namespace": self.namespace, "status": self.status}
+            data.update(self.extra_data)
+            form = self.form_class(data)
 
-        self.assertFalse(form.is_valid())
-        self.assertEqual("CIDR mask (e.g. /24) is required.", form.errors[self.field_name][0])
+            self.assertFalse(form.is_valid())
+            self.assertEqual("CIDR mask (e.g. /24) is required.", form.errors[self.field_name][0])
 
 
-class PrefixFormTest(BaseNetworkFormTest, FormTestCases.BaseFormTestCase):
+class PrefixFormTest(NetworkFormTestCases.BaseNetworkFormTest, FormTestCases.BaseFormTestCase):
     form_class = forms.PrefixForm
     field_name = "prefix"
     object_name = "prefix"
@@ -79,7 +81,7 @@ class PrefixFormTest(BaseNetworkFormTest, FormTestCases.BaseFormTestCase):
         }
 
 
-class IPAddressFormTest(BaseNetworkFormTest, TestCase):
+class IPAddressFormTest(NetworkFormTestCases.BaseNetworkFormTest):
     form_class = forms.IPAddressForm
     field_name = "address"
     object_name = "IP address"