nautobot 2.3.4__py3-none-any.whl → 2.3.6__py3-none-any.whl

nautobot/core/api/utils.py

@@ -116,7 +116,7 @@ def get_serializer_for_model(model, prefix=""):
         return dynamic_import(serializer_name)
     except AttributeError as exc:
         raise exceptions.SerializerNotFound(
-            f"Could not determine serializer for {app_label}.{model_name} with prefix '{prefix}'"
+            f"Serializer for {app_label}.{model_name} not found, expected it at {serializer_name}"
         ) from exc
 
 
@@ -129,16 +129,26 @@ def nested_serializers_for_models(models, prefix=""):
 
     Used exclusively in OpenAPI schema generation.
     """
+    from nautobot.core.api.serializers import BaseModelSerializer  # avoid circular import
+
     serializer_classes = []
     for model in models:
         try:
             serializer_classes.append(get_serializer_for_model(model, prefix=prefix))
         except exceptions.SerializerNotFound as exc:
-            logger.error("%s", exc)
+            logger.warning("%s", exc)
             continue
 
     nested_serializer_classes = []
     for serializer_class in serializer_classes:
+        if not issubclass(serializer_class, BaseModelSerializer):
+            logger.warning(
+                "Serializer class %s.%s does not inherit from nautobot.apps.api.BaseModelSerializer. "
+                "This should probably be corrected.",
+                serializer_class.__module__,
+                serializer_class.__name__,
+            )
+            continue
         nested_serializer_name = f"Nested{serializer_class.__name__}"
         if nested_serializer_name in NESTED_SERIALIZER_CACHE:
             nested_serializer_classes.append(NESTED_SERIALIZER_CACHE[nested_serializer_name])

nautobot/core/forms/fields.py

@@ -719,8 +719,11 @@ class NumericArrayField(SimpleArrayField):
 
     def to_python(self, value):
         try:
-            value = ",".join([str(n) for n in forms.parse_numeric_range(value)])
-        except ValueError as error:
+            if not value:
+                value = ""
+            else:
+                value = ",".join([str(n) for n in forms.parse_numeric_range(value)])
+        except (TypeError, ValueError) as error:
             raise ValidationError(error)
         return super().to_python(value)
 

nautobot/core/forms/utils.py

@@ -1,3 +1,4 @@
+from itertools import groupby
 import re
 
 from django import forms as django_forms
@@ -18,24 +19,31 @@ __all__ = (
 )
 
 
-def parse_numeric_range(string, base=10):
+def parse_numeric_range(input_string, base=10):
     """
