nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/core/templatetags/ui_framework.py

@@ -31,6 +31,23 @@ def render_components(context, components):
     return ""
 
 
+@register.simple_tag(takes_context=True)
+def render_table_config_forms(context, tabs):
+    if tabs is not None:
+        return format_html_join(
+            "\n",
+            "{}",
+            (
+                [panel.render_table_config_form(context)]
+                for tab in tabs
+                if tab.should_render_content(context)
+                for panel in tab.panels
+                if hasattr(panel, "render_table_config_form")
+            ),
+        )
+    return ""
+
+
 @register.simple_tag(takes_context=True)
 def render_title(context, mode="plain"):
     """

nautobot/core/testing/api.py

@@ -3,6 +3,7 @@ from io import StringIO
 from typing import Optional, Sequence, Union
 
 from django.conf import settings
+from django.contrib.auth.models import Group
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.db import connections, DEFAULT_DB_ALIAS
@@ -16,6 +17,7 @@ from rest_framework import serializers, status
 from rest_framework.relations import ManyRelatedField
 from rest_framework.test import APITransactionTestCase as _APITransactionTestCase
 
+from nautobot.core import constants
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.models import fields as core_fields
 from nautobot.core.models.tree_queries import TreeModel
@@ -253,7 +255,7 @@ class APIViewTestCases:
                 if not field.name.startswith("_"):
                     if isinstance(field, (ForeignKey, GenericForeignKey, ManyToManyField, core_fields.TagsField)) and (
                         # we represent content-types as "app_label.modelname" rather than as FKs
-                        field.related_model != ContentType
+                        field.related_model not in [ContentType, Group]
                         # user is a model field on Token but not a field on TokenSerializer
                         and not (field.name == "user" and self.model == users_models.Token)
                     ):
@@ -293,8 +295,9 @@ class APIViewTestCases:
             m2m_fields = self.get_m2m_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
             list_url = f"{self._get_list_url()}?depth=0"
+            # With exclude_m2m query parameter set to False
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=false", **self.header)
             base_num_queries = len(cqc)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
@@ -339,9 +342,9 @@ class APIViewTestCases:
                                 app_label, model_name = object_type.split(".")
                                 ContentType.objects.get(app_label=app_label, model=model_name)
 
-            list_url += "&exclude_m2m=true"
+            # With exclude_m2m query parameter set to True
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=true", **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
@@ -386,8 +389,9 @@ class APIViewTestCases:
             m2m_fields = self.get_m2m_fields()
             self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
             list_url = f"{self._get_list_url()}?depth=1"
+            # With exclude_m2m query parameter set to False
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=false", **self.header)
             base_num_queries = len(cqc)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
@@ -419,9 +423,9 @@ class APIViewTestCases:
                                 self.assertTrue(is_uuid(response_data[field]["id"]))
                             self.assertGreater(len(response_data[field].keys()), 3, response_data[field])
 
-            list_url += "&exclude_m2m=true"
+            # With exclude_m2m query parameter set to True
             with CaptureQueriesContext(connections[DEFAULT_DB_ALIAS]) as cqc:
-                response = self.client.get(list_url, **self.header)
+                response = self.client.get(list_url + "&exclude_m2m=true", **self.header)
 
             self.assertHttpStatus(response, status.HTTP_200_OK)
             self.assertIsInstance(response.data, dict)
@@ -457,6 +461,54 @@ class APIViewTestCases:
                     self.assertNotIn(field, response_data)
                 # TODO: we should assert that all other fields are still present, but there's a few corner cases...
 
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_list_objects_exclude_m2m(self):
+            """
+            GET a list of objects with or without the "exclude_m2m" parameter.
+
+            With exclude_m2m query parameter set to True, we should see no many-to-many fields.
+            With exclude_m2m query parameter set to False, we should see all many-to-many fields.
+            With exclude_m2m query parameter not set, we should only see the default many-to-many fields.
+            """
+            m2m_fields = self.get_m2m_fields()
+            if not m2m_fields:
+                self.skipTest("No many-to-many fields to test")
+            self.add_permissions(f"{self.model._meta.app_label}.view_{self.model._meta.model_name}")
+            list_url = f"{self._get_list_url()}"
+
+            # With exclude_m2m query parameter not set
+            response = self.client.get(list_url, **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+
+            for response_data in response.data["results"]:
+                for field in m2m_fields:
+                    if field in constants.DEFAULT_M2M_FIELDS:
+                        self.assertIn(field, response_data)
+                        self.assertIsInstance(response_data[field], list)
+                    else:
+                        self.assertNotIn(field, response_data)
+
+            # With exclude_m2m query parameter set to True
+            response = self.client.get(list_url + "?exclude_m2m=true", **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+            for response_data in response.data["results"]:
+                for field in m2m_fields:
+                    self.assertNotIn(field, response_data)
+
+            # With exclude_m2m query parameter set to False
+            response = self.client.get(list_url + "?exclude_m2m=false", **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            self.assertIsInstance(response.data, dict)
+            self.assertIn("results", response.data)
+            for response_data in response.data["results"]:
+                for field in m2m_fields:
+                    self.assertIn(field, response_data)
+                    self.assertIsInstance(response_data[field], list)
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_without_permission(self):
             """
