nautobot 3.0.0a3__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

nautobot/extras/templates/extras/configcontext_update.html

@@ -18,6 +18,7 @@
             {% render_field form.locations %}
             {% render_field form.roles %}
             {% render_field form.device_types %}
+            {% render_field form.device_families %}
             {% render_field form.platforms %}
             {% render_field form.cluster_groups %}
             {% render_field form.clusters %}

nautobot/extras/templates/extras/dynamicgroup_update.html

@@ -43,7 +43,7 @@
             <div class="tab-content">
                 <div class="tab-pane active" id="filter-form">
                     {% if filter_form %}
-                        <span class="form-text py-6">
+                        <span class="form-text mb-12">
                             Select the filtering criteria to determine membership of objects matching
                             the Content Type for this Dynamic Group. Fields that are not a dropdown are
                             expected to have string inputs and do not support multiple values.

nautobot/extras/templates/extras/objectchange_retrieve.html

@@ -2,8 +2,6 @@
 {% load helpers %}
 {% load static %}
 
-{% block title %}{{ object }} - Change Log{% endblock %}
-
 {% block content %}
     <div class="row">
         <div class="col-lg-5">

nautobot/extras/templates/extras/plugin_detail.html

@@ -70,7 +70,7 @@
                         {% if app_data.availability %}
                             <tr>
                                 <td>License</td>
-                                <td><label class="badge bg-transparent">{{ app_data.availability }}</label></td>
+                                <td><label class="badge border border-primary text-primary">{{ app_data.availability }}</label></td>
                             </tr>
                         {% endif %}
                     </table>
@@ -82,11 +82,11 @@
                     <table class="table table-hover card-body attr-table">
                         <tr>
                             <td>Min Nautobot Version</td>
-                            <td>v{{ object.min_version | placeholder }}</td>
+                            <td>{% if object.min_version %}v{{ object.min_version }}{% else %}{{ None|placeholder }}{% endif %}</td>
                         </tr>
                         <tr>
                             <td>Max Nautobot Version</td>
-                            <td>v{{ object.max_version | placeholder }}</td>
+                            <td>{% if object.max_version %}v{{ object.max_version }}{% else %}{{ None|placeholder }}{% endif %}</td>
                         </tr>
                     </table>
                 </div>

nautobot/extras/templates/extras/secret_create.html

@@ -13,7 +13,7 @@
     <div class="card">
         <div class="card-header"><strong>Parameters</strong></div>
         <div class="card-body">
-            <span class="form-text">
+            <span class="form-text mb-12">
                 All parameter values can be entered as Jinja2 templates if desired.
                 The requesting object (device, Git repository, etc.), if any, will be provided
                 as context variable <code>obj</code>.

nautobot/extras/tests/integration/test_computedfields.py

@@ -1,15 +1,14 @@
 from django.contrib.contenttypes.models import ContentType
-from django.test import tag
 from django.urls import reverse
 
-from nautobot.core.testing.integration import SeleniumTestCase
+from nautobot.core.testing.integration import ObjectDetailsMixin, ObjectsListMixin, SeleniumTestCase
 from nautobot.dcim.models import Device
 from nautobot.extras.models import ComputedField
 
 from . import create_test_device
 
 
-class ComputedFieldsTestCase(SeleniumTestCase):
+class ComputedFieldsTestCase(SeleniumTestCase, ObjectDetailsMixin, ObjectsListMixin):
     """
     Integration test to check nautobot.extras.models.ComputedField.advanced_ui functionality
     and computed fields appearing in an object list
@@ -26,7 +25,6 @@ class ComputedFieldsTestCase(SeleniumTestCase):
             template="{{ obj.name }} is awesome!",
         )
 
-    @tag("fix_in_v3")
     def test_computed_field_advanced_ui(self):
         """
         This test creates a device and a computed field for that device.
@@ -41,7 +39,7 @@ class ComputedFieldsTestCase(SeleniumTestCase):
         self.assertTrue(self.browser.is_text_present("Device Computed Field"))
         self.assertTrue(self.browser.is_text_present(f"{self.device.name} is awesome!"))
         # # Check the computed field does NOT appear in the advanced tab
-        self.browser.links.find_by_partial_text("Advanced")[0].click()
+        self.switch_tab("Advanced")
         self.assertFalse(self.browser.is_text_present("Device Computed Field"))
         self.assertFalse(self.browser.is_text_present(f"{self.device.name} is awesome!"))
         # Set the custom_field to only show in the advanced tab