-    Expand a numeric range (continuous or not) into a decimal or
+    Expand a numeric range (continuous or not) into a sorted decimal or
     hexadecimal list, as specified by the base parameter
       '0-3,5' => [0, 1, 2, 3, 5]
       '2,8-b,d,f' => [2, 8, 9, a, b, d, f]
     """
+    if base not in [10, 16]:
+        raise TypeError("Invalid base value.")
+
+    if not isinstance(input_string, str) or not input_string:
+        raise TypeError("Input value must be a string using a range format.")
+
     values = []
-    if not string:
-        return values
-    for dash_range in string.split(","):
+
+    for dash_range in input_string.split(","):
         try:
             begin, end = dash_range.split("-")
+            if begin == "" or end == "":
+                raise TypeError("Input value must be a string using a range format.")
         except ValueError:
             begin, end = dash_range, dash_range
         begin, end = int(begin.strip(), base=base), int(end.strip(), base=base) + 1
         values.extend(range(begin, end))
-    return list(set(values))
+    return sorted(list(set(values)))
 
 
 def parse_alphanumeric_range(string):
@@ -150,3 +158,20 @@ def add_field_to_filter_form_class(form_class, field_name, field_obj):
             f"There was a conflict with filter form field `{field_name}`, the custom filter form field was ignored."
         )
     form_class.base_fields[field_name] = field_obj
+
+
+def compress_range(iterable):
+    """
+    Generates compressed range from an un-sorted expanded range.
+    For example:
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101, 102, 103, 104, 105, 1000, 1100, 1101, 1102, 1103, 1104, 1105, 1106]
+        =>
+        iter1: (1, 10)
+        iter2: (100, 105)
+        iter3: (1000, 1000)
+        iter4: (1100, 1106)
+    """
+    iterable = sorted(set(iterable))
+    for _, grp in groupby(enumerate(iterable), lambda t: t[1] - t[0]):
+        grp = list(grp)
+        yield grp[0][1], grp[-1][1]

nautobot/core/models/fields.py

@@ -4,6 +4,7 @@ import re
 from django.core import exceptions
 from django.core.validators import MaxLengthValidator, RegexValidator
 from django.db import models
+from django.forms import TextInput
 from django.utils.text import slugify
 from django_extensions.db.fields import AutoSlugField as _AutoSlugField
 from netaddr import AddrFormatError, EUI, mac_unix_expanded
@@ -11,6 +12,7 @@ from taggit.managers import TaggableManager
 
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.forms import fields, widgets
+from nautobot.core.forms.utils import compress_range, parse_numeric_range
 from nautobot.core.models import ordering
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.validators import EnhancedURLValidator
@@ -415,3 +417,57 @@ class TagsField(TaggableManager):
         kwargs.setdefault("required", False)
         kwargs.setdefault("query_params", {"content_types": self.model._meta.label_lower})
         return super().formfield(form_class=form_class, **kwargs)
+
+
+class PositiveRangeNumberTextField(models.TextField):
+    default_error_messages = {
+        "invalid": "Invalid value. Specify a value using non-negative integers in a range format (i.e. '10-20').",
+    }
+
+    description = "A text based representation of positive number range."
+
+    def __init__(self, min_boundary=0, max_boundary=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.min_boundary = min_boundary
+        self.max_boundary = max_boundary
+
+    def to_python(self, value):
+        if value is None:
+            return None
+
+        try:
+            self.expanded = sorted(parse_numeric_range(value))
+        except (ValueError, AttributeError):
+            raise exceptions.ValidationError(
+                self.error_messages["invalid"],
+                code="invalid",
+                params={"value": value},
+            )
+
+        converted_ranges = compress_range(self.expanded)
+        normalized_range = ",".join([f"{x[0]}" if x[0] == x[1] else f"{x[0]}-{x[1]}" for x in converted_ranges])
+
+        return normalized_range
+
+    def validate(self, value, model_instance):
+        """
+        Validate `value` and raise ValidationError if necessary.
+        """
+        super().validate(value, model_instance)
+
+        if (self.min_boundary is not None and self.expanded[0] < self.min_boundary) or (
+            self.max_boundary is not None and self.expanded[-1] > self.max_boundary
+        ):
+            raise exceptions.ValidationError(
+                message=f"Invalid value. Specify a range value between {self.min_boundary}-{self.max_boundary or 'unlimited'}",
+                code="outofrange",
+                params={"value": value},
+            )
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            **{
+                "widget": TextInput,
+                **kwargs,
+            }
+        )

nautobot/core/tests/runner.py

@@ -64,9 +64,16 @@ class NautobotTestRunner(DiscoverRunner):
             action="store_true",
             help="Save test database to a json fixture file to re-use on subsequent tests.",
         )
+        parser.add_argument(
+            "--no-reusedb",
+            action="store_false",
+            dest="reusedb",
+            help="Supplement to --keepdb; if --no-reusedb is set an existing database will NOT be reused.",
+        )
 
-    def __init__(self, cache_test_fixtures=False, **kwargs):
+    def __init__(self, cache_test_fixtures=False, reusedb=True, **kwargs):
         self.cache_test_fixtures = cache_test_fixtures
+        self.reusedb = reusedb
 
         # Assert "integration" hasn't been provided w/ --tag
         incoming_tags = kwargs.get("tags") or []
@@ -118,7 +125,9 @@ class NautobotTestRunner(DiscoverRunner):
                         connection.creation.create_test_db(
                             verbosity=self.verbosity,
                             autoclobber=not self.interactive,
-                            keepdb=self.keepdb,
+                            keepdb=self.keepdb
+                            # Extra check added for Nautobot:
+                            and self.reusedb,
                             serialize=connection.settings_dict["TEST"].get("SERIALIZE", True),
                         )
 
@@ -149,7 +158,7 @@ class NautobotTestRunner(DiscoverRunner):
                                     verbosity=self.verbosity,
                                     keepdb=self.keepdb
                                     # Extra check added for Nautobot:
-                                    and not settings.TEST_USE_FACTORIES,
+                                    and self.reusedb,
                                 )
 
                 # Configure all other connections as mirrors of the first one
@@ -179,9 +188,7 @@ class NautobotTestRunner(DiscoverRunner):
                         connection.creation.destroy_test_db(
                             suffix=str(index + 1),
                             verbosity=self.verbosity,
-                            keepdb=self.keepdb
-                            # Extra check added for Nautobot
-                            and not settings.TEST_USE_FACTORIES,
+                            keepdb=self.keepdb,
                         )
 
                 # Extra block added for Nautobot

nautobot/core/tests/test_utils.py

@@ -11,6 +11,7 @@ from django.http import QueryDict
 from nautobot.circuits import models as circuits_models
 from nautobot.core import exceptions, forms, settings_funcs
 from nautobot.core.api import utils as api_utils
+from nautobot.core.forms.utils import compress_range
 from nautobot.core.models import fields as core_fields, utils as models_utils, validators
 from nautobot.core.testing import TestCase
 from nautobot.core.utils import data as data_utils, filtering, lookup, requests
@@ -365,6 +366,88 @@ class PrettyPrintQueryTest(TestCase):
                 self.assertEqual(models_utils.pretty_print_query(query), expected)
 
 
+class CompressRangeTest(TestCase):
+    """Tests for compress_range()."""
+
+    def test_compress_range_sparse(self):
+        values = [1500, 200, 10, 2222, 3000, 4096]
+        self.assertEqual(
+            list(compress_range(values)),
+            [
+                (10, 10),
+                (200, 200),
+                (1500, 1500),
+                (2222, 2222),
+                (3000, 3000),
+                (4096, 4096),
+            ],
+        )
+
+    def test_compress_range_dense(self):
+        values = [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            100,
+            101,
+            102,
+            103,
+            104,
+            105,
+            1100,
+            1101,
+            1102,
+            1103,
+            1104,
+            1105,
+            1106,
+        ]
+        self.assertEqual(
+            list(compress_range(values)),
+            [(1, 10), (100, 105), (1100, 1106)],
+        )
+
+    def test_compress_range_complex(self):
+        values = [
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            100,
+            200,
+            210,
+            211,
+            212,
+            222,
+            500,
+            501,
+            502,
+            503,
+            600,
+        ]
+        self.assertEqual(
+            list(compress_range(values)),
+            [
+                (10, 15),
+                (100, 100),
+                (200, 200),
+                (210, 212),
+                (222, 222),
+                (500, 503),
+                (600, 600),
+            ],
+        )
+
+
 class SlugifyFunctionsTest(TestCase):
     """Test custom slugify functions."""
 

nautobot/core/tests/test_views.py

@@ -1,8 +1,9 @@
 import re
-from unittest import mock
+from unittest import mock, skipIf
 import urllib.parse
 
 from django.apps import apps
+from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import override_settings, RequestFactory
@@ -572,3 +573,41 @@ class SilkUIAccessTestCase(TestCase):
 
         # Check for success status code (e.g., 200)
         self.assertEqual(response.status_code, 200)
+
+
+class ExampleViewWithCustomPermissionsTest(TestCase):
+    @skipIf(
+        "example_app" not in settings.PLUGINS,
+        "example_app not in settings.PLUGINS",
+    )
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_permission_classes_attribute_is_enforced(self):
+        """
+        If example app is installed, check if the ViewWithCustomPermissions
+        is enforcing the permissions specified in its `permission_classes` attribute.
+        """
+        # Test IsAuthenticated permission
+        self.add_permissions("example_app.view_examplemodel")
+        self.client.logout()
+        url = reverse("plugins:example_app:view_with_custom_permissions")
+        response = self.client.get(url, follow=True)
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        # check if the user is redirected to the login page
+        self.assertIn(f'<input type="hidden" name="next" value="{url}" />', response_body)
+
+        # Test IsAdmin permission
+        self.client.force_login(self.user)
+        response = self.client.get(url, follow=True)
+        self.assertHttpStatus(response, 403)
+        response_body = response.content.decode(response.charset)
+        # check if the users have to have the permission to access the page
+        self.assertIn("You do not have permission to access this page.", response_body)
+
+        # View should be successfully accessed
+        self.user.is_staff = True
+        self.user.save()
+        response = self.client.get(url)
+        self.assertHttpStatus(response, 200)
+        response_body = response.content.decode(response.charset)
+        self.assertIn("You are viewing a table of example models", response_body)

nautobot/core/views/generic.py

@@ -17,7 +17,7 @@ from django.db.models import ManyToManyField, ProtectedError, Q
 from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render
-from django.urls import reverse
+from django.urls import resolve, reverse
 from django.utils.encoding import iri_to_uri
 from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
@@ -205,17 +205,16 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         filter_form = None
         hide_hierarchy_ui = False
         clear_view = request.GET.get("clear_view", False)
+        resolved_path = resolve(request.path)
+        list_url = f"{resolved_path.app_name}:{resolved_path.url_name}"
 
         # If the user clicks on the clear view button, we do not check for global or user defaults
         if not clear_view and not request.GET.get("saved_view"):
             # Check if there is a default for this view for this specific user
-            app_label, model_name = model._meta.label.split(".")
-            view_name = f"{app_label}:{model_name.lower()}_list"
-
             if not isinstance(user, AnonymousUser):
                 try:
                     user_default_saved_view_pk = UserSavedViewAssociation.objects.get(
-                        user=user, view_name=view_name
+                        user=user, view_name=list_url
                     ).saved_view.pk
                     # Saved view should either belong to the user or be public
                     SavedView.objects.get(
@@ -229,7 +228,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
             # Check if there is a global default for this view
             try:
-                global_saved_view = SavedView.objects.get(view=view_name, is_global_default=True)
+                global_saved_view = SavedView.objects.get(view=list_url, is_global_default=True)
                 return redirect(reverse("extras:savedview", kwargs={"pk": global_saved_view.pk}))
             except ObjectDoesNotExist:
                 pass
@@ -302,7 +301,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         table_config_form = None
         current_saved_view = None
         current_saved_view_pk = self.request.GET.get("saved_view", None)
-        list_url = validated_viewname(model, "list")
         # We are not using .restrict(request.user, "view") here
         # User should be able to see any saved view that he has the list view access to.
         if user.has_perms(["extras.view_savedview"]):
@@ -315,15 +313,17 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
                 SavedView.objects.filter(view=list_url, owner=user).order_by("name").only("pk", "name")
             )
             saved_views = shared_saved_views | user_owned_saved_views
+
+        if current_saved_view_pk:
+            try:
+                # We are not using .restrict(request.user, "view") here
+                # User should be able to see any saved view that he has the list view access to.
+                current_saved_view = SavedView.objects.get(view=list_url, pk=current_saved_view_pk)
+            except ObjectDoesNotExist:
+                messages.error(request, f"Saved view {current_saved_view_pk} not found")
+
+        # Construct the objects table
         if self.table:
-            # Construct the objects table
-            if current_saved_view_pk:
-                try:
-                    # We are not using .restrict(request.user, "view") here
-                    # User should be able to see any saved view that he has the list view access to.
-                    current_saved_view = SavedView.objects.get(view=list_url, pk=current_saved_view_pk)
-                except ObjectDoesNotExist:
-                    messages.error(request, f"Saved view {current_saved_view_pk} not found")
             if self.request.GET.getlist("sort") or (
                 current_saved_view is not None and current_saved_view.config.get("sort_order")
             ):

nautobot/core/views/mixins.py

@@ -234,6 +234,7 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     serializer_class = None
     table_class = None
     notes_form_class = NoteForm
+    permission_classes = []
 
     def get_permissions_for_model(self, model, actions):
         """
