nautobot 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

nautobot/apps/api.py

@@ -12,6 +12,7 @@ from nautobot.core.api import (
 from nautobot.core.api.fields import (
     ChoiceField,
     ContentTypeField,
+    LaxURLField,
     NautobotHyperlinkedRelatedField,
     ObjectTypeField,
     SerializedPKRelatedField,
@@ -63,6 +64,7 @@ __all__ = (
     "get_view_name",
     "GetObjectCountsView",
     "is_api_request",
+    "LaxURLField",
     "ModelViewSet",
     "ModelViewSetMixin",
     "MultipleChoiceJSONField",

nautobot/apps/models.py

@@ -8,6 +8,7 @@ from nautobot.core.models.fields import (
     ForeignKeyLimitedByContentTypes,
     ForeignKeyWithAutoRelatedName,
     JSONArrayField,
+    LaxURLField,
     mac_unix_expanded_uppercase,
     MACAddressCharField,
     NaturalOrderingField,
@@ -83,6 +84,7 @@ __all__ = (
     "is_taggable",
     "JSONArrayField",
     "JSONBAgg",
+    "LaxURLField",
     "mac_unix_expanded_uppercase",
     "MACAddressCharField",
     "NameColorContentTypesModel",

nautobot/circuits/forms.py

@@ -145,6 +145,12 @@ class CircuitTypeForm(NautobotModelForm):
         ]
 
 
+class CircuitTypeFilterForm(NautobotFilterForm):
+    model = CircuitType
+    q = forms.CharField(required=False, label="Search")
+    name = forms.CharField(required=False)
+
+
 #
 # Circuits
 #
@@ -262,3 +268,12 @@ class CircuitTerminationForm(LocatableModelFormMixin, NautobotModelForm):
         widgets = {
             "term_side": forms.HiddenInput(),
         }
+
+
+class CircuitTerminationFilterForm(LocatableModelFilterFormMixin, NautobotFilterForm):
+    model = CircuitTermination
+    q = forms.CharField(required=False, label="Search")
+    circuit = DynamicModelMultipleChoiceField(queryset=Circuit.objects.all(), to_field_name="cid", required=False)
+    provider_network = DynamicModelMultipleChoiceField(
+        queryset=ProviderNetwork.objects.all(), to_field_name="name", required=False
+    )

nautobot/circuits/navigation.py

@@ -33,10 +33,18 @@ menu_items = (
                             ),
                         ),
                     ),
+                    NavMenuItem(
+                        link="circuits:circuittermination_list",
+                        name="Circuit Terminations",
+                        weight=200,
+                        permissions=[
+                            "circuits.view_circuittermination",
+                        ],
+                    ),
                     NavMenuItem(
                         link="circuits:circuittype_list",
                         name="Circuit Types",
-                        weight=200,
+                        weight=300,
                         permissions=[
                             "circuits.view_circuittype",
                         ],

nautobot/circuits/views.py

@@ -27,6 +27,7 @@ class CircuitTypeUIViewSet(
     view_mixins.ObjectNotesViewMixin,
 ):
     filterset_class = filters.CircuitTypeFilterSet
+    filterset_form_class = forms.CircuitTypeFilterForm
     form_class = forms.CircuitTypeForm
     queryset = CircuitType.objects.annotate(circuit_count=count_related(Circuit, "circuit_type"))
     serializer_class = serializers.CircuitTypeSerializer
@@ -67,6 +68,7 @@ class CircuitTerminationUIViewSet(
 ):
     action_buttons = ("import", "export")
     filterset_class = filters.CircuitTerminationFilterSet
+    filterset_form_class = forms.CircuitTerminationFilterForm
     form_class = forms.CircuitTerminationForm
     queryset = CircuitTermination.objects.all()
     serializer_class = serializers.CircuitTerminationSerializer

nautobot/core/api/fields.py

@@ -2,15 +2,18 @@ from collections import OrderedDict
 import logging
 
 from django.core.exceptions import ObjectDoesNotExist
+from django.core.validators import URLValidator
 from django.db.models import Model
 from drf_spectacular.utils import extend_schema_field
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
+from rest_framework.fields import URLField
 from rest_framework.relations import PrimaryKeyRelatedField, RelatedField
 from timezone_field.rest_framework import TimeZoneSerializerField as TimeZoneSerializerField_
 
 from nautobot.core.api.mixins import WritableSerializerMixin
 from nautobot.core.models.utils import deconstruct_composite_key
+from nautobot.core.models.validators import EnhancedURLValidator
 from nautobot.core.utils.data import is_url, is_uuid
 from nautobot.core.utils.lookup import get_route_for_model
 
@@ -124,6 +127,16 @@ class ContentTypeField(RelatedField):
         return f"{obj.app_label}.{obj.model}"
 
 
+class LaxURLField(URLField):
+    def __init__(self, validators=None, **kwargs):
+        super().__init__(**kwargs)
+        # Discard default URLValidator added by URLField
+        self.validators = [v for v in self.validators if not isinstance(v, URLValidator)]
+        if validators is not None:
+            self.validators.extend(validators)
+        self.validators.append(EnhancedURLValidator(message=self.error_messages["invalid"]))
+
+
 @extend_schema_field(
     {
         "type": "object",

nautobot/core/api/serializers.py

@@ -26,12 +26,13 @@ from rest_framework.serializers import SerializerMethodField
 from rest_framework.utils.model_meta import _get_to_field, RelationInfo
 
 from nautobot.core import constants
-from nautobot.core.api.fields import NautobotHyperlinkedRelatedField, ObjectTypeField
+from nautobot.core.api.fields import LaxURLField, NautobotHyperlinkedRelatedField, ObjectTypeField
 from nautobot.core.api.utils import (
     dict_to_filter_params,
     nested_serializer_factory,
 )
 from nautobot.core.exceptions import ViewConfigException
+from nautobot.core.models.fields import LaxURLField as LaxURLModelField
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.utils import construct_composite_key, construct_natural_slug
 from nautobot.core.templatetags.helpers import bettertitle
@@ -126,6 +127,11 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
       to enable the dynamic generation of nested serializers.
     """
 
+    serializer_field_mapping = {
+        **serializers.ModelSerializer.serializer_field_mapping,
+        LaxURLModelField: LaxURLField,
+    }
+
     serializer_related_field = NautobotHyperlinkedRelatedField
 
     display = serializers.SerializerMethodField(read_only=True, help_text="Human friendly display value")

nautobot/core/filters.py

@@ -176,6 +176,9 @@ class ContentTypeFilterMixin:
         if value in EMPTY_VALUES:
             return qs
 
+        if value.isdigit():
+            return qs.filter(**{f"{self.field_name}__pk": value})
+
         try:
             app_label, model = value.lower().split(".")
         except ValueError:
@@ -242,6 +245,9 @@ class ContentTypeMultipleChoiceFilter(django_filters.MultipleChoiceFilter):
             if self.conjoined:
                 qs = ContentTypeFilter.filter(self, qs, v)
             else:
+                if v.isdigit():
+                    q |= models.Q(**{f"{self.field_name}__pk": value})
+                    continue
                 # Similar to the ContentTypeFilter.filter() call above, but instead of narrowing the query each time
                 # (a AND b AND c ...) we broaden the query each time (a OR b OR c ...).
                 # Specifically, we're mapping a value like ['dcim.device', 'ipam.vlan'] to a query like
@@ -716,6 +722,11 @@ class BaseFilterSet(django_filters.FilterSet):
         """
         filters = super().get_filters()
 
+        # Remove any filters that may have been auto-generated from private model attributes
+        for filter_name in list(filters.keys()):
+            if filter_name.startswith("_"):
+                del filters[filter_name]
+
         # django-filters has no concept of "abstract" filtersets, so we have to fake it
         if cls._meta.model is not None:
             new_filters = {}

nautobot/core/management/commands/generate_test_data.py

@@ -30,6 +30,17 @@ class Command(BaseCommand):
             dest="interactive",
             help="Do NOT prompt the user for input or confirmation of any kind.",
         )
+        parser.add_argument(
+            "--print-hashes",
+            action="store_true",
+            help=(
+                "After creating each batch of records, print a hash of the list of all IDs of all objects of "
+                "the given type. This is useful for identifying any problems with factory randomness / determinism; "
+                "in general, successive runs with the same seed should output identical hashes for each stage, "
+                "while successive runs with differing seeds should output different hashes. "
+                "Setting environment variable GITHUB_ACTIONS to true is equivalent to specifying this argument."
+            ),
+        )
         parser.add_argument(
             "--cache-test-fixtures",
             action="store_true",
@@ -46,7 +57,7 @@ class Command(BaseCommand):
             help='The database to generate the test data in. Defaults to the "default" database.',
         )
 
-    def _generate_factory_data(self, seed, db_name):
+    def _generate_factory_data(self, seed, db_name, print_hashes=False):
         try:
             import factory.random
 
@@ -83,7 +94,6 @@ class Command(BaseCommand):
             from nautobot.extras.utils import TaggableClassesQuery
             from nautobot.ipam.choices import PrefixTypeChoices
             from nautobot.ipam.factory import (
-                IPAddressFactory,
                 NamespaceFactory,
                 PrefixFactory,
                 RIRFactory,
@@ -101,178 +111,135 @@ class Command(BaseCommand):
         self.stdout.write(f'Seeding the pseudo-random number generator with seed "{seed}"...')
         factory.random.reseed_random(seed)
 
-        self.stdout.write("Creating Roles...")
+        def _create_batch(some_factory, count, description="", **kwargs):
+            model = some_factory._meta.get_model_class()
+            if description:
+                description = " " + description
+            message = f"Creating {count} {model._meta.verbose_name_plural}{description}..."
+            self.stdout.write(message)
+            records = some_factory.create_batch(count, using=db_name, **kwargs)
+            if print_hashes:
+                model_ids = [record.id for record in records]
+                sha256_hash = hashlib.sha256(json.dumps(model_ids, cls=DjangoJSONEncoder).encode()).hexdigest()
+                self.stdout.write(f"  SHA256: {sha256_hash}")
+
         populate_role_choices(verbosity=0, using=db_name)
-        RoleFactory.create_batch(20)
-        self.stdout.write("Creating Statuses...")
+        _create_batch(RoleFactory, 20)
         populate_status_choices(verbosity=0, using=db_name)
-        StatusFactory.create_batch(10, using=db_name)
-        self.stdout.write("Creating Tags...")
+        _create_batch(StatusFactory, 10)
         # Ensure that we have some tags that are applicable to all relevant content-types
-        TagFactory.create_batch(5, content_types=TaggableClassesQuery().as_queryset(), using=db_name)
+        _create_batch(
+            TagFactory, 5, description="on all content-types", content_types=TaggableClassesQuery().as_queryset()
+        )
         # ...and some tags that apply to a random subset of content-types
-        TagFactory.create_batch(15, using=db_name)
-        self.stdout.write("Creating Contacts...")
-        ContactFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating Teams...")
-        TeamFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating TenantGroups...")
-        TenantGroupFactory.create_batch(10, has_parent=False, using=db_name)
-        TenantGroupFactory.create_batch(10, has_parent=True, using=db_name)
-        self.stdout.write("Creating Tenants...")
-        TenantFactory.create_batch(10, has_tenant_group=False, using=db_name)
-        TenantFactory.create_batch(10, has_tenant_group=True, using=db_name)
-        self.stdout.write("Creating LocationTypes...")
-        LocationTypeFactory.create_batch(7, using=db_name)  # only 7 unique LocationTypes are hard-coded presently
-        self.stdout.write("Creating Locations...")
+        _create_batch(TagFactory, 15, description="on some content-types")
+        _create_batch(ContactFactory, 20)
+        _create_batch(TeamFactory, 20)
+        _create_batch(TenantGroupFactory, 10, description="without parents", has_parent=False)
+        _create_batch(TenantGroupFactory, 10, description="with parents", has_parent=True)
+        _create_batch(TenantFactory, 10, description="without a parent group", has_tenant_group=False)
+        _create_batch(TenantFactory, 10, description="with a parent group", has_tenant_group=True)
+        _create_batch(LocationTypeFactory, 7)  # only 7 unique LocationTypes are hard-coded presently
         # First 7 locations must be created in specific order so subsequent objects have valid parents to reference
-        LocationFactory.create_batch(7, has_parent=True, using=db_name)
-        LocationFactory.create_batch(40, using=db_name)
-        LocationFactory.create_batch(10, has_parent=False, using=db_name)
-        self.stdout.write("Creating Controller with Groups...")
-        ControllerFactory.create_batch(1)
-        ControllerManagedDeviceGroupFactory.create_batch(5)
-        self.stdout.write("Creating RIRs...")
-        RIRFactory.create_batch(9, using=db_name)  # only 9 unique RIR names are hard-coded presently
-        self.stdout.write("Creating RouteTargets...")
-        RouteTargetFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating Namespaces...")
-        NamespaceFactory.create_batch(10, using=db_name)
-        self.stdout.write("Creating VRFs...")
-        VRFFactory.create_batch(10, has_tenant=True, using=db_name)
-        VRFFactory.create_batch(10, has_tenant=False, using=db_name)
-        self.stdout.write("Creating VLANGroups...")
-        VLANGroupFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating VLANs...")
-        VLANFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating Prefixes and IP Addresses...")
+        _create_batch(LocationFactory, 7, description="as structure", has_parent=True)
+        _create_batch(LocationFactory, 40)
+        _create_batch(LocationFactory, 10, description="without a parent Location", has_parent=False)
+        _create_batch(ControllerFactory, 1, description="without a Device or DeviceRedundancyGroup")
+        _create_batch(ControllerManagedDeviceGroupFactory, 5, description="to contain Devices")
+        _create_batch(RIRFactory, 9)  # only 9 unique RIR names are hard-coded presently
+        _create_batch(RouteTargetFactory, 20)
+        _create_batch(NamespaceFactory, 10)
+        _create_batch(VRFFactory, 20)
+        _create_batch(VLANGroupFactory, 20)
+        _create_batch(VLANFactory, 20)
         for i in range(30):
-            PrefixFactory.create(prefix=f"10.{i}.0.0/16", type=PrefixTypeChoices.TYPE_CONTAINER, using=db_name)
-            PrefixFactory.create(prefix=f"2001:db8:0:{i}::/64", type=PrefixTypeChoices.TYPE_CONTAINER, using=db_name)
-        self.stdout.write("Creating Empty Namespaces...")
-        NamespaceFactory.create_batch(5, using=db_name)
-        self.stdout.write("Creating Device Families...")
-        DeviceFamilyFactory.create_batch(20)
-        self.stdout.write("Creating Manufacturers...")
-        ManufacturerFactory.create_batch(8, using=db_name)  # First 8 hard-coded Manufacturers
-        self.stdout.write("Creating Platforms (with manufacturers)...")
-        PlatformFactory.create_batch(20, has_manufacturer=True, using=db_name)
-        self.stdout.write("Creating Platforms (without manufacturers)...")
-        PlatformFactory.create_batch(5, has_manufacturer=False, using=db_name)
-        self.stdout.write("Creating SoftwareVersions...")
-        SoftwareVersionFactory.create_batch(20)
-        self.stdout.write("Creating SoftwareImageFiles...")
-        SoftwareImageFileFactory.create_batch(25)
-        self.stdout.write("Creating Manufacturers without Platforms...")
-        ManufacturerFactory.create_batch(4, using=db_name)  # 4 more hard-coded Manufacturers
-        self.stdout.write("Creating DeviceTypes...")
-        DeviceTypeFactory.create_batch(30, using=db_name)
-        self.stdout.write("Creating Manufacturers without DeviceTypes or Platforms...")
-        ManufacturerFactory.create_batch(2, using=db_name)  # Last 2 hard-coded Manufacturers
-        self.stdout.write("Creating DeviceRedundancyGroups...")
-        DeviceRedundancyGroupFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating Devices...")
-        DeviceFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating SoftwareVersions with Devices, InventoryItems or VirtualMachines...")
-        SoftwareVersionFactory.create_batch(5)
-        self.stdout.write("Creating SoftwareImageFiles without DeviceTypes...")
-        SoftwareImageFileFactory.create_batch(5)
-        self.stdout.write("Creating CircuitTypes...")
-        CircuitTypeFactory.create_batch(40, using=db_name)
-        self.stdout.write("Creating Providers...")
-        ProviderFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating ProviderNetworks...")
-        ProviderNetworkFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating Circuits...")
-        CircuitFactory.create_batch(40, using=db_name)
-        self.stdout.write("Creating Providers without Circuits...")
-        ProviderFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating CircuitTerminations...")
-        CircuitTerminationFactory.create_batch(2, has_location=True, term_side="A", using=db_name)
-        CircuitTerminationFactory.create_batch(2, has_location=True, term_side="Z", using=db_name)
-        CircuitTerminationFactory.create_batch(2, has_location=False, term_side="A", using=db_name)
-        CircuitTerminationFactory.create_batch(2, has_location=False, term_side="Z", using=db_name)
-        CircuitTerminationFactory.create_batch(2, has_port_speed=True, has_upstream_speed=False, using=db_name)
-        CircuitTerminationFactory.create_batch(
-            size=2,
+            _create_batch(
+                PrefixFactory,
+                1,
+                description=f"(10.{i}.0.0/16 and descendants)",
+                prefix=f"10.{i}.0.0/16",
+                type=PrefixTypeChoices.TYPE_CONTAINER,
+            )
+            _create_batch(
+                PrefixFactory,
+                1,
+                description=f"(2001:db8:0:{i}::/64 and descendants)",
+                prefix=f"2001:db8:0:{i}::/64",
+                type=PrefixTypeChoices.TYPE_CONTAINER,
+            )
+        _create_batch(NamespaceFactory, 5, description="without any Prefixes or IPAddresses")
+        _create_batch(DeviceFamilyFactory, 20)
+        _create_batch(ManufacturerFactory, 8)  # First 8 hard-coded Manufacturers
+        _create_batch(PlatformFactory, 20, description="with Manufacturers", has_manufacturer=True)
+        _create_batch(PlatformFactory, 5, description="without Manufacturers", has_manufacturer=False)
+        _create_batch(SoftwareVersionFactory, 20, description="to be usable by Devices")
+        _create_batch(SoftwareImageFileFactory, 25, description="to be usable by DeviceTypes")
+        _create_batch(ManufacturerFactory, 4, description="without Platforms")  # 4 more hard-coded Manufacturers
+        _create_batch(DeviceTypeFactory, 30)
+        _create_batch(ManufacturerFactory, 2, description="without Platforms or DeviceTypes")  # Last 2 hard-coded
+        _create_batch(DeviceRedundancyGroupFactory, 20)
+        _create_batch(DeviceFactory, 20)
+        _create_batch(SoftwareVersionFactory, 5, description="without Devices")
+        _create_batch(SoftwareImageFileFactory, 5, description="without DeviceTypes")
+        _create_batch(CircuitTypeFactory, 40)
+        _create_batch(ProviderFactory, 20, description="to be usable by Circuits")
+        _create_batch(ProviderNetworkFactory, 20)
+        _create_batch(CircuitFactory, 40)
+        _create_batch(ProviderFactory, 20, description="without Circuits")
+        # TODO do we really need all of these specifics for CircuitTerminations?
+        _create_batch(
+            CircuitTerminationFactory, 2, description="with a location, for side A", has_location=True, term_side="A"
+        )
+        _create_batch(
+            CircuitTerminationFactory, 2, description="with a location, for side Z", has_location=True, term_side="Z"
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="without a location, for side A",
+            has_location=False,
+            term_side="A",
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="without a location, for side Z",
+            has_location=False,
+            term_side="Z",
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="with port_speed but without upstream_speed",
+            has_port_speed=True,
+            has_upstream_speed=False,
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="with a location, port_speed, upstream_speed, xconnect_id, pp_info, and description",
             has_location=True,
             has_port_speed=True,
             has_upstream_speed=True,
             has_xconnect_id=True,
             has_pp_info=True,
             has_description=True,
-            using=db_name,
         )
-        self.stdout.write("Creating ExternalIntegrations...")
-        ExternalIntegrationFactory.create_batch(20, using=db_name)
-        self.stdout.write("Creating Controllers with Device or DeviceRedundancyGroups...")
-        ControllerFactory.create_batch(10)
-        ControllerManagedDeviceGroupFactory.create_batch(30)
+        _create_batch(ExternalIntegrationFactory, 20)
+        _create_batch(ControllerFactory, 10, description="with Devices or DeviceRedundancyGroups")
+        _create_batch(ControllerManagedDeviceGroupFactory, 5, description="without any Devices")
         # make sure we have some tenants that have null relationships to make filter tests happy
-        self.stdout.write("Creating Tenants without Circuits, Locations, IPAddresses, or Prefixes...")
-        TenantFactory.create_batch(10, using=db_name)
+        _create_batch(TenantFactory, 10, description="without any associated objects")
         # TODO: nautobot.tenancy.tests.test_filters currently calls the following additional factories:
-        # UserFactory.create_batch(10)
-        # RackFactory.create_batch(10)
-        # RackReservationFactory.create_batch(10)
-        # ClusterTypeFactory.create_batch(10)
-        # ClusterGroupFactory.create_batch(10)
-        # ClusterFactory.create_batch(10)
-        # VirtualMachineFactory.create_batch(10)
+        # _create_batch(UserFactory, 10)
+        # _create_batch(RackFactory, 10)
+        # _create_batch(RackReservationFactory, 10)
+        # _create_batch(ClusterTypeFactory, 10)
+        # _create_batch(ClusterGroupFactory, 10)
+        # _create_batch(ClusterFactory, 10)
+        # _create_batch(VirtualMachineFactory, 10)
         # We need to remove them from there and enable them here instead, but that will require many test updates.
 
-        self._output_hash_for_factory_models(
-            factories=[
-                CircuitFactory,
-                CircuitTerminationFactory,
-                CircuitTypeFactory,
-                ContactFactory,
-                ControllerManagedDeviceGroupFactory,
-                ControllerFactory,
-                DeviceFactory,
-                DeviceFamilyFactory,
-                DeviceRedundancyGroupFactory,
-                DeviceTypeFactory,
-                ExternalIntegrationFactory,
-                IPAddressFactory,
-                LocationFactory,
-                LocationTypeFactory,
-                ManufacturerFactory,
-                NamespaceFactory,
-                PlatformFactory,
-                PrefixFactory,
-                ProviderFactory,
-                ProviderNetworkFactory,
-                RIRFactory,
-                RoleFactory,
-                RouteTargetFactory,
-                SoftwareImageFileFactory,
-                SoftwareVersionFactory,
-                StatusFactory,
-                TagFactory,
-                TeamFactory,
-                TenantFactory,
-                TenantGroupFactory,
-                VLANFactory,
-                VLANGroupFactory,
-                VRFFactory,
-            ]
-        )
-
-    def _output_hash_for_factory_models(self, factories):
-        """Output a hash of the IDs of all objects in the given factories' model.
-
-        Used for identifying factory determinism problems in unit tests. Only prints if GITHUB_ACTIONS environment variable is set to "true".
-        """
-        if not is_truthy(os.environ.get("GITHUB_ACTIONS", "false")):
-            return
-
-        for factory in factories:
-            model = factory._meta.get_model_class()
-            model_ids = list(model.objects.order_by("id").values_list("id", flat=True))
-            sha256_hash = hashlib.sha256(json.dumps(model_ids, cls=DjangoJSONEncoder).encode()).hexdigest()
-            self.stdout.write(f"SHA256 hash for {model.__name__}: {sha256_hash}")
-
     def handle(self, *args, **options):
         if options["flush"]:
             if options["interactive"]:
@@ -298,7 +265,10 @@ Type 'yes' to continue, or 'no' to cancel: """
             self.stdout.write(self.style.WARNING(f"Loading factory data from file {options['fixture_file']}"))
             call_command("loaddata", "--database", options["database"], options["fixture_file"])
         else:
-            self._generate_factory_data(options["seed"], options["database"])
+            print_hashes = options["print_hashes"]
+            if is_truthy(os.environ.get("GITHUB_ACTIONS", "false")):
+                print_hashes = True
+            self._generate_factory_data(options["seed"], options["database"], print_hashes=print_hashes)
 
             if options["cache_test_fixtures"]:
                 self.stdout.write(self.style.WARNING(f"Saving factory data to file {options['fixture_file']}"))

nautobot/core/models/fields.py

@@ -13,6 +13,7 @@ from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.forms import fields, widgets
 from nautobot.core.models import ordering
 from nautobot.core.models.managers import TagsManager
+from nautobot.core.models.validators import EnhancedURLValidator
 
 
 class mac_unix_expanded_uppercase(mac_unix_expanded):
@@ -381,6 +382,20 @@ class JSONArrayField(models.JSONField):
         )
 
 
+class LaxURLField(models.URLField):
+    """Like models.URLField, but using validators.EnhancedURLValidator and forms.LaxURLField."""
+
+    default_validators = [EnhancedURLValidator()]
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            **{
+                "form_class": fields.LaxURLField,
+                **kwargs,
+            },
+        )
+
+
 class TagsField(TaggableManager):
     """Override FormField method on taggit.managers.TaggableManager to match the Nautobot UI."""
 

nautobot/core/settings.yaml

@@ -773,7 +773,7 @@ properties:
     description: "A mapping of permissions to assign a new user account when created using SSO authentication."
     details: |-
       Each key in the dictionary will be the permission name specified as `<app_label>.<action>_<model>`,
-      and the value should be set to the permission [constraints](../guides/permissions.md#constraints),
+      and the value should be set to the permission [constraints](../guides/permissions.md#example-constraint-definitions),
       or `None` to allow all objects.
 
       Example:
@@ -1278,7 +1278,7 @@ properties:
 
       !!! note
           If a given device has an appropriately populated
-          [secrets group](../../platform-functionality/secret.md#secretsgroup) assigned to it,
+          [secrets group](../../platform-functionality/secret.md#secrets-groups) assigned to it,
           the [secrets](../../platform-functionality/secret.md) defined in that group will take precedence
           over these default values.
     environment_variable: "NAUTOBOT_NAPALM_PASSWORD"
@@ -1300,7 +1300,7 @@ properties:
 
       !!! note
           If a given device has an appropriately populated
-          [secrets group](../../platform-functionality/secret.md#secretsgroup) assigned to it,
+          [secrets group](../../platform-functionality/secret.md#secrets-groups) assigned to it,
           the [secrets](../../platform-functionality/secret.md) defined in that group will take precedence
           over these default values.
     environment_variable: "NAUTOBOT_NAPALM_USERNAME"

nautobot/core/testing/filters.py

@@ -1,12 +1,19 @@
 import random
 import string
 
+from django.contrib.contenttypes.models import ContentType
 from django.db.models import Count, Q
 from django.db.models.fields.related import ManyToManyField
 from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.test import tag
 
-from nautobot.core.filters import RelatedMembershipBooleanFilter, SearchFilter
+from nautobot.core.filters import (
+    ContentTypeChoiceFilter,
+    ContentTypeFilter,
+    ContentTypeMultipleChoiceFilter,
+    RelatedMembershipBooleanFilter,
+    SearchFilter,
+)
 from nautobot.core.models.generics import PrimaryModel
 from nautobot.core.testing import views
 from nautobot.tenancy import models
@@ -286,6 +293,22 @@ class FilterTestCases:
                         obj, obj_field_name = self._get_nested_related_obj_and_its_field_name(obj, obj_field_name)
                     self._assert_q_filter_predicate_validity(obj, obj_field_name, filter_field_name, lookup_method)
 
+        def test_content_type_related_fields_uses_content_type_filter(self):
+            for field in self.queryset.model._meta.fields:
+                related_model = getattr(field, "related_model", None)
+                if not related_model or related_model != ContentType:
+                    continue
+                with self.subTest(
+                    f"Assert {self.filterset.__class__.__name__}.{field.name} implements ContentTypeFilter"
+                ):
+                    filter_field = self.filterset.get_filters().get(field.name)
+                    if not filter_field:
+                        # This field is not part of the Filterset.
+                        continue
+                    self.assertIsInstance(
+                        filter_field, (ContentTypeFilter, ContentTypeMultipleChoiceFilter, ContentTypeChoiceFilter)
+                    )
+
     class NameOnlyFilterTestCase(FilterTestCase):
         """Add simple tests for filtering by name."""