nautobot 2.4.5__py3-none-any.whl → 2.4.7__py3-none-any.whl

nautobot/core/templatetags/helpers.py

@@ -2,7 +2,7 @@ import datetime
 import json
 import logging
 import re
-from urllib.parse import parse_qs
+from urllib.parse import parse_qs, quote_plus
 
 from django import template
 from django.conf import settings
@@ -711,6 +711,20 @@ def render_ancestor_hierarchy(value):
     return result
 
 
+@library.filter()
+@register.filter()
+def render_address(address):
+    if address:
+        map_link = format_html(
+            '<a href="https://maps.google.com/?q={}" target="_blank" class="btn btn-primary btn-xs">'
+            '<i class="mdi mdi-map-marker"></i> Map it</a>',
+            quote_plus(address),
+        )
+        address = format_html_join("", "{}<br>", ((line,) for line in address.split("\n")))
+        return format_html('<div class="pull-right noprint">{}</div>{}', map_link, address)
+    return HTML_NONE
+
+
 #
 # Tags
 #

nautobot/core/testing/api.py

@@ -702,6 +702,9 @@ class APIViewTestCases:
             else:
                 self.assertEqual(obj.key, expected_slug)
 
+        # 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
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_create_object(self):
             """
             POST a single object with permission.
@@ -738,6 +741,9 @@ class APIViewTestCases:
                     self.assertEqual(len(objectchanges), 1)
                     self.assertEqual(objectchanges[0].action, extras_choices.ObjectChangeActionChoices.ACTION_CREATE)
 
+        # 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
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_recreate_object_csv(self):
             """CSV export an object, delete it, and recreate it via CSV import."""
             if hasattr(self, "get_deletable_object"):
@@ -801,6 +807,9 @@ class APIViewTestCases:
                         f"{field_name} should have been unchanged on delete/recreate but it differs!",
                     )
 
+        # 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
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_create_objects(self):
             """
             POST a set of objects in a single request.
@@ -853,6 +862,9 @@ class APIViewTestCases:
                 response = self.client.patch(url, update_data, format="json", **self.header)
                 self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
 
+        # 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
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_update_object(self):
             """
             PATCH a single object identified by its ID.
@@ -965,6 +977,9 @@ class APIViewTestCases:
             instance.refresh_from_db()
             self.assertInstanceEqual(instance, update_data, exclude=self.validation_excluded_fields, api=True)
 
+        # 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
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_get_put_round_trip(self):
             """GET and then PUT an object and verify that it's accepted and unchanged."""
             self.maxDiff = None
@@ -995,6 +1010,9 @@ class APIViewTestCases:
             updated_serialized_object.pop("last_updated", None)
             self.assertEqual(initial_serialized_object, updated_serialized_object)
 
+        # 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
+        @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_update_objects(self):
             """
             PATCH a set of objects in a single request.

nautobot/core/testing/integration.py

@@ -35,11 +35,15 @@ class ObjectsListMixin:
         """
         self.browser.find_by_css("#object_list_form input.toggle").click()
 
-    def select_one_item(self):
+    def select_one_item(self, pk=None):
         """
         Click first row checkbox on items table list to select one row.
         """