@@ -267,7 +268,7 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
         """
         user = self.request.user
         permission_required = self.get_required_permission()
-        # Check that the user has been granted the required permission(s) one by one.
+        # Check that the user has been granted the required Nautobot-specific object permission(s) one by one.
         # In case the permission has `message` or `code`` attribute, we want to include those information in the permission_denied error.
         for permission in permission_required:
             # If the user does not have the permission required, we raise DRF's `NotAuthenticated` or `PermissionDenied` exception
@@ -280,6 +281,16 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
                     code=getattr(permission, "code", None),
                 )
 
+        # Check for drf-specific permissions (IsAutheticated, etc) in permission_classes which is empty by default.
+        # self.get_permissions() iterates through permissions specified in the `permission_classes` attribute.
+        for permission in self.get_permissions():
+            # If the user does not have the permission required, we raise DRF's `NotAuthenticated` or `PermissionDenied` exception
+            # which will be handled by self.handle_no_permission() in the UI appropriately in the dispatch() method
+            if not permission.has_permission(request, self):
+                self.permission_denied(
+                    request, message=getattr(permission, "message", None), code=getattr(permission, "code", None)
+                )
+
     def dispatch(self, request, *args, **kwargs):
         """
         Override the default dispatch() method to check permissions first.

nautobot/core/views/renderers.py

