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

nautobot/extras/tests/test_jobs.py

@@ -3,10 +3,11 @@ from io import StringIO
 import json
 from pathlib import Path
 import re
+import tempfile
 from unittest import mock
 import uuid
-import tempfile
 
+from constance.test import override_config
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
@@ -17,10 +18,10 @@ from django.test.client import RequestFactory
 from django.utils import timezone
 
 from nautobot.core.testing import (
-    TestCase,
-    TransactionTestCase,
     create_job_result_and_run_job,
     get_job_class_and_model,
+    TestCase,
+    TransactionTestCase,
 )
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.models import Device, Location, LocationType
@@ -31,7 +32,7 @@ from nautobot.extras.choices import (
     LogLevelChoices,
     ObjectChangeEventContextChoices,
 )
-from nautobot.extras.context_managers import JobHookChangeContext, change_logging, web_request_context
+from nautobot.extras.context_managers import change_logging, JobHookChangeContext, web_request_context
 from nautobot.extras.jobs import get_job
 
 
@@ -620,6 +621,34 @@ class JobFileOutputTest(TransactionTestCase):
     # 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.
 
+    def test_output_file_too_large(self):
+        module = "file_output"
+        name = "FileOutputJob"
+        data = {"lines": 1}
+
+        # Exactly JOB_CREATE_FILE_MAX_SIZE bytes should be okay:
+        with override_config(JOB_CREATE_FILE_MAX_SIZE=len("Hello world!\n")):
+            job_result = create_job_result_and_run_job(module, name, **data)
+            self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS, job_result.traceback)
+            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")
+
+        # Even one byte over is too much:
+        with override_config(JOB_CREATE_FILE_MAX_SIZE=len("Hello world!\n") - 1):
+            job_result = create_job_result_and_run_job(module, name, **data)
+            self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+            self.assertIn("ValueError", job_result.traceback)
+            self.assertEqual(0, job_result.files.count())
+
+        # settings takes precedence over constance config
+        with override_config(JOB_CREATE_FILE_MAX_SIZE=10 << 20):
+            with override_settings(JOB_CREATE_FILE_MAX_SIZE=len("Hello world!\n") - 1):
+                job_result = create_job_result_and_run_job(module, name, **data)
+                self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+                self.assertIn("ValueError", job_result.traceback)
+                self.assertEqual(0, job_result.files.count())
+
 
 class RunJobManagementCommandTest(TransactionTestCase):
     """Test cases for the `nautobot-server runjob` management command."""
@@ -998,6 +1027,6 @@ class ScheduledJobIntervalTestCase(TestCase):
         )
 
         requested_weekday = self.datetime_days[start_time.weekday()]
-        schedule_day_of_week = list(scheduled_job.schedule.day_of_week)[0]
+        schedule_day_of_week = next(iter(scheduled_job.schedule.day_of_week))
         scheduled_job_weekday = self.cron_days[schedule_day_of_week]
         self.assertEqual(scheduled_job_weekday, requested_weekday)

nautobot/extras/tests/test_models.py

@@ -1,6 +1,6 @@
 import os
 import tempfile
-from unittest import mock, expectedFailure
+from unittest import expectedFailure, mock
 import uuid
 import warnings
 
@@ -13,6 +13,7 @@ from django.db.utils import IntegrityError
 from django.test import override_settings
 from django.test.utils import isolate_apps
 from django.utils.timezone import now
+from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
 
 from nautobot.circuits.models import CircuitType
 from nautobot.core.choices import ColorChoices
