nautobot 3.0.0a3__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/core/templates/utilities/theme_preview.html

@@ -1139,6 +1139,9 @@ This:
                 <div class="icon-preview"><img alt="power icon" src="{% static 'nautobot-icons/battery-3.svg' %}">battery-3</div>
                 <div class="icon-preview"><img alt="branch icon" src="{% static 'nautobot-icons/branch.svg' %}">branch</div>
                 <div class="icon-preview"><img alt="briefcase-2 icon" src="{% static 'nautobot-icons/briefcase-2.svg' %}">briefcase-2</div>
+                <div class="icon-preview"><img alt="bus-globe icon" src="{% static 'nautobot-icons/bus-globe.svg' %}">bus-globe</div>
+                <div class="icon-preview"><img alt="bus-shield icon" src="{% static 'nautobot-icons/bus-shield.svg' %}">bus-shield</div>
+                <div class="icon-preview"><img alt="bus-shield-check icon" src="{% static 'nautobot-icons/bus-shield-check.svg' %}">bus-shield-check</div>
                 <div class="icon-preview"><img alt="cable-data icon" src="{% static 'nautobot-icons/cable-data.svg' %}">cable-data</div>
                 <div class="icon-preview"><img alt="cable-data-2 icon" src="{% static 'nautobot-icons/cable-data-2.svg' %}">cable-data-2</div>
                 <div class="icon-preview"><img alt="cast icon" src="{% static 'nautobot-icons/cast.svg' %}">cast</div>

nautobot/core/templates/widgets/number_input_with_choices.html

@@ -0,0 +1,44 @@
+<div class="input-group">
+    {% include 'django/forms/widgets/number.html' %}
+    {% if widget.choices %}
+        <span class="input-group-btn">
+            <button type="button" class="btn btn-secondary dropdown-toggle" data-bs-toggle="dropdown">
+                <span class="mdi mdi-chevron-down"></span>
+            </button>
+            <ul class="dropdown-menu dropdown-menu-end">
+                {% for value, label in widget.choices %}
+                    <li><a href="#" data-name="{{ widget.name }}" data-value="{{ value }}" class="set_value dropdown-item">{{ label }}</a></li>
+                {% endfor %}
+            </ul>
+        </span>
+    {% endif %}
+</div>
+
+{% if widget.choices %}
+    <script type="text/javascript">
+        (function() {
+            if (window.__nbNumberWithSelectWidgetBound) return;
+            window.__nbNumberWithSelectWidgetBound = true;
+            function bindNumberWithSelectHandler() {
+                document.addEventListener("click", function(e) {
+                    if (!e.target) return;
+                    var link = e.target.closest && e.target.closest("a.set_value");
+                    if (!link) return;
+                    e.preventDefault();
+                    var container = link.closest(".input-group");
+                    var name = link.getAttribute("data-name");
+                    var value = link.getAttribute("data-value");
+                    var input = container && name ? container.querySelector('input[name="' + name + '"]') : null;
+                    if (input) {
+                        input.value = value;
+                    }
+                });
+            }
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', bindNumberWithSelectHandler);
+            } else {
+                bindNumberWithSelectHandler();
+            }
+        })();
+    </script>
+{% endif %}

nautobot/core/templatetags/helpers.py

@@ -126,23 +126,29 @@ def placeholder(value):
 
 @library.filter()
 @register.filter()
-def pre_tag(value):
+def pre_tag(value, format_empty_value=True):
     """Render a value within `<pre></pre>` tags to enable formatting.
 
     Args:
         value (any): Input value, can be any variable.
+        format_empty_value (bool): Whether format empty value or render placeholder.
 
     Returns:
-        (str): Value wrapped in `<pre></pre>` tags.
+        (str): Value wrapped in `<pre></pre>` tags or placeholder if None or format_empty_values=False and empty
 
     Example:
         >>> pre_tag("")
         '<pre></pre>'
         >>> pre_tag("hello")
         '<pre>hello</pre>'
+        >>> pre_tag("", format_empty_value=False)
+        '<span class="text-secondary">&mdash;</span>'
     """
