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

nautobot/core/tests/nautobot_config.py

@@ -59,3 +59,201 @@ METRICS_ENABLED = True
 METRICS_AUTHENTICATED = True
 
 CONTENT_TYPE_CACHE_TIMEOUT = 0
+
+# Path to the kubernetes pod manifest yaml file used to create a job pod in the kubernetes cluster.
+KUBERNETES_JOB_MANIFEST = {
+    "apiVersion": "batch/v1",
+    "kind": "Job",
+    "metadata": {"name": "nautobot-job"},
+    "spec": {
+        "ttlSecondsAfterFinished": 5,
+        "template": {
+            "spec": {
+                "containers": [
+                    {
+                        "env": [
+                            {
+                                "name": "MYSQL_DATABASE",
+                                "valueFrom": {"configMapKeyRef": {"key": "MYSQL_DATABASE", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "MYSQL_PASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "MYSQL_PASSWORD", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "MYSQL_ROOT_PASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "MYSQL_ROOT_PASSWORD", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "MYSQL_USER",
+                                "valueFrom": {"configMapKeyRef": {"key": "MYSQL_USER", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_ALLOWED_HOSTS",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_ALLOWED_HOSTS", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_CHANGELOG_RETENTION",
+                                "valueFrom": {
+                                    "configMapKeyRef": {"key": "NAUTOBOT_CHANGELOG_RETENTION", "name": "dev-env"}
+                                },
+                            },
+                            {
+                                "name": "NAUTOBOT_CONFIG",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_CONFIG", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_CREATE_SUPERUSER",
+                                "valueFrom": {
+                                    "configMapKeyRef": {"key": "NAUTOBOT_CREATE_SUPERUSER", "name": "dev-env"}
+                                },
+                            },
+                            {
+                                "name": "NAUTOBOT_DB_HOST",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_DB_HOST", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_DB_NAME",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_DB_NAME", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_DB_PASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_DB_PASSWORD", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_DB_TIMEOUT",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_DB_TIMEOUT", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_DB_USER",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_DB_USER", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_INSTALLATION_METRICS_ENABLED",
+                                "valueFrom": {
+                                    "configMapKeyRef": {
+                                        "key": "NAUTOBOT_INSTALLATION_METRICS_ENABLED",
+                                        "name": "dev-env",
+                                    }
+                                },
+                            },
+                            {
+                                "name": "NAUTOBOT_LOG_DEPRECATION_WARNINGS",
+                                "valueFrom": {
+                                    "configMapKeyRef": {"key": "NAUTOBOT_LOG_DEPRECATION_WARNINGS", "name": "dev-env"}
+                                },
+                            },
+                            {
+                                "name": "NAUTOBOT_NAPALM_TIMEOUT",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_NAPALM_TIMEOUT", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_REDIS_HOST",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_REDIS_HOST", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_REDIS_PASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_REDIS_PASSWORD", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_REDIS_PORT",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_REDIS_PORT", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_SECRET_KEY",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_SECRET_KEY", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_SELENIUM_HOST",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_SELENIUM_HOST", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_SELENIUM_URL",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_SELENIUM_URL", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_SUPERUSER_API_TOKEN",
+                                "valueFrom": {
+                                    "configMapKeyRef": {"key": "NAUTOBOT_SUPERUSER_API_TOKEN", "name": "dev-env"}
+                                },
+                            },
+                            {
+                                "name": "NAUTOBOT_SUPERUSER_EMAIL",
+                                "valueFrom": {
+                                    "configMapKeyRef": {"key": "NAUTOBOT_SUPERUSER_EMAIL", "name": "dev-env"}
+                                },
+                            },
+                            {
+                                "name": "NAUTOBOT_SUPERUSER_NAME",
+                                "valueFrom": {"configMapKeyRef": {"key": "NAUTOBOT_SUPERUSER_NAME", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "NAUTOBOT_SUPERUSER_PASSWORD",
+                                "valueFrom": {
+                                    "configMapKeyRef": {"key": "NAUTOBOT_SUPERUSER_PASSWORD", "name": "dev-env"}
+                                },
+                            },
+                            {
+                                "name": "PGPASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "PGPASSWORD", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "POSTGRES_DB",
+                                "valueFrom": {"configMapKeyRef": {"key": "POSTGRES_DB", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "POSTGRES_PASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "POSTGRES_PASSWORD", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "POSTGRES_USER",
+                                "valueFrom": {"configMapKeyRef": {"key": "POSTGRES_USER", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "REDISCLI_AUTH",
+                                "valueFrom": {"configMapKeyRef": {"key": "REDISCLI_AUTH", "name": "dev-env"}},
+                            },
+                            {
+                                "name": "REDIS_PASSWORD",
+                                "valueFrom": {"configMapKeyRef": {"key": "REDIS_PASSWORD", "name": "dev-env"}},
+                            },
+                        ],
+                        "name": "nautobot-job",
+                        "image": "local/nautobot-dev:local-py3.11",
+                        "ports": [{"containerPort": 8080, "protocol": "TCP"}],
+                        "tty": True,
+                        "volumeMounts": [
+                            {"mountPath": "/opt/nautobot/media", "name": "media-root"},
+                            {
+                                "mountPath": "/opt/nautobot/nautobot_config.py",
+                                "name": "nautobot-cm1",
+                                "subPath": "nautobot_config.py",
+                            },
+                        ],
+                    }
+                ],
+                "volumes": [
+                    {"name": "media-root", "persistentVolumeClaim": {"claimName": "media-root"}},
+                    {
+                        "configMap": {
+                            "items": [{"key": "nautobot_config.py", "path": "nautobot_config.py"}],
+                            "name": "nautobot-cm1",
+                        },
+                        "name": "nautobot-cm1",
+                    },
+                ],
+                "restartPolicy": "Never",
+            }
+        },
+        "backoffLimit": 0,
+    },
+}
+
+# Name of the kubernetes pod created in the kubernetes cluster
+KUBERNETES_JOB_POD_NAME = "nautobot-job"
+
+# Namespace of the kubernetes pod created in the kubernetes cluster
+KUBERNETES_JOB_POD_NAMESPACE = "default"
+
+# Host of the kubernetes pod created in the kubernetes cluster
+KUBERNETES_DEFAULT_SERVICE_ADDRESS = "https://kubernetes.default.svc"

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())  # pylint: disable=no-member
+                                    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"]
@@ -158,8 +158,8 @@ class NautobotTestRunner(DiscoverRunner):
                                     verbosity=self.verbosity,
                                     keepdb=self.keepdb
                                     # Extra checks added for Nautobot:
-                                    and self.reusedb
-                                    and not settings.TEST_USE_FACTORIES,  # w/ factory data, clones can't be reused
+                                    and not settings.TEST_USE_FACTORIES
+                                    and self.reusedb,
                                 )
 
                 # Configure all other connections as mirrors of the first one

nautobot/core/tests/test_api.py

@@ -3,7 +3,6 @@ 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
@@ -24,6 +23,7 @@ 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.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
@@ -516,73 +516,6 @@ class NautobotCSVRendererTest(TestCase):
         self.assertEqual(read_data["parent__name"], location_type.parent.name)
 
 
-class BaseModelSerializerTest(TestCase):
-    """
-    Some unit tests for BaseModelSerializer (using concrete subclasses, since BaseModelSerializer is abstract).
-    """
-
-    def test_advanced_tab_fields(self):
-        """Test the advanced_tab_fields classproperty."""
-        self.assertEqual(
-            dcim_serializers.DeviceSerializer().advanced_tab_fields,
-            ["id", "url", "object_type", "created", "last_updated", "natural_slug"],
-        )
-
-    def test_list_display_fields(self):
-        """Test the list_display_fields classproperty."""
-        self.assertEqual(
-            dcim_serializers.DeviceSerializer().list_display_fields,
-            dcim_serializers.DeviceSerializer().Meta.list_display_fields,
-        )
-
-    def test_determine_view_options(self):
-        """Test the determine_view_options API."""
-        view_options = dcim_serializers.DeviceSerializer().determine_view_options()
-        self.maxDiff = None
-
-        # assert base structure rather than exhaustively testing every single field
-
-        self.assertIn("list", view_options)
-
-        self.assertIn("all_fields", view_options["list"])
-        self.assertIn({"dataIndex": "name", "key": "name", "title": "Name"}, view_options["list"]["all_fields"])
-        self.assertIn(
-            {"dataIndex": "parent_bay", "key": "parent_bay", "title": "Parent bay"}, view_options["list"]["all_fields"]
-        )
-
-        self.assertIn("default_fields", view_options["list"])
-        self.assertIn({"dataIndex": "name", "key": "name", "title": "Name"}, view_options["list"]["default_fields"])
-        self.assertNotIn(
-            {"dataIndex": "parent_bay", "key": "parent_bay", "title": "Parent bay"},
-            view_options["list"]["default_fields"],
-        )
-
-        self.assertIn("retrieve", view_options)
-        self.assertIn("tabs", view_options["retrieve"])
-
-        self.assertIn("Advanced", view_options["retrieve"]["tabs"])
-        self.assertIn("Object Details", view_options["retrieve"]["tabs"]["Advanced"][0])
-        self.assertIn("fields", view_options["retrieve"]["tabs"]["Advanced"][0]["Object Details"])
-        self.assertIn("id", view_options["retrieve"]["tabs"]["Advanced"][0]["Object Details"]["fields"])
-
-        self.assertIn("Device", view_options["retrieve"]["tabs"])
-        self.assertIn("Device", view_options["retrieve"]["tabs"]["Device"][0])
-        self.assertIn("fields", view_options["retrieve"]["tabs"]["Device"][0]["Device"])
-        self.assertIn("location", view_options["retrieve"]["tabs"]["Device"][0]["Device"]["fields"])
-
-        self.assertIn("Tags", view_options["retrieve"]["tabs"]["Device"][1])
-        self.assertIn("fields", view_options["retrieve"]["tabs"]["Device"][1]["Tags"])
-        self.assertIn("tags", view_options["retrieve"]["tabs"]["Device"][1]["Tags"]["fields"])
-
-        # Custom tab added through DeviceSerializer.get_additional_detail_view_tabs()
-        self.assertIn("Virtual Chassis", view_options["retrieve"]["tabs"])
-        self.assertIn("Virtual Chassis", view_options["retrieve"]["tabs"]["Virtual Chassis"][0])
-        self.assertIn("fields", view_options["retrieve"]["tabs"]["Virtual Chassis"][0]["Virtual Chassis"])
-        self.assertIn(
-            "virtual_chassis", view_options["retrieve"]["tabs"]["Virtual Chassis"][0]["Virtual Chassis"]["fields"]
-        )
-
-
 class WritableNestedSerializerTest(testing.APITestCase):
     """
     Test the operation of WritableNestedSerializer using VLANSerializer as our test subject.
@@ -755,25 +688,6 @@ 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):
     """
@@ -906,120 +820,6 @@ class SettingsJSONSchemaViewTestCase(testing.APITestCase):
         self.assertEqual(response.data, expected_schema_data)
 
 
-class NewUIGetMenuAPIViewTestCase(testing.APITestCase):
-    def test_get_menu(self):
-        """Asset response from new ui nav menu api returns a well formatted registry["new_ui_nav_menu"] expected by nautobot-ui."""
-        self.user.is_superuser = True
-        self.user.save()
-
-        url = reverse("ui-api:get-menu")
-        response = self.client.get(url, **self.header)
-        expected_response = {
-            "Inventory": {
-                "Devices": {
-                    "Devices": "/dcim/devices/",
-                    "Device Types": "/dcim/device-types/",
-                    "Platforms": "/dcim/platforms/",
-                    "Manufacturers": "/dcim/manufacturers/",
-                    "Virtual Chassis": "/dcim/virtual-chassis/",
-                    "Device Redundancy Groups": "/dcim/device-redundancy-groups/",
-                    "Connections": {
-                        "Cables": "/dcim/cables/",
-                        "Console Connections": "/dcim/console-connections/",
-                        "Power Connections": "/dcim/power-connections/",
-                        "Interface Connections": "/dcim/interface-connections/",
-                    },
-                    "Components": {
-                        "Interfaces": "/dcim/interfaces/",
-                        "Front Ports": "/dcim/front-ports/",
-                        "Rear Ports": "/dcim/rear-ports/",
-                        "Console Ports": "/dcim/console-ports/",
-                        "Console Server Ports": "/dcim/console-server-ports/",
-                        "Power Ports": "/dcim/power-ports/",
-                        "Power Outlets": "/dcim/power-outlets/",
-                        "Device Bays": "/dcim/device-bays/",
-                        "Inventory Items": "/dcim/inventory-items/",
-                    },
-                    "Dynamic Groups": "/extras/dynamic-groups/",
-                    "Racks": "/dcim/racks/",
-                    "Rack Groups": "/dcim/rack-groups/",
-                    "Rack Reservations": "/dcim/rack-reservations/",
-                    "Rack Elevations": "/dcim/rack-elevations/",
-                },
-                "Organization": {"Locations": "/dcim/locations/", "Location Types": "/dcim/location-types/"},
-                "Tenancy": {"Tenants": "/tenancy/tenants/", "Tenant Groups": "/tenancy/tenant-groups/"},
-                "Circuits": {
-                    "Circuits": "/circuits/circuits/",
-                    "Circuit Terminations": "/circuits/circuit-terminations/",
-                    "Circuit Types": "/circuits/circuit-types/",
-                    "Providers": "/circuits/providers/",
-                    "Provider Networks": "/circuits/provider-networks/",
-                },
-                "Power": {"Power Feeds": "/dcim/power-feeds/", "Power Panels": "/dcim/power-panels/"},
-                "Virtualization": {
-                    "Virtual Machines": "/virtualization/virtual-machines/",
-                    "VM Interfaces": "/virtualization/interfaces/",
-                    "Clusters": "/virtualization/clusters/",
-                    "Cluster Types": "/virtualization/cluster-types/",
-                    "Cluster Groups": "/virtualization/cluster-groups/",
-                },
-            },
-            "Networks": {
-                "IP Management": {
-                    "IP Addresses": "/ipam/ip-addresses/",
-                    "Prefixes": "/ipam/prefixes/",
-                    "RIRs": "/ipam/rirs/",
-                },
-                "Layer 2 / Switching": {"VLANs": "/ipam/vlans/", "VLAN Groups": "/ipam/vlan-groups/"},
-                "Layer 3 / Routing": {
-                    "Namespaces": "/ipam/namespaces/",
-                    "VRFs": "/ipam/vrfs/",
-                    "Route Targets": "/ipam/route-targets/",
-                },
-                "Services": {"Services": "/ipam/services/"},
-                "Config Contexts": {
-                    "Config Contexts": "/extras/config-contexts/",
-                    "Config Context Schemas": "/extras/config-context-schemas/",
-                },
-            },
-            "Security": {"Secrets": {"Secrets": "/extras/secrets/", "Secret Groups": "/extras/secrets-groups/"}},
-            "Automation": {
-                "Jobs": {
-                    "Jobs": "/extras/jobs/",
-                    "Job Approval Queue": "/extras/jobs/scheduled-jobs/approval-queue/",
-                    "Scheduled Jobs": "/extras/jobs/scheduled-jobs/",
-                    "Job Results": "/extras/job-results/",
-                    "Job Hooks": "/extras/job-hooks/",
-                    "Job Buttons": "/extras/job-buttons/",
-                },
-                "Extensibility": {
-                    "Webhooks": "/extras/webhooks/",
-                    "GraphQL Queries": "/extras/graphql-queries/",
-                    "Export Templates": "/extras/export-templates/",
-                },
-            },
-            "Platform": {
-                "Platform": {
-                    "Installed Apps": "/apps/installed-apps/",
-                    "Git Repositories": "/extras/git-repositories/",
-                },
-                "Governance": {"Change Log": "/extras/object-changes/"},
-                "Reference Data": {"Tags": "/extras/tags/", "Statuses": "/extras/statuses/", "Roles": "/extras/roles/"},
-                "Data Management": {
-                    "Relationships": "/extras/relationships/",
-                    "Computed Fields": "/extras/computed-fields/",
-                    "Custom Fields": "/extras/custom-fields/",
-                    "Custom Links": "/extras/custom-links/",
-                    "Notes": "/extras/notes/",
-                },
-                "Users": {"Saved Views": "/extras/saved-views/"},
-            },
-        }
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.data, expected_response)
-
-
 class NautobotGetViewNameTest(TestCase):
     """
     Some unit tests for the get_view_name() functionality.
@@ -1039,3 +839,84 @@ class NautobotGetViewNameTest(TestCase):
         }
         for view_name, view_kwarg in view_kwargs.items():
             self.assertEqual(view_name, get_view_name(viewset(**view_kwarg)))
+
+
+class RenderJinjaViewTest(testing.APITestCase):
+    """Test case for the RenderJinjaView API view."""
+
+    def test_render_jinja_template(self):
+        """
+        Test rendering a valid Jinja template.
+        """
+        interfaces = ["Ethernet1/1", "Ethernet1/2", "Ethernet1/3"]
+
+        template_code = "\n".join(
+            [
+                r"{% for int in interfaces -%}",
+                r"interface {{ int }}",
+                r"  speed {{ 1000000000|humanize_speed }}",
+                r"  duplex full",
+                r"{% endfor %}",
+            ]
+        )
+
+        expected_response = "\n".join(
+            [
+                "\n".join(
+                    [
+                        f"interface {int}",
+                        f"  speed {humanize_speed(1000000000)}",
+                        r"  duplex full",
+                    ]
+                )
+                for int in interfaces
+            ]
+            + [""]  # Add an extra newline at the end because jinja whitespace control is "fun"
+        )
+
+        response = self.client.post(
+            reverse("core-api:render_jinja_template"),
+            {
+                "template_code": template_code,
+                "context": {"interfaces": interfaces},
+            },
+            format="json",
+            **self.header,
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertSequenceEqual(
+            list(response.data.keys()),
+            ["rendered_template", "rendered_template_lines", "template_code", "context"],
+        )
+        self.assertEqual(response.data["rendered_template"], expected_response)
+        self.assertEqual(response.data["rendered_template_lines"], expected_response.split("\n"))
+
+    def test_render_jinja_template_failures(self):
+        """
+        Test rendering invalid Jinja templates.
+        """
+        test_data = [
+            {
+                "template_code": r"{% hello world %}",
+                "error_msg": "Encountered unknown tag 'hello'.",
+            },
+            {
+                "template_code": r"{{ hello world %}",
+                "error_msg": "expected token 'end of print statement', got 'world'",
+            },
+        ]
+
+        for data in test_data:
+            with self.subTest(data):
+                response = self.client.post(
+                    reverse("core-api:render_jinja_template"),
+                    {
+                        "template_code": data["template_code"],
+                        "context": {"foo": "bar"},
+                    },
+                    format="json",
+                    **self.header,
+                )
+                self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+                self.assertSequenceEqual(list(response.data.keys()), ["detail"])
+                self.assertEqual(response.data["detail"], f"Failed to render Jinja template: {data['error_msg']}")

nautobot/core/tests/test_csv.py

@@ -1,6 +1,3 @@
-import csv
-import io
-
 from django.contrib.contenttypes.models import ContentType
 from django.test import override_settings, RequestFactory, TestCase
 from django.urls import reverse
@@ -264,28 +261,9 @@ class CSVParsingRelatedTestCase(TestCase):
         self.assertEqual(response.status_code, 200)
         response_data = response.content.decode(response.charset)
 
-        # 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()}
+        # Replace Device Name
+        import_data = response_data.replace("TestDevice1", "TestDevice3").replace("TestDevice2", "")
+        data = {"csv_data": import_data}
         url = reverse("dcim:device_import")
         response = self.client.post(url, data)
         self.assertEqual(response.status_code, 200)