-        self.browser.find_by_css('#object_list_form input[name="pk"]').click()
+        selector = '#object_list_form input[name="pk"]'
+        if pk:
+            selector = f'{selector}[value="{pk}"]'
+
+        self.browser.find_by_css(selector).click()
 
     def set_per_page(self, per_page=1):
         """

nautobot/core/tests/nautobot_config.py

@@ -44,8 +44,6 @@ CONSTANCE_BACKEND = "constance.backends.memory.MemoryBackend"
 TEST_USE_FACTORIES = True
 # For now, use a constant PRNG seed for consistent results. In the future we can remove this for fuzzier testing.
 TEST_FACTORY_SEED = "Nautobot"
-# File in which all performance-specifc test baselines are stored
-TEST_PERFORMANCE_BASELINE_FILE = "nautobot/core/tests/performance_baselines.yml"
 
 # Make Celery run synchronously (eager), to always store eager results, and run the broker in-memory.
 # NOTE: Celery does not honor the TASK_TRACK_STARTED config when running in eager mode, so the job result is not saved until after the task completes.

nautobot/core/tests/runner.py

@@ -14,7 +14,6 @@ from django.db import connections
 from django.db.migrations.recorder import MigrationRecorder
 from django.test.runner import _init_worker, DiscoverRunner, ParallelTestSuite
 from django.test.utils import get_unique_databases_and_mirrors, NullTimeKeeper, override_settings
-import yaml
 
 from nautobot.core.celery import app, setup_nautobot_job_logging
 from nautobot.core.settings_funcs import parse_redis_connection
@@ -40,21 +39,25 @@ class NautobotParallelTestSuite(ParallelTestSuite):
 
 class NautobotTestRunner(DiscoverRunner):
     """
-    Custom test runner that excludes integration tests by default.
+    Custom test runner that excludes (slow) integration and migration tests by default.
 
     This test runner is aware of our use of the "integration" tag and only runs integration tests if
     explicitly passed in with `nautobot-server test --tag integration`.
+    Similarly, it only runs migration tests if explicitly called with `--tag migration_test`.
 
     By Nautobot convention, integration tests must be tagged with "integration". The base
     `nautobot.core.testing.integration.SeleniumTestCase` has this tag, therefore any test cases
     inheriting from that class do not need to be explicitly tagged.
 
     Only integration tests that DO NOT inherit from `SeleniumTestCase` will need to be explicitly tagged.
