nautobot 2.0.4__py3-none-any.whl → 2.1.0b1__py3-none-any.whl

nautobot/extras/tests/test_api.py

@@ -48,6 +48,8 @@ from nautobot.extras.models import (
     DynamicGroup,
     DynamicGroupMembership,
     ExportTemplate,
+    ExternalIntegration,
+    FileProxy,
     GitRepository,
     GraphQLQuery,
     ImageAttachment,
@@ -813,6 +815,96 @@ class ExportTemplateTest(APIViewTestCases.APIViewTestCase):
         )
 
 
+class ExternalIntegrationTest(APIViewTestCases.APIViewTestCase):
+    model = ExternalIntegration
+    create_data = [
+        {
+            "name": "Test External Integration 1",
+            "remote_url": "ssh://example.com/test1/",
+            "verify_ssl": False,
+            "timeout": 5,
+            "extra_config": "{'foo': 'bar'}",
+        },
+        {
+            "name": "Test External Integration 2",
+            "remote_url": "http://example.com/test2/",
+        },
+        {
+            "name": "Test External Integration 3",
+            "remote_url": "https://example.com/test3/",
+            "verify_ssl": True,
+            "timeout": 30,
+            "extra_config": "{'foo': ['bat', 'baz']}",
+        },
+    ]
+    bulk_update_data = {"timeout": 10, "verify_ssl": True, "extra_config": r"{}"}
+
+
+class FileProxyTest(
+    APIViewTestCases.GetObjectViewTestCase,
+    APIViewTestCases.ListObjectsViewTestCase,
+):
+    model = FileProxy
+
+    @classmethod
+    def setUpTestData(cls):
+        job = Job.objects.first()
+        job_results = (
+            JobResult.objects.create(
+                job_model=job,
+                name=job.class_path,
+                date_done=now(),
+                status=JobResultStatusChoices.STATUS_SUCCESS,
+            ),
+            JobResult.objects.create(
+                job_model=job,
+                name=job.class_path,
+                date_done=now(),
+                status=JobResultStatusChoices.STATUS_SUCCESS,
+            ),
+            JobResult.objects.create(
+                job_model=job,
+                name=job.class_path,
+                date_done=now(),
+                status=JobResultStatusChoices.STATUS_SUCCESS,
+            ),
+        )
+        cls.file_proxies = []
+        for i, job_result in enumerate(job_results):
+            file = SimpleUploadedFile(name=f"Output {i}.txt", content=f"Content {i}\n".encode("utf-8"))
+            file_proxy = FileProxy.objects.create(name=file.name, file=file, job_result=job_result)
+            cls.file_proxies.append(file_proxy)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_download_file_without_permission(self):
+        """Test `download` action without permission."""
+        url = reverse("extras-api:fileproxy-download", kwargs={"pk": self.file_proxies[0].pk})
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_403_FORBIDDEN)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_download_file_with_permission(self):
+        """Test `download` action with permission."""
+        obj_perm = ObjectPermission(
+            name="Test permission", constraints={"pk": self.file_proxies[0].pk}, actions=["view"]
+        )
+        obj_perm.validated_save()
+        obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+        obj_perm.users.add(self.user)
+
+        # FileProxy permitted by permission
+        url = reverse("extras-api:fileproxy-download", kwargs={"pk": self.file_proxies[0].pk})
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        content = b"".join(data for data in response)
+        self.assertEqual(content.decode("utf-8"), "Content 0\n")
+
+        # FileProxy not permitted by permission
+        url = reverse("extras-api:fileproxy-download", kwargs={"pk": self.file_proxies[1].pk})
+        response = self.client.get(url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_404_NOT_FOUND)
+
+
 class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
     model = GitRepository
     bulk_update_data = {

nautobot/extras/tests/test_context_managers.py

@@ -44,9 +44,9 @@ class WebRequestContextTestCase(TestCase):
                 pass
 
     def test_change_log_created(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
         with web_request_context(self.user):
-            location_type = LocationType.objects.get(name="Campus")
-            location_status = Status.objects.get_for_model(Location).first()
             location = Location(name="Test Location 1", location_type=location_type, status=location_status)
             location.save()
 
@@ -56,10 +56,100 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(oc_list[0].changed_object, location)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
 
+    def test_create_then_delete(self):
+        """Test that a create followed by a delete is logged as two changes"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+            location.save()
+            location_pk = location.pk
+            location.delete()
+
+        location = Location.objects.filter(pk=location_pk)
+        self.assertFalse(location.exists())
+        oc_list = get_changes_for_model(Location).filter(changed_object_id=location_pk)
+        self.assertEqual(len(oc_list), 2)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_DELETE)
+        self.assertEqual(oc_list[1].action, ObjectChangeActionChoices.ACTION_CREATE)
+
+    def test_update_then_delete(self):
+        """Test that an update followed by a delete is logged as a single delete"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+            location.save()
+            location_pk = location.pk
+        with web_request_context(self.user):
+            location.description = "changed"
+            location.save()
+            location.delete()
+
+        location = Location.objects.filter(pk=location_pk)
+        self.assertFalse(location.exists())
+        oc_list = get_changes_for_model(Location).filter(changed_object_id=location_pk)
+        self.assertEqual(len(oc_list), 2)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_DELETE)
+        snapshots = oc_list[0].get_snapshots()
+        self.assertIsNotNone(snapshots["prechange"])
+        self.assertIsNone(snapshots["postchange"])
+        self.assertIsNone(snapshots["differences"]["added"])
+        self.assertEqual(snapshots["differences"]["removed"]["description"], "")
+
+    def test_create_then_update(self):
+        """Test that a create followed by an update is logged as a single create"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+            location.save()
+            location.description = "changed"
+            location.save()
+
+        oc_list = get_changes_for_model(location)
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+        snapshots = oc_list[0].get_snapshots()
+        self.assertIsNone(snapshots["prechange"])
+        self.assertIsNotNone(snapshots["postchange"])
+        self.assertIsNone(snapshots["differences"]["removed"])
+        self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_delete_then_create(self):
+        """Test that a delete followed by a create is logged as a single update"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+            location.save()
+            location_pk = location.pk
+        with web_request_context(self.user):
+            location.delete()
+            location = Location.objects.create(
+                pk=location_pk,
+                name="Test Location 1",
+                location_type=location_type,
+                status=location_status,
+                description="changed",
+            )
+
+        oc_list = get_changes_for_model(location)
+        self.assertEqual(len(oc_list), 2)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_UPDATE)
+        snapshots = oc_list[0].get_snapshots()
+        self.assertIsNotNone(snapshots["prechange"])
+        self.assertIsNotNone(snapshots["postchange"])
+        self.assertSequenceEqual(
+            list(snapshots["differences"]["added"].keys()),
+            ("created", "description"),
+        )
+        self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
     def test_change_log_context(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
         with web_request_context(self.user, context_detail="test_change_log_context"):
-            location_type = LocationType.objects.get(name="Campus")
-            location_status = Status.objects.get_for_model(Location).first()
             location = Location(name="Test Location 1", location_type=location_type, status=location_status)
             location.save()
 

nautobot/extras/tests/test_customfields.py

@@ -2119,7 +2119,7 @@ class CustomFieldTableTest(TestCase):
             "url_field": '<a href="http://example.com/2">http://example.com/2</a>',
             "choice_field": '<span class="label label-default">Bar</span>',
             "multi_choice_field": (
-                '<span class="label label-default">Bar</span> <span class="label label-default">Baz</span> '
+                '<span class="label label-default">Bar</span> <span class="label label-default">Baz</span>'
             ),
         }
 