@@ -745,8 +797,12 @@ class APIViewTestCases:
                 # Verify ObjectChange creation
                 if hasattr(self.model, "to_objectchange"):
                     objectchanges = lookup.get_changes_for_model(instance)
-                    self.assertEqual(len(objectchanges), 1)
-                    self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_CREATE)
+                    # For models with ManyToMany relationships (like Device with clusters), the creation
+                    # process may generate both CREATE and UPDATE records. We just need to ensure at least
+                    # one ObjectChange record exists.
+                    self.assertGreaterEqual(len(objectchanges), 1)
+                    # Verify that at least one ObjectChange record is for this instance
+                    self.assertTrue(any(oc.changed_object == instance for oc in objectchanges))
 
         # TODO: The override_settings here is a temporary workaround for not breaking any app tests
         # long term fix should be using appropriate object permissions instead of the blanket override
@@ -1071,12 +1127,20 @@ class APIViewTestCases:
 
             self.assertIn("actions", data)
 
-            # Grab any field that has choices defined (fields with enums)
+            # Grab any field that has choices defined (fields with enums including child fields with enums)
             field_choices = {}
             if "POST" in data["actions"]:
-                field_choices = {k for k, v in data["actions"]["POST"].items() if "choices" in v}
+                field_choices = {
+                    k
+                    for k, v in data["actions"]["POST"].items()
+                    if "choices" in v or ("child" in v and "choices" in v["child"])
+                }
             elif "PUT" in data["actions"]:
-                field_choices = {k for k, v in data["actions"]["PUT"].items() if "choices" in v}
+                field_choices = {
+                    k
+                    for k, v in data["actions"]["PUT"].items()
+                    if "choices" in v or ("child" in v and "choices" in v["child"])
+                }
             else:
                 self.fail(f"Neither PUT nor POST are available actions in: {data['actions']}")
 

nautobot/core/testing/filters.py

@@ -21,7 +21,6 @@ from nautobot.core.filters import (
 )
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.testing import views
-from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Tag, Team
 from nautobot.tenancy import models
 
@@ -215,7 +214,9 @@ class FilterTestCases:
                 with self.subTest(f"{self.filterset.__name__} filter {filter_name} ({field_name})"):
                     test_data = self.get_filterset_test_values(field_name)
                     params = {filter_name: test_data}
-                    filterset_result = self.filterset(params, self.queryset).qs  # pylint: disable=not-callable
+                    filterset = self.filterset(params, self.queryset)  # pylint: disable=not-callable
+                    self.assertIn(filter_name, list(filterset.filters.keys()))
+                    filterset_result = filterset.qs
                     qs_result = self.queryset.filter(**{f"{field_name}__in": test_data}).distinct()
                     self.assertQuerysetEqualAndNotEmpty(filterset_result, qs_result, ordered=False)
 
