nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/core/tests/test_utils.py

@@ -1,16 +1,16 @@
-import pickle
+import uuid
 
 from django import forms as django_forms
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
 from django.http import QueryDict
-from django.test import RequestFactory, TestCase
+from django.test import TestCase
 
 from example_plugin.models import ExampleModel
 
 from nautobot.circuits import models as circuits_models
-from nautobot.core import constants, exceptions, forms, settings_funcs, testing
+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.utils import data as data_utils, filtering, lookup, requests
@@ -595,76 +595,20 @@ class LookupRelatedFunctionTest(TestCase):
         self.assertEqual(err.exception.code, 404)
 
 
-class NautobotFakeRequestTest(testing.TestCase):
-    """Test the NautobotFakeRequest class."""
-
-    def setUp(self):
-        """Create the RequestFactory."""
-        super().setUp()
-        self.factory = RequestFactory()
-
-    def get_with_user(self, url):
-        """RequestFactory() doesn't run middleware, so simulate it."""
-        request = self.factory.get(url)
-        request.user = self.user
-        return request
-
-    def test_copy_safe_request(self):
-        """Test that copy_safe_request() produces a realistic looking NautobotFakeRequest."""
-        real_request = self.get_with_user("/")
-        fake_request = requests.copy_safe_request(real_request)
-        self.assertEqual(real_request.POST, fake_request.POST)
-        self.assertEqual(real_request.GET, fake_request.GET)
-        self.assertEqual(real_request.user, fake_request.user)
-        self.assertEqual(real_request.path, fake_request.path)
-        for key in fake_request.META.keys():
-            self.assertIn(key, constants.HTTP_REQUEST_META_SAFE_COPY)
-            self.assertEqual(real_request.META[key], fake_request.META[key])
-        self.assertEqual(fake_request.user, self.user)
-
-    def test_fake_request_json_no_extra_db_access(self):
-        """Verify that serializing and deserializing a NautobotFakeRequest as JSON doesn't unnecessarily access the DB."""
-        real_request = self.get_with_user("/")
-        fake_request = requests.copy_safe_request(real_request)
-        with self.assertNumQueries(0):
-            new_fake_request = requests.NautobotFakeRequest.nautobot_deserialize(fake_request.nautobot_serialize())
-        # After creating the new instance, its `user` is a lazy attribute, which should evaluate on demand:
-        with self.assertNumQueries(1):
-            new_fake_request.user
-            self.assertEqual(new_fake_request.user, self.user)
-        # It should then be cached and not require re-lookup from the DB
-        with self.assertNumQueries(0):
-            new_fake_request.user
-
-    def test_fake_request_pickle_no_extra_db_access(self):
-        """Verify that pickling and unpickling a NautobotFakeRequest doesn't unnecessarily access the DB."""
-        real_request = self.get_with_user("/")
-        fake_request = requests.copy_safe_request(real_request)
-        with self.assertNumQueries(0):
-            new_fake_request = pickle.loads(pickle.dumps(fake_request))
-        # After creating the new instance, its `user` is a lazy attribute, which should evaluate on demand:
-        with self.assertNumQueries(1):
-            new_fake_request.user
-            self.assertEqual(new_fake_request.user, self.user)
-        # It should then be cached and not require re-lookup from the DB
-        with self.assertNumQueries(0):
-            new_fake_request.user
-
-
 class GetFilterFieldLabelTest(TestCase):
     @classmethod
     def setUpTestData(cls):
         device_ct = ContentType.objects.get_for_model(dcim_models.Device)
         cls.peer_relationship = extras_models.Relationship(
-            name="HA Device Peer",
-            slug="ha_device_peer",
+            label="HA Device Peer",
+            key="ha_device_peer",
             source_type=device_ct,
             destination_type=device_ct,
             source_label="Peer",
             destination_label="Peer",
             type=RelationshipTypeChoices.TYPE_ONE_TO_ONE_SYMMETRIC,
         )