nautobot/extras/tests/test_filters.py

@@ -2,6 +2,7 @@ import uuid
 
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
+from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models import Q
 from django.test import override_settings
 
@@ -33,6 +34,8 @@ from nautobot.extras.filters import (
     CustomFieldChoiceFilterSet,
     CustomLinkFilterSet,
     ExportTemplateFilterSet,
+    ExternalIntegrationFilterSet,
+    FileProxyFilterSet,
     GitRepositoryFilterSet,
     GraphQLQueryFilterSet,
     ImageAttachmentFilterSet,
@@ -59,6 +62,8 @@ from nautobot.extras.models import (
     CustomFieldChoice,
     CustomLink,
     ExportTemplate,
+    ExternalIntegration,
+    FileProxy,
     GitRepository,
     GraphQLQuery,
     ImageAttachment,
@@ -500,6 +505,63 @@ class ExportTemplateTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
 
+class FileProxyTestCase(FilterTestCases.FilterTestCase):
+    queryset = FileProxy.objects.all()
+    filterset = FileProxyFilterSet
+
+    generic_filter_tests = (
+        ["job", "job_result__job_model__id"],
+        ["job", "job_result__job_model__name"],
+        ["job_result_id"],
+        ["name"],
+        ["uploaded_at"],
+    )
+
+    @classmethod
+    def setUpTestData(cls):
+        jobs = Job.objects.all()[:3]
+        job_results = (JobResult.objects.create(job_model=job) for job in jobs)
+        for i, job_result in enumerate(job_results):
+            FileProxy.objects.create(
+                name=f"File {i}.txt", file=SimpleUploadedFile(name=f"File {i}.txt", content=b""), job_result=job_result
+            )
+
+
+class ExternalIntegrationTestCase(FilterTestCases.FilterTestCase):
+    queryset = ExternalIntegration.objects.all()
+    filterset = ExternalIntegrationFilterSet
+
+    generic_filter_tests = (
+        ["name"],
+        ["remote_url"],
+        ["timeout"],
+        ["secrets_group", "secrets_group__id"],
+        ["secrets_group", "secrets_group__name"],
+    )
+
+    @classmethod
+    def setUpTestData(cls):
+        secrets_groups = (
+            SecretsGroup.objects.create(name="Secrets Group 1"),
+            SecretsGroup.objects.create(name="Secrets Group 2"),
+        )
+        external_integrations = list(ExternalIntegration.objects.all()[:2])
+        external_integrations[0].secrets_group = secrets_groups[0]
+        external_integrations[1].secrets_group = secrets_groups[1]
+        for ei in external_integrations:
+            ei.validated_save()
+
+    def test_verify_ssl(self):
+        params = {"verify_ssl": True}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(verify_ssl=True)
+        )
+        params = {"verify_ssl": False}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs, self.queryset.filter(verify_ssl=False)
+        )
+
+
 class GitRepositoryTestCase(FilterTestCases.FilterTestCase):
     queryset = GitRepository.objects.all()
     filterset = GitRepositoryFilterSet
