nautobot 2.4.1__py3-none-any.whl → 2.4.3__py3-none-any.whl

nautobot/core/templates/inc/javascript.html

@@ -24,6 +24,8 @@
         onerror="window.location='{% url 'media_failure' %}?filename=js/theme.js'"></script>
 <script src="{% versioned_static 'js/table_sorting_indicator.js' %}"
         onerror="window.location='{% url 'media_failure' %}?filename=js/table_sorting_indicator.js'"></script>
+<script src="{% versioned_static 'js/dropdown.js' %}"
+        onerror="window.location='{% url 'media_failure' %}?filename=js/dropdown.js'"></script>
 <script type="text/javascript">
     var nautobot_api_path = "{% url 'api-root' %}";
     var nautobot_csrf_token = "{{ csrf_token }}";

nautobot/core/templates/widgets/clearable_file.html

@@ -0,0 +1,5 @@
+{% if widget.is_initial %}{{ widget.initial_text }}: <a href="{{ widget.value.url }}">{{ widget.value }}</a>{% if not widget.required %}
+<input type="checkbox" name="{{ widget.checkbox_name }}" id="{{ widget.checkbox_id }}"{% if widget.attrs.disabled %} disabled{% endif %}{% if widget.attrs.checked %} checked{% endif %}>
+<label for="{{ widget.checkbox_id }}">{{ widget.clear_checkbox_label }}</label>{% endif %}<br>
+{{ widget.input_text }}:{% endif %}
+<input type="{{ widget.type }}" name="{{ widget.name }}" class="filestyle" data-placeholder="No file selected" {% include "django/forms/widgets/attrs.html" %}>

nautobot/core/templatetags/helpers.py

@@ -870,9 +870,7 @@ def saved_view_modal(
 ):
     from nautobot.extras.forms import SavedViewModalForm
     from nautobot.extras.models import SavedView
-
-    param_dict = {}
-    filters_applied = parse_qs(params)
+    from nautobot.extras.utils import fixup_filterset_query_params
 
     sort_order = []
     per_page = None
@@ -889,6 +887,8 @@ def saved_view_modal(
         "table_changes_pending",
         "clear_view",
     ]
+    param_dict = {}
+    filters_applied = fixup_filterset_query_params(parse_qs(params), view, non_filter_params)
 
     view_class = lookup.get_view_for_model(model, "List")
     table_name = None

nautobot/core/testing/integration.py

@@ -1,7 +1,9 @@
 import os
+from typing import Any, Optional
 
 from django.conf import settings
 from django.contrib.staticfiles.testing import StaticLiveServerTestCase
+from django.db.models import Model
 from django.test import override_settings, tag
 from django.urls import reverse
 from django.utils.functional import classproperty
@@ -16,7 +18,7 @@ from nautobot.core import testing
 SELENIUM_URL = os.getenv("NAUTOBOT_SELENIUM_URL", "http://localhost:4444/wd/hub")
 
 # Hostname used by Selenium client to talk to Nautobot
-SELENIUM_HOST = os.getenv("NAUTOBOT_SELENIUM_HOST", "host.docker.internal")
+SELENIUM_HOST = os.getenv("NAUTOBOT_SELENIUM_HOST", "nautobot")
 
 # Default login URL
 LOGIN_URL = reverse(settings.LOGIN_URL)
