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

nautobot/core/tests/test_api.py

@@ -1,3 +1,6 @@
+from copy import deepcopy
+import csv
+from io import BytesIO, StringIO
 import json
 
 from django.contrib.contenttypes.models import ContentType
@@ -8,13 +11,20 @@ from django.urls import reverse
 from constance import config
 from constance.test import override_config
 from rest_framework import status
+from rest_framework.exceptions import ParseError
+from rest_framework.settings import api_settings
 
 from nautobot.circuits.models import Provider
 from nautobot.core import testing
+from nautobot.core.api.parsers import NautobotCSVParser
+from nautobot.core.api.renderers import NautobotCSVRenderer
+from nautobot.core.api.versioning import NautobotAPIVersioning
 from nautobot.dcim import models as dcim_models
+from nautobot.dcim.api import serializers as dcim_serializers
 from nautobot.extras import choices
 from nautobot.extras import models as extras_models
 from nautobot.ipam import models as ipam_models
+from nautobot.ipam.api import serializers as ipam_serializers
 
 
 class AppTest(testing.APITestCase):
@@ -171,27 +181,61 @@ class APIVersioningTestCase(testing.APITestCase):
     Testing our custom API versioning, NautobotAPIVersioning.
     """
 
+    OVERRIDE_REST_FRAMEWORK = deepcopy(settings.REST_FRAMEWORK)
+    # For Nautobot 2.0, the default/only supported API version is 2.0, which limits our ability to test with multiple
+    # or min/max versions. For test purposes we force there to be some extra versions available.
+    EXTRA_ALLOWED_VERSIONS = [
+        f"{settings.VERSION_MAJOR - 1}.99",
+        *settings.REST_FRAMEWORK["ALLOWED_VERSIONS"],
+        f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR + 1}",
+    ]
+    OVERRIDE_REST_FRAMEWORK["ALLOWED_VERSIONS"] = EXTRA_ALLOWED_VERSIONS
+    OVERRIDE_REST_FRAMEWORK["DEFAULT_VERSION"] = EXTRA_ALLOWED_VERSIONS[-1]
+
     def test_default_version(self):
-        """Test that a request with no specific API version gets the default version."""
+        """Test that a request with no specific API version gets the default version, which is the current version."""
         url = reverse("api-root")
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
-        self.assertEqual(response["API-Version"], settings.REST_FRAMEWORK["DEFAULT_VERSION"])
+        self.assertEqual(response["API-Version"], api_settings.DEFAULT_VERSION)
+        self.assertEqual(response["API-Version"], f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR}")
+
+        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
+            response = self.client.get(url, **self.header)
+            self.assertHttpStatus(response, 200)
+            self.assertIn("API-Version", response)
+            self.assertEqual(response["API-Version"], self.OVERRIDE_REST_FRAMEWORK["DEFAULT_VERSION"])
+            self.assertEqual(response["API-Version"], f"{settings.VERSION_MAJOR}.{settings.VERSION_MINOR + 1}")
+
+    def test_allowed_versions(self):
+        """Test that all expected versions are supported."""
+        for minor_version in range(0, settings.VERSION_MINOR + 1):
+            version = f"{settings.VERSION_MAJOR}.{minor_version}"
+            self.assertIn(version, settings.REST_FRAMEWORK["ALLOWED_VERSIONS"])
+            self.assertIn(version, api_settings.ALLOWED_VERSIONS)
+            self.assertIn(version, NautobotAPIVersioning.allowed_versions)
 
     def test_header_version(self):
         """Test that the API version can be specified via the HTTP Accept header."""
         url = reverse("api-root")
 
-        min_version = settings.REST_FRAMEWORK["ALLOWED_VERSIONS"][0]
+        min_version = api_settings.ALLOWED_VERSIONS[0]
         self.set_api_version(min_version)
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
         self.assertEqual(response["API-Version"], min_version)
 
-        max_version = settings.REST_FRAMEWORK["ALLOWED_VERSIONS"][-1]
-        self.set_api_version(max_version)
+        default_version = api_settings.DEFAULT_VERSION
+        self.set_api_version(default_version)
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, 200)
+        self.assertIn("API-Version", response)
+        self.assertEqual(response["API-Version"], default_version)
+
+        max_version = api_settings.ALLOWED_VERSIONS[-1]
+        self.set_api_version(min_version)
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
@@ -201,20 +245,49 @@ class APIVersioningTestCase(testing.APITestCase):
         self.set_api_version(invalid_version)
         response = self.client.get(url, **self.header)
         self.assertHttpStatus(response, 406)  # Not Acceptable
-        for version in settings.REST_FRAMEWORK["ALLOWED_VERSIONS"]:
+        for version in api_settings.ALLOWED_VERSIONS:
             self.assertIn(version, response.data["detail"])
 
+        # Also test with explicitly added additional allowed versions
+        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
+            min_version = self.EXTRA_ALLOWED_VERSIONS[0]
+            self.set_api_version(min_version)
+            response = self.client.get(url, **self.header)
+            self.assertHttpStatus(response, 200)
+            self.assertIn("API-Version", response)
+            self.assertEqual(response["API-Version"], min_version)
+
+            max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
+            self.set_api_version(max_version)
+            response = self.client.get(url, **self.header)
+            self.assertHttpStatus(response, 200)
+            self.assertIn("API-Version", response)
+            self.assertEqual(response["API-Version"], max_version)
+
+            invalid_version = "0.0"
+            self.set_api_version(invalid_version)
+            response = self.client.get(url, **self.header)
+            self.assertHttpStatus(response, 406)  # Not Acceptable
+            for version in self.EXTRA_ALLOWED_VERSIONS:
+                self.assertIn(version, response.data["detail"])
+
     def test_query_version(self):
         """Test that the API version can be specified via a query parameter."""
         url = reverse("api-root")
 
-        min_version = settings.REST_FRAMEWORK["ALLOWED_VERSIONS"][0]
+        min_version = api_settings.ALLOWED_VERSIONS[0]
         response = self.client.get(f"{url}?api_version={min_version}", **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
         self.assertEqual(response["API-Version"], min_version)
 
-        max_version = settings.REST_FRAMEWORK["ALLOWED_VERSIONS"][-1]
+        default_version = api_settings.DEFAULT_VERSION
+        response = self.client.get(f"{url}?api_version={default_version}", **self.header)
+        self.assertHttpStatus(response, 200)
+        self.assertIn("API-Version", response)
+        self.assertEqual(response["API-Version"], default_version)
+
+        max_version = api_settings.ALLOWED_VERSIONS[-1]
         response = self.client.get(f"{url}?api_version={max_version}", **self.header)
         self.assertHttpStatus(response, 200)
         self.assertIn("API-Version", response)
@@ -223,15 +296,36 @@ class APIVersioningTestCase(testing.APITestCase):
         invalid_version = "0.0"
         response = self.client.get(f"{url}?api_version={invalid_version}", **self.header)
         self.assertHttpStatus(response, 404)
-        for version in settings.REST_FRAMEWORK["ALLOWED_VERSIONS"]:
+        for version in api_settings.ALLOWED_VERSIONS:
             self.assertIn(version, response.data["detail"])
 
+        # Also test with explicitly added additional allowed versions
+        with override_settings(REST_FRAMEWORK=self.OVERRIDE_REST_FRAMEWORK):
+            min_version = self.EXTRA_ALLOWED_VERSIONS[0]
+            response = self.client.get(f"{url}?api_version={min_version}", **self.header)
+            self.assertHttpStatus(response, 200)
+            self.assertIn("API-Version", response)
+            self.assertEqual(response["API-Version"], min_version)
+
+            max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
+            response = self.client.get(f"{url}?api_version={max_version}", **self.header)
+            self.assertHttpStatus(response, 200)
+            self.assertIn("API-Version", response)
+            self.assertEqual(response["API-Version"], max_version)
+
+            invalid_version = "0.0"
+            response = self.client.get(f"{url}?api_version={invalid_version}", **self.header)
+            self.assertHttpStatus(response, 404)
+            for version in self.EXTRA_ALLOWED_VERSIONS:
+                self.assertIn(version, response.data["detail"])
+
+    @override_settings(REST_FRAMEWORK=OVERRIDE_REST_FRAMEWORK)
     def test_header_and_query_version(self):
         """Test the behavior when the API version is specified in both the Accept header *and* a query parameter."""
         url = reverse("api-root")
 
-        min_version = settings.REST_FRAMEWORK["ALLOWED_VERSIONS"][0]
-        max_version = settings.REST_FRAMEWORK["ALLOWED_VERSIONS"][-1]
+        min_version = self.EXTRA_ALLOWED_VERSIONS[0]
+        max_version = self.EXTRA_ALLOWED_VERSIONS[-1]
         # Specify same version both as Accept header and as query parameter (valid)
         self.set_api_version(max_version)
         response = self.client.get(f"{url}?api_version={max_version}", **self.header)
@@ -239,11 +333,10 @@ class APIVersioningTestCase(testing.APITestCase):
         self.assertIn("API-Version", response)
         self.assertEqual(response["API-Version"], max_version)
 
-        if min_version != max_version:
-            # Specify different versions in Accept header and query parameter (invalid)
-            response = self.client.get(f"{url}?api_version={min_version}", **self.header)
-            self.assertHttpStatus(response, 400)
-            self.assertIn("Version mismatch", response.data["detail"])
+        # Specify different versions in Accept header and query parameter (invalid)
+        response = self.client.get(f"{url}?api_version={min_version}", **self.header)
+        self.assertHttpStatus(response, 400)
+        self.assertIn("Version mismatch", response.data["detail"])
 
 
 class LookupTypeChoicesTestCase(testing.APITestCase):
@@ -329,11 +422,132 @@ class GenerateLookupValueDomElementViewTestCase(testing.APITestCase):
             {
                 "dom_element": '<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;]" '
-                'display-field="display" value-field="name" data-url="/api/extras/roles/" id="id_for_role" '
+                'display-field="display" value-field="name" data-depth="0" data-url="/api/extras/roles/" id="id_for_role" '
                 "multiple>\n</select>"
             },
         )
 
+        with self.subTest("Assert correct lookup field dom element is generated"):
+            response = self.client.get(url + "?content_type=dcim.location&field_name=name", **self.header)
+
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(
+                response.data,
+                {
+                    "dom_element": '<select name="name" class="form-control nautobot-select2-multi-value-char" data-multiple="1" id="id_for_name" multiple>\n</select>'
+                },
+            )
+
+        with self.subTest("Assert TempFilterForm is used if model filterform raises error at initialization"):
+            # The generation of a lookup field DOM representation is dependent on the ModelForm of the field;;
+            # if an error occurs when initializing the ModelForm, it should fall back to creating a temp ModelForm.
+            # Because the InterfaceModelForm requires a device to initialize, this is a perfect example to test that
+            # the Temp ModelForm is used.
+            response = self.client.get(url + "?content_type=dcim.interface&field_name=name", **self.header)
+
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(
+                response.data,
+                {
+                    "dom_element": '<select name="name" class="form-control nautobot-select2-multi-value-char" data-multiple="1" id="id_for_name" multiple>\n</select>'
+                },
+            )
+
+
+class NautobotCSVParserTest(TestCase):
+    """
+    Some unit tests for the NautobotCSVParser.
+
+    The class is also exercised by APIViewTestCases.CreateObjectViewTestCase.test_recreate_object_csv for each API.
+    """
+
+    def test_serializer_class_required(self):
+        with self.assertRaises(ParseError) as cm:
+            NautobotCSVParser().parse(BytesIO(b""))
+        self.assertEqual(str(cm.exception), "No serializer_class was provided by the parser_context")
+
+        with self.assertRaises(ParseError) as cm:
+            NautobotCSVParser().parse(BytesIO(b""), parser_context={"serializer_class": None})
+        self.assertEqual(str(cm.exception), "Serializer class for this parser_context is None, unable to proceed")
+
+    def test_parse_success(self):
+        status = extras_models.Status.objects.first()  # pylint: disable=redefined-outer-name
+        tags = extras_models.Tag.objects.get_for_model(ipam_models.VLAN)
+        csv_data = "\n".join(
+            [
+                # the "foobar" column is not understood by the serializer; per usual REST API behavior, it'll be skipped
+                "vid,name,foobar,description,status,tags,tenant",
+                f'22,hello,huh?,"It, I say, is a living!",{status.name},"{tags.first().name},{tags.last().name}",',
+            ]
+        )
+
+        data = NautobotCSVParser().parse(
+            BytesIO(csv_data.encode("utf-8")),
+            parser_context={"serializer_class": ipam_serializers.VLANSerializer},
+        )
+
+        self.assertEqual(
+            data,
+            [
+                {
+                    "vid": "22",  # parser could be enhanced to turn this to an int, but the serializer can handle it
+                    "name": "hello",
+                    "description": "It, I say, is a living!",
+                    "status": {"name": status.name},
+                    "tags": [{"name": tags.first().name}, {"name": tags.last().name}],
+                    "tenant": None,
+                },
+            ],
+        )
+
+    def test_parse_bad_header(self):
+        csv_data = "\n".join(
+            [
+                "vid,name,,description",
+                "22,hello,huh?,a description",
+            ]
+        )
+        with self.assertRaises(ParseError) as cm:
+            NautobotCSVParser().parse(
+                BytesIO(csv_data.encode("utf-8")),
+                parser_context={"serializer_class": ipam_serializers.VLANSerializer},
+            )
+        self.assertEqual(str(cm.exception), "Row 1: Column 3: missing/empty header for this column")
+
+
+class NautobotCSVRendererTest(TestCase):
+    """
+    Some unit tests for the NautobotCSVParser.
+
+    The class is also exercised by APIViewTestCases.CreateObjectViewTestCase.test_recreate_object_csv and
+    APIViewTestCases.ListObjectsViewTestCase.test_list_objects_csv for each API.
+    """
+
+    def test_render_success(self):
+        location_type = dcim_models.LocationType.objects.filter(parent__isnull=False).first()
+        data = dcim_serializers.LocationTypeSerializer(instance=location_type, context={"request": None}).data
+        csv_text = NautobotCSVRenderer().render(data)
+
+        # Make sure a) it's well-constructed parsable CSV and b) it contains what we expect it to, within reason
+        reader = csv.DictReader(StringIO(csv_text))
+        read_data = list(reader)[0]
+        self.assertIn("id", read_data)
+        self.assertEqual(read_data["id"], str(location_type.id))
+        self.assertIn("display", read_data)
+        self.assertEqual(read_data["display"], location_type.display)
+        self.assertIn("natural_key_slug", read_data)
+        self.assertEqual(read_data["natural_key_slug"], location_type.natural_key_slug)
+        self.assertIn("name", read_data)
+        self.assertEqual(read_data["name"], location_type.name)
+        self.assertIn("content_types", read_data)
+        # rendering/parsing of content-types field is tested elsewhere
+        self.assertIn("description", read_data)
+        self.assertEqual(read_data["description"], location_type.description)
+        self.assertIn("nestable", read_data)
+        self.assertEqual(read_data["nestable"], str(location_type.nestable))
+        self.assertIn("parent", read_data)
+        self.assertEqual(read_data["parent"], location_type.parent.natural_key_slug)
+
 
 class WritableNestedSerializerTest(testing.APITestCase):
     """
