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

nautobot/ipam/tests/test_api.py

@@ -2,7 +2,6 @@ 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
@@ -349,8 +348,6 @@ 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,
@@ -509,8 +506,7 @@ 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)
-        self.assertEqual(response.data["prefix_length"], "This field must be an integer.")
+        self.assertIn("prefix_length", response.data[0])
 
     def test_create_multiple_available_prefixes(self):
         """
@@ -575,126 +571,6 @@ 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.
@@ -718,76 +594,9 @@ 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 creating single IP will return 204 No content when pool is fully filled.
+        Test retrieval of the first available IP address within a parent prefix.
         """
         prefix = Prefix.objects.create(
             prefix="192.0.2.0/29",
@@ -855,116 +664,6 @@ 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)
-
 
 class PrefixLocationAssignmentTest(APIViewTestCases.APIViewTestCase):
     model = PrefixLocationAssignment
@@ -1323,7 +1022,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", "ipam.view_vlan")
+        self.add_permissions("ipam.view_vlangroup")
 
         # Retrieve all available VLAN IDs
         response = self.client.get(url, **self.header)
@@ -1340,7 +1039,6 @@ 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",
         )
 
@@ -1382,7 +1080,6 @@ 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",
         )
 
@@ -1429,7 +1126,6 @@ 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",
         )
 
@@ -1459,7 +1155,6 @@ 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",
         )
 
@@ -1486,114 +1181,6 @@ 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,6 +1,5 @@
 """Test IPAM forms."""
 
-from django.forms import Form
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
@@ -10,63 +9,62 @@ from nautobot.ipam.choices import IPAddressTypeChoices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
 
 
-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
-            )
+class BaseNetworkFormTest:
+    form_class = None
+    field_name = None
+    object_name = None
+    extra_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)
+    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
+        )
 
-            self.assertTrue(form.is_valid())
-            self.assertTrue(form.save())
+    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_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.assertTrue(form.is_valid())
+        self.assertTrue(form.save())
 
-            self.assertFalse(form.is_valid())
-            self.assertEqual("Please specify a valid IPv4 or IPv6 address.", form.errors[self.field_name][0])
+    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_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)
+        self.assertFalse(form.is_valid())
+        self.assertEqual("Please specify a valid IPv4 or IPv6 address.", form.errors[self.field_name][0])
 
-            # With the advent of `Prefix.parent`, it's now possible to create a /0 .
-            self.assertTrue(form.is_valid())
+    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_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)
+        # With the advent of `Prefix.parent`, it's now possible to create a /0 .
+        self.assertTrue(form.is_valid())
 
-            self.assertFalse(form.is_valid())
-            self.assertEqual("CIDR mask (e.g. /24) is required.", form.errors[self.field_name][0])
+    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])
 
 
-class PrefixFormTest(NetworkFormTestCases.BaseNetworkFormTest, FormTestCases.BaseFormTestCase):
+class PrefixFormTest(BaseNetworkFormTest, FormTestCases.BaseFormTestCase):
     form_class = forms.PrefixForm
     field_name = "prefix"
     object_name = "prefix"
@@ -81,7 +79,7 @@ class PrefixFormTest(NetworkFormTestCases.BaseNetworkFormTest, FormTestCases.Bas
         }
 
 
-class IPAddressFormTest(NetworkFormTestCases.BaseNetworkFormTest):
+class IPAddressFormTest(BaseNetworkFormTest, TestCase):
     form_class = forms.IPAddressForm
     field_name = "address"
     object_name = "IP address"