@@ -28,23 +30,72 @@ class ObjectsListMixin:
     """
 
     def select_all_items(self):
-        self.browser.find_by_xpath('//*[@id="object_list_form"]//input[@class="toggle"]').click()
+        """
+        Click "toggle all" on top of the items table list to select all rows.
+        """
+        self.browser.find_by_css("#object_list_form input.toggle").click()
 
     def select_one_item(self):
-        self.browser.find_by_xpath('//*[@id="object_list_form"]//input[@name="pk"]').click()
+        """
+        Click first row checkbox on items table list to select one row.
+        """
+        self.browser.find_by_css('#object_list_form input[name="pk"]').click()
+
+    def set_per_page(self, per_page=1):
+        """
+        Explicitly set the `per_page` parameter by navigating to the "current" page but with query param.
+        TODO: check if there are other query params and merge them
+        """
+        self.browser.visit(f"{self.browser.url}?per_page={per_page}")
+
+    def select_all_items_from_all_pages(self):
+        """
+        Selecting all the items from all pages by clicking "select all" on top of the items table list and then
+        select all on prompt that will show up.
+        """
+        self.select_all_items()
+        self.browser.find_by_css("#select_all").click()
 
     def click_bulk_delete(self):
+        """
+        Click bulk delete from dropdown menu on bottom of the items table list.
+        """
+        self.browser.execute_script(
+            "document.querySelector('#object_list_form button[type=\"submit\"]').scrollIntoView()"
+        )
         self.browser.find_by_xpath(
             '//*[@id="object_list_form"]//button[@type="submit"]/following-sibling::button[1]'
         ).click()
-        self.browser.find_by_xpath('//*[@id="object_list_form"]//button[@name="_delete"]').click()
+        self.browser.find_by_css('#object_list_form button[name="_delete"]').click()
+
+    def click_bulk_delete_all(self):
+        """
+        Click bulk delete all on prompt when selecting all items from all pages.
+        """
+        self.click_button('#select_all_box button[name="_delete"]')
 
     def click_bulk_edit(self):
-        self.browser.find_by_xpath('//*[@id="object_list_form"]//button[@type="submit"]').click()
+        """
+        Click bulk edit button on bottom of the items table list.
+        """
+        self.click_button('#object_list_form button[type="submit"]')
+
+    def click_bulk_edit_all(self):
+        """
+        Click bulk edit all on prompt when selecting all items from all pages.
+        """
+        self.click_button('#select_all_box button[name="_edit"]')
+
+    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()
 
     @property
     def objects_list_visible_items(self):
-        objects_table_container = self.browser.find_by_xpath('//*[@id="object_list_form"]/div[1]/div')
+        """
+        Calculating the visible items. Return 0 if there is no visible items.
+        """
+        objects_table_container = self.browser.find_by_xpath('//*[@id="object_list_form"]')
         try:
             objects_table = objects_table_container.find_by_tag("tbody")
             return len(objects_table.find_by_tag("tr"))
@@ -52,19 +103,48 @@ class ObjectsListMixin:
             return 0
 
     def apply_filter(self, field, value):
+        """
+        Open filter dialog and apply select2 filters.
+        You can apply more values to the same filter, by calling this function with same name but different value.
+        """
         self.browser.find_by_xpath('//*[@id="id__filterbtn"]').click()
         self.fill_filters_select2_field(field, value)
-        self.browser.find_by_xpath('//*[@id="default-filter"]//button[@type="submit"]').click()
+        self.click_button('#default-filter button[type="submit"]')
+
+
+class ObjectDetailsMixin:
+    def assertPanelValue(self, panel_label, field_label, expected_value, exact_match=False):
+        """
+        Find the proper panel and asserts if given value match rendered field value.
+        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'
+        value = self.browser.find_by_xpath(f'{panel_xpath}//td[text()="{field_label}"]/following-sibling::td[1]').text
+
+        if exact_match:
+            self.assertEqual(value, str(expected_value))
+        else:
+            self.assertIn(str(expected_value), value)
 
 
 class BulkOperationsMixin:
     def confirm_bulk_delete_operation(self):
-        self.browser.find_by_xpath('//button[@name="_confirm" and @type="submit"]').click()
+        """
+        Confirms bulk delete operation on the "warning" page after clicking bulk delete buttons.
+        """
+        self.click_button('button[name="_confirm"][type="submit"]')
 
     def submit_bulk_edit_operation(self):
-        self.browser.find_by_xpath("//button[@name='_apply']", wait_time=5).click()
+        """
+        Submits the bulk edit form.
+        """
+        self.click_button('button[name="_apply"]')
 
     def wait_for_job_result(self):
+        """
+        Waits 30s for job to be finished.
+        """
         end_statuses = ["Completed", "Failed"]
         WebDriverWait(self.browser, 30).until(
             lambda driver: driver.find_by_id("pending-result-label").text in end_statuses
@@ -73,16 +153,52 @@ class BulkOperationsMixin:
         return self.browser.find_by_id("pending-result-label").text
 
     def verify_job_description(self, expected_job_description):
+        """
+        Verifies if the job description is correct.
+        Waits 30s on page load in case of large payload being sent from bulk edit form.
+        """
+        WebDriverWait(self.browser, 30).until(lambda driver: driver.is_text_present("Job Description"))
+
         job_description = self.browser.find_by_xpath('//td[text()="Job Description"]/following-sibling::td[1]').text
         self.assertEqual(job_description, expected_job_description)
 
+    def update_edit_form_value(self, field_name, value, is_select=False):
+        """
+        Updates bulk edit form value.
+        """
+        if is_select:
+            self.fill_select2_field(field_name, value)
+        else:
+            self.browser.fill(field_name, value)
+
+    def assertBulkDeleteConfirmMessageIsValid(self, expected_count):
+        """
+        Asserts that bulk delete confirmation message is valid and if we're deleting proper number of items.
+        """
+        self.browser.is_element_present_by_tag("body", wait_time=30)
+
+        button_text = self.browser.find_by_xpath('//button[@name="_confirm" and @type="submit"]').text
+        self.assertIn(f"Delete these {expected_count}", button_text)
+
+        message_text = self.browser.find_by_id("confirm-bulk-deletion").find_by_xpath('//div[@class="panel-body"]').text
+        self.assertIn(f"The following operation will delete {expected_count}", message_text)
+
     def assertIsBulkDeleteJob(self):
+        """
+        Asserts if currently visible job is bulk delete job.
+        """
         self.verify_job_description("Bulk delete objects.")
 
     def assertIsBulkEditJob(self):
+        """
+        Asserts if currently visible job is bulk edit job.
+        """
         self.verify_job_description("Bulk edit objects.")
 
     def assertJobStatusIsCompleted(self):
+        """
+        Asserts that job was successfully completed.
+        """
         job_status = self.wait_for_job_result()
         self.assertEqual(job_status, "Completed")
 
@@ -100,6 +216,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
 
     host = "0.0.0.0"  # noqa: S104  # hardcoded-bind-all-interfaces -- false positive
     selenium_host = SELENIUM_HOST  # Docker: `nautobot`; else `host.docker.internal`
+    logged_in = False
 
     @classmethod
     def setUpClass(cls):
@@ -123,6 +240,10 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
     def live_server_url(cls):  # pylint: disable=no-self-argument
         return f"http://{cls.selenium_host}:{cls.server_thread.port}"
 
+    def tearDown(self):
+        if self.logged_in:
+            self.logout()
+
     @classmethod
     def tearDownClass(cls):
         """Close down the browser after tests are ran."""
@@ -195,19 +316,27 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         self.browser.is_element_not_present_by_css(".loading-results", wait_time=5)
         return search_box
 
+    def _select_select2_result(self):
+        found_results = self.browser.find_by_css(".select2-results li.select2-results__option")
+        # click the first found item if it's not `None`: special value to nullify field
+        if found_results.first.text != "None":
+            found_results.first.click()
+        else:
+            found_results[1].click()
+
     def fill_select2_field(self, field_name, value):
         """
         Helper function to fill a Select2 single selection field on add/edit forms.
         """
-        search_box = self._fill_select2_field(field_name, value)
-        search_box.first.type(Keys.ENTER)
+        self._fill_select2_field(field_name, value)
+        self._select_select2_result()
 
     def fill_filters_select2_field(self, field_name, value):
         """
         Helper function to fill a Select2 single selection field on filters modals.
         """
         self._fill_select2_field(field_name, value, search_box_class="select2-search select2-search--inline")
-        self.browser.find_by_xpath(f"//li[@class='select2-results__option' and text()='{value}']").click()
+        self._select_select2_result()
 
     def fill_select2_multiselect_field(self, field_name, value):
         """
@@ -220,3 +349,331 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         # wait for "searching" to disappear
         self.browser.is_element_not_present_by_css(".loading-results", wait_time=5)
         search_box.first.type(Keys.ENTER)
+
+    def click_button(self, query_selector):
+        btn = self.browser.find_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()")
+        btn.click()
+
+    def login_as_superuser(self):
+        self.user.is_superuser = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+        self.logged_in = True
+
+
+class BulkOperationsTestCases:
+    """
+    Helper classes that runs all the basic bulk-operations test cases like edit/delete with
+    filtered / not filtered items along with select all option.
+
+    To use this class create required items in setUp method:
+    - at least four entities in two different groups,
+    - provide field for filtering to distinguish between above two groups
+    - provide expected counts (if different from default)
+    - set edit field and value
+    """
+
+    class BaseTestCase(SeleniumTestCase):
+        model_menu_path: tuple[str, str]
+        model_base_viewname: str
+        model_edit_data: dict[str, Any]
+        model_filter_by: dict[str, Any]
+        model_class: type[Model]
+        override_model_plural: Optional[str] = None
+        model_expected_counts: dict[str, int] = {
+            "all": 5,
+            "filtered": 2,
+        }
+
+        @property
+        def model_plural(self) -> str:
+            if self.override_model_plural is None:
+                return self.model_class._meta.verbose_name_plural
+
+            return self.override_model_plural
+
+        def setUp(self):
+            super().setUp()
+
+            self.setup_items()
+            self.login_as_superuser()
+            self.go_to_model_list_page()
+
+        def go_to_model_list_page(self):
+            self.click_navbar_entry(*self.model_menu_path)
+            self.assertEqual(self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_list"))
+
+        def setup_items(self):
+            raise NotImplementedError
+
+    class BulkEditTestCase(BaseTestCase, ObjectsListMixin, BulkOperationsMixin):
+        def test_bulk_edit_require_selection(self):
+            # Click "edit selected" without selecting anything
+            self.click_bulk_edit()
+
+            self.assertEqual(self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_list"))
+            self.assertTrue(self.browser.is_text_present(f"No {self.model_plural} were selected", wait_time=5))
+
+        def test_bulk_edit_all_items(self):
+            # Select all items and edit them
+            self.select_all_items()
+            self.click_bulk_edit()
+            self.assertEqual(self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_edit"))
+
+            # Edit some data and submit the form
+            for field_name, field_value in self.model_edit_data.items():
+                self.update_edit_form_value(field_name, field_value)
+            self.submit_bulk_edit_operation()
+
+            # Verify job output
+            self.assertIsBulkEditJob()
+            self.assertJobStatusIsCompleted()
+
+            # Assert that data was changed
+            found_items = self.model_class.objects.filter(**self.model_edit_data).count()
+            self.assertEqual(found_items, self.model_expected_counts["all"])
+
+        def test_bulk_edit_one_item(self):
+            # Select one filtered item
+            self.select_one_item()
+            self.click_bulk_edit()
+            self.assertEqual(self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_edit"))
+
+            # Edit some data and submit the form
+            for field_name, field_value in self.model_edit_data.items():
+                self.update_edit_form_value(field_name, field_value)
+            self.submit_bulk_edit_operation()
+
+            # Verify job output
+            self.assertIsBulkEditJob()
+            self.assertJobStatusIsCompleted()
+
+            # Assert that data was changed
+            found_items = self.model_class.objects.filter(**self.model_edit_data).count()
+            self.assertEqual(found_items, 1)
+
+        def test_bulk_edit_all_items_from_all_pages(self):
+            # Select all from all pages
+            self.set_per_page()
+            self.select_all_items_from_all_pages()
+            self.click_bulk_edit_all()
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_edit"), self.browser.url)
+
+            # Edit some data and submit the form
+            for field_name, field_value in self.model_edit_data.items():
+                self.update_edit_form_value(field_name, field_value)
+            self.submit_bulk_edit_operation()
+
+            # Verify job output
+            self.assertIsBulkEditJob()
+            self.assertJobStatusIsCompleted()
+
+            # Assert that data was changed
+            found_items = self.model_class.objects.filter(**self.model_edit_data).count()
+            self.assertEqual(found_items, self.model_expected_counts["all"])
+
+        def test_bulk_edit_all_filtered_items(self):
+            # Filter items
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+
+            # Select all filtered items
+            self.select_all_items()
+            self.click_bulk_edit()
+            self.assertIn(
+                self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_edit"),
+                self.browser.url,
+            )
+
+            # Edit some data and submit the form
+            for field_name, field_value in self.model_edit_data.items():
+                self.update_edit_form_value(field_name, field_value)
+            self.submit_bulk_edit_operation()
+
+            # Verify job output
+            self.assertIsBulkEditJob()
+            self.assertJobStatusIsCompleted()
+
+            # Assert that data was changed
+            found_items = self.model_class.objects.filter(**self.model_edit_data).count()
+            self.assertEqual(found_items, self.model_expected_counts["filtered"])
+
+        def test_bulk_edit_one_filtered_item(self):
+            # Filter items
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+
+            # Select one item and edit it
+            self.select_one_item()
+            self.click_bulk_edit()
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_edit"), self.browser.url)
+
+            # Edit some data and submit the form
+            for field_name, field_value in self.model_edit_data.items():
+                self.update_edit_form_value(field_name, field_value)
+            self.submit_bulk_edit_operation()
+
+            # Verify job output
+            self.assertIsBulkEditJob()
+            self.assertJobStatusIsCompleted()
+
+            # Assert that data was changed
+            found_items = self.model_class.objects.filter(**self.model_edit_data).count()
+            self.assertEqual(found_items, 1)
+
+        def test_bulk_edit_all_filtered_items_from_all_pages(self):
+            # Filter items
+            self.set_per_page()
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+
+            # Select all items and delete them
+            self.select_all_items_from_all_pages()
+            self.click_bulk_edit_all()
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_edit"), self.browser.url)
+
+            # Edit some data and submit the form
+            for field_name, field_value in self.model_edit_data.items():
+                self.update_edit_form_value(field_name, field_value)
+            self.submit_bulk_edit_operation()
+
+            # Verify job output
+            self.assertIsBulkEditJob()
+            self.assertJobStatusIsCompleted()
+
+            # Assert that data was changed
+            found_items = self.model_class.objects.filter(**self.model_edit_data).count()
+            self.assertEqual(found_items, self.model_expected_counts["filtered"])
+
+    class BulkDeleteTestCase(BaseTestCase, ObjectsListMixin, BulkOperationsMixin):
+        def test_bulk_delete_require_selection(self):
+            # Click "delete selected" without selecting anything
+            self.click_bulk_delete()
+
+            self.assertEqual(self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_list"))
+            self.assertTrue(
+                self.browser.is_text_present(f"No {self.model_plural} were selected for deletion.", wait_time=5)
+            )
+
+        def test_bulk_delete_all_items(self):
+            # Select all items and delete them
+            self.select_all_items()
+            self.click_bulk_delete()
+
+            self.assertEqual(
+                self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_delete")
+            )
+            self.assertBulkDeleteConfirmMessageIsValid(self.model_expected_counts["all"])
+            self.confirm_bulk_delete_operation()
+
+            # Verify job output
+            self.assertIsBulkDeleteJob()
+            self.assertJobStatusIsCompleted()
+
+            self.go_to_model_list_page()
+            self.assertEqual(self.objects_list_visible_items, 0)
+
+        def test_bulk_delete_one_item(self):
+            # Select one item and delete it
+            self.select_one_item()
+            self.click_bulk_delete()
+
+            self.assertEqual(
+                self.browser.url, self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_delete")
+            )
+            self.assertBulkDeleteConfirmMessageIsValid(1)
+            self.confirm_bulk_delete_operation()
+
+            # Verify job output
+            self.assertIsBulkDeleteJob()
+            self.assertJobStatusIsCompleted()
+
+            self.go_to_model_list_page()
+            self.assertEqual(self.objects_list_visible_items, self.model_expected_counts["all"] - 1)
+
+        def test_bulk_delete_all_items_from_all_pages(self):
+            # Select all from all pages
+            self.set_per_page()
+            self.select_all_items_from_all_pages()
+            self.click_bulk_delete_all()
+
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_delete"), self.browser.url)
+            self.assertBulkDeleteConfirmMessageIsValid(self.model_expected_counts["all"])
+            self.confirm_bulk_delete_operation()
+
+            # Verify job output
+            self.assertIsBulkDeleteJob()
+            self.assertJobStatusIsCompleted()
+
+            self.go_to_model_list_page()
+            self.assertEqual(self.objects_list_visible_items, 0)
+
+        def test_bulk_delete_all_filtered_items(self):
+            # Filter items
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+
+            # Select all items and delete them
+            self.select_all_items()
+            self.click_bulk_delete()
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_delete"), self.browser.url)
+            self.confirm_bulk_delete_operation()
+
+            # Verify job output
+            self.assertIsBulkDeleteJob()
+            self.assertJobStatusIsCompleted()
+
+            self.go_to_model_list_page()
+            rest_items_count = self.model_expected_counts["all"] - self.model_expected_counts["filtered"]
+            self.assertEqual(self.objects_list_visible_items, rest_items_count)
+
+        def test_bulk_delete_one_filtered_items(self):
+            # Filter items
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+
+            # Select one item and delete it
+            self.select_one_item()
+            self.click_bulk_delete()
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_delete"), self.browser.url)
+            self.confirm_bulk_delete_operation()
+
+            # Verify job output
+            self.assertIsBulkDeleteJob()
+            self.assertJobStatusIsCompleted()
+
+            self.go_to_model_list_page()
+            self.assertEqual(self.objects_list_visible_items, self.model_expected_counts["all"] - 1)
+
+        def test_bulk_delete_all_filtered_items_from_all_pages(self):
+            # Filter items
+            self.set_per_page()
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+
+            # Select all items and delete them
+            self.select_all_items_from_all_pages()
+            self.click_bulk_delete_all()
+
+            self.assertIn(self.live_server_url + reverse(f"{self.model_base_viewname}_bulk_delete"), self.browser.url)
+            self.assertBulkDeleteConfirmMessageIsValid(self.model_expected_counts["filtered"])
+            self.confirm_bulk_delete_operation()
+
+            # Verify job output
+            self.assertIsBulkDeleteJob()
+            self.assertJobStatusIsCompleted()
+
+            self.go_to_model_list_page()
+            self.set_per_page(50)  # Set page size back to default
+            rest_items_count = self.model_expected_counts["all"] - self.model_expected_counts["filtered"]
+            self.assertEqual(self.objects_list_visible_items, rest_items_count)
+
+            # Filter again and assert that all items were deleted
+            for field, value in self.model_filter_by.items():
+                self.apply_filter(field, value)
+            self.assertEqual(self.objects_list_visible_items, 0)
+
+    class BulkOperationsTestCase(BulkEditTestCase, BulkDeleteTestCase):
+        pass

nautobot/core/tests/test_commands.py

@@ -0,0 +1,31 @@
+from io import StringIO
+
+from django.core.management import call_command
+import yaml
+
+from nautobot.core.testing import TestCase
+
+
+class ManagementCommandTestCase(TestCase):
+    """Test case for core management commands."""
+
+    def setUp(self):
+        """Initialize user and client."""
+        super().setUpNautobot()
+        self.user.is_superuser = True
+        self.user.is_staff = True
+        self.user.save()
+        self.client.force_login(self.user)
+
+    def test_generate_performance_test_endpoints(self):
+        """Test the generate_performance_test_endpoints management command."""
+        out = StringIO()
+        call_command("generate_performance_test_endpoints", stdout=out)
+        endpoints_dict = yaml.safe_load(out.getvalue())["endpoints"]
+        # status_code_to_endpoints = collections.defaultdict(list)
+        for view_name, value in endpoints_dict.items():
+            for endpoint in value:
+                response = self.client.get(endpoint, follow=True)
+                self.assertHttpStatus(
+                    response, 200, f"{view_name}: {endpoint} returns status Code {response.status_code} instead of 200"
+                )