+
+    Similarly, the `django-test-migrations` package `MigratorTestCase` base class has the tag `migration_test`, so
+    any subclasses thereof do not need to be explicitly tagged.
     """
 
     parallel_test_suite = NautobotParallelTestSuite
 
-    exclude_tags = ["integration"]
+    exclude_tags = ["integration", "migration_test"]
 
     @classmethod
     def add_arguments(cls, parser):
@@ -75,15 +78,19 @@ class NautobotTestRunner(DiscoverRunner):
         self.cache_test_fixtures = cache_test_fixtures
         self.reusedb = reusedb
 
-        # Assert "integration" hasn't been provided w/ --tag
         incoming_tags = kwargs.get("tags") or []
-        # Assert "exclude_tags" hasn't been provided w/ --exclude-tag; else default to our own.
-        incoming_exclude_tags = kwargs.get("exclude_tags") or []
+        exclude_tags = kwargs.get("exclude_tags") or []
+
+        for default_excluded_tag in self.exclude_tags:
+            if default_excluded_tag not in incoming_tags:
+                exclude_tags.append(default_excluded_tag)
+                # Can't just use self.log() here because we haven't yet called super().__init__()
+                if logger := kwargs.get("logger"):
+                    logger.info("Implicitly excluding tests tagged %r", default_excluded_tag)
+                elif kwargs.get("verbosity", 1) >= 1:
+                    print(f"Implicitly excluding tests tagged {default_excluded_tag!r}")
 
-        # Only include our excluded tags if "integration" isn't provided w/ --tag
-        if "integration" not in incoming_tags:
-            incoming_exclude_tags.extend(self.exclude_tags)
-            kwargs["exclude_tags"] = incoming_exclude_tags
+        kwargs["exclude_tags"] = exclude_tags
 
         super().__init__(**kwargs)
 
@@ -202,133 +209,3 @@ class NautobotTestRunner(DiscoverRunner):
                     print(f"Database {db_name} emptied!")
 
                 connection.creation.destroy_test_db(old_name, self.verbosity, self.keepdb)
-
-
-# Use django_slowtests only when GENERATE_PERFORMANCE_REPORT flag is set to true
-try:
-    from django_slowtests.testrunner import DiscoverSlowestTestsRunner
-
-    print("Using NautobotPerformanceTestRunner to run tests ...")
-
-    class NautobotPerformanceTestRunner(NautobotTestRunner, DiscoverSlowestTestsRunner):
-        """
-        Pre-requisite:
-            Set `GENERATE_PERFORMANCE_REPORT` to True in settings.py
-        This test runner is designated to run performance specific unit tests.
-
-        `ModelViewTestCase` is tagged with `performance` to test the time it will take to retrieve, list, create, bulk_create,
-        delete, bulk_delete, edit, bulk_edit object(s) and various other operations.
-
-        The results are compared to the corresponding entries in `TEST_PERFORMANCE_BASELINE_FILE` and only results that are significantly slower
-        than baseline will be exposed to the user.
-        """
-
-        def generate_report(self, test_results, result):
-            """
-            Generate Performance Report consists of unit tests that are significantly slower than baseline.
-            """
-            test_result_count = len(test_results)
-
-            # Add `--performance-snapshot` to the end of `invoke` commands to generate a report.json file consist of the performance tests result
-            if self.report_path:
-                data = [
-                    {
-                        "tests": [
-                            {
-                                "name": func_name,
-                                "execution_time": float(timing),
-                            }
-                            for func_name, timing in test_results
-                        ],
-                        "test_count": result.testsRun,
-                        "failed_count": len(result.errors + result.failures),
-                        "total_execution_time": result.timeTaken,
-                    }
-                ]
-                with open(self.report_path, "w") as outfile:
-                    yaml.dump(data, outfile, sort_keys=False)
-            # Print the results in the CLI.
-            else:
-                if test_result_count:
-                    print(f"\n{test_result_count} abnormally slower tests:")
-                    for func_name, timing in test_results:
-                        time = float(timing)
-                        baseline = self.baselines.get(func_name, None)
-                        if baseline:
-                            baseline = float(baseline)
-                            print(f"{time:.4f}s {func_name} is significantly slower than the baseline {baseline:.4f}s")
-                        else:
-                            print(
-                                f"Performance baseline for {func_name} is not available. Test took {time:.4f}s to run"
-                            )
-
-                if not test_results:
-                    print("\nNo tests signficantly slower than baseline. Success!")
-
-        def get_baselines(self):
-            """Load the performance_baselines.yml file for result comparison."""
-            baselines = {}
-            input_file = getattr(
-                settings, "TEST_PERFORMANCE_BASELINE_FILE", "nautobot/core/tests/performance_baselines.yml"
-            )
-
-            with open(input_file) as f:
-                data = yaml.safe_load(f)
-                for entry in data["tests"]:
-                    baselines[entry["name"]] = entry["execution_time"]
-            return baselines
-
-        def suite_result(self, suite, result):
-            """Compile the performance test results"""
-            return_value = super(DiscoverSlowestTestsRunner, self).suite_result(suite, result)
-            self.baselines = self.get_baselines()
-
-            # add `--performance_report` to `invoke` commands to generate report.
-            # e.g. `invoke unittest --performance_report`
-            if not self.should_generate_report:
-                self.remove_timing_tmp_files()
-                return return_value
-
-            # Grab slowest tests
-            timings = self.get_timings()
-            # Sort the results by test names x[0]
-            by_name = sorted(timings, key=lambda x: x[0])
-            test_results = by_name
-
-            if self.baselines:
-                # Filter tests by baseline numbers
-                test_results = []
-
-                for entry in by_name:
-                    # Convert test time from seconds to miliseconds for comparison
-                    result_time_ms = entry[1] * 1000
-                    # If self.report_path, that means the user wants to update the performance baselines.
-                    # so we append every result that is available to us.
-                    if self.report_path:
-                        test_results.append(entry)
-                    else:
-                        # If the test is completed under 1.5 times the baseline or the difference between the result and the baseline is less than 3 seconds,
-                        # dont show the test to the user.
-
-                        baseline = self.baselines.get(entry[0], None)
-
-                        # check if baseline is available
-                        if not baseline:
-                            test_results.append(entry)
-                            continue
-
-                        # baseline duration in milliseconds
-                        baseline_ms = baseline * 1000
-                        # Arbitrary criteria to not make performance test fail easily
-                        if result_time_ms <= baseline_ms * 1.5 or result_time_ms - baseline_ms <= 500:
-                            continue
-
-                        test_results.append(entry)
-
-            self.generate_report(test_results, result)
-            return return_value
-
-except ImportError:
-    print(
-        "Unable to import DiscoverSlowestTestsRunner from `django_slowtests`. Is the 'django_slowtests' package installed?"
-    )

nautobot/core/tests/test_api.py

@@ -639,7 +639,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
             "vlan_group": self.vlan_group1.pk,
         }
         url = reverse("ipam-api:vlan-list")
-        self.add_permissions("ipam.add_vlan")
+        self.add_permissions("ipam.add_vlan", "ipam.view_vlangroup", "extras.view_status")
 
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
@@ -672,7 +672,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
             "vlan_group": {"name": self.vlan_group1.name},
         }
         url = reverse("ipam-api:vlan-list")
-        self.add_permissions("ipam.add_vlan")
+        self.add_permissions("ipam.add_vlan", "ipam.view_vlangroup", "extras.view_status")
 
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
@@ -708,7 +708,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
             },
         }
         url = reverse("ipam-api:vlan-list")
-        self.add_permissions("ipam.add_vlan")
+        self.add_permissions("ipam.add_vlan", "ipam.view_vlangroup", "extras.view_status")
 
         with testing.disable_warnings("django.request"):
             response = self.client.post(url, data, format="json", **self.header)
@@ -775,7 +775,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
             "vlan_group": self.vlan_group1.pk,
         }
         url = reverse("ipam-api:vlan-list")
-        self.add_permissions("ipam.add_vlan")
+        self.add_permissions("ipam.add_vlan", "ipam.view_vlangroup", "extras.view_status")
 
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)

nautobot/core/tests/test_authentication.py

@@ -383,14 +383,31 @@ class ObjectPermissionAPIViewTestCase(TestCase):
         )
         obj_perm.users.add(self.user)
         obj_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
-
+        related_obj_perm = ObjectPermission.objects.create(
+            name="Related object permission",
+            actions=["view"],
+        )
+        related_obj_perm.users.add(self.user)
+        related_obj_perm.object_types.add(
+            ContentType.objects.get_for_model(Namespace),
+            ContentType.objects.get_for_model(Status),
+            ContentType.objects.get_for_model(Location),
+        )
         # Attempt to create a non-permitted object
         response = self.client.post(url, data, format="json", **self.header)
         self.assertEqual(response.status_code, 403)
         self.assertEqual(Prefix.objects.count(), initial_count)
 
-        # Create a permitted object
+        # Attempt to create a permitted object without related object permissions
         data["location"] = self.locations[0].pk
+        related_obj_perm.users.remove(self.user)
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertEqual(response.status_code, 400)
+        self.assertIn(b"Related object not found using the provided attribute", response.content)
+        self.assertEqual(Prefix.objects.count(), initial_count)
+
+        # Create a permitted object with related object permissions
+        related_obj_perm.users.add(self.user)
         response = self.client.post(url, data, format="json", **self.header)
         self.assertEqual(response.status_code, 201)
         self.assertEqual(Prefix.objects.count(), initial_count + 1)
@@ -411,17 +428,33 @@ class ObjectPermissionAPIViewTestCase(TestCase):
         )
         obj_perm.users.add(self.user)
         obj_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
-
+        related_obj_perm = ObjectPermission.objects.create(
+            name="Related object permission",
+            actions=["view"],
+        )
+        related_obj_perm.users.add(self.user)
+        related_obj_perm.object_types.add(
+            ContentType.objects.get_for_model(Namespace),
+            ContentType.objects.get_for_model(Status),
+            ContentType.objects.get_for_model(Location),
+        )
         # Attempt to edit a non-permitted object
         data = {"location": self.locations[0].pk}
         url = reverse("ipam-api:prefix-detail", kwargs={"pk": self.prefixes[3].pk})
         response = self.client.patch(url, data, format="json", **self.header)
         self.assertEqual(response.status_code, 404)
 
-        # Edit a permitted object
+        # Attempt to edit a permitted object without related object permissions
+        related_obj_perm.users.remove(self.user)
         data["status"] = self.statuses[1].pk
         url = reverse("ipam-api:prefix-detail", kwargs={"pk": self.prefixes[0].pk})
         response = self.client.patch(url, data, format="json", **self.header)
+        self.assertEqual(response.status_code, 400)
+        self.assertIn(b"Related object not found using the provided attribute", response.content)
+
+        # Edit a permitted object with related object permissions
+        related_obj_perm.users.add(self.user)
+        response = self.client.patch(url, data, format="json", **self.header)
         self.assertEqual(response.status_code, 200)
 
         # Attempt to modify a permitted object to a non-permitted object
@@ -456,6 +489,32 @@ class ObjectPermissionAPIViewTestCase(TestCase):
         response = self.client.delete(url, format="json", **self.header)
         self.assertEqual(response.status_code, 204)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_related_object_permission_constraints_on_get_requests(self):
+        """
+        Users who have permission to view Location objects, but not LocationType and Status objects
+        should still be able to view Location objects from the API.
+        """
+        self.add_permissions("dcim.view_location")
+        response = self.client.get(reverse("dcim-api:location-list"), **self.header)
+        self.assertEqual(response.status_code, 200)
+        # we should be able to get all the locations
+        self.assertEqual(len(response.data["results"]), Location.objects.count())
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_related_object_permission_constraints_on_patch_requests(self):
+        """
+        Users who have permission to view and change Location objects, but not LocationType and Status objects
+        should still be able to change a Location object's name from the API.
+        """
+        self.add_permissions("dcim.view_location", "dcim.change_location")
+        location = Location.objects.first()
+        data = {"name": "New Location Name"}
+        url = reverse("dcim-api:location-detail", kwargs={"pk": location.pk})
+        response = self.client.patch(url, data, format="json", **self.header)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["name"], "New Location Name")
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
     def test_user_token_constraints(self):
         """
