nautobot 2.2.5__py3-none-any.whl → 2.2.7__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/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/mixins.py

@@ -6,7 +6,7 @@ from django.core.exceptions import (
     MultipleObjectsReturned,
     ObjectDoesNotExist,
 )
-from django.db.models import AutoField
+from django.db.models import AutoField, Model
 from rest_framework.exceptions import ValidationError
 
 from nautobot.core.api.utils import dict_to_filter_params
@@ -70,6 +70,11 @@ class WritableSerializerMixin:
             # Strip the trailing slash and split on slashes, taking the last value as the PK.
             data = data.rstrip("/").split("/")[-1]
 
+        # If we're passing the validated_data from one serializer as input to another serializer,
+        # data might already be a model instance:
+        if isinstance(data, Model):
+            return {"pk": data.pk}
+
         try:
             # The int case here is taking into account for the User model we inherit from django
             pk = int(data) if isinstance(queryset.model._meta.pk, AutoField) else uuid.UUID(str(data))

nautobot/core/api/schema.py

@@ -4,7 +4,7 @@ import re
 from drf_spectacular.contrib.django_filters import DjangoFilterExtension
 from drf_spectacular.extensions import OpenApiSerializerFieldExtension
 from drf_spectacular.openapi import AutoSchema
-from drf_spectacular.plumbing import build_array_type, build_media_type_object, get_doc, is_serializer
+from drf_spectacular.plumbing import build_array_type, build_media_type_object, get_doc, is_serializer, list_hash
 from drf_spectacular.serializers import PolymorphicProxySerializerExtension
 from rest_framework import serializers
 from rest_framework.relations import ManyRelatedField
@@ -359,6 +359,8 @@ class ChoiceFieldFix(OpenApiSerializerFieldExtension):
             return {
                 "type": value_type,
                 "enum": list(choices.keys()),
+                # Used to deduplicate enums with the same set of choices, since drf-spectacular 0.27.2
+                "x-spec-enum-id": list_hash([(k, v) for k, v in choices.items() if k not in ("", None)]),
             }
         else:
             return {

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/celery/__init__.py

@@ -109,7 +109,7 @@ def _import_jobs_from_git_repositories():
             and not GitRepository.objects.filter(slug=filename).exists()
         ):
             logger.warning("Deleting unmanaged (leftover?) Git repository clone at %s", filepath)
-            shutil.rmtree(filepath)
+            shutil.rmtree(filepath, ignore_errors=True)
 
     # Make sure all GitRepository records that include Jobs have up-to-date git clones, and load their jobs
     for repo in GitRepository.objects.filter(provided_contents__contains="extras.job"):

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/tests/runner.py

@@ -1,8 +1,10 @@
 import copy
+import hashlib
 
 from django.conf import settings
 from django.core.management import call_command
 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
@@ -113,6 +115,14 @@ class NautobotTestRunner(DiscoverRunner):
                             command += ["--seed", settings.TEST_FACTORY_SEED]
                         if self.cache_test_fixtures:
                             command += ["--cache-test-fixtures"]
+                            # Use the list of applied migrations as a unique hash to keep fixtures from differing
+                            # branches/releases of Nautobot in separate files.
+                            hexdigest = hashlib.shake_128(
+                                ",".join(
+                                    sorted(f"{m.app}.{m.name}" for m in MigrationRecorder.Migration.objects.all())
+                                ).encode("utf-8")
+                            ).hexdigest(10)
+                            command += ["--fixture-file", f"development/factory_dump.{hexdigest}.json"]
                         with time_keeper.timed(f'  Pre-populating test database "{alias}" with factory data...'):
                             db_command = [*command, "--database", alias]
                             call_command(*db_command)

nautobot/core/tests/test_utils.py

@@ -4,6 +4,7 @@ from django import forms as django_forms
 from django.apps import apps
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
 from django.db.models import Q
 from django.http import QueryDict
 from django.test import TestCase
@@ -11,7 +12,7 @@ from django.test import TestCase
 from nautobot.circuits import models as circuits_models
 from nautobot.core import exceptions, forms, settings_funcs
 from nautobot.core.api import utils as api_utils
-from nautobot.core.models import fields as core_fields, utils as models_utils
+from nautobot.core.models import fields as core_fields, utils as models_utils, validators
 from nautobot.core.utils import data as data_utils, filtering, lookup, requests
 from nautobot.core.utils.migrations import update_object_change_ct_for_replaced_models
 from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models, tables
@@ -372,6 +373,52 @@ class SlugifyFunctionsTest(TestCase):
             self.assertEqual(core_fields.slugify_dashes_to_underscores(content), expected)
 
 
+class LaxURLFieldTest(TestCase):
+    """Test LaxURLField and related functionality."""
+
+    VALID_URLS = [
+        "http://example.com",
+        "https://local-dns/foo/bar.git",  # not supported out-of-the-box by Django, hence our custom classes
+        "https://1.1.1.1:8080/",
+        "https://[2001:db8::]/",
+    ]
+    INVALID_URLS = [
+        "unknown://example.com/",
+        "foo:/",
+        "http://file://",
+    ]
+
+    def test_enhanced_url_validator(self):
+        for valid in self.VALID_URLS:
+            with self.subTest(valid=valid):
+                validators.EnhancedURLValidator()(valid)
+
+        for invalid in self.INVALID_URLS:
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(django_forms.ValidationError):
+                    validators.EnhancedURLValidator()(invalid)
+
+    def test_forms_lax_url_field(self):
+        for valid in self.VALID_URLS:
+            with self.subTest(valid=valid):
+                forms.LaxURLField().clean(valid)
+
+        for invalid in self.INVALID_URLS:
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(django_forms.ValidationError):
+                    forms.LaxURLField().clean(invalid)
+
+    def test_models_lax_url_field(self):
+        for valid in self.VALID_URLS:
+            with self.subTest(valid=valid):
+                core_fields.LaxURLField().run_validators(valid)
+
+        for invalid in self.INVALID_URLS:
+            with self.subTest(invalid=invalid):
+                with self.assertRaises(ValidationError):
+                    core_fields.LaxURLField().run_validators(invalid)
+
+
 class LookupRelatedFunctionTest(TestCase):
     def test_is_single_choice_field(self):
         """