nautobot 2.2.6__py3-none-any.whl → 2.2.8__py3-none-any.whl

nautobot/core/api/mixins.py

@@ -6,7 +6,7 @@ from django.core.exceptions import (
     MultipleObjectsReturned,
     ObjectDoesNotExist,
 )
-from django.db.models import AutoField
+from django.db.models import AutoField, Model
 from rest_framework.exceptions import ValidationError
 
 from nautobot.core.api.utils import dict_to_filter_params
@@ -70,6 +70,11 @@ class WritableSerializerMixin:
             # Strip the trailing slash and split on slashes, taking the last value as the PK.
             data = data.rstrip("/").split("/")[-1]
 
+        # If we're passing the validated_data from one serializer as input to another serializer,
+        # data might already be a model instance:
+        if isinstance(data, Model):
+            return {"pk": data.pk}
+
         try:
             # The int case here is taking into account for the User model we inherit from django
             pk = int(data) if isinstance(queryset.model._meta.pk, AutoField) else uuid.UUID(str(data))

nautobot/core/api/schema.py

@@ -4,7 +4,7 @@ import re
 from drf_spectacular.contrib.django_filters import DjangoFilterExtension
 from drf_spectacular.extensions import OpenApiSerializerFieldExtension
 from drf_spectacular.openapi import AutoSchema
-from drf_spectacular.plumbing import build_array_type, build_media_type_object, get_doc, is_serializer
+from drf_spectacular.plumbing import build_array_type, build_media_type_object, get_doc, is_serializer, list_hash
 from drf_spectacular.serializers import PolymorphicProxySerializerExtension
 from rest_framework import serializers
 from rest_framework.relations import ManyRelatedField
@@ -359,6 +359,8 @@ class ChoiceFieldFix(OpenApiSerializerFieldExtension):
             return {
                 "type": value_type,
                 "enum": list(choices.keys()),
+                # Used to deduplicate enums with the same set of choices, since drf-spectacular 0.27.2
+                "x-spec-enum-id": list_hash([(k, v) for k, v in choices.items() if k not in ("", None)]),
             }
         else:
             return {

nautobot/core/celery/__init__.py

@@ -109,7 +109,7 @@ def _import_jobs_from_git_repositories():
             and not GitRepository.objects.filter(slug=filename).exists()
         ):
             logger.warning("Deleting unmanaged (leftover?) Git repository clone at %s", filepath)
-            shutil.rmtree(filepath)
+            shutil.rmtree(filepath, ignore_errors=True)
 
     # Make sure all GitRepository records that include Jobs have up-to-date git clones, and load their jobs
     for repo in GitRepository.objects.filter(provided_contents__contains="extras.job"):

nautobot/core/graphql/generators.py

@@ -55,12 +55,12 @@ def generate_null_choices_resolver(name, resolver_name):
 
 def generate_filter_resolver(schema_type, resolver_name, field_name):
     """
-    Generate function to resolve OneToMany filtering.
+    Generate function to resolve filtering of ManyToOne and ManyToMany related objects.
 
     Args:
         schema_type (DjangoObjectType): DjangoObjectType for a given model
         resolver_name (str): name of the resolver
-        field_name (str): name of OneToMany field to filter
+        field_name (str): name of ManyToOneField, ManyToManyRel, or ManyToOneRel field to filter
     """
     filterset_class = schema_type._meta.filterset_class
 

nautobot/core/graphql/schema.py

@@ -6,7 +6,8 @@ import logging
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.validators import ValidationError
-from django.db.models.fields.reverse_related import ManyToOneRel, OneToOneRel
+from django.db.models import ManyToManyField
+from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel, OneToOneRel
 import graphene
 from graphene.types import generic
 
