nautobot 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

nautobot/apps/tables.py

@@ -15,6 +15,7 @@ from nautobot.core.tables import (
     TagColumn,
     ToggleColumn,
 )
+from nautobot.extras.plugins import TableExtension
 from nautobot.extras.tables import RoleTableMixin, StatusTableMixin
 
 __all__ = (
@@ -32,5 +33,6 @@ __all__ = (
     "RoleTableMixin",
     "StatusTableMixin",
     "TagColumn",
+    "TableExtension",
     "ToggleColumn",
 )

nautobot/core/forms/__init__.py

@@ -7,6 +7,8 @@ from nautobot.core.forms.constants import (
     NUMERIC_EXPANSION_PATTERN,
 )
 from nautobot.core.forms.fields import (
+    AutoPositionField,
+    AutoPositionPatternField,
     CommentField,
     CSVChoiceField,
     CSVContentTypeField,
@@ -80,6 +82,8 @@ __all__ = (
     "ALPHANUMERIC_EXPANSION_PATTERN",
     "APISelect",
     "APISelectMultiple",
+    "AutoPositionField",
+    "AutoPositionPatternField",
     "BOOLEAN_CHOICES",
     "BOOLEAN_WITH_BLANK_CHOICES",
     "BootstrapMixin",

nautobot/core/forms/fields.py

@@ -444,6 +444,38 @@ class SlugField(django_forms.SlugField):
         self.widget.attrs["slug-source"] = slug_source
 
 
+class AutoPositionField(django_forms.CharField):
+    def __init__(self, source="name", *args, **kwargs):
+        """
+        Instantiate a AutoPositionField.
+
+        Args:
+            source (str, tuple): Name of the field (or a list of field names) that will be used to suggest a position.
+        """
+        kwargs.setdefault("label", "Position")
+        kwargs.setdefault("widget", forms.SlugWidget)
+        super().__init__(*args, **kwargs)
+        if isinstance(source, (tuple, list)):
+            source = " ".join(source)
+        self.widget.attrs["source"] = source
+
+
+class AutoPositionPatternField(ExpandableNameField):
+    def __init__(self, source="name_pattern", *args, **kwargs):
+        """
+        Instantiate a AutoPositionPatternField.
+
+        Args:
+            source (str, tuple): Name pattern of the field (or a list of field names) that will be used to suggest a position pattern.
+        """
+        kwargs.setdefault("label", "Position")
+        kwargs.setdefault("widget", forms.SlugWidget)
+        super().__init__(*args, **kwargs)
+        if isinstance(source, (tuple, list)):
+            source = " ".join(source)
+        self.widget.attrs["source"] = source
+
+
 class DynamicModelChoiceMixin:
     """
     :param display_field: The name of the attribute of an API response object to display in the selection list

nautobot/core/jobs/__init__.py

@@ -19,7 +19,12 @@ from nautobot.core.jobs.cleanup import LogsCleanup
 from nautobot.core.jobs.groups import RefreshDynamicGroupCaches
 from nautobot.core.utils.lookup import get_filterset_for_model
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params
-from nautobot.extras.datasources import ensure_git_repository, git_repository_dry_run, refresh_datasource_content
+from nautobot.extras.datasources import (
+    ensure_git_repository,
+    git_repository_dry_run,
+    refresh_datasource_content,
+    refresh_job_code_from_repository,
+)
 from nautobot.extras.jobs import BooleanVar, ChoiceVar, FileVar, Job, ObjectVar, RunJobTaskFailed, StringVar, TextVar
 from nautobot.extras.models import ExportTemplate, GitRepository
 
@@ -49,13 +54,24 @@ class GitRepositorySync(Job):
         self.logger.info(f'Creating/refreshing local copy of Git repository "{repository.name}"...')
 
         try:
-            ensure_git_repository(repository, logger=self.logger)
-            refresh_datasource_content("extras.gitrepository", repository, user, job_result, delete=False)
-            # Given that the above succeeded, tell all workers (including ourself) to call ensure_git_repository()
-            app.control.broadcast("refresh_git_repository", repository_pk=repository.pk, head=repository.current_head)
-        finally:
-            if job_result.duration:
-                self.logger.info("Repository synchronization completed in %s", job_result.duration)
+            with transaction.atomic():
+                ensure_git_repository(repository, logger=self.logger)
+                refresh_datasource_content("extras.gitrepository", repository, user, job_result, delete=False)
+                # Given that the above succeeded, tell all workers (including ourself) to call ensure_git_repository()
+                app.control.broadcast(
+                    "refresh_git_repository", repository_pk=repository.pk, head=repository.current_head
+                )
+                if job_result.duration:
+                    self.logger.info("Repository synchronization completed in %s", job_result.duration)
+        except Exception:
+            job_result.log("Changes to database records have been reverted.")
+            # Re-check-out previous commit if any
+            repository.refresh_from_db()
+            if repository.current_head:
+                job_result.log(f"Attempting to revert local repository clone to commit {repository.current_head}")
+                ensure_git_repository(repository, logger=self.logger, head=repository.current_head)
+                refresh_job_code_from_repository(repository.slug, ignore_import_errors=True)
+            raise
 
 
 class GitRepositoryDryRun(Job):

nautobot/core/models/tree_queries.py

@@ -1,9 +1,11 @@
 from django.core.cache import cache
 from django.db.models import Case, When
+from django.db.models.signals import post_delete, post_save
 from tree_queries.models import TreeNode
 from tree_queries.query import TreeManager as TreeManager_, TreeQuerySet as TreeQuerySet_
 
 from nautobot.core.models import BaseManager, querysets
+from nautobot.core.signals import invalidate_max_depth_cache
 
 
 class TreeQuerySet(TreeQuerySet_, querysets.RestrictedQuerySet):
@@ -117,3 +119,9 @@ class TreeModel(TreeNode):
         display_str += self.name
         cache.set(cache_key, display_str, 5)
         return display_str
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        post_save.connect(invalidate_max_depth_cache, sender=cls)
+        post_delete.connect(invalidate_max_depth_cache, sender=cls)

nautobot/core/settings.py

@@ -418,7 +418,14 @@ if "NAUTOBOT_ALLOWED_HOSTS" in os.environ and os.environ["NAUTOBOT_ALLOWED_HOSTS
     ALLOWED_HOSTS = os.environ["NAUTOBOT_ALLOWED_HOSTS"].split(" ")
 else:
     ALLOWED_HOSTS = []
+
+# Allow CSRF trusted origins to be set via an environment variable
+# This allows Nautobot to be run behind a reverse proxy that terminates TLS
+# and fix potential issues with CSRF validation
 CSRF_TRUSTED_ORIGINS = []
+if "NAUTOBOT_CSRF_TRUSTED_ORIGINS" in os.environ and os.environ["NAUTOBOT_CSRF_TRUSTED_ORIGINS"] != "":
+    CSRF_TRUSTED_ORIGINS = os.getenv("NAUTOBOT_CSRF_TRUSTED_ORIGINS", "").split(_CONFIG_SETTING_SEPARATOR)
+
 CSRF_FAILURE_VIEW = "nautobot.core.views.csrf_failure"
 DATE_FORMAT = os.getenv("NAUTOBOT_DATE_FORMAT", "N j, Y")
 DATETIME_FORMAT = os.getenv("NAUTOBOT_DATETIME_FORMAT", "N j, Y g:i a")

nautobot/core/settings.yaml

@@ -587,6 +587,16 @@ properties:
     description: >-
       A list of hosts (fully-qualified domain names (FQDNs) or subdomains) that are considered trusted origins
       for cross-site secure requests such as HTTPS POST.
+
+      You might need to set this if you are using a reverse proxy or load balancer that changes the host header or if you face the error
+      'Invalid Form Submission - CSRF failure has occured' and 'Origin checking failed - https://subdomain.example.com does not match any trusted origins.'
+
+      Example:
+
+      ```python
+      CSRF_TRUSTED_ORIGINS = ['https://subdomain.example.com', 'https://*.example.com']
+      ```
+    environment_variable: "NAUTOBOT_CSRF_TRUSTED_ORIGINS"
     items:
       type: "string"
     see_also:

nautobot/core/signals.py

@@ -7,7 +7,6 @@ import logging
 
 from django.contrib.auth.signals import user_logged_in, user_logged_out
 from django.core.cache import cache
-from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver, Signal
 import redis.exceptions
 
@@ -62,10 +61,12 @@ def disable_for_loaddata(signal_handler):
     return wrapper
 
 
-@receiver(post_save)
-@receiver(post_delete)
 def invalidate_max_depth_cache(sender, **kwargs):
-    """Clear the appropriate TreeManager.max_depth cache as the create/update/delete may have changed the tree."""
+    """
+    Clear the appropriate TreeManager.max_depth cache as the create/update/delete may have changed the tree.
+
+    Note that this signal is connected in `TreeModel.__init_subclass__()` so as to only apply to those models.
+    """
     from nautobot.core.models.tree_queries import TreeManager
 
     if not isinstance(sender.objects, TreeManager):

nautobot/core/templates/inc/paginator.html

@@ -29,6 +29,9 @@
             {% endif %}
         {% endfor %}
         <select name="per_page" id="per_page" class="form-control">
+            {% if page.paginator.per_page not in "PER_PAGE_DEFAULTS"|settings_or_config %}
+                <option value="{{ page.paginator.per_page }}" selected="selected">{{ page.paginator.per_page }}</option>
+            {% endif %}
             {% for n in "PER_PAGE_DEFAULTS"|settings_or_config %}
                 <option value="{{ n }}"{% if page.paginator.per_page == n %} selected="selected"{% endif %}>{{ n }}</option>
             {% endfor %}

nautobot/core/templates/nautobot_config.py.j2

@@ -94,9 +94,13 @@ SECRET_KEY = os.getenv("NAUTOBOT_SECRET_KEY", "{{ secret_key }}")
 # FQDNs that are considered trusted origins for secure, cross-domain, requests such as HTTPS POST.
 # If running Nautobot under a single domain, you may not need to set this variable;
 # if running on multiple domains, you *may* need to set this variable to more or less the same as ALLOWED_HOSTS above.
+# You also want to set this variable if you are facing CSRF validation issues such as 
+# 'CSRF failure has occured' or 'Origin checking failed - https://subdomain.example.com does not match any trusted origins.'
 # https://docs.djangoproject.com/en/stable/ref/settings/#csrf-trusted-origins
 #
 # CSRF_TRUSTED_ORIGINS = []
+# if "NAUTOBOT_CSRF_TRUSTED_ORIGINS" in os.environ and os.environ["NAUTOBOT_CSRF_TRUSTED_ORIGINS"] != "":
+#    CSRF_TRUSTED_ORIGINS = os.getenv("NAUTOBOT_CSRF_TRUSTED_ORIGINS", "").split(_CONFIG_SETTING_SEPARATOR)
 
 # Date/time formatting. See the following link for supported formats:
 # https://docs.djangoproject.com/en/stable/ref/templates/builtins/#date

nautobot/core/templates/utilities/obj_table.html

@@ -45,7 +45,7 @@
 {% else %}
     {% include table_template|default:'responsive_table.html' %}
 {% endif %}
-{% if not disable_pagination %}
+{% if table.paginator.num_pages > 1 and not disable_pagination %}
     {% include 'inc/paginator.html' with paginator=table.paginator page=table.page %}
 {% endif %}
 <div class="clearfix"></div>

nautobot/dcim/api/serializers.py

@@ -798,14 +798,19 @@ class InterfaceSerializer(
     def validate(self, data):
         # Validate many-to-many VLAN assignments
         device = self.instance.device if self.instance else data.get("device")
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to assign a VLAN belongs to
-        # the parent Location or the child location of `device.location`?
+        location = None
+        if device:
+            location = device.location
+        if location:
+            location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        else:
+            location_ids = []
         for vlan in data.get("tagged_vlans", []):
-            if vlan.locations.exists() and not vlan.locations.filter(pk=device.location.pk).exists():
+            if vlan.locations.exists() and not vlan.locations.filter(pk__in=location_ids).exists():
                 raise serializers.ValidationError(
                     {
-                        "tagged_vlans": f"VLAN {vlan} must have a common location as the interface's parent device, or "
-                        f"it must be global."
+                        "tagged_vlans": f"VLAN {vlan} must have the same location as the interface's parent device, "
+                        f"or is in one of the parents of the interface's parent device's location, or it must be global."
                     }
                 )
 

nautobot/dcim/forms.py

@@ -13,6 +13,8 @@ from nautobot.core.forms import (
     add_blank_choice,
     APISelect,
     APISelectMultiple,
+    AutoPositionField,
+    AutoPositionPatternField,
     BootstrapMixin,
     BulkEditNullBooleanSelect,
     ColorSelect,
@@ -213,23 +215,27 @@ class InterfaceCommonForm(forms.Form):
         elif mode == InterfaceModeChoices.MODE_TAGGED_ALL:
             self.cleaned_data["tagged_vlans"] = []
 
-        # Validate tagged VLANs; must be a global VLAN or in the same location
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
-        # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
+        # Validate tagged VLANs; must be a global VLAN or in the same location as the
+        # parent device/VM or any of that location's parent locations
         elif mode == InterfaceModeChoices.MODE_TAGGED:
-            valid_location = self.cleaned_data[parent_field].location
+            location = self.cleaned_data[parent_field].location
+            if location:
+                location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+            else:
+                location_ids = []
             invalid_vlans = [
                 str(v)
                 for v in tagged_vlans
                 if v.locations.without_tree_fields().exists()
-                and not VLANLocationAssignment.objects.filter(location=valid_location, vlan=v).exists()
+                and not VLANLocationAssignment.objects.filter(location__in=location_ids, vlan=v).exists()
             ]
 
             if invalid_vlans:
                 raise forms.ValidationError(
                     {
-                        "tagged_vlans": f"The tagged VLANs ({', '.join(invalid_vlans)}) must belong to the same location as "
-                        f"the interface's parent device/VM, or they must be global"
+                        "tagged_vlans": f"The tagged VLANs ({', '.join(invalid_vlans)}) must have the same location as the "
+                        "interface's parent device, or is in one of the parents of the interface's parent device's location, "
+                        "or it must be global."
                     }
                 )
 
@@ -265,23 +271,7 @@ class ComponentForm(BootstrapMixin, forms.Form):
 
 
 class ModularComponentForm(ComponentForm):
-    name_pattern = ExpandableNameField(
-        label="Name",
-        help_text="""
-            Alphanumeric ranges are supported for bulk creation. Mixed cases and types within a single range
-            are not supported. Examples:
-            <ul>
-                <li><code>[ge,xe]-0/0/[0-9]</code></li>
-                <li><code>e[0-3][a-d,f]</code></li>
-            </ul>
-
-            The variables <code>{module}</code>, <code>{module.parent}</code>, <code>{module.parent.parent}</code>, etc.
-            may be used in the name field and will be replaced by the <code>position</code> of the module bay that the
-            module occupies (skipping over any bays with a blank <code>position</code>). These variables can be used
-            multiple times in the component name and there is no limit to the depth of parent levels.
-            Any variables that cannot be replaced by a suitable position value will remain unchanged.
-                """,
-    )
+    """Base class for forms for components that can be assigned to either a device or a module."""
 
 
 #
@@ -1060,11 +1050,27 @@ class ComponentTemplateCreateForm(ComponentForm):
     description = forms.CharField(required=False)
 
 
-class ModularComponentTemplateCreateForm(ModularComponentForm):
+class ModularComponentTemplateCreateForm(ComponentTemplateCreateForm):
     """
     Base form for the creation of modular device component templates (subclassed from ModularComponentTemplateModel).
     """
 
+    name_pattern = ExpandableNameField(
+        label="Name",
+        help_text="""
+        Alphanumeric ranges are supported for bulk creation. Mixed cases and types within a single range
+        are not supported. Examples:
+        <ul>
+            <li><code>[ge,xe]-0/0/[0-9]</code></li>
+            <li><code>e[0-3][a-d,f]</code></li>
+        </ul>
+
+        The variables <code>{module}</code>, <code>{module.parent}</code>, <code>{module.parent.parent}</code>, etc.
+        may be used in the name field and will be replaced by the <code>position</code> of the module bay that the
+        module occupies (skipping over any bays with a blank <code>position</code>). These variables can be used
+        multiple times in the component name and there is no limit to the depth of parent levels.
+        Any variables that cannot be replaced by a suitable position value will remain unchanged.""",
+    )
     device_type = DynamicModelChoiceField(
         queryset=DeviceType.objects.all(),
         required=False,
@@ -1073,7 +1079,6 @@ class ModularComponentTemplateCreateForm(ModularComponentForm):
         queryset=ModuleType.objects.all(),
         required=False,
     )
-    description = forms.CharField(required=False)
 
 
 class ConsolePortTemplateForm(ModularComponentTemplateForm):
@@ -1566,10 +1571,10 @@ class ModuleBayBaseCreateForm(BootstrapMixin, forms.Form):
         required=False,
         help_text="Alphanumeric ranges are supported. (Must match the number of names being created.)",
     )
-    position_pattern = ExpandableNameField(
-        label="Position",
+    position_pattern = AutoPositionPatternField(
         required=False,
-        help_text="Alphanumeric ranges are supported. (Must match the number of names being created.)",
+        help_text="Alphanumeric ranges are supported. (Must match the number of names being created.)"
+        " Default to the names of the module bays unless manually supplied by the user.",
     )
     description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
 
@@ -2538,12 +2543,8 @@ class DeviceBulkAddComponentForm(ComponentForm, CustomFieldModelBulkEditFormMixi
         nullable_fields = []
 
 
-class ModuleBulkAddComponentForm(ModularComponentForm, CustomFieldModelBulkEditFormMixin):
+class ModuleBulkAddComponentForm(DeviceBulkAddComponentForm):
     pk = forms.ModelMultipleChoiceField(queryset=Module.objects.all(), widget=forms.MultipleHiddenInput())
-    description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
-
-    class Meta:
-        nullable_fields = []
 
 
 #
@@ -3562,6 +3563,12 @@ class ModuleBayFilterForm(NautobotFilterForm):
 
 
 class ModuleBayForm(NautobotModelForm):
+    position = AutoPositionField(
+        max_length=CHARFIELD_MAX_LENGTH,
+        help_text="The position of the module bay within the parent device/module. "
+        "Defaults to the name of the module bay unless overridden.",
+        required=False,
+    )
     parent_device = DynamicModelChoiceField(
         queryset=Device.objects.all(),
         required=False,

nautobot/dcim/models/device_components.py

@@ -727,19 +727,22 @@ class Interface(ModularComponentModel, CableTermination, PathEndpoint, BaseInter
                     )
 
         # Validate untagged VLAN
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to assign a VLAN belongs to
-        # the parent Locations or the child locations of `device.location`?
+        location = self.parent.location if self.parent is not None else None
+        if location:
+            location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        else:
+            location_ids = []
         if (
             self.untagged_vlan
             and self.untagged_vlan.locations.exists()
             and self.parent
-            and not self.untagged_vlan.locations.filter(id=self.parent.location_id).exists()
+            and not self.untagged_vlan.locations.filter(pk__in=location_ids).exists()
         ):
             raise ValidationError(
                 {
                     "untagged_vlan": (
                         f"The untagged VLAN ({self.untagged_vlan}) must have a common location as the interface's parent "
-                        f"device, or it must be global."
+                        f"device, or is in one of the parents of the interface's parent device's location, or it must be global."
                     )
                 }
             )
@@ -1277,3 +1280,8 @@ class ModuleBay(PrimaryModel):
 
         if not (self.parent_device or self.parent_module):
             raise ValidationError("Either parent_device or parent_module must be set")
+
+        # Populate the position field with the name of the module bay if it is not supplied by the user.
+
+        if not self.position:
+            self.position = self.name

nautobot/dcim/tables/devices.py

@@ -173,6 +173,7 @@ class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
         template_code="""{% if record.device_redundancy_group %}<span class="badge badge-default">{{ record.device_redundancy_group_priority|default:'None' }}</span>{% else %}—{% endif %}"""
     )
     controller_managed_device_group = tables.Column(linkify=True)
+    software_version = tables.Column(linkify=True, verbose_name="Software Version")
     secrets_group = tables.Column(linkify=True)
     tags = TagColumn(url_name="dcim:device_list")
 
@@ -201,6 +202,7 @@ class DeviceTable(StatusTableMixin, RoleTableMixin, BaseTable):
             "vc_priority",
             "device_redundancy_group",
             "device_redundancy_group_priority",
+            "software_version",
             "controller_managed_device_group",
             "secrets_group",
             "tags",
@@ -616,7 +618,7 @@ class DeviceModulePowerOutletTable(PowerOutletTable):
         row_attrs = {"class": cable_status_color_css}
 
 
-class BaseInterfaceTable(BaseTable):
+class BaseInterfaceTable(StatusTableMixin, RoleTableMixin, BaseTable):
     enabled = BooleanColumn()
     ip_addresses = tables.TemplateColumn(
         template_code=INTERFACE_IPADDRESSES,
@@ -632,7 +634,7 @@ class BaseInterfaceTable(BaseTable):
     vrf = tables.Column(linkify=True, verbose_name="VRF")
 
 
-class InterfaceTable(StatusTableMixin, ModularDeviceComponentTable, BaseInterfaceTable, PathEndpointTable):
+class InterfaceTable(ModularDeviceComponentTable, BaseInterfaceTable, PathEndpointTable):
     mgmt_only = BooleanColumn()
     tags = TagColumn(url_name="dcim:interface_list")
 

nautobot/dcim/tests/test_api.py

@@ -2198,6 +2198,34 @@ class InterfaceTest(Mixins.ModularDeviceComponentMixin, Mixins.BasePortTestMixin
             self.client.post(url, self.untagged_vlan_data, format="json", **self.header), status.HTTP_201_CREATED
         )
 
+    def test_tagged_vlan_must_be_in_the_location_or_parent_locations_of_the_parent_device(self):
+        self.add_permissions("dcim.add_interface")
+
+        interface_status = Status.objects.get_for_model(Interface).first()
+        location = self.devices[0].location
+        location_ids = [ancestor.id for ancestor in location.ancestors()]
+        non_valid_locations = Location.objects.exclude(pk__in=location_ids)
+        faulty_vlan = self.vlans[0]
+        faulty_vlan.locations.set([non_valid_locations.first().pk])
+        faulty_vlan.validated_save()
+        faulty_data = {
+            "device": self.devices[0].pk,
+            "name": "Test Vlans Interface",
+            "type": "virtual",
+            "status": interface_status.pk,
+            "mode": InterfaceModeChoices.MODE_TAGGED,
+            "parent_interface": self.interfaces[1].pk,
+            "tagged_vlans": [faulty_vlan.pk, self.vlans[1].pk],
+            "untagged_vlan": self.vlans[2].pk,
+        }
+        response = self.client.post(self._get_list_url(), data=faulty_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            b"must have the same location as the interface's parent device, or is in one of the parents of the interface's parent device's location, or "
+            b"it must be global.",
+            response.content,
+        )
+
     def test_interface_belonging_to_common_device_or_vc_allowed(self):
         """Test parent, bridge, and LAG interfaces belonging to common device or VC is valid"""
         self.add_permissions("dcim.add_interface")

nautobot/dcim/tests/test_forms.py

@@ -341,9 +341,25 @@ class InterfaceTestCase(TestCase):
             "tagged_vlans": [cls.vlan.pk],
         }
 
+    def test_interface_form_clean_vlan_location_success(self):
+        """Assert that form validation succeeds when matching locations/parent locations are associated to tagged VLAN"""
+        location = self.device.location
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        self.vlan.locations.set([location.id])
+        self.data["tagged_vlans"] = [self.vlan]
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+        self.vlan.locations.set(location_ids[:2])
+        self.data["tagged_vlans"] = [self.vlan]
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
     def test_interface_form_clean_vlan_location_fail(self):
         """Assert that form validation fails when no matching locations are associated to tagged VLAN"""
-        self.vlan.locations.set(list(Location.objects.exclude(pk=self.device.location.pk))[:2])
+        location = self.device.location
+        location_ids = location.ancestors(include_self=True).values_list("id", flat=True)
+        self.vlan.locations.set(list(Location.objects.exclude(pk__in=location_ids))[:2])
+        self.data["tagged_vlans"] = [self.vlan]
         form = InterfaceForm(data=self.data, instance=self.interface)
         self.assertFalse(form.is_valid())
 

nautobot/dcim/tests/test_models.py

@@ -2376,19 +2376,57 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         )
 
     def test_error_raised_when_adding_tagged_vlan_with_different_location_from_interface_parent_location(self):
+        intf_status = Status.objects.get_for_model(Interface).first()
+        intf_role = Role.objects.get_for_model(Interface).first()
+        location_type = LocationType.objects.get(name="Campus")
+        child_location = Location.objects.filter(parent__isnull=False, location_type=location_type).first()
+        self.device.location = child_location
+        self.device.validated_save()
+        # Same location as the device
+        interface = Interface.objects.create(
+            name="Test Interface 2",
+            mode=InterfaceModeChoices.MODE_TAGGED,
+            device=self.device,
+            status=intf_status,
+            role=intf_role,
+        )
+        self.other_location_vlan.locations.set([self.device.location.pk])
+        interface.tagged_vlans.set([self.other_location_vlan.pk])
+
+        # One of the parent locations of the device's location
+        interface = Interface.objects.create(
+            name="Test Interface 3",
+            mode=InterfaceModeChoices.MODE_TAGGED,
+            device=self.device,
+            status=intf_status,
+            role=intf_role,
+        )
+        self.other_location_vlan.locations.set([self.device.location.ancestors().first().pk])
+        interface.tagged_vlans.set([self.other_location_vlan.pk])
+
         with self.assertRaises(ValidationError) as err:
             interface = Interface.objects.create(
-                name="Test Interface",
+                name="Test Interface 1",
                 mode=InterfaceModeChoices.MODE_TAGGED,
                 device=self.device,
-                status=Status.objects.get_for_model(Interface).first(),
-                role=Role.objects.get_for_model(Interface).first(),
+                status=intf_status,
+                role=intf_role,
             )
+            location_3 = Location.objects.create(
+                name="Invalid VLAN Location",
+                location_type=LocationType.objects.get(name="Campus"),
+                status=Status.objects.get_for_model(Location).first(),
+            )
+            # clear the valid locations
+            self.other_location_vlan.locations.set([])
+            # assign the invalid location
+            self.other_location_vlan.location = location_3
+            self.other_location_vlan.validated_save()
             interface.tagged_vlans.add(self.other_location_vlan)
         self.assertEqual(
             err.exception.message_dict["tagged_vlans"][0],
             f"Tagged VLAN with names {[self.other_location_vlan.name]} must all belong to the "
-            f"same location as the interface's parent device, or it must be global.",
+            f"same location as the interface's parent device, one of the parent locations of the interface's parent device's location, or it must be global.",
         )
 
     def test_add_ip_addresses(self):
@@ -2811,6 +2849,22 @@ class ModuleBayTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
         self.assertIsNone(child_module_bay.parent)
         self.assertIsNone(grandchild_module_bay.parent)
 
+    def test_position_value_auto_population(self):
+        """
+        Assert that the value of the module bay position is auto-populated by its name if position is not provided by the user.
+        """
+
+        module_bay = ModuleBay.objects.create(
+            parent_device=self.device,
+            name="1111",
+        )
+        module_bay.validated_save()
+        self.assertEqual(module_bay.position, module_bay.name)
+        # Test the default value is overriden if the user provides a position value.
+        module_bay.position = "1222"
+        module_bay.validated_save()
+        self.assertEqual(module_bay.position, "1222")
+
 
 class ModuleBayTemplateTestCase(ModularDeviceComponentTemplateTestCaseMixin, ModelTestCases.BaseModelTestCase):
     model = ModuleBayTemplate