-        # cls.peer_relationship.validated_save()
+        cls.peer_relationship.validated_save()
 
         cls.custom_field = extras_models.CustomField(key="labeled_custom_field", label="Moo!", type="text")
         cls.custom_field.validated_save()
@@ -683,12 +627,11 @@ class GetFilterFieldLabelTest(TestCase):
                 filtering.get_filter_field_label(device_filter_set_filters["has_interfaces"]), "Has interfaces"
             )
 
-        # TODO: Fix once validated save on Relationship doesn't throw content type errors
-        # with self.subTest("Relationship field name"):
-        #     self.assertEqual(
-        #         filtering.get_filter_field_label(device_filter_set_filters[f"cr_{self.peer_relationship.slug}__peer"]),
-        #         self.peer_relationship.source_label,
-        #     )
+        with self.subTest("Relationship field name"):
+            self.assertEqual(
+                filtering.get_filter_field_label(device_filter_set_filters[f"cr_{self.peer_relationship.key}__peer"]),
+                self.peer_relationship.source_label,
+            )
 
         with self.subTest("Custom field with label"):
             self.assertEqual(
@@ -714,3 +657,24 @@ class FieldNameToDisplayTest(TestCase):
             # This shouldn't ever be an input because get_filter_field_label
             # will use the label from the custom field instead of the field name
             self.assertEqual(filtering._field_name_to_display("cr_sister_sites__peer"), "Cr_sister_sites peer")
+
+
+class IsFooTest(TestCase):
+    def test_is_url(self):
+        """Validate the operation of `is_url()`."""
+        with self.subTest("Test a valid URL."):
+            self.assertTrue(
+                data_utils.is_url("http://localhost:3000/api/extras/statuses/3256ead7-0745-432a-a031-3928c9b7d075/")
+            )
+        with self.subTest("Test an nvalid URL."):
+            self.assertFalse(data_utils.is_url("pizza"))
+
+    def test_is_uuid(self):
+        """Validate the operation of `is_uuid()`."""
+        with self.subTest("Test valid UUID."):
+            self.assertTrue(data_utils.is_uuid(uuid.uuid4()))
+            self.assertTrue(data_utils.is_uuid(str(uuid.uuid4())))
+        with self.subTest("Test invalid UUID."):
+            self.assertFalse(data_utils.is_uuid(None))
+            self.assertFalse(data_utils.is_uuid(1))
+            self.assertFalse(data_utils.is_uuid("abc123"))

nautobot/core/tests/test_views.py

@@ -187,8 +187,8 @@ class NavRestrictedUI(TestCase):
         return response.content.decode(response.charset)
 
     @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_installed_plugins_visible_to_staff_with_hide_restricted_ui_true(self):
-        """The "Installed Plugins" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
+    def test_installed_apps_visible_to_staff_with_hide_restricted_ui_true(self):
+        """The "Installed Apps" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
         # Make user admin
         self.user.is_staff = True
         self.user.save()
@@ -197,16 +197,15 @@ class NavRestrictedUI(TestCase):
         self.assertInHTML(
             f"""
             <li>
-              <div class="buttons pull-right"></div>
-              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Plugins</a>
+              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Apps</a>
             </li>
             """,
             response_content,
         )
 
     @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_installed_plugins_visible_to_staff_with_hide_restricted_ui_false(self):
-        """The "Installed Plugins" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
+    def test_installed_apps_visible_to_staff_with_hide_restricted_ui_false(self):
+        """The "Installed Apps" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
         # Make user admin
         self.user.is_staff = True
         self.user.save()
@@ -215,30 +214,28 @@ class NavRestrictedUI(TestCase):
         self.assertInHTML(
             f"""
             <li>
-              <div class="buttons pull-right"></div>
-              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Plugins</a>
+              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Apps</a>
             </li>
             """,
             response_content,
         )
 
     @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_installed_plugins_not_visible_to_non_staff_user_with_hide_restricted_ui_true(self):
-        """The "Installed Plugins" menu item should be hidden from a non-staff user when HIDE_RESTRICTED_UI=True."""
+    def test_installed_apps_not_visible_to_non_staff_user_with_hide_restricted_ui_true(self):
+        """The "Installed Apps" menu item should be hidden from a non-staff user when HIDE_RESTRICTED_UI=True."""
         response_content = self.make_request()
 
-        self.assertNotRegex(response_content, r"Installed\s+Plugins")
+        self.assertNotRegex(response_content, r"Installed\s+Apps")
 
     @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_installed_plugins_disabled_to_non_staff_user_with_hide_restricted_ui_false(self):
-        """The "Installed Plugins" menu item should be disabled for a non-staff user when HIDE_RESTRICTED_UI=False."""
+    def test_installed_apps_disabled_to_non_staff_user_with_hide_restricted_ui_false(self):
+        """The "Installed Apps" menu item should be disabled for a non-staff user when HIDE_RESTRICTED_UI=False."""
         response_content = self.make_request()
 
         self.assertInHTML(
             f"""
             <li class="disabled">
-              <div class="buttons pull-right"></div>
-              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Plugins</a>
+              <a href="{self.url}" data-item-weight="{self.item_weight}">Installed Apps</a>
             </li>
             """,
             response_content,

nautobot/core/utils/data.py

@@ -2,6 +2,7 @@ from collections import OrderedDict, namedtuple
 from decimal import Decimal
 import uuid
 
+from django.core import validators
 from django.template import engines
 
 from nautobot.dcim import choices  # TODO move dcim.choices.CableLengthUnitChoices into core
@@ -66,6 +67,22 @@ def is_uuid(value):
     return False
 
 
+def is_url(value):
+    """
+    Validate whether a value is a URL.
+
+    Args:
+        value (str): String to validate.
+
+    Returns:
+        bool
+    """
+    try:
+        return validators.URLValidator()(value) is None
+    except validators.ValidationError:
+        return False
+
+
 def render_jinja2(template_code, context):
     """
     Render a Jinja2 template with the provided context. Return the rendered content.

nautobot/core/utils/deprecation.py

@@ -9,8 +9,8 @@ from nautobot.core.settings import LOG_DEPRECATION_WARNINGS
 logger = logging.getLogger(__name__)
 
 
-def class_deprecated_in_favor_of(replacement_class):
-    """Decorator to mark a class as deprecated and suggest a replacement class if it is subclassed from."""
+def class_deprecated(message):
+    """Decorator to mark a class as deprecated with a custom message about what to do instead of subclassing it."""
 
     def decorate(cls):
         def init_subclass(new_subclass):
@@ -24,8 +24,7 @@ def class_deprecated_in_favor_of(replacement_class):
                 stacklevel = 1
             warnings.warn(
                 f"Class {cls.__name__} is deprecated, and will be removed in a future Nautobot release. "
-                f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, "
-                f"please migrate your code to inherit from class {replacement_class.__name__} instead.",
+                f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, {message}.",
                 DeprecationWarning,
                 stacklevel=stacklevel,
             )
@@ -33,8 +32,7 @@ def class_deprecated_in_favor_of(replacement_class):
                 # Since DeprecationWarnings are silenced by default, also log a traditional warning.
                 logger.warning(
                     f"Class {cls.__name__} is deprecated, and will be removed in a future Nautobot release. "
-                    f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, "
-                    f"please migrate your code to inherit from class {replacement_class.__name__} instead.",
+                    f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, {message}.",
                     stacklevel=stacklevel,
                 )
 
@@ -42,3 +40,8 @@ def class_deprecated_in_favor_of(replacement_class):
         return cls
 
     return decorate
+
+
+def class_deprecated_in_favor_of(replacement_class):
+    """Decorator to mark a class as deprecated and suggest a replacement class if it is subclassed from."""
+    return class_deprecated(f"please migrate your code to inherit from class {replacement_class.__name__} instead")

nautobot/core/utils/filtering.py

@@ -123,8 +123,13 @@ def get_filterset_parameter_form_field(model, parameter, filterset=None):
             form_attr["query_params"] = {"content_types": model._meta.label_lower}
 
         form_field = DynamicModelMultipleChoiceField(**form_attr)
-    elif isinstance(field, ContentTypeMultipleChoiceFilter):
-        plural_name = model._meta.verbose_name_plural
+    elif isinstance(
+        field, ContentTypeMultipleChoiceFilter
+    ):  # While there are other objects using `ContentTypeMultipleChoiceFilter`, the case where
+        # models that have sucha  filter and the `verbose_name_plural` has multiple words is ony one: "dynamic groups".
+        from nautobot.core.models.fields import slugify_dashes_to_underscores  # Avoid circular import
+
+        plural_name = slugify_dashes_to_underscores(model._meta.verbose_name_plural)
         try:
             form_field = MultipleContentTypeField(choices_as_strings=True, feature=plural_name)
         except KeyError:
@@ -133,7 +138,7 @@ def get_filterset_parameter_form_field(model, parameter, filterset=None):
             # In this case use queryset
             queryset_map = {
                 "tags": TaggableClassesQuery,
-                "job hooks": ChangeLoggedModelsQuery,
+                "job_hooks": ChangeLoggedModelsQuery,
                 "roles": RoleModelsQuery,
             }
             form_field = MultipleContentTypeField(

nautobot/core/utils/git.py

@@ -69,17 +69,25 @@ class GitRepo:
         if url not in self.repo.remotes.origin.urls:
             self.repo.remotes.origin.set_url(url)
 
+    @property
+    def head(self):
+        """Current checked out repository head commit."""
+        return self.repo.head.commit.hexsha
+
     def fetch(self):
         self.repo.remotes.origin.fetch()
 
     def checkout(self, branch, commit_hexsha=None):
         """
         Check out the given branch, and optionally the specified commit within that branch.
+
+        Returns:
+            (str, bool): commit_hexsha the repo contains now, whether any change occurred
         """
         # Short-circuit logic - do we already have this commit checked out?
-        if commit_hexsha and commit_hexsha == self.repo.head.commit.hexsha:
+        if commit_hexsha and commit_hexsha == self.head:
             logger.debug(f"Commit {commit_hexsha} is already checked out.")
-            return commit_hexsha
+            return (commit_hexsha, False)
 
         self.fetch()
         if commit_hexsha:
@@ -92,7 +100,7 @@ class GitRepo:
                 raise RuntimeError(f"Requested to check out commit `{commit_hexsha}`, but it's not in branch {branch}!")
             logger.info(f"Checking out commit `{commit_hexsha}` on branch `{branch}`...")
             self.repo.git.checkout(commit_hexsha)
-            return commit_hexsha
+            return (commit_hexsha, True)
 
         if branch in self.repo.heads:
             branch_head = self.repo.heads[branch]
@@ -117,7 +125,7 @@ class GitRepo:
         self.repo.head.reset(f"origin/{branch}", index=True, working_tree=True)
         commit_hexsha = self.repo.head.reference.commit.hexsha
         logger.info(f"Latest commit on branch `{branch}` is `{commit_hexsha}`")
-        return commit_hexsha
+        return (commit_hexsha, True)
 
     def diff_remote(self, branch):
         logger.debug("Fetching from remote.")

nautobot/core/utils/lookup.py

@@ -85,7 +85,9 @@ def get_route_for_model(model, action, api=False):
     else:
         app_label = model._meta.app_label
     prefix = f"{app_label}{suffix}:{model._meta.model_name}"
-    sep = "_" if not api else "-"
+    sep = ""
+    if action != "":
+        sep = "_" if not api else "-"
     viewname = f"{prefix}{sep}{action}"
 
     if model._meta.app_label in settings.PLUGINS:

nautobot/core/utils/requests.py

@@ -1,118 +1,15 @@
-import copy
 import re
 
 from django import forms
-from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.http import QueryDict
-from django.utils.functional import SimpleLazyObject
 import django_filters
 
-from nautobot.core import constants, exceptions
+from nautobot.core import exceptions
 from nautobot.core.utils.filtering import get_filterset_field
 
 
-#
-# Fake request object
-#
-
-
-class NautobotFakeRequest:
-    """
-    A fake request object which is explicitly defined at the module level so it is able to be pickled. It simply
-    takes what is passed to it as kwargs on init and sets them as instance variables.
-    """
-
-    def __init__(self, _dict):
-        self.__dict__ = _dict
-
-    def _get_user(self):
-        """Lazy lookup function for self.user."""
-        if not self._cached_user:
-            User = get_user_model()
-            self._cached_user = User.objects.get(pk=self._user_pk)
-        return self._cached_user
-
-    def _init_user(self):
-        """Set up self.user as a lazy attribute, similar to a real Django Request object."""
-        self._cached_user = None
-        self.user = SimpleLazyObject(self._get_user)
-
-    def nautobot_serialize(self):
-        """
-        Serialize a JSON representation that is safe to pass to Celery.
-
-        This function is called from nautobot.core.celery.NautobotKombuJSONEncoder.
-        """
-        data = copy.deepcopy(self.__dict__)
-        # We don't want to try to pickle/unpickle or serialize/deserialize the actual User object,
-        # but make sure we do store its PK so that we can look it up on-demand after being deserialized.
-        user = data.pop("user")
-        data.pop("_cached_user", None)
-        if "_user_pk" not in data:
-            # We have a user but haven't stored its PK yet, so look it up and store it
-            data["_user_pk"] = user.pk
-        return data
-
-    @classmethod
-    def nautobot_deserialize(cls, data):
-        """
-        Deserialize a JSON representation that is safe to pass to Celery and return a NautobotFakeRequest instance.
-
-        This function is registered for usage by Celery in nautobot/core/celery/__init__.py
-        """
-        obj = cls(data)
-        obj._init_user()
-        return obj
-
-    def __getstate__(self):
-        """
-        Implement `pickle` serialization API.
-
-        It turns out that Celery uses pickle internally in apply_async()/send_job() even if we have configured Celery
-        to use JSON for all I/O (and we do, see settings.py), so we need to support pickle and JSON both.
-        """
-        return self.nautobot_serialize()
-
-    def __setstate__(self, state):
-        """
-        Implement `pickle` deserialization API.
-
-        It turns out that Celery uses pickle internally in apply_async()/send_job() even if we have configured Celery
-        to use JSON for all I/O (and we do, see settings.py), so we need to support pickle and JSON both.
-        """
-        # Generic __setstate__ behavior
-        self.__dict__.update(state)
-        # Set up lazy `self.user` attribute based on `state["_user_pk"]`
-        self._init_user()
-
-
-def copy_safe_request(request):
-    """
-    Copy selected attributes from a request object into a new fake request object. This is needed in places where
-    thread safe pickling of the useful request data is needed.
-
-    Note that `request.FILES` is explicitly omitted because they cannot be uniformly serialized.
-    """
-    meta = {
-        k: request.META[k]
-        for k in constants.HTTP_REQUEST_META_SAFE_COPY
-        if k in request.META and isinstance(request.META[k], str)
-    }
-
-    return NautobotFakeRequest(
-        {
-            "META": meta,
-            "POST": request.POST,
-            "GET": request.GET,
-            "user": request.user,
-            "path": request.path,
-            "id": getattr(request, "id", None),  # UUID assigned by middleware
-        }
-    )
-
-
 def convert_querydict_to_factory_formset_acceptable_querydict(request_querydict, filterset):
     """
     Convert request QueryDict/GET into an acceptable factory formset QueryDict

nautobot/core/views/__init__.py

@@ -34,6 +34,7 @@ from nautobot.extras.forms import GraphQLQueryForm
 
 class HomeView(AccessMixin, TemplateView):
     template_name = "home.html"
+    use_new_ui = True
 
     def render_additional_content(self, request, context, details):
         # Collect all custom data using callback functions.