@@ -487,6 +546,16 @@ class ObjectPermissionAPIViewTestCase(TestCase):
         )
         obj_perm.users.add(self.user, obj_user2)
         obj_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
+        related_obj_perm = ObjectPermission.objects.create(
+            name="Related object permission",
+            actions=["view"],
+        )
+        related_obj_perm.users.add(self.user, obj_user2)
+        related_obj_perm.object_types.add(
+            ContentType.objects.get_for_model(Namespace),
+            ContentType.objects.get_for_model(Status),
+            ContentType.objects.get_for_model(Location),
+        )
         # Create one Prefix object per user
         self.client.post(url, data[0], format="json", **self.header)
         self.client.post(url, data[1], format="json", **header_user2)
@@ -550,6 +619,16 @@ class ObjectPermissionAPIViewTestCase(TestCase):
         )
         obj_perm.users.add(self.user, obj_user2)
         obj_perm.object_types.add(ContentType.objects.get_for_model(Prefix))
+        related_obj_perm = ObjectPermission.objects.create(
+            name="Related object permission",
+            actions=["view"],
+        )
+        related_obj_perm.users.add(self.user, obj_user2)
+        related_obj_perm.object_types.add(
+            ContentType.objects.get_for_model(Namespace),
+            ContentType.objects.get_for_model(Status),
+            ContentType.objects.get_for_model(Location),
+        )
         # Create one Prefix object per user
         self.client.post(url, data[0], format="json", **self.header)
         self.client.post(url, data[1], format="json", **header_user2)