-    if value is not None:
+    if format_empty_value and value is not None:
+        return format_html("<pre>{}</pre>", value)
+    elif value:
         return format_html("<pre>{}</pre>", value)
+
     return HTML_NONE
 
 
@@ -395,17 +401,19 @@ def humanize_speed(speed):
         1544 => "1.544 Mbps"
         100000 => "100 Mbps"
         10000000 => "10 Gbps"
+        1000000000 => "1 Tbps"
+        1600000000 => "1.6 Tbps"
+        10000000000 => "10 Tbps"
     """
     if not speed:
         return ""
-    if speed >= 1000000000 and speed % 1000000000 == 0:
-        return f"{int(speed / 1000000000)} Tbps"
-    elif speed >= 1000000 and speed % 1000000 == 0:
-        return f"{int(speed / 1000000)} Gbps"
-    elif speed >= 1000 and speed % 1000 == 0:
-        return f"{int(speed / 1000)} Mbps"
+
+    if speed >= 1000000000:
+        return f"{speed / 1000000000:g} Tbps"
+    elif speed >= 1000000:
+        return f"{speed / 1000000:g} Gbps"
     elif speed >= 1000:
-        return f"{float(speed) / 1000} Mbps"
+        return f"{speed / 1000:g} Mbps"
     else:
         return f"{speed} Kbps"
 
@@ -507,7 +515,9 @@ def get_docs_url(model):
 
     Example:
         >>> get_docs_url(location_instance)
-        "static/docs/models/dcim/location.html"
+        "static/docs/user-guide/core-data-model/dcim/location.html"
+        >>> get_docs_url(virtual_server_instance)
+        "static/docs/user-guide/core-data-model/load-balancers/virtualserver.html"
         >>> get_docs_url(example_model)
         "/docs/example-app/models/examplemodel.html"
     """
@@ -532,7 +542,9 @@ def get_docs_url(model):
     elif model._meta.app_label == "extras":
         path = f"docs/user-guide/platform-functionality/{model._meta.model_name}.html"
     else:
-        path = f"docs/user-guide/core-data-model/{model._meta.app_label}/{model._meta.model_name}.html"
+        path = (
+            f"docs/user-guide/core-data-model/{model._meta.app_label.replace('_', '-')}/{model._meta.model_name}.html"
+        )
 
     # Check to see if documentation exists in any of the static paths.
     if find(path):

nautobot/core/testing/integration.py

@@ -66,13 +66,14 @@ class ObjectsListMixin:
         """
         Click bulk delete from dropdown menu on bottom of the items table list.
         """
-        self.browser.execute_script(
-            "document.querySelector('#bulk-action-buttons button[type=\"submit\"]').scrollIntoView()"
-        )
+        self.scroll_element_into_view(css='#bulk-action-buttons button[type="submit"]')
         self.browser.find_by_xpath(
             '//*[@id="bulk-action-buttons"]//button[@type="submit"]/following-sibling::button[1]'
         ).click()
-        self.browser.find_by_css('#bulk-action-buttons button[name="_delete"]').click()
+        bulk_delete_button = self.browser.find_by_css('#bulk-action-buttons button[name="_delete"]')
+        bulk_delete_button.is_visible(wait_time=5)
+        self.scroll_element_into_view(element=bulk_delete_button)
+        bulk_delete_button.click()
 
     def click_bulk_delete_all(self):
         """
@@ -110,7 +111,7 @@ class ObjectsListMixin:
         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"))
+            return len(objects_table.find_by_xpath(".//tr[not(count(td[@colspan])=1)]"))
         except ElementDoesNotExist:
             return 0
 
@@ -238,7 +239,7 @@ class BulkOperationsMixin:
         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
+        message_text = self.browser.find_by_id("confirm-bulk-deletion").find_by_xpath('//div[@class="card-body"]').text
         self.assertIn(f"The following operation will delete {expected_count}", message_text)
 
     def assertIsBulkDeleteJob(self):
@@ -413,7 +414,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
             search_box_class = "select2-search select2-search--dropdown"
 
         self.browser.find_by_xpath(f"//select[@id='id_{field_name}']//following-sibling::span").click()
-        self.browser.execute_script(f"""document.querySelector('#id_{field_name}').scrollIntoView()""")
+        self.scroll_element_into_view(css=f"#id_{field_name}")
         search_box = self.browser.find_by_xpath(f"//*[@class='{search_box_class}']//input", wait_time=5)
         for _ in search_box.first.type(value, slowly=True):
             pass
@@ -459,9 +460,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
     def click_button(self, query_selector):
         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({{ behavior: 'instant', block: 'start' }});"
-        )
+        self.scroll_element_into_view(css=query_selector)
         # 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)
@@ -473,9 +472,7 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         """
         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