@@ -1170,7 +1232,7 @@ class RelationshipAssociationTestCase(FilterTestCases.FilterTestCase):
             ),
         )
         vlan_status = Status.objects.get_for_model(VLAN).first()
-        vlan_group = VLANGroup.objects.first()
+        vlan_group = VLANGroup.objects.create(name="Test VLANGroup 1")
         cls.vlans = (
             VLAN.objects.create(vid=1, name="VLAN 1", status=vlan_status, vlan_group=vlan_group),
             VLAN.objects.create(vid=2, name="VLAN 2", status=vlan_status, vlan_group=vlan_group),
@@ -1297,7 +1359,7 @@ class RelationshipModelFilterSetTestCase(FilterTestCases.FilterTestCase):
             ),
         )
         vlan_status = Status.objects.get_for_model(VLAN).first()
-        vlan_group = VLANGroup.objects.first()
+        vlan_group = VLANGroup.objects.create(name="Test VLANGroup 1")
         cls.vlans = (
             VLAN.objects.create(vid=1, name="VLAN 1", status=vlan_status, vlan_group=vlan_group),
             VLAN.objects.create(vid=2, name="VLAN 2", status=vlan_status, vlan_group=vlan_group),

nautobot/extras/tests/test_jobs.py

@@ -7,6 +7,7 @@ from unittest import mock
 import uuid
 import tempfile
 
+from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.management import call_command
@@ -483,6 +484,20 @@ class JobTransactionTest(TransactionTestCase):
         self.assertTrue(profiling_result.exists())
         profiling_result.unlink()
 
+    @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
+    def test_job_fires_webhooks(self, mock_enqueue_webhooks):
+        module = "atomic_transaction"
+        name = "TestAtomicDecorator"
+
+        status_ct = ContentType.objects.get_for_model(models.Status)
+        webhook = models.Webhook.objects.create(name="Test Webhook", type_create=True, payload_url="http://localhost/")
+        webhook.content_types.set([status_ct])
+
+        job_result = create_job_result_and_run_job(module, name)
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+
+        mock_enqueue_webhooks.assert_called_once()
+
 
 class JobFileUploadTest(TransactionTestCase):
     """Test a job that uploads/deletes files."""
@@ -568,6 +583,44 @@ class JobFileUploadTest(TransactionTestCase):
         self.assertEqual(models.FileProxy.objects.count(), 0)
 
 
+class JobFileOutputTest(TransactionTestCase):
+    """Test a job that outputs files."""
+
+    databases = ("default", "job_logs")
+
+    @override_settings(
+        MEDIA_ROOT=tempfile.gettempdir(),
+    )
+    def test_output_file_to_database(self):
+        module = "file_output"
+        name = "FileOutputJob"
+        data = {"lines": 3}
+        job_result = create_job_result_and_run_job(module, name, **data)
+
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS, job_result.traceback)
+        # JobResult should have one attached file
+        self.assertEqual(1, job_result.files.count())
+        self.assertEqual(job_result.files.first().name, "output.txt")
+        self.assertEqual(job_result.files.first().file.read().decode("utf-8"), "Hello World!\n" * 3)
+        # File shouldn't exist on filesystem
+        self.assertFalse(Path(settings.MEDIA_ROOT, "files", "output.txt").exists())
+        self.assertFalse(Path(settings.MEDIA_ROOT, "files", f"{job_result.files.first().pk}-output.txt").exists())
+        # File should exist in DB
+        # `filename` value is weird, see https://github.com/victor-o-silva/db_file_storage/issues/22
+        models.FileAttachment.objects.get(filename="extras.FileAttachment/bytes/filename/mimetype/output.txt")
+
+        # Make sure cleanup is successful
+        job_result.delete()
+        with self.assertRaises(models.FileProxy.DoesNotExist):
+            models.FileProxy.objects.get(name="output.txt")
+        with self.assertRaises(models.FileAttachment.DoesNotExist):
+            models.FileAttachment.objects.get(filename="extras.FileAttachment/bytes/filename/mimetype/output.txt")
+
+    # It would be great to also test the output-to-filesystem case when using JOB_FILE_IO_STORAGE=FileSystemStorage;
+    # unfortunately with FileField(storage=callable), the callable gets evaluated only at declaration time, not at
+    # usage/runtime, so override_settings(JOB_FILE_IO_STORAGE) doesn't work the way you'd hope it would.
+
+
 class RunJobManagementCommandTest(TransactionTestCase):
     """Test cases for the `nautobot-server runjob` management command."""
 
@@ -857,17 +910,17 @@ class JobHookTransactionTest(TransactionTestCase):  # TODO: BaseModelTestCase mi
         with web_request_context(user=self.user):
             status = models.Status.objects.get_for_model(Location).first()
             Location.objects.create(name="Test Job Hook Location 1", location_type=self.location_type, status=status)
-            job_result = models.JobResult.objects.get(job_model=self.job_model)
-            expected_log_messages = [
-                ("info", "Running job"),
-                ("info", f"change: dcim | location Test Job Hook Location 1 created by {self.user.username}"),
-                ("info", "action: create"),
-                ("info", f"jobresult.user: {self.user.username}"),
-                ("info", "Test Job Hook Location 1"),
-                ("info", "Job completed"),
-            ]
-            log_messages = models.JobLogEntry.objects.filter(job_result=job_result).values_list("log_level", "message")
-            self.assertSequenceEqual(log_messages, expected_log_messages)
+        job_result = models.JobResult.objects.get(job_model=self.job_model)
+        expected_log_messages = [
+            ("info", "Running job"),
+            ("info", f"change: dcim | location Test Job Hook Location 1 created by {self.user.username}"),
+            ("info", "action: create"),
+            ("info", f"jobresult.user: {self.user.username}"),
+            ("info", "Test Job Hook Location 1"),
+            ("info", "Job completed"),
+        ]
+        log_messages = models.JobLogEntry.objects.filter(job_result=job_result).values_list("log_level", "message")
+        self.assertSequenceEqual(log_messages, expected_log_messages)
 
     def test_enqueue_job_hook_m2m(self):
         """
@@ -883,17 +936,17 @@ class JobHookTransactionTest(TransactionTestCase):  # TODO: BaseModelTestCase mi
         tag.content_types.add(ContentType.objects.get_for_model(Location))
         with web_request_context(user=self.user):
             loc.tags.add(tag)
-            job_result = models.JobResult.objects.get(job_model=self.job_model)
-            expected_log_messages = [
-                ("info", "Running job"),
-                ("info", f"change: dcim | location Test Job Hook Location 1 updated by {self.user.username}"),
-                ("info", "action: update"),
-                ("info", f"jobresult.user: {self.user.username}"),
-                ("info", "Test Job Hook Location 1"),
-                ("info", "Job completed"),
-            ]
-            log_messages = models.JobLogEntry.objects.filter(job_result=job_result).values_list("log_level", "message")
-            self.assertSequenceEqual(log_messages, expected_log_messages)
+        job_result = models.JobResult.objects.get(job_model=self.job_model)
+        expected_log_messages = [
+            ("info", "Running job"),
+            ("info", f"change: dcim | location Test Job Hook Location 1 updated by {self.user.username}"),
+            ("info", "action: update"),
+            ("info", f"jobresult.user: {self.user.username}"),
+            ("info", "Test Job Hook Location 1"),
+            ("info", "Job completed"),
+        ]
+        log_messages = models.JobLogEntry.objects.filter(job_result=job_result).values_list("log_level", "message")
+        self.assertSequenceEqual(log_messages, expected_log_messages)
 
 
 class RemoveScheduledJobManagementCommandTestCase(TestCase):

nautobot/extras/tests/test_models.py

@@ -48,6 +48,7 @@ from nautobot.extras.models import (
     ConfigContextSchema,
     DynamicGroup,
     ExportTemplate,
+    ExternalIntegration,
     FileAttachment,
     FileProxy,
     GitRepository,
@@ -776,6 +777,39 @@ class ExportTemplateTest(ModelTestCases.BaseModelTestCase):
             nonduplicate_template.validated_save()
 
 
+class ExternalIntegrationTest(ModelTestCases.BaseModelTestCase):
+    """
+    Tests for the ExternalIntegration model class.
+    """
+
+    model = ExternalIntegration
+
+    def test_remote_url_validation(self):
+        with self.assertRaises(ValidationError):
+            ei = ExternalIntegration(
+                name="Test Integration",
+                remote_url="foo://localhost",
+            )
+            ei.validated_save()
+
+        ei.remote_url = "http://localhost"
+        ei.validated_save()
+
+    def test_timeout_validation(self):
+        with self.assertRaises(ValidationError):
+            ei = ExternalIntegration(
+                name="Test Integration",
+                remote_url="http://localhost",
+                timeout=-1,
+            )
+            ei.validated_save()
+
+        ei.timeout = 0
+        ei.validated_save()
+        ei.timeout = 65536
+        ei.validated_save()
+
+
 class FileProxyTest(ModelTestCases.BaseModelTestCase):
     model = FileProxy
 

nautobot/extras/tests/test_relationships.py

@@ -1206,13 +1206,13 @@ class RequiredRelationshipTestMixin:
                 ],
                 "expected_errors": {
                     "api": {
-                        "objects_nonexistent": "Circuit types require a platform, but no platforms exist yet. "
+                        "objects_nonexistent": "Circuit Types require a platform, but no platforms exist yet. "
                         "Create a platform by posting to /api/dcim/platforms/",
                         "objects_not_specified": 'You need to specify ["relationships"]["circuittype_platform_o2o"]'
                         '["destination"]["objects"].',
                     },
                     "ui": {
-                        "objects_nonexistent": "Circuit types require a platform, but no platforms exist yet.",
+                        "objects_nonexistent": "Circuit Types require a platform, but no platforms exist yet.",
                         "objects_not_specified": "You need to select a platform.",
                     },
                 },