@@ -198,9 +199,11 @@ def extend_schema_type_filter(schema_type, model):
         (DjangoObjectType): The extended schema_type object
     """
     for field in model._meta.get_fields():
-        # Check attribute is a ManyToOne field
-        # OneToOneRel is a subclass of ManyToOneRel, but we don't want to treat is as a list
-        if not isinstance(field, ManyToOneRel) or isinstance(field, OneToOneRel):
+        # Check whether attribute is a ManyToOne or ManyToMany field
+        if not isinstance(field, (ManyToManyField, ManyToManyRel, ManyToOneRel)):
+            continue
+        # OneToOneRel is a subclass of ManyToOneRel, but we don't want to treat it as a list
+        if isinstance(field, OneToOneRel):
             continue
         child_schema_type = registry["graphql_types"].get(field.related_model._meta.label_lower)
         if child_schema_type:

nautobot/core/tests/integration/test_general_functionality.py

@@ -0,0 +1,36 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase
+
+
+class StaticMediaFailureTestCase(SeleniumTestCase):
+    """Integration test to make sure no static media failures are encountered."""
+
+    def setUp(self):
+        super().setUp()
+        self.user.is_superuser = True
+        self.user.is_staff = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+    def tearDown(self):
+        self.logout()
+        super().tearDown()
+
+    def test_for_static_media_failure(self):
+        test_urls = [
+            reverse("home"),
+            reverse("api-root"),
+            reverse("graphql"),
+            reverse("api_docs"),
+            "/admin/",
+            "/static/docs/overview/index.html",
+        ]
+        for url in test_urls:
+            with self.subTest(test_url=url):
+                self.browser.visit(self.live_server_url + url)
+                # Wait for body element to appear
+                self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=10), "Page failed to load")
+                # Ensure we weren't redirected to another page
+                self.assertEqual(self.browser.url, self.live_server_url + url)
+                self.assertTrue(self.browser.is_text_not_present("Static Media Failure"))

nautobot/core/tests/runner.py

@@ -1,8 +1,10 @@
 import copy
+import hashlib
 
 from django.conf import settings
 from django.core.management import call_command
 from django.db import connections
+from django.db.migrations.recorder import MigrationRecorder
 from django.test.runner import _init_worker, DiscoverRunner, ParallelTestSuite
 from django.test.utils import get_unique_databases_and_mirrors, NullTimeKeeper, override_settings
 import yaml
@@ -113,6 +115,14 @@ class NautobotTestRunner(DiscoverRunner):
                             command += ["--seed", settings.TEST_FACTORY_SEED]
                         if self.cache_test_fixtures:
                             command += ["--cache-test-fixtures"]
+                            # Use the list of applied migrations as a unique hash to keep fixtures from differing
+                            # branches/releases of Nautobot in separate files.
+                            hexdigest = hashlib.shake_128(
+                                ",".join(
+                                    sorted(f"{m.app}.{m.name}" for m in MigrationRecorder.Migration.objects.all())
+                                ).encode("utf-8")
+                            ).hexdigest(10)
+                            command += ["--fixture-file", f"development/factory_dump.{hexdigest}.json"]
                         with time_keeper.timed(f'  Pre-populating test database "{alias}" with factory data...'):
                             db_command = [*command, "--database", alias]
                             call_command(*db_command)

nautobot/core/tests/test_graphql.py

@@ -729,8 +729,8 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.location_type = LocationType.objects.get(name="Campus")
         cls.location1 = Location.objects.filter(location_type=cls.location_type).first()
         cls.location2 = Location.objects.filter(location_type=cls.location_type).last()
-        cls.location1.name = "Location-1"
-        cls.location2.name = "Location-2"
+        cls.location1.name = "Campus Location-1"
+        cls.location2.name = "Campus Location-2"
         cls.location1.status = cls.location_statuses[0]
         cls.location2.status = cls.location_statuses[1]
         cls.location1.validated_save()
@@ -930,6 +930,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.prefix1 = Prefix.objects.create(
             prefix="10.0.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
         )
+        cls.prefix1.locations.add(cls.location1, cls.location2)
         cls.ipaddr1 = IPAddress.objects.create(
             address="10.0.1.1/24", namespace=cls.namespace, status=cls.ip_statuses[0]
         )
@@ -968,6 +969,7 @@ class GraphQLQueryTest(GraphQLTestCaseBase):
         cls.prefix2 = Prefix.objects.create(
             prefix="10.0.2.0/24", namespace=cls.namespace, status=cls.prefix_statuses[1]
         )
+        cls.prefix2.locations.add(cls.location1, cls.location2)
         cls.ipaddr2 = IPAddress.objects.create(
             address="10.0.2.1/30", namespace=cls.namespace, status=cls.ip_statuses[1]
         )
@@ -1507,9 +1509,9 @@ query {
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_locations_filter(self):
         filters = (
-            ('name: "Location-1"', 1),
-            ('name: ["Location-1"]', 1),
-            ('name: ["Location-1", "Location-2"]', 2),
+            ('name: "Campus Location-1"', 1),
+            ('name: ["Campus Location-1"]', 1),
+            ('name: ["Campus Location-1", "Campus Location-2"]', 2),
             ('name__ic: "Location"', Location.objects.filter(name__icontains="Location").count()),
             ('name__ic: ["Location"]', Location.objects.filter(name__icontains="Location").count()),
             ('name__nic: "Location"', Location.objects.exclude(name__icontains="Location").count()),
@@ -1541,6 +1543,50 @@ query {
                 self.assertIsNone(result.errors)
                 self.assertEqual(len(result.data["locations"]), nbr_expected_results)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_prefixes_nested_m2m_filter(self):
+        """
+        Test functionality added to address https://github.com/nautobot/nautobot/issues/5906.
+
+        Prefix.locations is a ManyToManyField, which was not filterable in our GraphQL schema before this fix.
+        """
+        query = 'query { prefixes (prefix_length__gte:16) { prefix locations (location_type:["Campus"]) { name } } }'
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        found_valid_location = False
+        found_invalid_location = False
+        for prefix_data in result.data["prefixes"]:
+            for location_data in prefix_data["locations"]:
+                if location_data["name"].startswith("Campus"):
+                    found_valid_location = True
+                else:
+                    print(f"Found unexpected unfiltered location {location_data['name']} under {prefix_data['prefix']}")
+                    found_invalid_location = True
+        self.assertTrue(found_valid_location)
+        self.assertFalse(found_invalid_location)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_query_locations_nested_reverse_m2m_filter(self):
+        """
+        Test functionality added to address https://github.com/nautobot/nautobot/issues/5906.
+
+        Location.prefixes is a (reverse) ManyToManyRel, which was not filterable in our GraphQL schema before this fix.
+        """
+        query = "query { locations { name prefixes (prefix_length:24) { prefix } } }"
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        found_valid_prefix = False
+        found_invalid_prefix = False
+        for location_data in result.data["locations"]:
+            for prefix_data in location_data["prefixes"]:
+                if prefix_data["prefix"].endswith("/24"):
+                    found_valid_prefix = True
+                else:
+                    print(f"Found unexpected unfiltered prefix {prefix_data['prefix']} under {location_data['name']}")
+                    found_invalid_prefix = True
+        self.assertTrue(found_valid_prefix)
+        self.assertFalse(found_invalid_prefix)
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_devices_filter(self):
         filterset_class = DeviceFilterSet

nautobot/dcim/models/devices.py

@@ -832,9 +832,16 @@ class Device(PrimaryModel, ConfigContextModel):
         # Update Location and Rack assignment for any child Devices
         devices = Device.objects.filter(parent_bay__device=self)
         for device in devices:
-            device.location = self.location
-            device.rack = self.rack
-            device.save()
+            save_child_device = False
+            if device.location != self.location:
+                device.location = self.location
+                save_child_device = True
+            if device.rack != self.rack:
+                device.rack = self.rack
+                save_child_device = True
+
+            if save_child_device:
+                device.save()
 
     def create_components(self):
         """Create device components from the device type definition."""

nautobot/dcim/tests/test_models.py

@@ -16,6 +16,7 @@ from nautobot.dcim.choices import (
     InterfaceTypeChoices,
     PortTypeChoices,
     PowerOutletFeedLegChoices,
+    SubdeviceRoleChoices,
 )
 from nautobot.dcim.models import (
     Cable,
@@ -886,6 +887,13 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.device_type = DeviceType.objects.create(
             manufacturer=manufacturer,
             model="Test Device Type 1",
+            subdevice_role=SubdeviceRoleChoices.ROLE_PARENT,
+        )
+        self.child_devicetype = DeviceType.objects.create(
+            model="Child Device Type 1",
+            manufacturer=manufacturer,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+            u_height=0,
         )
         self.device_role = Role.objects.get_for_model(Device).first()
         self.device_status = Status.objects.get_for_model(Device).first()
@@ -1188,6 +1196,73 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         self.device_type.software_image_files.add(software_image_file)
         self.device.validated_save()
 
+    def test_child_devices_are_not_saved_when_unnecessary(self):
+        parent_device = Device.objects.create(
+            name="Parent Device 1",
+            location=self.location_3,
+            device_type=self.device_type,
+            role=self.device_role,
+            status=self.device_status,
+        )
+        parent_device.validated_save()
+
+        child_device = Device.objects.create(
+            name="Child Device 1",
+            location=parent_device.location,
+            device_type=self.child_devicetype,
+            role=parent_device.role,
+            status=self.device_status,
+        )
+        child_device.validated_save()
+        child_mtime_before_parent_saved = str(child_device.last_updated)
+
+        devicebay = DeviceBay.objects.get(device=parent_device, name="Device Bay 1")
+        devicebay.installed_device = child_device
+        devicebay.validated_save()
+
+        #
+        # Tests
+        #
+
+        #
+        # On a NOOP save, the child device shouldn't be updated
+        parent_device.save()
+
+        child_mtime_after_parent_noop_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertEqual(child_mtime_before_parent_saved, child_mtime_after_parent_noop_save)
+
+        #
+        # On a serial number update, the child device shouldn't be updated
+        parent_device.serial = "12345"
+        parent_device.save()
+
+        child_mtime_after_parent_serial_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertEqual(child_mtime_before_parent_saved, child_mtime_after_parent_serial_update_save)
+
+        #
+        # If the parent rack updates, the child mtime should update.
+        rack = Rack.objects.create(name="Rack 1", location=parent_device.location, status=self.device_status)
+        parent_device.rack = rack
+        parent_device.save()
+
+        child_mtime_after_parent_rack_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertNotEqual(child_mtime_after_parent_noop_save, child_mtime_after_parent_rack_update_save)
+
+        #
+        # If the parent site updates, the child mtime should update
+        location = Location.objects.create(
+            name="New Site 1", status=self.device_status, location_type=self.location_type_3
+        )
+        parent_device.location = location
+        parent_device.save()
+
+        child_mtime_after_parent_site_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
+
+        self.assertNotEqual(child_mtime_after_parent_rack_update_save, child_mtime_after_parent_site_update_save)
+
 
 class DeviceTypeToSoftwareImageFileTestCase(ModelTestCases.BaseModelTestCase):
     model = DeviceTypeToSoftwareImageFile

nautobot/extras/models/groups.py

@@ -597,10 +597,17 @@ class DynamicGroup(OrganizationalModel):
             query |= filter_field.generate_query(gq_value)
 
         # For vanilla multiple-choice filters, we want all values in a set union (boolean OR)
-        # because we want ANY of the filter values to match.
+        # because we want ANY of the filter values to match. Unless the filter field is explicitly
+        # conjoining the values, in which case we want a set intersection (boolean AND). We know this isn't right
+        # since the resulting query actually does tag.name == tag_1 AND tag.name == tag_2, but django_filter does
+        # not use Q evaluation for conjoined filters. This function is only used for the display, and the display
+        # is good enough to get the point across.
         elif isinstance(filter_field, django_filters.MultipleChoiceFilter):
             for v in value:
-                query |= models.Q(**filter_field.get_filter_predicate(v))
+                if filter_field.conjoined:
+                    query &= models.Q(**filter_field.get_filter_predicate(v))
+                else:
+                    query |= models.Q(**filter_field.get_filter_predicate(v))
 
         # The method `get_filter_predicate()` is only available on instances or subclasses
         # of `MultipleChoiceFilter`, so we must construct a lookup if a filter is not

nautobot/extras/models/relationships.py

@@ -244,6 +244,18 @@ class RelationshipModel(models.Model):
             if relation.skip_required(cls, opposite_side):
                 continue
 
+            if getattr(relation, f"{relation.required_on}_filter") and instance:
+                filterset = get_filterset_for_model(cls)
+                if filterset:
+                    filter_params = getattr(relation, f"{relation.required_on}_filter")
+                    # If the relationship is required on the model, but the object is not in the filter,
+                    # we should allow the object to be saved, as the object is not part of the relationship.
+                    # Example: We want a Device with a Role of Switch to be required to have a relationship
+                    # with a Device that has a Role of Router. A Device with a Role of Printer should
+                    # be exempt from the requirement.
+                    if not filterset(filter_params, cls.objects.filter(id=instance.id)).qs.exists():
+                        continue
+
             if relation.has_many(opposite_side):
                 num_required_verbose = "at least one"
             else:

nautobot/extras/tests/integration/test_dynamicgroups.py

@@ -74,7 +74,7 @@ class DynamicGroupTestCase(SeleniumTestCase):
 
         # And just a cursory check to make sure that the filter worked.
         group = DynamicGroup.objects.get(name=name)
-        self.assertEqual(group.count, len(devices))
+        self.assertEqual(group.count, Device.objects.filter(status__name="Active").count())
         self.assertEqual(group.filter, {"status": ["Active"]})
 
         # Verify dynamic group shows up on device detail tab

nautobot/extras/tests/test_dynamicgroups.py

@@ -646,7 +646,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
 
         queryset = group.get_queryset()
 
-        # Assert that both querysets resturn the same results
+        # Assert that both querysets return the same results
         group_qs = queryset.filter(multi_query)
         device_qs = Device.objects.filter(location__name__in=multi_value)
         self.assertQuerySetEqual(group_qs, device_qs)
@@ -659,6 +659,13 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         interface_qs = Device.objects.filter(interfaces__isnull=True)
         self.assertQuerySetEqual(solo_qs, interface_qs)
 
+        # Tags are conjoined in the TagFilterSet, ensure that tags__name is using AND. We know this isn't right
+        # since the resulting query actually does tag.name == tag_1 AND tag.name == tag_2, but django_filter does
+        # not use Q evaluation for conjoined filters. This function is only used for the display, and the display
+        # is good enough to get the point across.
+        tags_query = group.generate_query_for_filter(filter_field=fs.filters["tags"], value=["tag_1", "tag_2"])
+        self.assertEqual(str(tags_query), "(AND: ('tags__name', 'tag_1'), ('tags__name', 'tag_2'))")
+
         # Test that a nested field_name w/ `generate_query` works as expected. This is explicitly to
         # test a regression w/ nested name-related values such as `DeviceFilterSet.manufacturer` which
         # filters on `device_type__manufacturer`.