@@ -5,6 +5,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models import Q
 from django.template import engines, loader
+from django.urls import resolve
 from django_tables2 import RequestConfig
 from rest_framework import renderers
 
@@ -295,7 +296,8 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
             # Construct valid actions for list view.
             valid_actions = self.validate_action_buttons(view, request)
             # Query SavedViews for dropdown button
-            list_url = validated_viewname(model, "list")
+            resolved_path = resolve(request.path)
+            list_url = f"{resolved_path.app_name}:{resolved_path.url_name}"
             saved_views = None
             if model.is_saved_view_model:
                 # We are not using .restrict(request.user, "view") here

nautobot/core/views/utils.py

@@ -213,7 +213,7 @@ def handle_protectederror(obj_list, request, e):
     protected_objects = list(e.protected_objects)
     protected_count = len(protected_objects) if len(protected_objects) <= 50 else "More than 50"
     err_message = format_html(
-        "Unable to delete <strong>{}</strong>. {} dependent objects were found: ",
+        str(e.args[0]) if e.args else "Unable to delete <strong>{}</strong>. {} dependent objects were found: ",
         ", ".join(str(obj) for obj in obj_list),
         protected_count,
     )

nautobot/dcim/api/serializers.py

@@ -389,6 +389,7 @@ class RackElevationDetailFilterSerializer(serializers.Serializer):
     expand_devices = serializers.BooleanField(required=False, default=True)
     include_images = serializers.BooleanField(required=False, default=True)
     display_fullname = serializers.BooleanField(required=False, default=True)