nautobot/core/tests/test_forms.py

@@ -486,20 +486,23 @@ class NumericArrayFieldTest(TestCase):
         self.field = dcim_forms.DeviceFilterForm().fields["device_redundancy_group_priority"]
 
     def test_valid_input(self):
-        # Mapping of input => expected
-        tests = {
-            None: [],
-            "": [],
-            "80,443-444": [80, 443, 444],
-            "1024-1028,31337": [1024, 1025, 1026, 1027, 1028, 31337],
-        }
-        for test, expected in tests.items():
+        #  List of (input, expected output) tuples
+        tests = [
+            (None, []),
+            ("", []),
+            ("80,443-444", [80, 443, 444]),
+            ("1024-1028,31337", [1024, 1025, 1026, 1027, 1028, 31337]),
+            (["47-49", "103"], [47, 48, 49, 103]),
+            ([231, 432, 313], [231, 313, 432]),
+        ]
+        for test, expected in tests:
             self.assertEqual(self.field.clean(test), expected)
 
     def test_invalid_input(self):
         tests = [
             "pizza",
             "-41",
+            "[84,52,33]",
         ]
         for test in tests:
             with self.assertRaises(django_forms.ValidationError):

nautobot/core/tests/test_graphql.py

@@ -1,3 +1,4 @@
+import contextlib
 import datetime
 import random
 import types