@@ -53,18 +51,20 @@ class ComputedFieldsTestCase(SeleniumTestCase):
         self.assertFalse(self.browser.is_text_present("Device Computed Field"))
         self.assertFalse(self.browser.is_text_present(f"{self.device.name} is awesome!"))
         # Check the computed field appears in the advanced tab
-        self.browser.links.find_by_partial_text("Advanced")[0].click()
+        self.switch_tab("Advanced")
         self.assertTrue(self.browser.is_text_present("Device Computed Field"))
         self.assertTrue(self.browser.is_text_present(f"{self.device.name} is awesome!"))
 
-    @tag("fix_in_v3")
     def test_computed_field_appears_in_object_list(self):
         """
         This test sets the computed field to be visible on the object list
         and then checks to see if it actually appears there.
         """
         self.browser.visit(f"{self.live_server_url}/dcim/devices/")
-        self.click_button("#table-configure-button")
+        self.click_button("""button[title="Configure table"]""")
+        nb_drawer_open_xpath = "//section[contains(@class, 'nb-drawer') and contains(@class, 'nb-drawer-open')]"
+        self.assertTrue(self.browser.is_element_present_by_xpath(nb_drawer_open_xpath, wait_time=5))
+        self.assertTrue(self.browser.find_by_xpath(nb_drawer_open_xpath).is_visible(wait_time=5))
         select_option = self.browser.find_by_xpath(
             ".//select[@id='id_columns']/option[contains(text(), 'Device Computed Field')]"
         )
@@ -72,6 +72,5 @@ class ComputedFieldsTestCase(SeleniumTestCase):
         select_option.click()
         self.browser.find_by_xpath(".//input[@value='Save']").click()
         self.assertTrue(self.browser.is_text_present(f"{self.device.name} is awesome!"))
-        self.browser.find_by_xpath(".//button[@data-original-title='Configure table']").click()
         self.browser.find_by_xpath(".//input[@value='Reset']").click()
         self.assertFalse(self.browser.is_text_present(f"{self.device.name} is awesome!"))

nautobot/extras/tests/integration/test_customfields.py

@@ -304,9 +304,7 @@ class CustomFieldTestCase(SeleniumTestCase, ObjectDetailsMixin):
         # Visit the device edit page
         self.browser.visit(f"{self.live_server_url}{reverse('dcim:device_edit', kwargs={'pk': device.pk})}")
         # Get the first item selected on the custom field
-        self.browser.execute_script(
-            'document.querySelector(\'label:has(+ * [name="cf_test_selection_field"])\').scrollIntoView({ behavior: "instant" });'
-        )
+        self.scroll_element_into_view(css='label:has(+ * [name="cf_test_selection_field"])')
         self.browser.find_by_xpath(".//label[contains(text(), 'Device Selection Field')]").click()
         active_web_element = self.browser.driver.switch_to.active_element
         active_web_element.send_keys(Keys.ENTER)

nautobot/extras/tests/integration/test_dynamicgroups.py

@@ -1,16 +1,15 @@
 from django.contrib.contenttypes.models import ContentType
-from django.test import tag
 from django.urls import reverse
 from selenium.webdriver.common.keys import Keys
 
-from nautobot.core.testing.integration import SeleniumTestCase
+from nautobot.core.testing.integration import ObjectsListMixin, SeleniumTestCase
 from nautobot.dcim.models import Device
 from nautobot.extras.models import DynamicGroup
 
 from . import create_test_device
 
 
-class DynamicGroupTestCase(SeleniumTestCase):
+class DynamicGroupTestCase(SeleniumTestCase, ObjectsListMixin):
     """
     Integration test to check nautobot.extras.models.DynamicGroup add/edit functionality.
     """
@@ -19,7 +18,6 @@ class DynamicGroupTestCase(SeleniumTestCase):
         super().setUp()
         self.login_as_superuser()
 
-    @tag("fix_in_v3")
     def test_create_and_update(self):
         """
         Test initial add and then update of a new DynamicGroup
@@ -32,7 +30,7 @@ class DynamicGroupTestCase(SeleniumTestCase):
         self.click_navbar_entry("Organization", "Dynamic Groups")
 
         # Click add button
-        self.browser.find_by_id("add-button").click()
+        self.click_add_item()
 
         # Fill out the form.
         name = "devices-active"
@@ -40,19 +38,20 @@ class DynamicGroupTestCase(SeleniumTestCase):
         self.browser.select("content_type", ct_label)
 
         # Click that "Create" button
-        self.browser.find_by_text("Create").click()
+        self.click_edit_form_create_button()
 
         # Verify form redirect and presence of content.
         self.assertTrue(self.browser.is_text_present(f"Created dynamic group {name}"))
         self.assertTrue(self.browser.is_text_present("Edit"))
 
         # Edit the newly created DynamicGroup (Click that "Edit" button)
-        self.browser.find_by_id("edit-button").click()
+        self.click_button("#edit-button")
 
         # Find the "Status" dynamic multi-select and type into it. Xpath is used
         # to find the next "input" after the "status" select field.
         status_field = self.browser.find_by_name("filter-status").first
         status_input = status_field.find_by_xpath("./following::input[1]").first
+        self.scroll_element_into_view(element=status_input)
         status_input.click()  # Force focus on the input field to bring it on-screen
 
         # Fill in "Status: Active".
@@ -61,7 +60,7 @@ class DynamicGroupTestCase(SeleniumTestCase):
         status_input.type(Keys.ENTER)
 
         # Click that "Update" button
-        self.browser.find_by_text("Update").click()
+        self.browser.find_by_xpath("//button[normalize-space()='Update']").click()
 
         # Verify form redirect and presence of content.
         self.assertTrue(self.browser.is_text_present(f"Modified dynamic group {name}"))

nautobot/extras/tests/integration/test_relationships.py

@@ -1,5 +1,4 @@
 from django.contrib.contenttypes.models import ContentType
-from django.test import tag
 from django.urls import reverse
 
 from nautobot.core.testing.integration import ObjectDetailsMixin, SeleniumTestCase
@@ -19,7 +18,6 @@ class RelationshipsTestCase(SeleniumTestCase, ObjectDetailsMixin):
         super().setUp()
         self.login_as_superuser()
 
-    @tag("fix_in_v3")
     def test_relationship_advanced_ui(self):
         """
         This test creates a device and a relationship for that device.

nautobot/extras/tests/test_api.py

@@ -2252,6 +2252,69 @@ class JobTest(
         self.assertTrue(schedule.approval_required)
         self.assertEqual(schedule.kwargs["var4"], str(device_role.pk))
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    @mock.patch("nautobot.extras.api.views.get_worker_count")
+    @mock.patch("nautobot.extras.models.jobs.JobResult.enqueue_job")
+    def test_run_job_filtered_approval(self, mock_enqueue_job, mock_get_worker_count):
+        """
+        Run a job with a defined approval workflow whose filter should or should not include it.
+        """
+        workflow = ApprovalWorkflowDefinition(
+            name="Test Approval Workflow Definition 1",
+            model_content_type=ContentType.objects.get_for_model(ScheduledJob),
+            weight=0,
+            model_constraints={"job_model__job_class_name": "APITestJob"},
+        )
+        workflow.validated_save()
+
+        # Do the stuff.
+        mock_get_worker_count.return_value = 1
+        self.add_permissions("extras.run_job")
+        device_role = Role.objects.get_for_model(Device).first()
+        job_data = {
+            "var1": "FooBar",
+            "var2": 123,
+            "var3": False,
+            "var4": device_role.pk,
+        }
+
+        data = {
+            "data": job_data,
+            # schedule is omitted
+        }
+
+        url = self.get_run_url()
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, self.run_success_response_status)
+
+        # Assert that a JobResult for this job was NOT created.
+        self.assertFalse(JobResult.objects.filter(name=self.job_model.name).exists())
+
+        # Assert that we have an immediate ScheduledJob and that it matches the job_model.
+        schedule = ScheduledJob.objects.last()
+        self.assertIsNotNone(schedule)
+        self.assertEqual(schedule.interval, JobExecutionType.TYPE_FUTURE)
+        self.assertTrue(schedule.approval_required)
+        self.assertEqual(schedule.kwargs["var4"], str(device_role.pk))
+        mock_enqueue_job.assert_not_called()
+
+        # Change the workflow definition so that it no longer applies to this job model
+        workflow.model_constraints = {"job_model__job_class_name__istartswith": "SomeOtherJob"}
+        workflow.validated_save()
+
+        mock_enqueue_job.return_value = None
+        deserialized_data = self.job_class.deserialize_data(job_data)
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, self.run_success_response_status)
+        expected_enqueue_job_args = (self.job_model, self.user)
+        expected_enqueue_job_kwargs = {
+            "job_queue": self.job_model.default_job_queue,
+            **self.job_class.serialize_data(deserialized_data),
+        }
+        mock_enqueue_job.assert_called_with(*expected_enqueue_job_args, **expected_enqueue_job_kwargs)
+        # No new scheduled job should be created
+        self.assertEqual(schedule, ScheduledJob.objects.last())
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     @mock.patch("nautobot.extras.api.views.get_worker_count")
     @mock.patch("nautobot.extras.models.jobs.JobResult.enqueue_job")

nautobot/extras/tests/test_changelog.py

@@ -542,13 +542,35 @@ class ObjectChangeModelTest(TestCase):  # TODO: change to BaseModelTestCase once
     def setUpTestData(cls):
         cls.location_status = Status.objects.get_for_model(Location).first()
 
+    def test_m2m_fields_not_excluded(self):
+        """Ensure that m2m fields are included in object changes, even if exclude_m2m is the default in the REST API."""
+        with context_managers.web_request_context(self.user):
+            location_type = LocationType.objects.create(name="Test m2m locationtype")
+
+        with context_managers.web_request_context(self.user):
+            location_type.content_types.set(ContentType.objects.filter(app_label="dcim"))
+
+        object_changes = get_changes_for_model(location_type)
+        self.assertEqual(object_changes.count(), 2)
+
+        snapshots = object_changes.first().get_snapshots()
+        self.assertIsNotNone(snapshots["differences"]["removed"])
+        self.assertIsNotNone(snapshots["differences"]["added"])
+        self.assertIn("content_types", snapshots["differences"]["removed"])
+        self.assertIn("content_types", snapshots["differences"]["added"])
+        self.assertEqual(
+            len(snapshots["differences"]["added"]["content_types"]),
+            ContentType.objects.filter(app_label="dcim").count(),
+        )
+
     def test_opt_out(self):
         """Hidden static group associations can "opt out" of change logging."""
         dg = DynamicGroup.objects.exclude(group_type=DynamicGroupTypeChoices.TYPE_STATIC).first()
         # Force reassignment of all cached memberships:
         members = list(dg.members)
-        dg._set_members([])
-        dg._set_members(members)
+        with context_managers.web_request_context(self.user):
+            dg._set_members([])
+            dg._set_members(members)
 
         for sga in dg.static_group_associations(manager="all_objects").all():
             self.assertIsNone(get_changes_for_model(sga).first())

nautobot/extras/tests/test_filters.py

@@ -14,6 +14,7 @@ from nautobot.core.testing import FilterTestCases
 from nautobot.dcim.filters import DeviceFilterSet
 from nautobot.dcim.models import (
     Device,
+    DeviceFamily,
     DeviceType,
     Interface,
     Location,
@@ -605,6 +606,8 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
         ("cluster_group", "cluster_groups__id"),
         ("cluster_group", "cluster_groups__name"),
         ("cluster_group_id", "cluster_groups__id"),
+        ("device_family", "device_families__id"),
+        ("device_family", "device_families__name"),
         ("device_type", "device_types__id"),
         ("device_type", "device_types__model"),
         ("device_type_id", "device_types__id"),
@@ -631,10 +634,28 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
 
         manufacturer = Manufacturer.objects.first()
 
+        cls.device_families = (
+            DeviceFamily.objects.create(name="Device Family A"),
+            DeviceFamily.objects.create(name="Device Family B"),
+            DeviceFamily.objects.create(name="Device Family C"),
+        )
+
         device_types = (
-            DeviceType.objects.create(model="Device Type 1", manufacturer=manufacturer),
-            DeviceType.objects.create(model="Device Type 2", manufacturer=manufacturer),
-            DeviceType.objects.create(model="Device Type 3", manufacturer=manufacturer),
+            DeviceType.objects.create(
+                model="Device Type 1",
+                manufacturer=manufacturer,
+                device_family=cls.device_families[0],
+            ),
+            DeviceType.objects.create(
+                model="Device Type 2",
+                manufacturer=manufacturer,
+                device_family=cls.device_families[1],
+            ),
+            DeviceType.objects.create(
+                model="Device Type 3",
+                manufacturer=manufacturer,
+                device_family=cls.device_families[2],
+            ),
         )
         cls.device_types = device_types
 
@@ -669,6 +690,7 @@ class ConfigContextTestCase(FilterTestCases.FilterTestCase):
             )
             c.locations.set([cls.locations[i]])
             c.roles.set([device_roles[i]])
+            c.device_families.set([cls.device_families[i]])
             c.device_types.set([device_types[i]])
             c.platforms.set([platforms[i]])
             c.cluster_groups.set([cluster_groups[i]])
@@ -2142,6 +2164,8 @@ class SecretTestCase(FilterTestCases.FilterTestCase):
         ("created",),
         ("last_updated",),
         ("name",),