@@ -237,8 +238,8 @@ class FilterTestCases:
             """Test all `RelatedMembershipBooleanFilter` filters found in `self.filterset.filters`
             except for the ones with custom filter logic defined in its `method` attribute.
 
-            This test asserts that `filter=True` matches `self.queryset.filter(field__isnull=False)` and
-            that `filter=False` matches `self.queryset.filter(field__isnull=True)`.
+            This test asserts that `filter=True` matches `self.queryset.filter(field__isnull=...)` and
+            that `filter=False` matches `self.queryset.exclude(field__isnull=...)`.
             """
             self.assertIsNotNone(self.filterset)
             for filter_name, filter_object in self.filterset().filters.items():  # pylint: disable=not-callable
@@ -425,31 +426,14 @@ class FilterTestCases:
                         # This field is not part of the Filterset.
                         continue
                     self.assertIsInstance(
-                        filter_field, (ContentTypeFilter, ContentTypeMultipleChoiceFilter, ContentTypeChoiceFilter)
+                        filter_field,
+                        (
+                            ContentTypeFilter,
+                            ContentTypeMultipleChoiceFilter,
+                            ContentTypeChoiceFilter,
+                        ),
                     )
 
-    # Test cases should just explicitly include `name` as a generic_filter_tests entry
-    @class_deprecated_in_favor_of(FilterTestCase)  # pylint: disable=undefined-variable
-    class NameOnlyFilterTestCase(FilterTestCase):
-        """Add simple tests for filtering by name."""
-
-        def test_filters_generic(self):
-            if not any(test[0] == "name" for test in self.generic_filter_tests):
-                self.generic_filter_tests = (["name"], *self.generic_filter_tests)
-            super().test_filters_generic()
-
-    # Test cases should just explicitly include `name` and `slug` as generic_filter_tests entries
-    @class_deprecated_in_favor_of(FilterTestCase)  # pylint: disable=undefined-variable
-    class NameSlugFilterTestCase(FilterTestCase):
-        """Add simple tests for filtering by name and by slug."""
-
-        def test_filters_generic(self):
-            if not any(test[0] == "slug" for test in self.generic_filter_tests):
-                self.generic_filter_tests = (["slug"], *self.generic_filter_tests)
-            if not any(test[0] == "name" for test in self.generic_filter_tests):
-                self.generic_filter_tests = (["name"], *self.generic_filter_tests)
-            super().test_filters_generic()
-
     class TenancyFilterTestCaseMixin(views.TestCase):
         """Add test cases for tenant and tenant-group filters."""
 

nautobot/core/testing/integration.py

@@ -7,7 +7,9 @@ from django.db.models import Model
 from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.functional import classproperty
+from selenium.webdriver.common.by import By
 from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.expected_conditions import element_to_be_clickable
 from selenium.webdriver.support.wait import WebDriverWait
 from splinter.browser import Browser
 from splinter.exceptions import ElementDoesNotExist
@@ -90,6 +92,12 @@ class ObjectsListMixin:
         """
         self.click_button('#select_all_box button[name="_edit"]')
 
+    def click_add_item(self):
+        """
+        Click add item button on top of the items table list.
+        """
+        self.click_button("#add-button")
+
     def click_table_link(self, row=1, column=2):
         """By default, tries to click column next to checkbox to go to the details page."""
         self.browser.find_by_xpath(f'//*[@id="object_list_form"]//tbody/tr[{row}]/td[{column}]/a').click()
@@ -123,7 +131,7 @@ class ObjectDetailsMixin:
         By default, it's not using the exact match, because on the UI we're often adding
         additional tags, relationships or units.
         """
-        panel_xpath = f'//*[@id="main"]//div[@class="panel-heading"][contains(normalize-space(), "{panel_label}")]/following-sibling::table'
+        panel_xpath = f'//*[@id="main"]//div[contains(@class, "card-header") and contains(normalize-space(), "{panel_label}")]/following-sibling::div[contains(@class, "collapse")]/table'
         value = self.browser.find_by_xpath(f'{panel_xpath}//td[text()="{field_label}"]/following-sibling::td[1]').text
 
         if exact_match:
@@ -131,6 +139,52 @@ class ObjectDetailsMixin:
         else:
             self.assertIn(str(expected_value), value)
 
+    def find_and_open_panel_v2(self, panel_label):
+        """
+        Finds panel with given title and expand it if needed. Works with v2 template panels.
+
+        TODO: remove after all panels will be moved to UI Components Framework or new Bootstrap 5 templates.
+        """
+        panel_xpath = f'//*[@id="main"]//div[@class="card-header"][contains(normalize-space(), "{panel_label}")]'
+        expand_button_xpath = f"{panel_xpath}/button[normalize-space()='Expand All Groups']"
+        expand_button = self.browser.find_by_xpath(expand_button_xpath)
+        if not expand_button.is_empty():
+            expand_button.click()
+        return self.browser.find_by_xpath(f"{panel_xpath}/../table")
+
+    def switch_tab(self, tab_name):
+        """Finds and click tab based on tab name from the tab link."""
+        self.get_tab_link(tab_name).click()
+
+    def get_tab_link(self, tab_name):
+        """
+        Finds tab link either in dropdown menu, cloned menu or standard tabs list
+        depending on the browser size and tabs count.
+
+        Please note, that if tab will be placed in dropdown menu this function will left this menu open.
+        """
+        tabs_container_xpath = '//div[@data-nb-tests-id="object-details-header-tabs"]'
+        toggle_button_xpath = f'{tabs_container_xpath}//button[@data-bs-toggle="dropdown"]'
+        toggle_button = self.browser.find_by_xpath(toggle_button_xpath, wait_time=5)
+        if toggle_button:
+            # Our tab might be hidden
+            tab_xpath = (
+                f'{tabs_container_xpath}//ul[@data-clone="true"]/li/a[contains(normalize-space(), "{tab_name}")]'
+            )
+            visible_tab = self.browser.find_by_xpath(tab_xpath, wait_time=5)
+            if visible_tab:
+                return visible_tab
+
+            # If hidden, click toggle to show the dropdown menu
+            toggle_button.click()
+            tab_xpath = f'{toggle_button_xpath}/following-sibling::ul//a[contains(normalize-space(), "{tab_name}")]'
+            return self.browser.find_by_xpath(tab_xpath, wait_time=5)
+
+        tab_xpath = (
+            f'//ul[@data-nb-tests-id="object-details-header-tabs-ul"]//a[contains(normalize-space(), "{tab_name}")]'
+        )
+        return self.browser.find_by_xpath(tab_xpath, wait_time=5)
+
 
 class BulkOperationsMixin:
     def confirm_bulk_delete_operation(self):
@@ -173,7 +227,7 @@ class BulkOperationsMixin:
         if is_select:
             self.fill_select2_field(field_name, value)
         else:
-            self.browser.fill(field_name, value)
+            self.fill_input(field_name, value)
 
     def assertBulkDeleteConfirmMessageIsValid(self, expected_count):
         """
@@ -207,6 +261,44 @@ class BulkOperationsMixin:
         self.assertEqual(job_status, "Completed")
 
 
+class SidenavSection:
+    """
+    Helper class which represents a Sidenav section and simplify moving around sidenav, expanding section and clicking
+    proper navigation link.
+    """
+
+    def __init__(self, browser, section_name):
+        self.browser = browser
+        self.section_name = section_name
+        self.section_xpath = f"//*[@id='sidenav']//li[@data-section-name='{self.section_name}']"
+        self.section = self.browser.find_by_xpath(self.section_xpath)
+
+    @property
+    def button(self):
+        return self.section.find_by_xpath(f"{self.section_xpath}/button")
+
+    @property
+    def flyout(self):
+        return self.section.find_by_xpath(f"{self.section_xpath}/div[@class='nb-sidenav-flyout']")
+
+    @property
+    def is_expanded(self):
+        return self.button["aria-expanded"] == "true"
+
+    def toggle(self):
+        if not self.is_expanded:
+            self.button.click()
+
+    def find_link(self, link_name):
+        return self.section.find_by_xpath(
+            f"{self.section_xpath}/div[@class='nb-sidenav-flyout']//a[@class='nb-sidenav-link' and normalize-space()='{link_name}']"
+        )
+
+    def click_link(self, link_name):
+        link = self.find_link(link_name)
+        link.click()
+
+
 # In CI, sometimes the FQDN of SELENIUM_HOST gets used, other times it seems to be just the hostname?
 @override_settings(ALLOWED_HOSTS=["nautobot.example.com", SELENIUM_HOST, SELENIUM_HOST.split(".")[0]])
 @tag("integration")
@@ -265,23 +357,31 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         if self.browser.is_text_present("Please enter a correct username and password."):
             self.fail(f"Unable to login in with username {username}")
 
+        self.logged_in = True
+
     def logout(self):
         self.browser.visit(f"{self.live_server_url}/logout")
 
+    def find_sidenav_section(self, tab_name):
+        """
+        Helper function to find sidenav section known as "tab_name". In `nav_menu` we still have tabs/groups naming.
+        """
+        return SidenavSection(self.browser, tab_name)
+
     def click_navbar_entry(self, parent_menu_name, child_menu_name):
         """
         Helper function to click on a parent menu and child menu in the navigation bar.
         """
-        parent_menu_xpath = f"//*[@id='navbar']//a[@class='dropdown-toggle' and normalize-space()='{parent_menu_name}']"
-        parent_menu = self.browser.find_by_xpath(parent_menu_xpath, wait_time=5)
-        if not parent_menu["aria-expanded"] == "true":
-            parent_menu.click()
-        child_menu_xpath = f"{parent_menu_xpath}/following-sibling::ul//li[.//a[normalize-space()='{child_menu_name}']]"
+        section_xpath = f"//*[@id='sidenav']//li[@data-section-name='{parent_menu_name}']"
+        sidenav_button = self.browser.find_by_xpath(f"{section_xpath}/button", wait_time=5)
+        if not sidenav_button["aria-expanded"] == "true":
+            sidenav_button.click()
+        child_menu_xpath = f"{section_xpath}/div[@class='nb-sidenav-flyout']//a[contains(@class, 'nb-sidenav-link') and normalize-space()='{child_menu_name}']"
         child_menu = self.browser.find_by_xpath(child_menu_xpath, wait_time=5)
         old_url = self.browser.url
         child_menu.click()
 
-        WebDriverWait(self.browser, 5).until(lambda driver: driver.url != old_url)
+        WebDriverWait(self.browser, 30).until(lambda driver: driver.url != old_url)
         # Wait for body element to appear
         self.assertTrue(self.browser.is_element_present_by_tag("body", wait_time=5), "Page failed to load")
 
@@ -357,11 +457,29 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         search_box.first.type(Keys.ENTER)
 
     def click_button(self, query_selector):
-        btn = self.browser.find_by_css(query_selector, wait_time=5)
+        self.browser.is_element_present_by_css(query_selector, wait_time=5)
         # Button might be visible but on the edge and then impossible to click due to vertical/horizontal scrolls
-        self.browser.execute_script(f"document.querySelector('{query_selector}').scrollIntoView()")
+        self.browser.execute_script(
+            f"document.querySelector('{query_selector}').scrollIntoView({{ behavior: 'instant', block: 'start' }});"
+        )
+        # Scrolling may be asynchronous, wait until it's actually clickable.
+        WebDriverWait(self.browser.driver, 30).until(element_to_be_clickable((By.CSS_SELECTOR, query_selector)))
+        btn = self.browser.find_by_css(query_selector)
         btn.click()
 
+    def fill_input(self, input_name, input_value):
+        """
+        Helper function to fill an input field. Solves issue with element could not be scrolled into view for some pages.
+        """
+        self.browser.is_element_present_by_name(input_name, wait_time=5)
+        element = self.browser.find_by_name(input_name)
+        self.browser.execute_script(
+            "arguments[0].scrollIntoView({ behavior: 'instant', block: 'start' });", element.first._element
+        )
+        element.is_visible(wait_time=5)
+        self.browser.execute_script("arguments[0].focus();", element.first._element)
+        self.browser.fill(input_name, input_value)
+
     def login_as_superuser(self):
         self.user.is_superuser = True
         self.user.save()

nautobot/core/testing/mixins.py

@@ -19,6 +19,7 @@ from nautobot.core.testing import utils
 from nautobot.core.utils import permissions
 from nautobot.extras import management, models as extras_models
 from nautobot.extras.choices import JobResultStatusChoices
+from nautobot.ipam.models import default_namespace_pk
 from nautobot.users import models as users_models
 
 # Use the proper swappable User model
@@ -81,6 +82,7 @@ class NautobotTestCaseMixin:
         """
         super().tearDown()
         cache.clear()
+        default_namespace_pk.set(None)
 
     def prepare_instance(self, instance):
         """
@@ -220,10 +222,11 @@ class NautobotTestCaseMixin:
         Compare a model instance to a dictionary, checking that its attribute values match those specified
         in the dictionary.
 
-        :param instance: Python object instance
-        :param data: Dictionary of test data used to define the instance
-        :param exclude: List of fields to exclude from comparison (e.g. passwords, which get hashed)
-        :param api: Set to True is the data is a JSON representation of the instance
+        Args:
+            instance (Model): Django model instance
+            data (dict): Dictionary of test data used to define the instance
+            exclude (Optional[List[str]]): List of fields to exclude from comparison (e.g. passwords, which get hashed)
+            api (bool): Set to True is the data is a JSON representation of the instance
         """
         if exclude is None:
             exclude = []

nautobot/core/testing/utils.py

@@ -10,6 +10,8 @@ from django.db.models import Q
 from django.db.models.deletion import PROTECT
 from tree_queries.models import TreeNodeForeignKey
 
+from nautobot.core.templatetags.helpers import bettertitle
+
 # Use the proper swappable User model
 User = get_user_model()
 
@@ -70,17 +72,20 @@ def extract_page_body(content):
     <html>
       <head>...</head>
       <body>
-        <nav>...</nav>
-        <div class="container-fluid wrapper"> <!-- BEGIN -->
-          ...
-        </div> <!-- END -->
+        <nav id="sidenav">...</nav><!-- BEGIN -->
+        <header><nav><!-- breadcrumbs --></nav></header>
+        <main class="container-fluid wrapper" id="main-content" tabindex="-1">
+        ...
+        </div><!-- END -->
         <footer class="footer">...</footer>
         ...
       </body>
     </html>
     """
     try:
-        return re.findall(r"(?<=</nav>).*(?=<footer)", content, flags=(re.MULTILINE | re.DOTALL))[0]
+        return re.findall(
+            r"<nav id=\"sidenav\"[^>]*>.*?</nav>(.*?)(?=<footer)", content, flags=(re.MULTILINE | re.DOTALL)
+        )[0]
     except IndexError:
         return content
 
@@ -117,3 +122,21 @@ def generate_random_device_asset_tag_of_specified_size(size):
     """
     asset_tag = "".join(random.choices(string.ascii_letters + string.digits, k=size))  # noqa: S311  # suspicious-non-cryptographic-random-usage
     return asset_tag
+
+
+def get_expected_menu_item_name(view_model) -> str:
+    """Return the expected menu item name for a given model."""
+    name_map = {
+        "VM Interfaces": "Interfaces",
+        "Object Changes": "Change Log",
+        "Controller Managed Device Groups": "Device Groups",
+        "Min Max Validation Rules": "Min/Max Rules",
+        "Regular Expression Validation Rules": "Regex Rules",
+        "Required Validation Rules": "Required Rules",
+        "Unique Validation Rules": "Unique Rules",
+        "Approval Workflow Definitions": "Workflow Definitions",
+        "Approval Workflow Stages": "Approval Dashboard",
+    }
+
+    expected = bettertitle(view_model._meta.verbose_name_plural)
+    return name_map.get(expected, expected)