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

nautobot/ipam/tests/test_filters.py

@@ -65,45 +65,20 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
     tenancy_related_name = "vrfs"
     # skip testing "rd" attribute for generic q filter test as it's not trivially modifiable
     exclude_q_filter_predicates = ["rd"]
+    generic_filter_tests = (
+        ("export_targets", "export_targets__id"),
+        ("export_targets", "export_targets__name"),
+        ("import_targets", "import_targets__id"),
+        ("import_targets", "import_targets__name"),
+        ("name",),
+        ("rd",),
+    )
 
     @classmethod
     def setUpTestData(cls):
         instance = cls.queryset.first()
         instance.tags.set(Tag.objects.all()[:2])
 
-    def test_name(self):
-        names = list(self.queryset.values_list("name", flat=True))[:2]
-        params = {"name": names}
-        self.assertQuerysetEqual(self.filterset(params, self.queryset).qs, self.queryset.filter(name__in=names))
-
-    def test_rd(self):
-        vrfs = self.queryset.filter(rd__isnull=False)[:2]
-        params = {"rd": [vrfs[0].rd, vrfs[1].rd]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-    def test_import_targets(self):
-        route_targets = list(RouteTarget.objects.filter(importing_vrfs__isnull=False).distinct())[:2]
-        params = {"import_targets": [route_targets[0].pk, route_targets[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(import_targets__in=route_targets).distinct(),
-            ordered=False,
-        )
-
-    def test_export_targets(self):
-        route_targets = list(RouteTarget.objects.filter(exporting_vrfs__isnull=False).distinct())[:2]
-        params = {"export_targets": [route_targets[0].pk, route_targets[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(export_targets__in=route_targets).distinct(),
-            ordered=False,
-        )
-
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class RouteTargetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RouteTarget.objects.all()
@@ -111,44 +86,27 @@ class RouteTargetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.Tenanc
     tenancy_related_name = "route_targets"
     # skip testing "name" attribute for generic q filter test as it's not trivially modifiable
     exclude_q_filter_predicates = ["name"]
+    generic_filter_tests = (
+        ("exporting_vrfs", "exporting_vrfs__id"),
+        ("exporting_vrfs", "exporting_vrfs__rd"),
+        ("importing_vrfs", "importing_vrfs__id"),
+        ("importing_vrfs", "importing_vrfs__rd"),
+        ("name",),
+    )
 
     @classmethod
     def setUpTestData(cls):
         instance = cls.queryset.first()
         instance.tags.set(Tag.objects.all()[:2])
 
-    def test_name(self):
-        params = {"name": [self.queryset[0].name, self.queryset[1].name, self.queryset[2].name]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
-
-    def test_importing_vrfs(self):
-        vrfs = list(VRF.objects.filter(import_targets__isnull=False, rd__isnull=False).distinct())[:2]
-        params = {"importing_vrfs": [vrfs[0].pk, vrfs[1].rd]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs, self.queryset.filter(importing_vrfs__in=vrfs).distinct()
-        )
 
-    def test_exporting_vrfs(self):
-        vrfs = list(VRF.objects.filter(export_targets__isnull=False, rd__isnull=False).distinct())[:2]
-        params = {"exporting_vrfs": [vrfs[0].pk, vrfs[1].rd]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs, self.queryset.filter(exporting_vrfs__in=vrfs).distinct()
-        )
-
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
-
-class RIRTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class RIRTestCase(FilterTestCases.FilterTestCase):
     queryset = RIR.objects.all()
     filterset = RIRFilterSet
-
-    def test_description(self):
-        descriptions = self.queryset.exclude(description="").values_list("description", flat=True)[:2]
-        params = {"description": list(descriptions)}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+    generic_filter_tests = (
+        ("description",),
+        ("name",),
+    )
 
     def test_is_private(self):
         params = {"is_private": "true"}
@@ -224,8 +182,8 @@ class PrefixTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilt
 class PrefixLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
     queryset = PrefixLocationAssignment.objects.all()
     filterset = PrefixLocationAssignmentFilterSet
-
     # NOTE: No generic logic in place yet to test TreeNodeMultipleChoiceFilter
+    generic_filter_tests = ()
     # generic_filter_tests = (
     #     ["location", "location__name"],
     #     ["location", "location__id"],
@@ -1022,9 +980,16 @@ class IPAddressToInterfaceTestCase(FilterTestCases.FilterTestCase):
                 )
 
 
-class VLANGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class VLANGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = VLANGroup.objects.all()
     filterset = VLANGroupFilterSet
+    generic_filter_tests = (
+        ("description",),
+        # NOTE: No generic logic in place yet to test TreeNodeMultipleChoiceFilter
+        # ("location", "location__id"),
+        # ("location", "location__name"),
+        ("name",),
+    )
 
     @classmethod
     def setUpTestData(cls):
@@ -1044,26 +1009,21 @@ class VLANGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
         VLANGroup.objects.create(name="VLAN Group 3", location=cls.locations[2], description="C")
         VLANGroup.objects.create(name="VLAN Group 4", location=None)
 
-    def test_description(self):
-        descriptions = list(VLANGroup.objects.exclude(description="").values_list("description", flat=True)[:2])
-        params = {"description": descriptions}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-    def test_location(self):
-        params = {"location": [self.locations[0].pk, self.locations[1].pk]}
-        self.assertQuerysetEqual(
-            self.filterset(params, self.queryset).qs, self.queryset.filter(location__in=params["location"])
-        )
-        params = {"location": [self.locations[0].name, self.locations[1].name]}
-        self.assertQuerysetEqual(
-            self.filterset(params, self.queryset).qs, self.queryset.filter(location__name__in=params["location"])
-        )
-
 
 class VLANTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = VLAN.objects.all()
     filterset = VLANFilterSet
     tenancy_related_name = "vlans"
+    generic_filter_tests = (
+        ("name",),
+        ("role", "role__id"),
+        ("role", "role__name"),
+        ("status", "status__id"),
+        ("status", "status__name"),
+        ("vid",),
+        ("vlan_group", "vlan_group__id"),
+        ("vlan_group", "vlan_group__name"),
+    )
 
     @classmethod
     def setUpTestData(cls):
@@ -1149,16 +1109,6 @@ class VLANTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
         vlans[0].tags.set(Tag.objects.all()[:2])
         vlans[1].tags.set(Tag.objects.all()[:2])
 
-    def test_name(self):
-        names = list(VLAN.objects.all().values_list("name", flat=True)[:2])
-        params = {"name": names}
-        self.assertQuerysetEqual(self.filterset(params, self.queryset).qs, self.queryset.filter(name__in=names))
-
-    def test_vid(self):
-        vids = list(VLAN.objects.all().values_list("vid", flat=True)[:3])
-        params = {"vid": vids}
-        self.assertQuerysetEqual(self.filterset(params, self.queryset).qs, self.queryset.filter(vid__in=vids))
-
     def test_location(self):
         params = {"location": [self.locations[0].pk, self.locations[1].pk]}
         self.assertQuerysetEqual(
@@ -1181,31 +1131,6 @@ class VLANTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilter
             self.queryset.filter(locations__name__in=params["locations"]).distinct(),
         )
 
-    def test_vlan_group(self):
-        groups = list(VLANGroup.objects.filter(vlans__isnull=False).distinct())[:2]
-        filter_params = [{"vlan_group": [groups[0].pk, groups[1].pk]}, {"vlan_group": [groups[0].pk, groups[1].name]}]
-        for params in filter_params:
-            self.assertQuerysetEqualAndNotEmpty(
-                self.filterset(params, self.queryset).qs, self.queryset.filter(vlan_group__in=groups)
-            )
-
-    def test_role(self):
-        roles = Role.objects.get_for_model(VLAN)[:2]
-        params = {"role": [roles[0].pk, roles[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs, self.queryset.filter(role__in=[roles[0], roles[1]])
-        )
-
-    def test_status(self):
-        statuses = list(Status.objects.get_for_model(VLAN).filter(vlans__isnull=False).distinct())[:2]
-        params = {"status": [statuses[0].name, statuses[1].id]}
-        self.assertQuerysetEqual(self.filterset(params, self.queryset).qs, self.queryset.filter(status__in=statuses))
-
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
     def test_available_on_device(self):
         manufacturer = Manufacturer.objects.first()
         devicetype = DeviceType.objects.create(manufacturer=manufacturer, model="Device Type 1")
@@ -1361,8 +1286,3 @@ class ServiceTestCase(FilterTestCases.FilterTestCase):
     def test_ports(self):
         params = {"ports": "1001"}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)

nautobot/ipam/tests/test_forms.py

@@ -1,8 +1,5 @@
 """Test IPAM forms."""
 
-from __future__ import annotations  # python 3.8
-
-from django.forms import Form
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
@@ -12,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"
@@ -83,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"

nautobot/ipam/tests/test_migrations.py

@@ -29,29 +29,29 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
             request_id=uuid.uuid4(),
         )
 
-    def populateDataBeforeMigration(self, installed_apps):
+    def populateDataBeforeMigration(self, apps):
         """Populate Aggregate data before migrating to Prefixes"""
 
-        self.aggregate = installed_apps.get_model("ipam", "Aggregate")
+        self.aggregate = apps.get_model("ipam", "Aggregate")
         # Workaround for django-taggit manager not working in migrations.
         # https://github.com/jazzband/django-taggit/issues/101
         # https://github.com/jazzband/django-taggit/issues/454
         self.aggregate.tags = TagsField()
-        self.computed_field = installed_apps.get_model("extras", "computedfield")
-        self.content_type = installed_apps.get_model("contenttypes", "ContentType")
-        self.custom_field = installed_apps.get_model("extras", "customfield")
-        self.custom_link = installed_apps.get_model("extras", "customlink")
-        self.dynamic_group = installed_apps.get_model("extras", "DynamicGroup")
-        self.note = installed_apps.get_model("extras", "note")
-        self.object_change = installed_apps.get_model("extras", "objectchange")
-        self.object_permission = installed_apps.get_model("users", "objectpermission")
-        self.prefix = installed_apps.get_model("ipam", "prefix")
+        self.computed_field = apps.get_model("extras", "computedfield")
+        self.content_type = apps.get_model("contenttypes", "ContentType")
+        self.custom_field = apps.get_model("extras", "customfield")
+        self.custom_link = apps.get_model("extras", "customlink")
+        self.dynamic_group = apps.get_model("extras", "DynamicGroup")
+        self.note = apps.get_model("extras", "note")
+        self.object_change = apps.get_model("extras", "objectchange")
+        self.object_permission = apps.get_model("users", "objectpermission")
+        self.prefix = apps.get_model("ipam", "prefix")
         self.prefix.tags = TagsField()
-        self.relationship = installed_apps.get_model("extras", "relationship")
-        self.relationship_association = installed_apps.get_model("extras", "relationshipassociation")
-        self.rir = installed_apps.get_model("ipam", "RIR")
-        self.status = installed_apps.get_model("extras", "status")
-        self.tag = installed_apps.get_model("extras", "tag")
+        self.relationship = apps.get_model("extras", "relationship")
+        self.relationship_association = apps.get_model("extras", "relationshipassociation")
+        self.rir = apps.get_model("ipam", "RIR")
+        self.status = apps.get_model("extras", "status")
+        self.tag = apps.get_model("extras", "tag")
 
         self.aggregate_ct = self.content_type.objects.get_for_model(self.aggregate)
         self.prefix_ct = self.content_type.objects.get_for_model(self.prefix)
@@ -114,8 +114,8 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
         self.aggregate1.tags.add("AggregateTagA", "AggregateTagB")
         self.aggregate2.tags.add("AggregateTagA")
         self.aggregate3.tags.add("AggregateTagB")
-        self.aggregate5.tags.add("AggregateTagA", "AggregateTagB")  # pylint: disable=no-member
-        self.aggregate6.tags.add("AggregateTagB")  # pylint: disable=no-member
+        self.aggregate5.tags.add("AggregateTagA", "AggregateTagB")
+        self.aggregate6.tags.add("AggregateTagB")
 
         # notes
         self.note.objects.create(
@@ -141,7 +141,7 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
         self.note.objects.create(
             note="Aggregate5 test note",
             assigned_object_type=self.aggregate_ct,
-            assigned_object_id=self.aggregate5.id,  # pylint: disable=no-member
+            assigned_object_id=self.aggregate5.id,
         )
 
         # object permissions
@@ -157,8 +157,8 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
         # object changes
         self._create_objectchange(self.prefix1, "Pre-migration object change for prefix1")
         self._create_objectchange(self.prefix4, "Pre-migration object change for prefix4")
-        self._create_objectchange(self.prefix5, "Pre-migration object change for prefix5")  # pylint: disable=no-member
-        self._create_objectchange(self.aggregate5, "Pre-migration object change for aggregate5")  # pylint: disable=no-member
+        self._create_objectchange(self.prefix5, "Pre-migration object change for prefix5")
+        self._create_objectchange(self.aggregate5, "Pre-migration object change for aggregate5")
 
         # custom fields
         prefix_cf1 = self.custom_field.objects.create(name="prefixcf1")
@@ -179,24 +179,24 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
 
         self.aggregate3._custom_field_data["aggregatecf1"] = "testdata aggregatecf1 aggregate3"
 
-        self.prefix5._custom_field_data["prefixcf1"] = "testdata prefixcf1 prefix5"  # pylint: disable=no-member
-        self.prefix5._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 prefix5"  # pylint: disable=no-member
+        self.prefix5._custom_field_data["prefixcf1"] = "testdata prefixcf1 prefix5"
+        self.prefix5._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 prefix5"
 
-        self.aggregate5._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate5"  # pylint: disable=no-member
-        self.aggregate5._custom_field_data["aggregatecf1"] = "testdata aggregatecf1 aggregate5"  # pylint: disable=no-member
+        self.aggregate5._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate5"
+        self.aggregate5._custom_field_data["aggregatecf1"] = "testdata aggregatecf1 aggregate5"
 
-        self.aggregate6._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate6"  # pylint: disable=no-member
+        self.aggregate6._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate6"
 
         self.prefix1.save()
         self.prefix2.save()
         self.prefix3.save()
         self.prefix4.save()
-        self.prefix5.save()  # pylint: disable=no-member
+        self.prefix5.save()
         self.aggregate1.save()
         self.aggregate2.save()
         self.aggregate3.save()
-        self.aggregate5.save()  # pylint: disable=no-member
-        self.aggregate6.save()  # pylint: disable=no-member
+        self.aggregate5.save()
+        self.aggregate6.save()
 
     @skipIf(
         connection.vendor != "postgresql",
@@ -390,7 +390,7 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
                 2,
             )
 
-        for prefix in (self.prefix2, self.prefix3, self.prefix5):  # pylint: disable=no-member
+        for prefix in (self.prefix2, self.prefix3, self.prefix5):
             self.assertEqual(
                 self.object_change.objects.filter(changed_object_id=prefix.id).count(),
                 1,

nautobot/ipam/tests/test_models.py

@@ -1,5 +1,4 @@
 from unittest import skipIf
-from unittest.mock import patch
 
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
@@ -414,39 +413,6 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         self.child1 = Prefix.objects.create(prefix="101.102.0.0/26", status=self.status, namespace=self.namespace)
         self.child2 = Prefix.objects.create(prefix="101.102.0.64/26", status=self.status, namespace=self.namespace)
 
-    def test_parent_exists_after_model_clean(self):
-        prefix = Prefix(
-            prefix="101.102.0.2/26", status=self.status, namespace=self.namespace, type=PrefixTypeChoices.TYPE_CONTAINER
-        )
-        prefix.clean()
-        self.assertEqual(prefix.parent, self.child1)
-
-    def test_reparent_subnets_and_reparent_ips_call(self):
-        """Assert reparent_subnets and reparent_ips are only called if there is an update to either of network, namespace or prefix_length"""
-        prefix_ip = "101.102.0.0/28"
-        with self.subTest("Assert reparent_subnets"):
-            with patch.object(Prefix, "reparent_subnets", return_value=None) as mock_reparent_subnets:
-                Prefix.objects.create(prefix=prefix_ip, status=self.status, namespace=self.namespace)
-                mock_reparent_subnets.assert_called_once()
-
-            with patch.object(Prefix, "reparent_subnets", return_value=None) as mock_reparent_subnets:
-                prefix = Prefix.objects.get(prefix=prefix_ip)
-                prefix.description = "Sample Description"
-                prefix.save()
-                mock_reparent_subnets.assert_not_called()
-                prefix.delete()
-
-        with self.subTest("Assert reparent_ips"):
-            with patch.object(Prefix, "reparent_ips", return_value=None) as reparent_ips:
-                Prefix.objects.create(prefix=prefix_ip, status=self.status, namespace=self.namespace)
-                reparent_ips.assert_called_once()
-
-            with patch.object(Prefix, "reparent_ips", return_value=None) as reparent_ips:
-                prefix = Prefix.objects.get(prefix=prefix_ip)
-                prefix.description = "Sample Description"
-                prefix.save()
-                reparent_ips.assert_not_called()
-
     def test_location_queries(self):
         locations = Location.objects.all()[:4]
         for location in locations:
@@ -800,13 +766,6 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         IPAddress.objects.create(address="10.0.0.4/24", status=self.status, namespace=self.namespace)
         self.assertEqual(parent_prefix.get_first_available_ip(), "10.0.0.5/24")
 
-    def test_get_first_available_ip_calculate_child_ips(self):
-        parent_prefix = Prefix.objects.create(prefix="10.0.3.0/29", status=self.status, namespace=self.namespace)
-        Prefix.objects.create(prefix="10.0.3.0/30", status=self.status, namespace=self.namespace)
-        IPAddress(address="10.0.3.1/30", status=self.status, namespace=self.namespace).save()
-
-        self.assertEqual(parent_prefix.get_first_available_ip(), "10.0.3.2/29")
-
     def test_get_utilization(self):
         # Container Prefix
         prefix = Prefix.objects.create(

nautobot/ipam/tests/test_querysets.py

@@ -1,15 +1,13 @@
 import re
 from unittest import skipIf
 
-from django.contrib.contenttypes.models import ContentType
-from django.db import connection, transaction
+from django.db import connection
 import netaddr
 
 from nautobot.core.testing import TestCase
 from nautobot.extras.models import Status
 from nautobot.ipam import choices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
-from nautobot.users.models import ObjectPermission
 
 
 class IPAddressQuerySet(TestCase):
@@ -268,28 +266,6 @@ class IPAddressQuerySet(TestCase):
             [instance for ip, instance in self.ips.items() if "10.0.0" in ip],
         )
 
-    def test_lookup_not_ambiguous(self):
-        """Check for issues like https://github.com/nautobot/nautobot/issues/5166."""
-        obj_perm = ObjectPermission.objects.create(name="Test Permission", constraints={}, actions=["view"])
-        obj_perm.object_types.add(ContentType.objects.get_for_model(IPAddress))
-        obj_perm.users.add(self.user)
-        queryset = IPAddress.objects.select_related("parent", "nat_inside", "status")
-
-        for permission_constraint in (
-            {"host__family": 4},
-            {"host__net_host": "10.0.0.1"},
-            {"host__net_host_contained": "10.0.0.0/24"},
-            {"host__net_in": ["10.0.0.0/24"]},
-        ):
-            with self.subTest(permission_type=next(iter(permission_constraint.keys()))):
-                try:
-                    with transaction.atomic():
-                        obj_perm.constraints = permission_constraint
-                        obj_perm.save()
-                        list(queryset.restrict(self.user, "view"))
-                finally:
-                    delattr(self.user, "_object_perm_cache")
-
     @skipIf(
         connection.vendor == "postgresql",
         "Not currently supported on postgresql",
@@ -478,20 +454,6 @@ class IPAddressQuerySet(TestCase):
             [instance for ip, instance in self.ips.items() if re.match(r"2001(.*)1", ip)],
         )
 
-    def test_get_or_create(self):
-        # https://github.com/nautobot/nautobot/issues/6676
-        ip_obj, created = IPAddress.objects.update_or_create(
-            defaults={
-                "status": self.ipaddr_status,
-            },
-            host="10.0.0.1",
-            mask_length="24",
-            namespace=self.namespace,
-        )
-        self.assertFalse(created)
-        self.assertEqual(str(ip_obj.address), "10.0.0.1/24")
-        self.assertEqual(ip_obj.parent.namespace, self.namespace)
-
 
 class PrefixQuerysetTestCase(TestCase):
     queryset = Prefix.objects.all()
@@ -686,30 +648,6 @@ class PrefixQuerysetTestCase(TestCase):
         prefix = Prefix.objects.filter(network__net_equals="192.168.0.0/16")[0]
         self.assertEqual(Prefix.objects.filter(prefix="192.168.0.0/16")[0], prefix)
 
-    def test_lookup_not_ambiguous(self):
-        """Check for issues like https://github.com/nautobot/nautobot/issues/5166."""
-        obj_perm = ObjectPermission.objects.create(name="Test Permission", constraints={}, actions=["view"])
-        obj_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
-        obj_perm.users.add(self.user)
-        queryset = Prefix.objects.select_related("parent", "rir", "role", "status", "namespace")
-
-        for permission_constraint in (
-            {"network__family": 4},
-            {"network__net_equals": "192.168.0.0/16"},
-            {"network__net_contained": "192.0.0.0/8"},
-            {"network__net_contained_or_equal": "192.0.0.0/8"},
-            {"network__net_contains": "192.168.3.192/32"},
-            {"network__net_contains_or_equals": "192.168.3.192/32"},
-        ):
-            with self.subTest(permission_type=next(iter(permission_constraint.keys()))):
-                try:
-                    with transaction.atomic():
-                        obj_perm.constraints = permission_constraint
-                        obj_perm.save()
-                        list(queryset.restrict(self.user, "view"))
-                finally:
-                    delattr(self.user, "_object_perm_cache")
-
     @skipIf(
         connection.vendor == "postgresql",
         "Not currently supported on postgresql",