+        ("secrets_groups", "secrets_groups__id"),
+        ("secrets_groups", "secrets_groups__name"),
         ("tags", "tags__id"),
         ("tags", "tags__name"),
     )
@@ -2170,6 +2194,15 @@ class SecretTestCase(FilterTestCases.FilterTestCase):
         secrets[0].tags.set(Tag.objects.get_for_model(Secret))
         secrets[1].tags.set(Tag.objects.get_for_model(Secret)[:3])
 
+        secrets_groups = (
+            SecretsGroup.objects.create(
+                name="Secrets Group 1",
+            ),
+            SecretsGroup.objects.create(name="Secrets Group 2"),
+        )
+        secrets_groups[0].secrets.set([secrets[0]])
+        secrets_groups[1].secrets.set([secrets[1]])
+
     def test_provider(self):
         params = {"provider": ["environment-variable"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)

nautobot/extras/tests/test_models.py

@@ -27,6 +27,7 @@ from nautobot.core.testing import TestCase
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.dcim.models import (
     Device,
+    DeviceFamily,
     DeviceType,
     Location,
     LocationType,
@@ -677,8 +678,11 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        manufacturer = Manufacturer.objects.first()
-        cls.devicetype = DeviceType.objects.create(manufacturer=manufacturer, model="Device Type 1")
+        cls.manufacturer = Manufacturer.objects.first()
+        cls.devicefamily = DeviceFamily.objects.create(name="Device Family 1")
+        cls.devicetype = DeviceType.objects.create(
+            manufacturer=cls.manufacturer, model="Device Type 1", device_family=cls.devicefamily
+        )
         cls.devicerole = Role.objects.get_for_model(Device).first()
         root_location_type = LocationType.objects.create(name="Root Location Type")
         parent_location_type = LocationType.objects.create(name="Parent Location Type", parent=root_location_type)
@@ -1217,6 +1221,38 @@ class ConfigContextTest(ModelTestCases.BaseModelTestCase):
             self.assertNotIn("cluster_group_2", context.keys())
             self.assertNotIn("cluster_group_12", context.keys())
 
+    def test_device_family_context(self):
+        """
+        A config context assigned to the device's DeviceFamily is included in get_config_context().
+        """
+
+        # Create a Family-level context
+        cc_family = ConfigContext.objects.create(
+            name="Device Family 1",
+            weight=100,
+            data={
+                "device_family": "Device Family 1",
+            },
+        )
+        cc_family.device_families.add(self.devicefamily)
+        ctx1 = self.device.get_config_context()
+
+        # Create a second device for a negative test and verify that it does NOT receive the family context
+        device_type2 = DeviceType.objects.create(manufacturer=self.manufacturer, model="Device Type2")
+        device2 = Device.objects.create(
+            name="Device 2",
+            location=self.location,
+            tenant=self.tenant,
+            platform=self.platform,
+            role=self.devicerole,
+            status=self.device_status,
+            device_type=device_type2,
+        )
+        ctx2 = device2.get_config_context()
+
+        self.assertEqual(ctx1.get("device_family"), "Device Family 1")
+        self.assertEqual(ctx2.get("device_family"), None)
+
 
 class ConfigContextSchemaTestCase(ModelTestCases.BaseModelTestCase):
     """

nautobot/extras/tests/test_utils.py

@@ -4,7 +4,7 @@ import uuid
 from django.core.cache import cache
 
 from nautobot.core.testing import TestCase
-from nautobot.dcim.models import Device, LocationType
+from nautobot.dcim.models import Cable, Device, PowerPort
 from nautobot.extras.choices import JobQueueTypeChoices
 from nautobot.extras.models import JobQueue
 from nautobot.extras.registry import registry
@@ -23,11 +23,10 @@ class UtilsTestCase(TestCase):
             self.assertEqual(get_base_template("dcim/device/base.html", Device), "dcim/device/base.html")
 
         with self.subTest("<model>.html wins over <model>_retrieve.html"):
-            # TODO: why do we even have both locationtype.html and locationtype_retrieve.html?
-            self.assertEqual(get_base_template(None, LocationType), "dcim/locationtype.html")
+            self.assertEqual(get_base_template(None, PowerPort), "dcim/powerport.html")
 
         with self.subTest("<model>_retrieve.html is used if present"):
-            self.assertEqual(get_base_template(None, JobQueue), "extras/jobqueue_retrieve.html")
+            self.assertEqual(get_base_template(None, Cable), "dcim/cable_retrieve.html")
 
         with self.subTest("generic/object_retrieve.html is used as a fallback"):
             self.assertEqual(get_base_template(None, Token), "generic/object_retrieve.html")