-        )
+        self.scroll_element_into_view(element=element)
         element.is_visible(wait_time=5)
         self.browser.execute_script("arguments[0].focus();", element.first._element)
         self.browser.fill(input_name, input_value)
@@ -486,6 +483,20 @@ class SeleniumTestCase(StaticLiveServerTestCase, testing.NautobotTestCaseMixin):
         self.login(self.user.username, self.password)
         self.logged_in = True
 
+    def scroll_element_into_view(self, element=None, css=None, xpath=None, block="start"):
+        """
+        Scroll element into view. Element can be expressed either as Splinter `ElementList`, `ElementAPI`, CSS query selector or XPath.
+        """
+        if css:
+            element = self.browser.find_by_css(css)
+        elif xpath:
+            element = self.browser.find_by_xpath(xpath)
+
+        self.browser.execute_script(
+            f"arguments[0].scrollIntoView({{ behavior: 'instant', block: '{block}' }});",
+            element.first._element if hasattr(element, "__iter__") else element._element,
+        )
+
 
 class BulkOperationsTestCases:
     """

nautobot/core/testing/utils.py

@@ -90,6 +90,20 @@ def extract_page_body(content):
         return content
 
 
+def extract_page_title(content):
+    """
+    Given raw HTML content from an HTTP response, extract the page title section only.
+
+    <div id="page-title" ...>...</header>
+    """
+    try:
+        return re.findall(
+            r"<div class=\"col-4\" id=\"page-title\">(.*?)(?=<\/header)", content, flags=(re.MULTILINE | re.DOTALL)
+        )[0]
+    except IndexError:
+        return content
+
+
 @contextmanager
 def disable_warnings(logger_name):
     """
@@ -127,15 +141,15 @@ def generate_random_device_asset_tag_of_specified_size(size):
 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",
+        "Approval Workflow Definitions": "Workflow Definitions",
+        "Approval Workflow Stages": "Approval Dashboard",
         "Controller Managed Device Groups": "Device Groups",
+        "Object Changes": "Change Log",
         "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",
+        "VM Interfaces": "Interfaces",
     }
 
     expected = bettertitle(view_model._meta.verbose_name_plural)

nautobot/core/testing/views.py

@@ -27,7 +27,10 @@ from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.models.tree_queries import TreeModel
 from nautobot.core.templatetags import buttons, helpers
 from nautobot.core.testing import mixins, utils
+from nautobot.core.testing.utils import extract_page_title
+from nautobot.core.ui.object_detail import ObjectsTablePanel
 from nautobot.core.utils import lookup
+from nautobot.core.views.mixins import NautobotViewSetMixin, PERMISSIONS_ACTION_MAP
 from nautobot.dcim.models.device_components import ComponentModel
 from nautobot.extras import choices as extras_choices, models as extras_models, querysets as extras_querysets
 from nautobot.extras.forms import CustomFieldModelFormMixin, RelationshipModelFormMixin
@@ -191,12 +194,10 @@ class ViewTestCases:
             # Try GET with model-level permission
             with CaptureQueriesContext(connection) as capture_queries_context:
                 response = self.client.get(instance.get_absolute_url())