@@ -8,6 +9,7 @@ from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
 from django.db.models import Count, Q
 from django.test import override_settings, TestCase
 from django.test.client import RequestFactory
@@ -17,6 +19,7 @@ from graphene_django.registry import get_global_registry
 from graphene_django.settings import graphene_settings
 from graphql import get_default_backend, GraphQLError
 from graphql.error.located_error import GraphQLLocatedError
+import redis.exceptions
 from rest_framework import status
 
 from nautobot.circuits.models import CircuitTermination, Provider
@@ -396,6 +399,12 @@ class GraphQLExtendSchemaRelationship(GraphQLTestCaseBase):
         self.location_schema = generate_schema_type(app_name="dcim", model=Location)
         self.vlan_schema = generate_schema_type(app_name="ipam", model=VLAN)
 
+    def tearDown(self):
+        """Ensure that relationship caches are cleared to avoid leakage into other tests."""
+        with contextlib.suppress(redis.exceptions.ConnectionError):
+            cache.delete_pattern(f"{Relationship.objects.get_for_model_source.cache_key_prefix}.*")
+            cache.delete_pattern(f"{Relationship.objects.get_for_model_destination.cache_key_prefix}.*")
+
     def test_extend_relationship_default_prefix(self):
         """Verify that relationships are correctly added to the schema."""
         schema = extend_schema_type_relationships(self.vlan_schema, VLAN)

nautobot/core/tests/test_jobs.py

@@ -353,6 +353,13 @@ class ImportObjectsTestCase(TransactionTestCase):
             self.assertEqual(log_successes[4].message, "Created 4 status object(s) from 5 row(s) of data")
 
     def test_csv_import_contact_assignment(self):