@@ -346,22 +560,24 @@ class WritableNestedSerializerTest(testing.APITestCase):
         self.location_type_1 = dcim_models.LocationType.objects.get(name="Campus")
         self.location_type_2 = dcim_models.LocationType.objects.get(name="Building")
 
+        self.statuses = extras_models.Status.objects.get_for_model(dcim_models.Location)
         self.location1 = dcim_models.Location.objects.create(
-            location_type=self.location_type_1, name="Location 1", slug="location-1"
+            location_type=self.location_type_1, name="Location 1", slug="location-1", status=self.statuses[0]
         )
         self.location2 = dcim_models.Location.objects.create(
             location_type=self.location_type_2,
             name="Location 2",
             slug="location-2",
             parent=self.location1,
+            status=self.statuses[0],
         )
         self.location3 = dcim_models.Location.objects.create(
             location_type=self.location_type_2,
             name="Location 3",
             slug="location-3",
             parent=self.location1,
+            status=self.statuses[0],
         )
-        self.statuses = extras_models.Status.objects.get_for_model(dcim_models.Location)
 
     def test_related_by_pk(self):
         data = {
@@ -375,7 +591,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
 
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(response.data["location"]["id"], str(self.location1.pk))
+        self.assertEqual(str(response.data["location"]), self.absolute_api_url(self.location1))
         vlan = ipam_models.VLAN.objects.get(pk=response.data["id"])
         self.assertEqual(vlan.status, self.statuses.first())
         self.assertEqual(vlan.location, self.location1)
@@ -408,7 +624,7 @@ class WritableNestedSerializerTest(testing.APITestCase):
 
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(response.data["location"]["id"], str(self.location1.pk))
+        self.assertEqual(str(response.data["location"]), self.absolute_api_url(self.location1))
         vlan = ipam_models.VLAN.objects.get(pk=response.data["id"])
         self.assertEqual(vlan.location, self.location1)
 
@@ -462,3 +678,56 @@ class WritableNestedSerializerTest(testing.APITestCase):
             response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(ipam_models.VLAN.objects.filter(name="Test VLAN 100").count(), 0)
+
+
+class APIOrderingTestCase(testing.APITestCase):
+    """
+    Testing integration with DRF's OrderingFilter.
+    """
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.url = reverse("circuits-api:provider-list")
+        cls.field_type_map = {
+            "CharField": "name",
+            "IntegerField": "asn",
+            "URLField": "portal_url",
+            "TextField": "admin_contact",
+            "DateTimeField": "created",
+        }
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_ascending_sort(self):
+        """Tests that results are returned in the expected ascending order."""
+
+        for field_type, field_name in self.field_type_map.items():
+            with self.subTest(f"Testing {field_type}"):
+                response = self.client.get(f"{self.url}?sort={field_name}&limit=10", **self.header)
+                self.assertHttpStatus(response, 200)
+                self.assertEqual(
+                    list(map(lambda p: p["id"], response.data["results"])),
+                    list(
+                        map(
+                            lambda p: str(p),  # pylint: disable=unnecessary-lambda
+                            Provider.objects.order_by(field_name).values_list("id", flat=True)[:10],
+                        )
+                    ),
+                )
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_descending_sort(self):
+        """Tests that results are returned in the expected descending order."""
+
+        for field_type, field_name in self.field_type_map.items():
+            with self.subTest(f"Testing {field_type}"):
+                response = self.client.get(f"{self.url}?sort=-{field_name}&limit=10", **self.header)
+                self.assertHttpStatus(response, 200)
+                self.assertEqual(
+                    list(map(lambda p: p["id"], response.data["results"])),
+                    list(
+                        map(
+                            lambda p: str(p),  # pylint: disable=unnecessary-lambda
+                            Provider.objects.order_by(f"-{field_name}").values_list("id", flat=True)[:10],
+                        )
+                    ),
+                )

nautobot/core/tests/test_checks.py

@@ -5,13 +5,6 @@ from nautobot.core import checks
 
 
 class CheckCoreSettingsTest(TestCase):
-    @override_settings(
-        CACHEOPS_DEFAULTS={"timeout": 0},
-    )
-    def test_check_cache_timeout(self):
-        """Error if CACHEOPS_DEFAULTS['timeout'] is 0."""
-        self.assertEqual(checks.check_cache_timeout(None), [checks.E001])
-
     @override_settings(
         AUTHENTICATION_BACKENDS=["django.contrib.auth.backends.ModelBackend"],
     )