-            # The object's display name or string representation should appear in the response body
-            # TODO: some models (e.g. JobResult) intentionally do NOT display the full `.display` in the detail view,
-            # but only use the `.name` or `str()`.
-            # This check will always pass in the case where the Example App is installed, because of the banner
-            # it adds, but can/should/may? fail otherwise.
-            self.assertBodyContains(response, escape(getattr(instance, "display", str(instance))))
+
+            # The object's display name or string representation should appear in the header
+            expected_title = escape(getattr(instance, "page_title", str(instance)))
+            self.assertInHTML(expected_title, extract_page_title(response.content.decode(response.charset)))
 
             # If any Relationships are defined, they should appear in the response
             if self.relationships is not None:
@@ -366,18 +367,104 @@ class ViewTestCases:
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_custom_actions(self):
+            base_view = lookup.get_view_for_model(self.model)
+            if not issubclass(base_view, NautobotViewSetMixin):
+                self.skipTest(f"View {base_view} is not using NautobotUIViewSet")
+
+            instance = self._get_queryset().first()
+            for action_func in base_view.get_extra_actions():
+                if not action_func.detail:
+                    continue
+                if "get" not in action_func.mapping:
+                    continue
+                if action_func.url_name == "data-compliance" and not getattr(base_view, "object_detail_content", None):
+                    continue
+                with self.subTest(action=action_func.url_name):
+                    if action_func.url_name in self.custom_action_required_permissions:
+                        required_permissions = self.custom_action_required_permissions[action_func.url_name]
+                    else:
+                        base_action = action_func.kwargs.get("custom_view_base_action")
+                        if base_action is None:
+                            if action_func.__name__ not in PERMISSIONS_ACTION_MAP:
+                                self.fail(f"Missing custom_view_base_action for action {action_func.__name__}")
+                            base_action = PERMISSIONS_ACTION_MAP[action_func.__name__]
+
+                        required_permissions = [
+                            f"{self.model._meta.app_label}.{base_action}_{self.model._meta.model_name}"
+                        ]
+                        required_permissions += action_func.kwargs.get("custom_view_additional_permissions", [])
+
+                    try:
+                        url = self._get_url(action_func.url_name, instance)
+                        self.assertHttpStatus(self.client.get(url), [403, 404])
+                        for permission in required_permissions[:-1]:
+                            self.add_permissions(permission)
+                            self.assertHttpStatus(self.client.get(url), [403, 404])
+
+                        self.add_permissions(required_permissions[-1])
+                        self.assertHttpStatus(self.client.get(url), 200)
+                    finally:
+                        # delete the permissions here so that we start from a clean slate on the next loop
+                        self.remove_permissions(*required_permissions)
+
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+        def test_body_content_table_list_url(self):
+            """
+            Testing that the badge links on related object panels are working as expected.
+            """
+            self.user.is_superuser = True
+            self.user.save()
             instance = self._get_queryset().first()
-            for url_name, required_permissions in self.custom_action_required_permissions.items():
-                url = reverse(url_name, kwargs={"pk": instance.pk})
-                self.assertHttpStatus(self.client.get(url), 403)
-                for permission in required_permissions[:-1]:
-                    self.add_permissions(permission)
-                    self.assertHttpStatus(self.client.get(url), 403)
-
-                self.add_permissions(required_permissions[-1])
-                self.assertHttpStatus(self.client.get(url), 200)
-                # delete the permissions here so that repetitive calls to add_permissions do not create duplicate permissions.
-                self.remove_permissions(*required_permissions)
+            if not instance:
+                # We should have a better mechanism to test against an empty instance, but this will remove blocker for now.
+                self.skipTest("No instances to test against.")
+            errors = []
+            model_name = self.model._meta.model_name
+
+            response = self.client.get(instance.get_absolute_url())
+            self.assertHttpStatus(response, 200)
+            context = response.context
+            if not context.get("object_detail_content"):
+                self.skipTest("Model is not using UIViewSet")
+            for tab in context["object_detail_content"].tabs:
+                if not tab.should_render(context):
+                    continue
+                tab_label = f"'{tab.label}'" if tab.label else "main"
+                for panel in tab.panels:
+                    if not isinstance(panel, ObjectsTablePanel) or panel.context_table_key:
+                        continue
+                    extra_context = panel.get_extra_context(context)
+                    list_url = extra_context.get("body_content_table_list_url")
+                    table_title = panel.label or extra_context.get("body_content_table_verbose_name_plural")
+                    if not list_url:
+                        # If `header_extra_content_template_path` is not set,
+                        # we don't render the badge in the header nor the link
+                        if not panel.header_extra_content_template_path or not panel.enable_related_link:
+                            continue
+                        errors.append(
+                            (
+                                f"Error on {model_name} {tab_label} tab: panel '{table_title}' badge link does not exist."
+                                " Please ensure the related model has a list view, or override with a custom list URL via 'related_list_url_name=app:model_list'."
+                                " If the link should not be enabled, you must explicitly set 'enable_related_link=False' on the ObjectsTablePanel."
+                            )
+                        )
+                        continue
+                    try:
+                        list_response = self.client.get(list_url)
+                    except Exception as e:
+                        errors.append(
+                            f"Error on {model_name} {tab_label} tab: panel '{table_title}' badge link '{list_url}': {e}"
+                        )
+                    else:
+                        self.assertHttpStatus(list_response, 200)
+                        for error in list_response.context["errors"]:
+                            errors.append(
+                                (
+                                    f"Error on {model_name} {tab_label} tab: panel '{table_title}' badge link '{list_url}': {error}."
+                                )
+                            )
+            if errors:
+                self.fail("\n".join(errors))
 
     class GetObjectChangelogViewTestCase(ModelViewTestCase):
         """

nautobot/core/tests/integration/test_filters.py

@@ -69,7 +69,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
         filter_button.click()
 
         # assert the filter drawer has appeared
-        self.assertTrue(filter_drawer.visible)
+        self.assertTrue(filter_drawer.is_visible(wait_time=10))
 
         # start typing a parent into select2
         location_type = LocationType.objects.filter(parent__isnull=True).first()
@@ -170,9 +170,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
 
         # Open the filter drawer, configure filter and apply filter
         self.browser.find_by_id("id__filterbtn").click()
-        self.browser.execute_script(
-            f"document.querySelector('[name={text_field_name}]').scrollIntoView({{ behavior: 'instant', block: 'end' }})"
-        )
+        self.scroll_element_into_view(css=f"[name={text_field_name}]", block="end")
         self.change_field_value(text_field_name, "example-text")
         self.change_field_value(integer_field_name, 4356)
         self.change_field_value(select_field_name, "SingleSelect Option A", field_type="select")
@@ -188,9 +186,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
 
         # Assert on update of field in Default Filter the update is replicated on Advanced Filter
         self.browser.find_by_xpath("//a[@href='#default-filter']").click()  # Go back to Basic tab
-        self.browser.execute_script(
-            f"document.querySelector('[name={text_field_name}]').scrollIntoView({{ behavior: 'instant', block: 'end' }})"
-        )
+        self.scroll_element_into_view(css=f"[name={text_field_name}]", block="end")
         self.change_field_value(text_field_name, "test new")
         self.change_field_value(integer_field_name, 1111)
         self.change_field_value(select_field_name, "SingleSelect Option B", field_type="select")
@@ -260,9 +256,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
         )
         dynamic_filter_add_button.click()
         self.browser.find_by_xpath("//a[@href='#default-filter']").click()
-        self.browser.execute_script(
-            f"document.querySelector('[name={text_field_name}]').scrollIntoView({{ behavior: 'instant', block: 'end' }})"
-        )
+        self.scroll_element_into_view(css=f"[name={text_field_name}]", block="end")
         self.assertEqual(self.browser.find_by_name(text_field_name)[0].value, "test new update")
         self.assertEqual(self.browser.find_by_name(integer_field_name)[0].value, "8888")
         custom_select_values = self.browser.find_by_name(select_field_name)[0].find_by_tag("option")
@@ -325,7 +319,7 @@ class ListViewFilterTestCase(SeleniumTestCase):
         self.browser.find_by_xpath(apply_btn_xpath).click()
         filter_drawer = self.browser.find_by_id("FilterForm_drawer", wait_time=10)
         # Drawer is kept open
-        self.assertTrue(filter_drawer.visible)
+        self.assertTrue(filter_drawer.is_visible(wait_time=10))
         # Assert the choice is applied
         self.browser.find_by_xpath(
             f"//span[@class='badge' and @data-nb-value='{tag_object.name}' and contains(text(),{tag_object.name})]"
@@ -334,3 +328,46 @@ class ListViewFilterTestCase(SeleniumTestCase):
         self.browser.find_by_xpath(
             "//a[@href='#advanced-filter']//span[contains(@class,'nb-btn-indicator') and contains(text(),'Some of the applied filters can only be viewed in Advanced')]"
         )
+
+    def test_selected_advanced_filter_automatic_application(self):
+        """Assert that selected advanced filter is still used even if not manually applied by user."""
+        # Go to the location list view
+        self.browser.visit(f"{self.live_server_url}{reverse('dcim:location_list')}")
+
+        # Open the filter drawer
+        self.browser.find_by_id("id__filterbtn").click()
+        # Go to advanced Tab
+        self.browser.find_by_xpath("//a[@href='#advanced-filter']").click()
+
+        # Click on the first column lookup field and select ASN
+        lookup_field_container = self.browser.find_by_id("select2-id_form-0-lookup_field-container")
+        self.assertTrue(lookup_field_container.is_visible(wait_time=10))
+        lookup_field_container.click()
+        self.browser.find_by_xpath(
+            "//ul[@id='select2-id_form-0-lookup_field-results']/li[contains(@class,'select2-results__option') "
+            "and contains(text(),'ASN')]"
+        ).click()
+
+        # Click on the second column lookup type and select exact
+        self.browser.find_by_id("select2-id_form-0-lookup_type-container").click()
+        self.browser.find_by_xpath(
+            "//ul[@id='select2-id_form-0-lookup_type-results']/li[contains(@class,'select2-results__option') "
+            "and contains(text(),'exact')]"
+        ).click()
+
+        # Fill ASN input value with "65001"
+        self.browser.find_by_xpath("//input[@id='id_for_asn']").fill("65001")
+
+        # Click "Apply Specified" button
+        self.browser.find_by_xpath("//form[@id='dynamic-filter-form']//button[@type='submit']").click()
+
+        # Wait for filters button indicator to appear, meaning that the page was reloaded and selected filters applied.
+        self.assertTrue(
+            self.browser.is_element_present_by_xpath(
+                "//button[@id='id__filterbtn']//span[@class='nb-btn-indicator']", wait_time=10
+            )
+        )
+
+        # Assert that the filter has been successfully applied to the URL, despite not being previously added to the
+        # selected filters list with "Add Filter" button.
+        self.assertEqual(self.browser.url, f"{self.live_server_url}{reverse('dcim:location_list')}" + "?asn=65001")

nautobot/core/tests/integration/test_theme.py

@@ -1,5 +1,3 @@
-from django.test import tag
-
 from nautobot.core.testing.integration import SeleniumTestCase
 
 
@@ -24,7 +22,6 @@ class ThemeTestCase(SeleniumTestCase):
         # Validate modal is not visible
         self.assertFalse(theme_modal[0].visible)
 
-    @tag("fix_in_v3")
     def test_modal_rendered(self):
         """Modal should render when selecting the 'theme' button in the footer."""
 
@@ -35,30 +32,34 @@ class ThemeTestCase(SeleniumTestCase):
         self.assertEqual(len(self.browser.find_by_xpath("//div[@class[contains(., 'modal-backdrop')]]")), 1)
 
         # Validate modal is visible
-        theme_modal = self.browser.find_by_xpath("//div[@id[contains(., 'theme_modal')]]")
-        self.assertTrue(theme_modal[0].visible)
+        theme_modal = self.browser.find_by_xpath("//div[@id='theme_modal']")
+        self.assertTrue(theme_modal[0].is_visible(wait_time=5))
 
         # Validate 3 themes available to select
-        self.assertEqual(
-            len(self.browser.find_by_xpath("//div[@class[contains(., 'modal-body')]]//tbody/tr")), 1
-        )  # 1 row
-
-        columns = self.browser.find_by_xpath("//div[@class[contains(., 'modal-body')]]//tbody/tr/td")
+        columns = self.browser.find_by_xpath("//div[@class[contains(., 'modal-body')]]//dl/dt")
         self.assertEqual(len(columns), 3)  # 3 columns (light, dark, system)
 
         # Validate 3 modes in order are light, dark, and system
-        self.assertIn("light", columns[0].html)
-        self.assertIn("dark", columns[1].html)
-        self.assertIn("system", columns[2].html)
+        self.assertIn("Light", columns[0].html)
+        self.assertIn("Dark", columns[1].html)
+        self.assertIn("System", columns[2].html)
 
         # Validate only System theme is selected by default
-        system_theme = self.browser.find_by_xpath(".//td[@id='td-light-theme']")
-        self.assertFalse(system_theme[0].has_class("active-theme"))
-        system_theme = self.browser.find_by_xpath(".//td[@id='td-dark-theme']")
-        self.assertFalse(system_theme[0].has_class("active-theme"))
-        system_theme = self.browser.find_by_xpath(".//td[@id='td-system-theme']")
-        self.assertTrue(system_theme[0].has_class("active-theme"))
+        light_theme = self.browser.find_by_xpath(".//dd/button[@data-nb-theme='light']")
+        self.assertFalse(light_theme[0].has_class("border"))
+        self.assertFalse(light_theme[0].has_class("border-primary"))
+        dark_theme = self.browser.find_by_xpath(".//dd/button[@data-nb-theme='dark']")
+        self.assertFalse(dark_theme[0].has_class("border"))
+        self.assertFalse(dark_theme[0].has_class("border-primary"))
+        system_theme = self.browser.find_by_xpath(".//dd/button[@data-nb-theme='system']")
+        self.assertTrue(system_theme[0].has_class("border"))
+        self.assertTrue(system_theme[0].has_class("border-primary"))
+
+        # Why is it required to click the cancel button twice? I honestly don't know, but for some reason Selenium seems
+        # to have troubles here. The first press only focuses the cancel button, and only after clicking it for the
+        # second time, the modal closes successfully.
+        self.browser.find_by_xpath(".//button[@id='dismiss-modal-theme']").click()
+        self.browser.find_by_xpath(".//button[@id='dismiss-modal-theme']").click()
 
         # Validate Modal closes when cancel button clicked
-        self.browser.find_by_xpath(".//button[@id='dismiss-modal-theme']").click()
-        self.assertFalse(theme_modal[0].visible)
+        self.assertTrue(theme_modal[0].is_not_visible(wait_time=5))

nautobot/core/tests/nautobot_config.py

@@ -10,6 +10,9 @@ from nautobot.core.settings_funcs import parse_redis_connection
 
 ALLOWED_HOSTS = ["nautobot.example.com"]
 
+# Do *not* send anonymized install metrics when migration or post_upgrade management commands are run while testing
+INSTALLATION_METRICS_ENABLED = False
+
 # Discover test jobs from within the Nautobot source code
 JOBS_ROOT = os.path.join(
     os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "extras", "test_jobs"

nautobot/core/tests/runner.py

@@ -162,8 +162,7 @@ class NautobotTestRunner(DiscoverRunner):
                             db_command = [*command, "--database", alias]
                             call_command(*db_command)
 
-                        # Calculate membership for the dynamic groups that were generated by the factories/fixtures
-                        call_command("refresh_dynamic_group_member_caches")
+                        call_command("post_upgrade")
 
                     if self.parallel > 1:
                         for index in range(self.parallel):