+        self.add_permissions(
+            "dcim.view_locationtype",
+            "extras.view_status",
+            "dcim.view_location",
+            "extras.add_role",
+            "extras.add_contact",
+        )
         location_types_csv = "\n".join(["name", "ContactAssignmentImportTestLocationType"])
         locations_csv = "\n".join(
             [

nautobot/core/ui/object_detail.py

@@ -8,7 +8,7 @@ import logging
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist
 from django.db import models
-from django.db.models import CharField, JSONField, URLField
+from django.db.models import CharField, JSONField, Q, URLField
 from django.db.models.fields.related import ManyToManyField
 from django.template import Context
 from django.template.defaultfilters import truncatechars
@@ -375,6 +375,11 @@ class Tab(Component):
 class DistinctViewTab(Tab):
     """
     A Tab that doesn't render inline on the same page, but instead links to a distinct view of its own when clicked.
+
+    Args:
+        url_name (str): The name of the URL pattern to link to, which will be reversed to generate the URL.
+        label_wrapper_template_path (str, optional): Template path to render the tab label to HTML.
+        related_object_attribute (str, optional): The name of the related object attribute to count for the tab label.
     """
 
     def __init__(
@@ -382,9 +387,11 @@ class DistinctViewTab(Tab):
         *,
         url_name,
         label_wrapper_template_path="components/tab/label_wrapper_distinct_view.html",
+        related_object_attribute="",
         **kwargs,
     ):
         self.url_name = url_name
+        self.related_object_attribute = related_object_attribute
         super().__init__(label_wrapper_template_path=label_wrapper_template_path, **kwargs)
 
     def get_extra_context(self, context: Context):
@@ -393,6 +400,30 @@ class DistinctViewTab(Tab):
     def render(self, context: Context):
         return ""
 
+    def render_label(self, context: Context):
+        if not self.related_object_attribute:
+            return super().render_label(context)
+
+        obj = get_obj_from_context(context)
+        if not hasattr(obj, self.related_object_attribute):
+            logger.warning(
+                f"{obj} does not have a related attribute {self.related_object_attribute} to count for tab label."
+            )
+            return super().render_label(context)
+
+        try:
+            related_obj_count = getattr(obj, self.related_object_attribute).count()
+            return format_html(
+                "{} {}",
+                self.label,
+                render_to_string("utilities/templatetags/badge.html", badge(related_obj_count)),
+            )
+        except AttributeError:
+            logger.warning(
+                f"{obj}'s attribute {self.related_object_attribute} is not a related manager to count for tab label."
+            )
+            return super().render_label(context)
+
 
 class Panel(Component):
     """Base class for defining an individual display panel within a Layout within a Tab."""
@@ -634,10 +665,14 @@ class ObjectsTablePanel(Panel):
                 Table (`BaseTable`) instance. Mutually exclusive with `table_class`, `table_filter`, `table_attribute`.
             table_class (obj): The table class that will be instantiated and rendered e.g. CircuitTable, DeviceTable.
                 Mutually exclusive with `context_table_key`.
-            table_filter (str, optional): The name of the filter to apply to the queryset to initialize the table class.
+            table_filter (str, list, optional): The filter(s) to apply to the queryset to initialize the table class.
                 For example, in a LocationType detail view, for an ObjectsTablePanel of related Locations, this would
                 be `location_type`, because `Location.objects.filter(location_type=obj)` gives the desired queryset.
                 Mutually exclusive with `table_attribute`.
+                For example, in ProviderNetwork detail view, for an ObjectsTablePanel of related Circuits, this would
+                be `["circuit_termination_a__provider_network", "circuit_termination_z__provider_network"]` because
+                `Circuit.objects.filter(Q(circuit_termination_a__provider_network=instance)
+                | Q(circuit_termination_z__provider_network=instance))` gives the desired queryset.
             table_attribute (str, optional): The attribute of the detail view instance that contains the queryset to
                 initialize the table class. e.g. `dynamic_groups`.
                 Mutually exclusive with `table_filter`.
@@ -758,7 +793,16 @@ class ObjectsTablePanel(Panel):
             if self.table_attribute:
                 body_content_table_queryset = getattr(instance, self.table_attribute)
             else:
-                body_content_table_queryset = body_content_table_model.objects.filter(**{self.table_filter: instance})
+                if isinstance(self.table_filter, str):
+                    table_filters = [self.table_filter]
+                elif isinstance(self.table_filter, list):
+                    table_filters = self.table_filter
+                else:
+                    table_filters = []
+                query = Q()
+                for table_filter in table_filters:
+                    query = query | Q(**{table_filter: instance})
+                body_content_table_queryset = body_content_table_model.objects.filter(query)
 
             body_content_table_queryset = body_content_table_queryset.restrict(request.user, "view")
             if self.select_related_fields: