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

nautobot/circuits/tests/integration/test_circuits_bulk_operations.py

@@ -0,0 +1,43 @@
+import uuid
+
+from nautobot.circuits.models import Circuit, CircuitType, Provider
+from nautobot.core.testing.integration import (
+    BulkOperationsTestCases,
+)
+from nautobot.extras.models import Status
+
+
+class CircuitBulkOperationsTestCase(BulkOperationsTestCases.BulkOperationsTestCase):
+    """
+    Test circuits bulk edit / delete operations.
+    """
+
+    model_menu_path = ("Circuits", "Circuits")
+    model_base_viewname = "circuits:circuit"
+    model_edit_data = {"commit_rate": "12345"}
+    model_filter_by = {"circuit_type": "Copper"}
+    model_class = Circuit
+
+    def setup_items(self):
+        Circuit.objects.all().delete()
+
+        # Create locations for test
+        self.create_circuit()
+        self.create_circuit()
+        self.create_circuit()
+        self.create_circuit("Copper")
+        self.create_circuit("Copper")
+
+    @staticmethod
+    def create_circuit(circuit_type="Fiber"):
+        circuit_id = f"TestCircuit-{str(uuid.uuid4())[:6]}"
+        provider, _ = Provider.objects.get_or_create(name="A Test Provider")
+        circuit_type, _ = CircuitType.objects.get_or_create(name=circuit_type)
+
+        circuit_status = Status.objects.get_for_model(Circuit).first()
+        Circuit.objects.get_or_create(
+            cid=circuit_id,
+            provider=provider,
+            status=circuit_status,
+            circuit_type=circuit_type,
+        )

nautobot/circuits/tests/integration/test_relationships.py

@@ -19,7 +19,7 @@ class CircuitRelationshipsTestCase(SeleniumTestCase):
         self.user.is_superuser = True
         self.user.save()
         self.login(self.user.username, self.password)
-        location_type = LocationType.objects.get(name="Campus")
+        location_type, _ = LocationType.objects.get_or_create(name="Campus")
         location_ct = ContentType.objects.get_for_model(Location)
         circuit_termination_ct = ContentType.objects.get_for_model(CircuitTermination)
         provider_ct = ContentType.objects.get_for_model(Provider)

nautobot/core/apps/__init__.py

@@ -367,11 +367,6 @@ class CoreConfig(NautobotConfig):
 
         super().ready()
 
-        # Register jobs last after everything else has been done.
-        from nautobot.core.celery import import_jobs
-
-        import_jobs()
-
 
 class NautobotConstanceConfig(ConstanceConfig):
     """Override "Constance" app name to "Configuration"."""

nautobot/core/templates/generic/object_bulk_destroy.html

@@ -7,7 +7,7 @@
 {% block content %}
     <div class="row">
         <div class="col-md-8 col-md-offset-2">
-            <div class="panel panel-danger">
+            <div class="panel panel-danger" id="confirm-bulk-deletion">
                 <div class="panel-heading"><strong>Confirm Bulk Deletion</strong></div>
                 <div class="panel-body">
                     <p><strong>Warning:</strong> The following operation will delete {{ total_objs_to_delete }} {{ obj_type_plural }}. {% if not delete_all %}Please carefully review the {{ obj_type_plural }} to be deleted and confirm below.{% endif %}</p>

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,68 @@ 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"]')
 
     @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 +99,32 @@ 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 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 +133,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")
 
@@ -207,7 +303,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         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.browser.find_by_xpath(f"//li[contains(@class, 'select2-results__option') and text()='{value}']").click()
 
     def fill_select2_multiselect_field(self, field_name, value):
         """
@@ -220,3 +316,334 @@ 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)
+
+
+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 tearDown(self):
+            self.logout()
+            super().tearDown()
+
+        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_jobs.py

@@ -750,16 +750,48 @@ class BulkEditTestCase(TransactionTestCase):
             description="Example description for bulk edit",
         )
 
-        # Assert Namespaces withing pk_list updated tags
+        # Assert Namespaces within pk_list get updated tags
         for namespace in namespaces[:3]:
             self.assertTrue(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[:3]]).exists())
             self.assertFalse(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[3:]]).exists())
 
-        # Assert Namespaces not withing pk_list tags did not get updated
+        # Assert Namespaces not within pk_list did not get updated tags
         for namespace in namespaces[3:]:
             self.assertFalse(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[:3]]).exists())
             self.assertTrue(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[3:]]).exists())
 
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.namespace_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={
+                "pk": pk_list,
+                "description": "Example description for bulk edit",
+                "add_tags": [str(self.tags[0].id)],
+                "remove_tags": [str(self.tags[-1].id)],
+            },
+            username=self.user.username,
+        )
+
+        self._common_no_error_test_assertion(
+            Namespace,
+            job_result,
+            3,
+            description="Example description for bulk edit",
+        )
+
+        # Assert Namespaces within pk_list get updated tag
+        for namespace in namespaces[:3]:
+            self.assertTrue(namespace.tags.filter(pk__in=[self.tags[0].pk]).exists())
+            self.assertFalse(namespace.tags.filter(pk__in=[self.tags[-1].pk]).exists())
+
+        # Assert Namespaces not within pk_list did not get updated tag
+        for namespace in namespaces[3:]:
+            self.assertFalse(namespace.tags.filter(pk__in=[self.tags[0].pk]).exists())
+            self.assertTrue(namespace.tags.filter(pk__in=[self.tags[-1].pk]).exists())
+
     def test_bulk_edit_objects_filter_all(self):
         """
         Bulk edit all of the filtered Status instances.

nautobot/core/utils/git.py

@@ -57,7 +57,7 @@ class BranchDoesNotExist(Exception):
 
 
 class GitRepo:
-    def __init__(self, path, url, clone_initially=True):
+    def __init__(self, path, url, clone_initially=True, branch=None, depth=0):
         """
         Ensure that we have a clone of the given remote Git repository URL at the given local directory path.
 
@@ -65,6 +65,8 @@ class GitRepo:
             path (str): path to git repo
             url (str): git repo url
             clone_initially (bool): True if the repo needs to be cloned
+            branch (str): branch to checkout
+            depth (int): depth of the clone
         """
         self.url = url
         self.sanitized_url = sanitize(url)
@@ -73,7 +75,10 @@ class GitRepo:
         elif clone_initially:
             # Don't log `url` as it may include authentication details.
             logger.debug("Cloning git repository to %s...", path)
-            self.repo = Repo.clone_from(url, to_path=path, env=GIT_ENVIRONMENT)
+            if not depth:
+                self.repo = Repo.clone_from(url, to_path=path, env=GIT_ENVIRONMENT, branch=branch)
+            else:
+                self.repo = Repo.clone_from(url, to_path=path, env=GIT_ENVIRONMENT, branch=branch, depth=depth)
         else:
             self.repo = Repo.init(path)
             self.repo.create_remote("origin", url=url)