nautobot 2.3.15b1__py3-none-any.whl → 2.4.0__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,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"

nautobot/ipam/tests/test_migrations.py

@@ -29,29 +29,29 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
             request_id=uuid.uuid4(),
         )
 
-    def populateDataBeforeMigration(self, apps):
+    def populateDataBeforeMigration(self, installed_apps):
         """Populate Aggregate data before migrating to Prefixes"""
 
-        self.aggregate = apps.get_model("ipam", "Aggregate")
+        self.aggregate = installed_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 = 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.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.prefix.tags = TagsField()
-        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.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.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")
-        self.aggregate6.tags.add("AggregateTagB")
+        self.aggregate5.tags.add("AggregateTagA", "AggregateTagB")  # pylint: disable=no-member
+        self.aggregate6.tags.add("AggregateTagB")  # pylint: disable=no-member
 
         # 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,
+            assigned_object_id=self.aggregate5.id,  # pylint: disable=no-member
         )
 
         # 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")
-        self._create_objectchange(self.aggregate5, "Pre-migration object change for aggregate5")
+        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
 
         # 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"
-        self.prefix5._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 prefix5"
+        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.aggregate5._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate5"
-        self.aggregate5._custom_field_data["aggregatecf1"] = "testdata aggregatecf1 aggregate5"
+        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.aggregate6._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate6"
+        self.aggregate6._custom_field_data["prefixaggregatecf1"] = "testdata prefixaggregatecf1 aggregate6"  # pylint: disable=no-member
 
         self.prefix1.save()
         self.prefix2.save()
         self.prefix3.save()
         self.prefix4.save()
-        self.prefix5.save()
+        self.prefix5.save()  # pylint: disable=no-member
         self.aggregate1.save()
         self.aggregate2.save()
         self.aggregate3.save()
-        self.aggregate5.save()
-        self.aggregate6.save()
+        self.aggregate5.save()  # pylint: disable=no-member
+        self.aggregate6.save()  # pylint: disable=no-member
 
     @skipIf(
         connection.vendor != "postgresql",
@@ -390,7 +390,7 @@ class AggregateToPrefixMigrationTestCase(NautobotDataMigrationTest):
                 2,
             )
 
-        for prefix in (self.prefix2, self.prefix3, self.prefix5):
+        for prefix in (self.prefix2, self.prefix3, self.prefix5):  # pylint: disable=no-member
             self.assertEqual(
                 self.object_change.objects.filter(changed_object_id=prefix.id).count(),
                 1,

nautobot/ipam/tests/test_models.py

@@ -416,10 +416,13 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
 
     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="101.102.0.128/26",
+            status=self.status,
+            namespace=self.namespace,
+            type=PrefixTypeChoices.TYPE_CONTAINER,
         )
         prefix.clean()
-        self.assertEqual(prefix.parent, self.child1)
+        self.assertEqual(prefix.parent, self.root)
 
     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"""
@@ -510,51 +513,68 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         """Test the various ways of creating a Prefix all result in correctly populated fields."""
         with self.subTest("Creation with a prefix and status"):
             prefix = Prefix(prefix="192.0.3.0/24", status=self.status)
-            prefix.save()
-            self.assertEqual(prefix.network, "192.0.3.0")
-            self.assertEqual(prefix.broadcast, "192.0.3.255")
-            self.assertEqual(prefix.prefix_length, 24)
-            self.assertEqual(prefix.type, PrefixTypeChoices.TYPE_NETWORK)  # default value
-            # parent field is tested exhaustively below
-            self.assertEqual(prefix.ip_version, 4)
-            self.assertEqual(prefix.namespace, get_default_namespace())  # default value
+            for method in [prefix.clean, prefix.save, prefix.refresh_from_db]:
+                method()
+                self.assertEqual(prefix.network, "192.0.3.0")
+                self.assertEqual(prefix.broadcast, "192.0.3.255")
+                self.assertEqual(prefix.prefix_length, 24)
+                self.assertEqual(prefix.type, PrefixTypeChoices.TYPE_NETWORK)  # default value
+                # parent field is tested exhaustively below
+                self.assertEqual(prefix.ip_version, 4)
+                self.assertEqual(prefix.namespace, get_default_namespace())  # default value
+
+        with self.subTest("Creation with a network and prefix_length"):
+            prefix = Prefix(network="192.0.4.0", prefix_length=24, status=self.status)
+            for method in [prefix.clean, prefix.save, prefix.refresh_from_db]:
+                method()
+                self.assertEqual(prefix.network, "192.0.4.0")
+                self.assertEqual(prefix.broadcast, "192.0.4.255")
+                self.assertEqual(prefix.prefix_length, 24)
+                self.assertEqual(prefix.type, PrefixTypeChoices.TYPE_NETWORK)  # default value
+                # parent field is tested exhaustively below
+                self.assertEqual(prefix.ip_version, 4)
+                self.assertEqual(prefix.namespace, get_default_namespace())  # default value
+                self.assertEqual(prefix.prefix, netaddr.IPNetwork("192.0.4.0/24"))
 
         with self.subTest("Creation with a network, broadcast, and prefix_length"):
-            prefix = Prefix(network="192.0.4.0", broadcast="192.0.4.255", prefix_length=24, status=self.status)
-            prefix.save()
-            self.assertEqual(prefix.network, "192.0.4.0")
-            self.assertEqual(prefix.broadcast, "192.0.4.255")
-            self.assertEqual(prefix.prefix_length, 24)
-            self.assertEqual(prefix.type, PrefixTypeChoices.TYPE_NETWORK)  # default value
-            # parent field is tested exhaustively below
-            self.assertEqual(prefix.ip_version, 4)
-            self.assertEqual(prefix.namespace, get_default_namespace())  # default value
-            self.assertEqual(prefix.prefix, netaddr.IPNetwork("192.0.4.0/24"))
-
-        with self.subTest("Creation with conflicting values - prefix takes precedence"):
+            prefix = Prefix(network="192.0.5.0", broadcast="192.0.5.255", prefix_length=24, status=self.status)
+            for method in [prefix.clean, prefix.save, prefix.refresh_from_db]:
+                method()
+                self.assertEqual(prefix.network, "192.0.5.0")
+                self.assertEqual(prefix.broadcast, "192.0.5.255")
+                self.assertEqual(prefix.prefix_length, 24)
+                self.assertEqual(prefix.type, PrefixTypeChoices.TYPE_NETWORK)  # default value
+                # parent field is tested exhaustively below
+                self.assertEqual(prefix.ip_version, 4)
+                self.assertEqual(prefix.namespace, get_default_namespace())  # default value
+                self.assertEqual(prefix.prefix, netaddr.IPNetwork("192.0.5.0/24"))
+
+        with self.subTest("With conflicting values - prefix overrules network/broadcast/prefix_length/ip_version"):
             prefix = Prefix(
-                prefix="192.0.5.0/24",
+                prefix="192.0.6.0/24",
                 status=self.status,
                 network="1.1.1.1",
                 broadcast="2.2.2.2",
                 prefix_length=27,
                 ip_version=6,
             )
-            prefix.save()
-            self.assertEqual(prefix.network, "192.0.5.0")
-            self.assertEqual(prefix.broadcast, "192.0.5.255")
-            self.assertEqual(prefix.prefix_length, 24)
-            self.assertEqual(prefix.ip_version, 4)
-
-        with self.subTest("Creation with conflicting values - network and prefix_length take precedence"):
+            for method in [prefix.clean, prefix.save, prefix.refresh_from_db]:
+                method()
+                self.assertEqual(prefix.network, "192.0.6.0")
+                self.assertEqual(prefix.broadcast, "192.0.6.255")
+                self.assertEqual(prefix.prefix_length, 24)
+                self.assertEqual(prefix.ip_version, 4)
+
+        with self.subTest("With conflicting values - network/prefix_length overrule broadcast/ip_version"):
             prefix = Prefix(
-                status=self.status, network="192.0.6.0", prefix_length=24, broadcast="192.0.6.127", ip_version=6
+                status=self.status, network="192.0.7.0", prefix_length=24, broadcast="192.0.7.127", ip_version=6
             )
-            prefix.save()
-            self.assertEqual(prefix.network, "192.0.6.0")
-            self.assertEqual(prefix.broadcast, "192.0.6.255")
-            self.assertEqual(prefix.prefix_length, 24)
-            self.assertEqual(prefix.ip_version, 4)
+            for method in [prefix.clean, prefix.save, prefix.refresh_from_db]:
+                method()
+                self.assertEqual(prefix.network, "192.0.7.0")
+                self.assertEqual(prefix.broadcast, "192.0.7.255")
+                self.assertEqual(prefix.prefix_length, 24)
+                self.assertEqual(prefix.ip_version, 4)
 
     def test_tree_methods(self):
         """Test the various tree methods work as expected."""

nautobot/ipam/tests/test_querysets.py

@@ -478,6 +478,20 @@ 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()

nautobot/ipam/tests/test_views.py

@@ -1054,6 +1054,9 @@ class VLANGroupTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
     def get_deletable_object(self):
         return VLANGroup.objects.create(name="TEST DELETE ME")
 
+    def get_deletable_object_pks(self):
+        return [VLANGroup.objects.create(name="TEST DELETE ME").pk]
+
 
 class VLANTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = VLAN