+    is_occupied = serializers.BooleanField(required=False, allow_null=True, default=None)
 
     def validate(self, attrs):
         attrs.setdefault("unit_width", get_settings_or_config("RACK_ELEVATION_DEFAULT_UNIT_WIDTH"))

nautobot/dcim/api/views.py

@@ -231,6 +231,8 @@ class RackViewSet(NautobotModelViewSet):
                 exclude=data["exclude"],
                 expand_devices=data["expand_devices"],
             )
+            if data["is_occupied"] is not None:
+                elevation = [u for u in elevation if u["occupied"] == data["is_occupied"]]
 
             # Enable filtering rack units by ID
             q = data["q"]

nautobot/dcim/forms.py

@@ -1900,7 +1900,7 @@ class DeviceForm(LocatableModelFormMixin, NautobotModelForm, TenancyForm, LocalC
         widget=APISelect(
             api_url="/api/dcim/racks/{{rack}}/elevation/",
             attrs={
-                "disabled-indicator": "device",
+                "disabled-indicator": "occupied",
                 "data-query-param-face": '["$face"]',
             },
         ),

nautobot/dcim/templates/dcim/devicefamily_retrieve.html

@@ -16,7 +16,7 @@
                 </tr>
                 <tr>
                     <td>Device Types</td>
-                    <td><a href="{% url 'dcim:devicetype_list' %}?device_family={{ object.name }}">{{ object.device_type_count }}</a></td>
+                    <td><a href="{% url 'dcim:devicetype_list' %}?device_family={{ object.name }}">{{ device_type_count }}</a></td>
                 </tr>
                 <tr>
                     <td>Total Devices</td>

nautobot/dcim/tests/test_api.py

@@ -139,7 +139,7 @@ class Mixins:
             super().setUpTestData()
             cls.device_type = DeviceType.objects.first()
             cls.manufacturer = cls.device_type.manufacturer
-            cls.location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+            cls.location = Location.objects.filter(location_type__name="Campus").first()
             cls.device_role = Role.objects.get_for_model(Device).first()
             cls.device_status = Status.objects.get_for_model(Device).first()
             cls.device = Device.objects.create(
@@ -539,6 +539,8 @@ class RackGroupTest(APIViewTestCases.APIViewTestCase, APIViewTestCases.TreeModel
     def setUpTestData(cls):
         cls.status = Status.objects.get_for_model(Location).first()
         location_type = LocationType.objects.create(name="Location Type 1")
+        location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
+
         cls.locations = (
             Location.objects.create(name="Location 1", location_type=location_type, status=cls.status),
             Location.objects.create(name="Location 2", location_type=location_type, status=cls.status),
@@ -548,8 +550,6 @@ class RackGroupTest(APIViewTestCases.APIViewTestCase, APIViewTestCases.TreeModel
             RackGroup.objects.create(location=cls.locations[1], name="Parent Rack Group 2"),
         )
 
-        location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
-
         RackGroup.objects.create(
             location=cls.locations[0],
             name="Rack Group 1",
@@ -643,7 +643,10 @@ class RackTest(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        locations = Location.objects.all()[:2]
+        locations = Location.objects.filter(devices__isnull=False)[:2]
+        for location in locations:
+            location.location_type.content_types.add(ContentType.objects.get_for_model(RackGroup))
+            location.location_type.content_types.add(ContentType.objects.get_for_model(Rack))
 
         rack_groups = (
             RackGroup.objects.create(location=locations[0], name="Rack Group 1"),
@@ -675,6 +678,22 @@ class RackTest(APIViewTestCases.APIViewTestCase):
             status=statuses[0],
         )
 
+        populated_rack = Rack.objects.create(
+            location=locations[0],
+            rack_group=rack_groups[0],
+            role=rack_roles[0],
+            name="Populated Rack",
+            status=statuses[0],
+        )
+        # Place a device in Rack 4
+        device = Device.objects.filter(
+            location=populated_rack.location, rack__isnull=True, device_type__u_height__gt=0
+        ).first()
+        device.rack = populated_rack
+        device.face = "front"
+        device.position = 10
+        device.save()
+
         cls.create_data = [
             {
                 "name": "Test Rack 4",
@@ -742,6 +761,44 @@ class RackTest(APIViewTestCases.APIViewTestCase):
         response = self.client.get(url, params, **self.header)
         self.assertHttpStatus(response, 200)
 
+    def test_filter_rack_elevation_is_occupied(self):
+        """
+        Test filtering the list of rack elevations by occupied status.
+        """
+        rack = Rack.objects.get(name="Populated Rack")
+        self.add_permissions("dcim.view_rack")
+        url = reverse("dcim-api:rack-elevation", kwargs={"pk": rack.pk})
+        # Get all units first
+        params = {"face": "front"}
+        response = self.client.get(url, params, **self.header)
+        all_units = response.data["results"]
+        # Assert the count is equal to the number of units in the rack
+        self.assertEqual(len(all_units), rack.u_height)
+
+        # Next get only unoccupied units
+        params = {"face": "front", "is_occupied": False}
+        response = self.client.get(url, params, **self.header)
+        unoccupied_units = response.data["results"]
+        # Assert the count is more than 0
+        self.assertGreater(len(unoccupied_units), 0)
+        # Assert the unoccupied count is less than the total number of units
+        self.assertLess(len(unoccupied_units), len(all_units))
+
+        # Next get only occupied units
+        params = {"face": "front", "is_occupied": True}
+        response = self.client.get(url, params, **self.header)
+        occupied_units = response.data["results"]
+        # Assert the count is more than 0
+        self.assertGreater(len(occupied_units), 0)
+        # Assert the occupied count is less than the total number of units
+        self.assertLess(len(occupied_units), len(all_units))
+
+        # Assert that the sum of unoccupied and occupied units is equal to the total number of units
+        self.assertEqual(len(unoccupied_units) + len(occupied_units), len(all_units))
+        # Assert that the lists are mutually exclusive
+        self.assertEqual(len([unit for unit in unoccupied_units if unit in occupied_units]), 0)
+        self.assertEqual(len([unit for unit in occupied_units if unit in unoccupied_units]), 0)
+
     def test_get_rack_elevation_svg(self):
         """
         GET a single rack elevation in SVG format.