@@ -28,8 +29,8 @@ from nautobot.dcim.models import (
     Platform,
 )
 from nautobot.extras.choices import (
-    LogLevelChoices,
     JobResultStatusChoices,
+    LogLevelChoices,
     ObjectChangeActionChoices,
     ObjectChangeEventContextChoices,
     SecretsGroupAccessTypeChoices,
@@ -129,10 +130,11 @@ class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
         cpf1 = ComputedField(
             label="Test 1",
             key="12_test_1",
+            template="{{obj}}",
             content_type=ContentType.objects.get_for_model(Device),
         )
         with self.assertRaises(ValidationError) as error:
-            cpf1.validated_save()
+            cpf1.save()
         self.assertIn(
             "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
             str(error.exception),
@@ -140,7 +142,7 @@ class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
         # Check if it catches the cpf.key with whitespace.
         cpf1.key = "test 1"
         with self.assertRaises(ValidationError) as error:
-            cpf1.validated_save()
+            cpf1.save()
         self.assertIn(
             "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
             str(error.exception),
@@ -148,7 +150,7 @@ class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
         # Check if it catches the cpf.key with hyphens.
         cpf1.key = "test-1-computed-field"
         with self.assertRaises(ValidationError) as error:
-            cpf1.validated_save()
+            cpf1.save()
         self.assertIn(
             "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
             str(error.exception),
@@ -156,7 +158,7 @@ class ComputedFieldTest(ModelTestCases.BaseModelTestCase):
         # Check if it catches the cpf.key with special characters
         cpf1.key = "test_1_computed_f)(&d"
         with self.assertRaises(ValidationError) as error:
-            cpf1.validated_save()
+            cpf1.save()
         self.assertIn(
             "This key is not Python/GraphQL safe. Please do not start the key with a digit and do not use hyphens or whitespace",
             str(error.exception),
@@ -193,6 +195,9 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
         cls.platform = Platform.objects.first()
         cls.tenant = Tenant.objects.first()
         cls.tenantgroup = cls.tenant.tenant_group
+        cls.child_tenant = Tenant.objects.filter(tenant_group__isnull=False, tenant_group__parent__isnull=False).first()
+        cls.parent_tenantgroup = cls.child_tenant.tenant_group.parent
+        cls.child_tenantgroup = cls.child_tenant.tenant_group
         cls.tag, cls.tag2 = Tag.objects.get_for_model(Device)[:2]
         cls.dynamic_groups = DynamicGroup.objects.create(
             name="Dynamic Group",
@@ -297,6 +302,12 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
         self.assertEqual(device_context, annotated_queryset[0].get_config_context())
         for key in ["location", "platform", "tenant_group", "tenant", "tag", "dynamic_group"]:
             self.assertIn(key, device_context)
+        # Add a device type constraint that does not match the device in question to the location config context
+        # And make sure that location_context is not applied to it anymore.
+        no_match_device_type = DeviceType.objects.exclude(pk=self.devicetype.pk).first()
+        location_context.device_types.add(no_match_device_type)
+        device_context = device.get_config_context()
+        self.assertNotIn("location", device_context)
 
     def test_annotation_same_as_get_for_object_device_relations_in_child_locations(self):
         location_context = ConfigContext.objects.create(name="root-location", weight=100, data={"location-1": 1})
@@ -312,10 +323,41 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             status=self.device_status,
             device_type=self.devicetype,
         )
+
         device_context = device.get_config_context()
+        annotated_queryset = Device.objects.filter(name=device.name).annotate_config_context_data()
+        self.assertEqual(device_context, annotated_queryset[0].get_config_context())
+
         for key in ["location-1", "location-2", "location-3"]:
             self.assertIn(key, device_context)
 
+    def test_annotation_same_as_get_for_object_device_relations_in_child_tenant_groups(self):
+        tenant_group_context = ConfigContext.objects.create(
+            name="parent_tenant_group", weight=100, data={"parent-group-1": 1}
+        )
+        tenant_group_context.tenant_groups.add(self.parent_tenantgroup)
+        tenant_group_context = ConfigContext.objects.create(
+            name="child_tenant_group", weight=100, data={"child-group-1": 2}
+        )
+        tenant_group_context.tenant_groups.add(self.child_tenantgroup)
+        tenant_context = ConfigContext.objects.create(name="child_tenant", weight=100, data={"child-tenant-1": 3})
+        tenant_context.tenants.add(self.child_tenant)
+        device = Device.objects.create(
+            name="Child Tenant Device",
+            location=self.location,
+            role=self.devicerole,
+            status=self.device_status,
+            device_type=self.devicetype,
+            tenant=self.child_tenant,
+        )
+
+        device_context = device.get_config_context()
+        annotated_queryset = Device.objects.filter(name=device.name).annotate_config_context_data()
+        self.assertEqual(device_context, annotated_queryset[0].get_config_context())
+
+        for key in ["parent-group-1", "child-group-1", "child-tenant-1"]:
+            self.assertIn(key, device_context)
+
     def test_annotation_same_as_get_for_object_virtualmachine_relations(self):
         location_context = ConfigContext.objects.create(name="location", weight=100, data={"location": 1})
         location_context.locations.add(self.location)
@@ -338,6 +380,7 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             cluster_group=cluster_group,
             cluster_type=cluster_type,
             location=self.location,
+            tenant=self.tenant,
         )
         cluster_context = ConfigContext.objects.create(name="cluster", weight=100, data={"cluster": 1})
         cluster_context.clusters.add(cluster)
@@ -372,6 +415,12 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             "vm_dynamic_group",
         ]:
             self.assertIn(key, vm_context)
+        # Add a platform constraint that does not match the device in question to the location config context
+        # And make sure that location_context is not applied to it anymore.
+        no_match_platform = Platform.objects.exclude(pk=self.platform.pk).first()
+        location_context.platforms.add(no_match_platform)
+        device_context = virtual_machine.get_config_context()
+        self.assertNotIn("location", device_context)
 
     def test_annotation_same_as_get_for_object_virtualmachine_relations_in_child_locations(self):
         location_context = ConfigContext.objects.create(name="root-location", weight=100, data={"location-1": 1})
@@ -395,7 +444,12 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             role=self.devicerole,
             status=vm_status,
         )
+
+        annotated_queryset = VirtualMachine.objects.filter(name=virtual_machine.name).annotate_config_context_data()
         vm_context = virtual_machine.get_config_context()
+
+        self.assertEqual(vm_context, annotated_queryset[0].get_config_context())
+
         for key in [
             "location-1",
             "location-2",
@@ -403,6 +457,46 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
         ]:
             self.assertIn(key, vm_context)
 
+    def test_annotation_same_as_get_for_object_virtualmachine_relations_in_child_tenant_groups(self):
+        tenant_group_context = ConfigContext.objects.create(
+            name="parent_tenant_group", weight=100, data={"parent-group-1": 1}
+        )
+        tenant_group_context.tenant_groups.add(self.parent_tenantgroup)
+        tenant_group_context = ConfigContext.objects.create(
+            name="child_tenant_group", weight=200, data={"child-group-1": 2}
+        )
+        tenant_group_context.tenant_groups.add(self.child_tenantgroup)
+        tenant_context = ConfigContext.objects.create(name="child_tenant", weight=300, data={"child-tenant-1": 3})
+        tenant_context.tenants.add(self.child_tenant)
+        vm_status = Status.objects.get_for_model(VirtualMachine).first()
+        cluster_group = ClusterGroup.objects.create(name="Cluster Group")
+        cluster_type = ClusterType.objects.create(name="Cluster Type 1")
+        cluster = Cluster.objects.create(
+            name="Cluster",
+            cluster_group=cluster_group,
+            cluster_type=cluster_type,
+            location=self.location,
+        )
+        virtual_machine = VirtualMachine.objects.create(
+            name="Child Tenant VM",
+            cluster=cluster,
+            role=self.devicerole,
+            status=vm_status,
+            tenant=self.child_tenant,
+        )
+
+        annotated_queryset = VirtualMachine.objects.filter(name=virtual_machine.name).annotate_config_context_data()
+        vm_context = virtual_machine.get_config_context()
+
+        self.assertEqual(vm_context, annotated_queryset[0].get_config_context())
+
+        for key in [
+            "parent-group-1",
+            "child-group-1",
+            "child-tenant-1",
+        ]:
+            self.assertIn(key, vm_context)
+
     def test_multiple_tags_return_distinct_objects(self):
         """
         Tagged items use a generic relationship, which results in duplicate rows being returned when queried.
@@ -809,6 +903,62 @@ class ExternalIntegrationTest(ModelTestCases.BaseModelTestCase):
         ei.timeout = 65536
         ei.validated_save()
 
+    def test_render_extra_config(self):
+        ei_with_extra_config = ExternalIntegration.objects.filter(extra_config__isnull=False)
+        ei_without_extra_config = ExternalIntegration.objects.filter(extra_config__isnull=True)
+        ei = ei_with_extra_config.first()
+        self.assertEqual(
+            ei.render_extra_config({}),
+            ei.extra_config,
+        )
+        self.assertEqual(
+            ei_without_extra_config.first().render_extra_config({}),
+            {},
+        )
+        # Data gets substituted correctly
+        ei.extra_config = {"config": "{{ data }}"}
+        ei.save()
+        context = {"data": "extra_config_data"}
+        self.assertEqual(ei.render_extra_config(context), {"config": "extra_config_data"})
+        # Invalid template tag
+        ei.extra_config = {"context": "{% foo %}"}
+        ei.save()
+        with self.assertRaises(TemplateSyntaxError):
+            ei.render_extra_config({})
+        # Invalid template helper
+        ei.extra_config = "{{ data | notvalid }}"
+        ei.save()
+        with self.assertRaises(TemplateAssertionError):
+            ei.render_extra_config({})
+
+    def test_render_headers(self):
+        ei_with_headers = ExternalIntegration.objects.filter(headers__isnull=False)
+        ei_without_headers = ExternalIntegration.objects.filter(headers__isnull=True)
+        ei = ei_with_headers.first()
+        self.assertEqual(
+            ei.render_headers({}),
+            ei.headers,
+        )
+        self.assertEqual(
+            ei_without_headers.first().render_headers({}),
+            {},
+        )
+        # Data gets substituted correctly
+        ei.headers = {"headers": "{{ data }}"}
+        ei.save()
+        context = {"data": "headers_data"}
+        self.assertEqual(ei.render_headers(context), {"headers": "headers_data"})
+        # Invalid template tag
+        ei.headers = {"context": "{% foo %}"}
+        ei.save()
+        with self.assertRaises(TemplateSyntaxError):
+            ei.render_headers({})
+        # Invalid template helper
+        ei.headers = "{{ data | notvalid }}"
+        ei.save()
+        with self.assertRaises(TemplateAssertionError):
+            ei.render_headers({})
+
 
 class FileProxyTest(ModelTestCases.BaseModelTestCase):
     model = FileProxy

nautobot/extras/tests/test_notes.py

@@ -6,7 +6,6 @@ from nautobot.core.testing.models import ModelTestCases
 from nautobot.dcim.models import Location
 from nautobot.extras.models import Note
 
-
 User = get_user_model()
 
 

nautobot/extras/tests/test_plugins.py

@@ -1,4 +1,4 @@
-from unittest import mock, skipIf, skip
+from unittest import mock, skip, skipIf
 
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
@@ -6,25 +6,24 @@ from django.core.exceptions import ValidationError
 from django.template import engines
 from django.test import override_settings
 from django.urls import NoReverseMatch, reverse
-
 import netaddr
 
 from nautobot.circuits.models import Circuit, CircuitType, Provider
 from nautobot.core.celery import app
-from nautobot.core.testing import APIViewTestCases, TestCase, ViewTestCases, extract_page_body
-from nautobot.dcim.models import Device, DeviceType, Manufacturer, Location, LocationType
+from nautobot.core.testing import APIViewTestCases, disable_warnings, extract_page_body, TestCase, ViewTestCases
+from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.dcim.tests.test_views import create_test_device
-from nautobot.tenancy.models import Tenant, TenantGroup
-from nautobot.tenancy.filters import TenantFilterSet
-from nautobot.tenancy.forms import TenantFilterForm
 from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.jobs import get_job
 from nautobot.extras.models import CustomField, Relationship, RelationshipAssociation, Role, Secret, Status
 from nautobot.extras.plugins.exceptions import PluginImproperlyConfigured
 from nautobot.extras.plugins.utils import load_plugin
 from nautobot.extras.plugins.validators import wrap_model_clean_methods
-from nautobot.extras.registry import registry, DatasourceContent
-from nautobot.ipam.models import Prefix, IPAddress, Namespace
+from nautobot.extras.registry import DatasourceContent, registry
+from nautobot.ipam.models import IPAddress, Namespace, Prefix
+from nautobot.tenancy.filters import TenantFilterSet
+from nautobot.tenancy.forms import TenantFilterForm
+from nautobot.tenancy.models import Tenant, TenantGroup
 from nautobot.users.models import ObjectPermission
 
 from example_plugin import config as example_config
@@ -485,6 +484,69 @@ class PluginCustomValidationTest(TestCase):
             relationship_assoc.clean()
 
 
+@skipIf(
+    "example_plugin" not in settings.PLUGINS,
+    "example_plugin not in settings.PLUGINS",
+)
+class ExampleModelCustomActionViewTest(TestCase):
+    """Test for custom action view `all_names` added to Example App"""
+
+    model = ExampleModel
+
+    @classmethod
+    def setUpTestData(cls):
+        ExampleModel.objects.create(name="Example 1", number=100)
+        ExampleModel.objects.create(name="Example 2", number=200)
+        ExampleModel.objects.create(name="Example 3", number=300)
+        cls.custom_view_url = reverse("plugins:example_plugin:examplemodel_all_names")
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_custom_action_view_anonymous(self):
+        self.client.logout()
+        response = self.client.get(self.custom_view_url)
+        self.assertHttpStatus(response, 302)
+
+    def test_custom_action_view_without_permission(self):
+        with disable_warnings("django.request"):
+            response = self.client.get(self.custom_view_url)
+            self.assertHttpStatus(response, 403)
+            response_body = response.content.decode(response.charset)
+            self.assertNotIn("/login/", response_body, msg=response_body)
+
+    def test_custom_action_view_with_permission(self):
+        self.add_permissions(f"{self.model._meta.app_label}.all_names_{self.model._meta.model_name}")
+
+        response = self.client.get(self.custom_view_url)
+        self.assertHttpStatus(response, 200)
+
+        response_body = extract_page_body(response.content.decode(response.charset))
+
+        for example_model in self.model.objects.all():
+            self.assertIn(example_model.name, response_body, msg=response_body)
+
+    def test_custom_action_view_with_constrained_permission(self):
+        instance1 = self.model.objects.first()
+        # Add object-level permission
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk": instance1.pk},
+            actions=["all_names"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(self.model))
+
+        response = self.client.get(self.custom_view_url)
+        self.assertHttpStatus(response, 200)
+
+        response_body = extract_page_body(response.content.decode(response.charset))
+
+        self.assertIn(instance1.name, response_body, msg=response_body)
+
+        for example_model in self.model.objects.exclude(pk=instance1.pk):
+            self.assertNotIn(example_model.name, response_body, msg=response_body)
+
+
 class FilterExtensionTest(TestCase):
     """
     Tests for adding filter extensions

nautobot/extras/tests/test_relationships.py

@@ -15,12 +15,12 @@ from nautobot.core.tables import RelationshipColumn
 from nautobot.core.testing import TestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.core.utils.lookup import get_route_for_model
-from nautobot.dcim.models import Device, Platform, Rack, Location, LocationType
+from nautobot.dcim.models import Device, Location, LocationType, Platform, Rack
 from nautobot.dcim.tables import LocationTable
 from nautobot.dcim.tests.test_views import create_test_device
-from nautobot.ipam.models import VLAN, VLANGroup
 from nautobot.extras.choices import RelationshipRequiredSideChoices, RelationshipSideChoices, RelationshipTypeChoices
 from nautobot.extras.models import Relationship, RelationshipAssociation, Status
+from nautobot.ipam.models import VLAN, VLANGroup
 
 
 class RelationshipBaseTest:
@@ -1368,7 +1368,7 @@ class RequiredRelationshipTestMixin:
                     # Object is updated with the required relationship data (succeeds)
                     response = self.send_data(
                         from_model,
-                        {**{"name": f'{params["create_data"]["name"]} edited'}, **related_objects_data},
+                        {"name": f'{params["create_data"]["name"]} edited', **related_objects_data},
                         interact_with,
                         action="edit",
                         url_kwargs={"pk": newly_created_object.pk},

nautobot/extras/tests/test_tags.py

@@ -1,5 +1,5 @@
-from django.urls import reverse
 from django.contrib.contenttypes.models import ContentType
+from django.urls import reverse
 from rest_framework import status
 
 from nautobot.core.testing import APITestCase, TestCase