nautobot 2.4.0b1__py3-none-any.whl → 2.4.2__py3-none-any.whl

nautobot/core/testing/views.py

@@ -21,17 +21,19 @@ from nautobot.core.models.tree_queries import TreeModel
 from nautobot.core.templatetags import helpers
 from nautobot.core.testing import mixins, utils
 from nautobot.core.utils import lookup
+from nautobot.dcim.models.device_components import ComponentModel
 from nautobot.extras import choices as extras_choices, models as extras_models, querysets as extras_querysets
 from nautobot.extras.forms import CustomFieldModelFormMixin, RelationshipModelFormMixin
 from nautobot.extras.models import CustomFieldModel, RelationshipModel
+from nautobot.extras.models.jobs import JobResult
 from nautobot.extras.models.mixins import NotesMixin
 from nautobot.ipam.models import Prefix
 from nautobot.users import models as users_models
 
 __all__ = (
-    "TestCase",
     "ModelTestCase",
     "ModelViewTestCase",
+    "TestCase",
     "ViewTestCases",
 )
 
@@ -1019,6 +1021,17 @@ class ViewTestCases:
             for instance in self._get_queryset().filter(pk__in=pk_list):
                 self.assertInstanceEqual(instance, self.bulk_edit_data)
 
+        def validate_redirect_to_job_result(self, response):
+            # Get the last Bulk Edit Objects JobResult created
+            job_result = JobResult.objects.filter(name="Bulk Edit Objects").first()
+            # Assert redirect to Job Results
+            self.assertRedirects(
+                response,
+                reverse("extras:jobresult", args=[job_result.pk]),
+                status_code=302,
+                target_status_code=200,
+            )
+
         def test_bulk_edit_objects_without_permission(self):
             pk_list = list(self._get_queryset().values_list("pk", flat=True)[:3])
             data = {
@@ -1044,9 +1057,8 @@ class ViewTestCases:
             # Assign model-level permission
             self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
-            # Try POST with model-level permission
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_edit"), data), 302)
-            self.validate_object_data_after_bulk_edit(pk_list)
+            response = self.client.post(self._get_url("bulk_edit"), data)
+            self.validate_redirect_to_job_result(response)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_edit_form_contains_all_pks(self):
@@ -1071,7 +1083,7 @@ class ViewTestCases:
             for pk in pk_list:
                 self.assertNotIn(str(pk), response_body)
             self.assertInHTML(
-                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
+                '<input type="hidden" name="_all" value="True" class="form-control" placeholder="None" id="id__all">',
                 response_body,
             )
 
@@ -1107,7 +1119,7 @@ class ViewTestCases:
             self.assertNotIn(str(third_pk), response_body)
             self.assertIn("Editing 2 ", response_body)
             self.assertInHTML(
-                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
+                '<input type="hidden" name="_all" value="True" class="form-control" placeholder="None" id="id__all">',
                 response_body,
             )
 
@@ -1147,21 +1159,9 @@ class ViewTestCases:
 
             # Attempt to bulk edit permitted objects into a non-permitted state
             response = self.client.post(self._get_url("bulk_edit"), data)
-            # 200 because we're sent back to the edit form to try again; if the update were successful it'd be a 302
-            self.assertHttpStatus(response, 200)
-            # Assert that the objects are NOT updated
-            for instance in self._get_queryset().filter(pk__in=pk_list):
-                self.assertIn(field.value_from_object(instance), values)
-                self.assertNotEqual(field.value_from_object(instance), self.bulk_edit_data[attr_name])
-
-            # Update permission constraints to permit all objects
-            obj_perm.constraints = {"pk__gt": 0}
-            obj_perm.save()
-
-            # Bulk edit permitted objects and expect a redirect back to the list view
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_edit"), data), 302)
-            # Assert that the objects were all updated correctly
-            self.validate_object_data_after_bulk_edit(pk_list)
+            # NOTE: There is no way of testing constrained failure as bulk edit is a system Job;
+            # and can only be tested by checking JobLogs.
+            self.validate_redirect_to_job_result(response)
 
     class BulkDeleteObjectsViewTestCase(ModelViewTestCase):
         """
@@ -1193,7 +1193,6 @@ class ViewTestCases:
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_bulk_delete_objects_with_permission(self):
             pk_list = self.get_deletable_object_pks()
-            initial_count = self._get_queryset().count()
             data = {
                 "pk": pk_list,
                 "confirm": True,
@@ -1201,11 +1200,18 @@ class ViewTestCases:
             }
 
             # Assign unconstrained permission
-            self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
+            self.add_permissions(
+                f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}", "extras.view_jobresult"
+            )
 
-            # Try POST with model-level permission
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_delete"), data), 302)
-            self.assertEqual(self._get_queryset().count(), initial_count - len(pk_list))
+            response = self.client.post(self._get_url("bulk_delete"), data)
+            job_result = JobResult.objects.filter(name="Bulk Delete Objects").first()
+            self.assertRedirects(
+                response,
+                reverse("extras:jobresult", args=[job_result.pk]),
+                status_code=302,
+                target_status_code=200,
+            )
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_bulk_delete_form_contains_all_objects(self):
@@ -1289,9 +1295,16 @@ class ViewTestCases:
             obj_perm.constraints = {"pk__isnull": False}  # Match a non-existent pk (i.e., allow all)
             obj_perm.save()
 
-            # Bulk delete permitted objects
-            self.assertHttpStatus(self.client.post(self._get_url("bulk_delete"), data), 302)
-            self.assertEqual(self._get_queryset().count(), initial_count - len(pk_list))
+            # User would be redirected to Job Result therefore user needs to have permission to view Job Result
+            self.add_permissions("extras.view_jobresult")
+            response = self.client.post(self._get_url("bulk_delete"), data)
+            job_result = JobResult.objects.filter(name="Bulk Delete Objects").first()
+            self.assertRedirects(
+                response,
+                reverse("extras:jobresult", args=[job_result.pk]),
+                status_code=302,
+                target_status_code=200,
+            )
 
     class BulkRenameObjectsViewTestCase(ModelViewTestCase):
         """
@@ -1441,6 +1454,8 @@ class ViewTestCases:
         maxDiff = None
         bulk_add_data = None
         """Used for bulk-add (distinct from bulk-create) view testing; self.bulk_create_data will be used if unset."""
+        selected_objects: list[ComponentModel]
+        selected_objects_parent_name: str
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_add_component(self):

nautobot/core/tests/integration/test_app_home.py

@@ -9,7 +9,6 @@ from example_app.models import ExampleModel
 class AppHomeTestCase(SeleniumTestCase):
     """Integration test the Example App homepage extensions."""
 
-    fixtures = ["user-data.json"]  # bob/bob
     layout = {
         "Organization": {
             "Locations": {"model": Location, "permission": "dcim.view_location"},

nautobot/core/tests/integration/test_app_navbar.py

@@ -5,7 +5,6 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class AppNavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 
-    fixtures = ["user-data.json"]
     navbar = {
         "Circuits": {
             "Circuits": {

nautobot/core/tests/integration/test_filters.py

@@ -11,8 +11,6 @@ from nautobot.extras.models import CustomField, CustomFieldChoice, Status
 class ListViewFilterTestCase(SeleniumTestCase):
     """Integration test for the list view filter ui."""
 
-    fixtures = ["user-data.json"]
-
     def setUp(self):
         super().setUp()
         self.login(self.user.username, self.password)

nautobot/core/tests/integration/test_home.py

@@ -7,7 +7,6 @@ from nautobot.tenancy.models import Tenant
 class HomeTestCase(SeleniumTestCase):
     """Integration tests against the home page."""
 
-    fixtures = ["user-data.json"]  # bob/bob
     layout = {
         "Organization": {
             "Locations": {"model": Location, "permission": "dcim.view_location"},

nautobot/core/tests/integration/test_navbar.py

@@ -4,7 +4,6 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class NavBarTestCase(SeleniumTestCase):
     """Integration test the navigation menu."""
 
-    fixtures = ["user-data.json"]
     navbar = {
         "Organization": {
             "Locations": {

nautobot/core/tests/integration/test_view_authentication.py

@@ -31,6 +31,7 @@ class AuthenticationEnforcedTestCase(TestCase):
                     "/health/",
                     "/login/",
                     "/media-failure/",
+                    "/robots.txt",
                     "/template.css",
                 ]:
                     self.assertHttpStatus(response, 200, msg=url)

nautobot/core/tests/runner.py

@@ -142,7 +142,7 @@ class NautobotTestRunner(DiscoverRunner):
                             # 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())
+                                    sorted(f"{m.app}.{m.name}" for m in MigrationRecorder.Migration.objects.all())  # pylint: disable=no-member
                                 ).encode("utf-8")
                             ).hexdigest(10)
                             command += ["--fixture-file", f"development/factory_dump.{hexdigest}.json"]

nautobot/core/tests/test_api.py

@@ -3,6 +3,7 @@ from io import BytesIO, StringIO
 import json
 import os
 from unittest import skip
+import uuid
 
 from constance import config
 from constance.test import override_config
@@ -14,6 +15,7 @@ from django.urls import reverse
 from rest_framework import status
 from rest_framework.exceptions import ParseError
 from rest_framework.settings import api_settings
+from rest_framework.test import APIRequestFactory, force_authenticate
 import yaml
 
 from nautobot.circuits.models import Provider
@@ -22,13 +24,14 @@ from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.api.renderers import NautobotCSVRenderer
 from nautobot.core.api.utils import get_serializer_for_model, get_view_name
 from nautobot.core.api.versioning import NautobotAPIVersioning
+from nautobot.core.api.views import ModelViewSet
 from nautobot.core.constants import COMPOSITE_KEY_SEPARATOR
 from nautobot.core.templatetags.helpers import humanize_speed
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim import models as dcim_models
 from nautobot.dcim.api import serializers as dcim_serializers
 from nautobot.extras import choices, models as extras_models
-from nautobot.ipam import models as ipam_models
+from nautobot.ipam import filters as ipam_filters, models as ipam_models
 from nautobot.ipam.api import serializers as ipam_serializers, views as ipam_api_views
 from nautobot.tenancy import models as tenancy_models
 
@@ -381,6 +384,7 @@ class GenerateLookupValueDomElementViewTestCase(testing.APITestCase):
             (
                 '<select name="role" class="form-control nautobot-select2-api" data-multiple="1" '
                 'data-query-param-content_types="[&quot;dcim.device&quot;, &quot;virtualization.virtualmachine&quot;]" '
+                'data-query-param-exclude_m2m="[&quot;true&quot;]" '
                 'display-field="display" value-field="name" data-depth="0" data-url="/api/extras/roles/" id="id_for_role" '
                 "multiple>\n</select>"
             ),
@@ -516,6 +520,80 @@ class NautobotCSVRendererTest(TestCase):
         self.assertEqual(read_data["parent__name"], location_type.parent.name)
 
 
+class ModelViewSetMixinTest(testing.APITestCase):
+    """Unit tests for ModelViewSetMixin, base class for ModelViewSet/ReadOnlyModelViewSet classes."""
+
+    class SimpleIPAddressViewSet(ModelViewSet):
+        queryset = ipam_models.IPAddress.objects.all()  # no explicit optimizations
+        serializer_class = ipam_serializers.IPAddressSerializer
+        filterset_class = ipam_filters.IPAddressFilterSet
+
+    def test_get_queryset_optimizations(self):
+        """Test that the queryset is appropriately optimized based on request parameters."""
+        self.user.is_superuser = True
+        self.user.save()
+
+        # Default behavior - m2m fields included
+        view = self.SimpleIPAddressViewSet()
+        view.action_map = {"get": "list"}
+        request = APIRequestFactory().get(reverse("ipam-api:ipaddress-list"), headers=self.header)
+        force_authenticate(request, user=self.user)
+        request = view.initialize_request(request)
+        view.setup(request)
+        view.initial(request)
+
+        queryset = view.get_queryset()
+        with self.assertNumQueries(5):  # IPAddress plus four prefetches
+            instance = queryset.first()
+        # FK related objects should have been auto-selected
+        with self.assertNumQueries(0):
+            instance.status
+            instance.role
+            instance.parent
+            instance.tenant
+            instance.nat_inside
+        # Reverse relations should have been auto-prefetched
+        with self.assertNumQueries(0):
+            list(instance.nat_outside_list.all())
+        # Many-to-many relations should have been auto-prefetched
+        with self.assertNumQueries(0):
+            list(instance.interfaces.all())
+            list(instance.vm_interfaces.all())
+            list(instance.tags.all())
+
+        # With exclude_m2m query parameter
+        view = self.SimpleIPAddressViewSet()
+        view.action_map = {"get": "list"}
+        request = APIRequestFactory().get(
+            reverse("ipam-api:ipaddress-list"), headers=self.header, data={"exclude_m2m": True}
+        )
+        force_authenticate(request, user=self.user)
+        request = view.initialize_request(request)
+        view.setup(request)
+        view.initial(request)
+
+        queryset = view.get_queryset()
+        with self.assertNumQueries(1):  # IPAddress only, no prefetches
+            instance = queryset.first()
+        # FK related objects should still have been auto-selected
+        with self.assertNumQueries(0):
+            instance.status
+            instance.role
+            instance.parent
+            instance.tenant
+            instance.nat_inside
+        # Reverse relations should NOT have been auto-prefetched
+        with self.assertNumQueries(1):
+            list(instance.nat_outside_list.all())
+        # Many-to-many relations should NOT have been auto-prefetched
+        with self.assertNumQueries(1):
+            list(instance.interfaces.all())
+        with self.assertNumQueries(1):
+            list(instance.vm_interfaces.all())
+        with self.assertNumQueries(1):
+            list(instance.tags.all())
+
+
 class WritableNestedSerializerTest(testing.APITestCase):
     """
     Test the operation of WritableNestedSerializer using VLANSerializer as our test subject.
@@ -688,6 +766,25 @@ class WritableNestedSerializerTest(testing.APITestCase):
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(ipam_models.VLAN.objects.filter(name="Test VLAN 100").count(), 0)
 
+    def test_create_with_specified_id(self):
+        data = {
+            "id": str(uuid.uuid4()),
+            "vid": 400,
+            "name": "Test VLAN 400",
+            "status": self.statuses.first().pk,
+            "vlan_group": self.vlan_group1.pk,
+        }
+        url = reverse("ipam-api:vlan-list")
+        self.add_permissions("ipam.add_vlan")
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(str(response.data["vlan_group"]["url"]), self.absolute_api_url(self.vlan_group1))
+        self.assertEqual(str(response.data["id"]), data["id"])
+        vlan = ipam_models.VLAN.objects.get(pk=response.data["id"])
+        self.assertEqual(vlan.status, self.statuses.first())
+        self.assertEqual(vlan.vlan_group, self.vlan_group1)
+
 
 class APIOrderingTestCase(testing.APITestCase):
     """

nautobot/core/tests/test_csv.py

@@ -1,3 +1,6 @@
+import csv
+import io
+
 from django.contrib.contenttypes.models import ContentType
 from django.test import override_settings, RequestFactory, TestCase
 from django.urls import reverse
@@ -261,9 +264,28 @@ class CSVParsingRelatedTestCase(TestCase):
         self.assertEqual(response.status_code, 200)
         response_data = response.content.decode(response.charset)
 
-        # Replace Device Name
-        import_data = response_data.replace("TestDevice1", "TestDevice3").replace("TestDevice2", "")
-        data = {"csv_data": import_data}
+        # parse the csv data
+        csv_reader = csv.DictReader(response_data.splitlines())
+        # remove the 'id' column so that all the items are imported new
+        fieldnames = [field for field in csv_reader.fieldnames if field != "id"]
+        # read all entries into a list
+        response_csv = list(csv_reader)
+
+        # mutate our data for testing purposes
+        for row in response_csv:
+            if row["name"] == "TestDevice1":
+                row["name"] = "TestDevice3"
+            elif row["name"] == "TestDevice2":
+                row["name"] = ""
+
+        # prep our data to write out
+        with io.StringIO() as import_csv:
+            writer = csv.DictWriter(import_csv, fieldnames=fieldnames)
+            writer.writeheader()
+            for row in response_csv:
+                filtered_row = {key: row[key] for key in fieldnames}
+                writer.writerow(filtered_row)
+            data = {"csv_data": import_csv.getvalue()}
         url = reverse("dcim:device_import")
         response = self.client.post(url, data)
         self.assertEqual(response.status_code, 200)